/**
 * 肉鸽模式配置脚本 - 增强版
 * 
 * 功能说明：
 * - 提供基础的刷怪配置：刷什么怪，刷多少怪
 * - 支持程序化关卡生成逻辑，每一关的怪物组合、数量和强度应随关卡进度递增而变化
 * - 支持随机事件系统
 * 
 * @author 游戏开发团队
 * @version 2.0 增强版
 * @date 2025-10-19
 */

import { getMonList, HeroInfo } from "../common/config/heroSet";
import { Attrs } from "../common/config/SkillSet";

// 精英怪物配置表
export const EliteMonsterList = [
    5201, // 兽人战士
    5202, // 兽人刺客
    5203, // 兽人护卫
    // 可以添加更多精英怪物UUID
];

// Boss怪物配置表
export const BossMonsterList = [
    5201, // 兽人战士
    5202, // 兽人刺客
    // 可以添加更多Boss怪物UUID
];

/**
 * 怪物类型枚举
 */
export enum MonsterType {
    NORMAL = "normal",    // 普通怪物
    ELITE = "elite",      // 精英怪物
    BOSS = "boss"         // Boss怪物
}

/**
 * 关卡类型枚举
 */
export enum StageType {
    NORMAL = "normal",      // 普通关卡
    ELITE = "elite",        // 精英关卡
    BOSS = "boss",          // Boss关卡
    EVENT = "event"         // 事件关卡
}

/**
 * 随机事件类型枚举
 */
export enum EventType {
    TREASURE = "treasure",          // 额外奖励
    TRAP = "trap",                  // 陷阱伤害
    BUFF = "buff",                  // 临时增益效果
    DEBUFF = "debuff"               // 临时减益效果
}

/**
 * 关卡配置规则 - 增强版，支持怪物数量和强度随关卡递增
 */
export const StageConfigRules = {
    // 普通关卡
    [StageType.NORMAL]: {
        description: "普通关卡",
        monsters: [
            { type: MonsterType.NORMAL, count: 3, minCount: 2, maxCount: 6 }  // 普通怪物数量随关卡递增
        ]
    },
    
    // 精英关卡
    [StageType.ELITE]: {
        description: "精英关卡", 
        monsters: [
            { type: MonsterType.ELITE, count: 2, minCount: 1, maxCount: 4 },   // 精英怪物
            { type: MonsterType.NORMAL, count: 3, minCount: 2, maxCount: 5 }   // 普通怪物
        ]
    },
    
    // Boss关卡
    [StageType.BOSS]: {
        description: "Boss关卡",
        monsters: [
            { type: MonsterType.BOSS, count: 1, minCount: 1, maxCount: 1 },    // 1个Boss怪物
            { type: MonsterType.ELITE, count: 2, minCount: 1, maxCount: 3 },   // 精英怪物
            { type: MonsterType.NORMAL, count: 2, minCount: 1, maxCount: 4 }   // 普通怪物
        ]
    },
    
    // 事件关卡
    [StageType.EVENT]: {
        description: "事件关卡",
        monsters: [
            { type: MonsterType.NORMAL, count: 2, minCount: 1, maxCount: 4 }   // 少量普通怪物
        ]
    }
};

/**
 * 随机事件配置
 */
export const EventConfig = {
    [EventType.TREASURE]: {
        description: "宝箱事件",
        probability: 0.3,  // 30%概率触发
        effect: "获得额外奖励"
    },
    [EventType.TRAP]: {
        description: "陷阱事件",
        probability: 0.25, // 25%概率触发
        effect: "受到一定伤害"
    },
    [EventType.BUFF]: {
        description: "增益事件",
        probability: 0.25, // 25%概率触发
        effect: "获得临时增益效果"
    },
    [EventType.DEBUFF]: {
        description: "减益事件",
        probability: 0.2,  // 20%概率触发
        effect: "受到临时减益效果"
    }
};

/**
 * 根据关卡号和等级判断关卡类型
 * @param stageNumber 关卡号（从1开始）
 * @param level 等级（1-5）
 * @returns 关卡类型
 */
export function getStageType(stageNumber: number, level: number = 1): StageType {
    // 每隔5关设置特殊事件关卡
    if (stageNumber % 5 === 0 && level === 3) {
        return StageType.EVENT;
    }
    
    // 第10关的特殊规则
    if (stageNumber % 10 === 0) {
        if (level === 5) {
            return StageType.BOSS;      // 第10关第5级为Boss关
        } else if (level === 4) {
            return StageType.ELITE;     // 第10关第4级为精英关
        } else {
            return StageType.NORMAL;    // 第10关1-3级为普通关
        }
    }
    // 1-9关的规则
    else {
        if (level === 5) {
            return StageType.ELITE;     // 1-9关第5级为精英关
        } else {
            return StageType.NORMAL;    // 1-9关1-4级为普通关
        }
    }
}

/**
 * 计算怪物数量，随关卡进度递增
 * @param stageNumber 关卡号
 * @param baseCount 基础数量
 * @param minCount 最小数量
 * @param maxCount 最大数量
 * @returns 实际怪物数量
 */
export function calculateMonsterCount(stageNumber: number, baseCount: number, minCount: number, maxCount: number): number {
    // 随关卡递增，每5关增加1个怪物，最多不超过最大数量
    const increment = Math.floor(stageNumber / 5);
    let count = baseCount + increment;
    
    // 确保在最小和最大数量之间
    count = Math.max(minCount, Math.min(maxCount, count));
    
    return count;
}

/**
 * 计算怪物强度倍率，随关卡进度递增
 * @param stageNumber 关卡号
 * @param level 等级
 * @returns 强度倍率
 */
export function calculateMonsterStrengthMultiplier(stageNumber: number, level: number): number {
    // 基础倍率基于关卡号和等级
    const stageMultiplier = 1 + (stageNumber - 1) * 0.1;  // 每关增加10%
    const levelMultiplier = 1 + (level - 1) * 0.05;       // 每级增加5%
    
    return stageMultiplier * levelMultiplier;
}

/**
 * 生成关卡配置
 * @param stageNumber 关卡号（从1开始）
 * @param level 等级（1-5）
 * @returns MonsterType数组格式
 */
export function generateStageConfig(stageNumber: number, level: number = 1): MonsterType[] {
    const stageType = getStageType(stageNumber, level);
    const rule = StageConfigRules[stageType];
    const monsterArray: MonsterType[] = [];
    
    // 根据配置生成怪物类型数组
    rule.monsters.forEach(monsterGroup => {
        // 计算实际怪物数量
        const actualCount = calculateMonsterCount(
            stageNumber, 
            monsterGroup.count, 
            monsterGroup.minCount, 
            monsterGroup.maxCount
        );
        
        for (let i = 0; i < actualCount; i++) {
            monsterArray.push(monsterGroup.type);
        }
    });
    
    return monsterArray;
}

/**
 * 根据怪物类型获取对应配置表中的怪物UUID数组
 * @param monsterType 怪物类型
 * @returns 怪物UUID数组
 */
export function getMonsterUUIDsByType(monsterType: MonsterType): number[] {
    switch (monsterType) {
        case MonsterType.NORMAL:
            // 普通怪物使用原有的getMonList方法
            return getMonList();
        case MonsterType.ELITE:
            // 精英怪物使用精英配置表
            return EliteMonsterList;
        case MonsterType.BOSS:
            // Boss怪物使用Boss配置表
            return BossMonsterList;
        default:
            return [];
    }
}

/**
 * 获取当前关卡对应的所有怪物UUID数组
 * @param stageNumber 关卡号
 * @param level 等级（1-5）
 * @returns 怪物UUID数组，按关卡配置顺序排列
 */
export function getStageMonsterUUIDs(stageNumber: number, level: number = 1): number[] {
    const monsterTypes = generateStageConfig(stageNumber, level);
    const monsterUUIDs: number[] = [];
    
    monsterTypes.forEach(monsterType => {
        const availableUUIDs = getMonsterUUIDsByType(monsterType);
        if (availableUUIDs.length > 0) {
            // 随机选择一个该类型的怪物
            const randomUUID = availableUUIDs[Math.floor(Math.random() * availableUUIDs.length)];
            monsterUUIDs.push(randomUUID);
        }
    });
    
    return monsterUUIDs;
}

/**
 * 获取关卡怪物配置（包含UUID和强度信息）
 * @param stageNumber 关卡号
 * @param level 等级（1-5）
 * @returns 怪物配置数组
 */
export function getStageMonsterConfigs(stageNumber: number, level: number = 1) {
    const monsterTypes = generateStageConfig(stageNumber, level);
    const monsterConfigs = [];
    
    // 计算强度倍率
    const strengthMultiplier = calculateMonsterStrengthMultiplier(stageNumber, level);
    
    monsterTypes.forEach((monsterType, index) => {
        const availableUUIDs = getMonsterUUIDsByType(monsterType);
        if (availableUUIDs.length > 0) {
            const randomUUID = availableUUIDs[Math.floor(Math.random() * availableUUIDs.length)];
            
            monsterConfigs.push({
                uuid: randomUUID,
                type: monsterType,
                stageNumber: stageNumber,
                level: level,
                strengthMultiplier: strengthMultiplier  // 强度倍率
            });
        }
    });
    
    return monsterConfigs;
}

/**
 * 随机决定是否触发事件
 * @returns 事件类型或null
 */
export function getRandomEvent(): EventType | null {
    const random = Math.random();
    let cumulativeProbability = 0;
    
    for (const eventType in EventConfig) {
        cumulativeProbability += EventConfig[eventType].probability;
        if (random <= cumulativeProbability) {
            return eventType as EventType;
        }
    }
    
    return null; // 不触发事件
}