import { _decorator, Component, Node } from 'cc';
const { ccclass, property } = _decorator;

/**
 * 技能等级效果配置接口
 */
export interface SkillLevelEffects {
    descriptions: string[];
    [effectName: string]: number[] | string[];
}

/**
 * 技能数据接口
 */
export interface SkillData {
    id: string;
    name: string;
    description: string;
    iconPath: string;
    maxLevel: number;
    currentLevel: number;
    levelEffects: SkillLevelEffects;
}

/**
 * 技能效果事件
 */
export interface SkillEffectEvent {
    skillId: string;
    skillLevel: number;
    effectType: string;
    value: number;
}

/**
 * 技能管理器 - 单例模式
 * 负责技能数据管理和效果计算
 */
@ccclass('SkillManager')
export class SkillManager extends Component {
    private static _instance: SkillManager | null = null;
    private _skills: Map<string, SkillData> = new Map();
    private _eventCallbacks: Map<string, Function[]> = new Map();

    public static getInstance(): SkillManager | null {
        return SkillManager._instance;
    }

    onLoad() {
        if (SkillManager._instance === null) {
            SkillManager._instance = this;
        } else {
            this.destroy();
            return;
        }
    }

    onDestroy() {
        if (SkillManager._instance === this) {
            SkillManager._instance = null;
        }
    }

    /**
     * 初始化技能数据
     */
    public initSkills(skillsData: SkillData[]) {
        this._skills.clear();
        skillsData.forEach(skill => {
            this._skills.set(skill.id, { ...skill });
        });
    }

    /**
     * 获取技能等级
     */
    public getSkillLevel(skillId: string): number {
        const skill = this._skills.get(skillId);
        return skill ? skill.currentLevel : 0;
    }

    /**
     * 设置技能等级
     */
    public setSkillLevel(skillId: string, level: number): void {
        const skill = this._skills.get(skillId);
        if (skill) {
            skill.currentLevel = Math.max(0, Math.min(skill.maxLevel, level));
            this.notifySkillChanged(skillId);
        }
    }

    /**
     * 升级技能
     */
    public upgradeSkill(skillId: string): boolean {
        const skill = this._skills.get(skillId);
        if (skill && skill.currentLevel < skill.maxLevel) {
            skill.currentLevel++;
            this.notifySkillChanged(skillId);
            return true;
        }
        return false;
    }

    // ==================== 技能效果计算方法 ====================
    
    /**
     * 便宜单位技能效果 - 计算降价后的价格
     */
    public static calculateCheaperUnitsPrice(originalPrice: number, skillLevel: number): number {
        if (skillLevel <= 0) return originalPrice;
        const skillManager = SkillManager.getInstance();
        if (!skillManager) return originalPrice;
        
        const reductionRate = skillManager.getSkillEffectValue('cheaper_units', 'priceReduction', skillLevel);
        return originalPrice * (1 - reductionRate);
    }

    /**
     * 暴击几率技能效果 - 计算新的暴击率
     */
    public static calculateCritChance(baseCritChance: number, skillLevel: number): number {
        if (skillLevel <= 0) return baseCritChance;
        const skillManager = SkillManager.getInstance();
        if (!skillManager) return baseCritChance;
        
        const bonusCritChance = skillManager.getSkillEffectValue('crit_chance', 'critChanceIncrease', skillLevel);
        return Math.min(1.0, baseCritChance + bonusCritChance);
    }

    /**
     * 暴击伤害计算
     */
    public static calculateCritDamage(baseDamage: number, skillLevel: number): number {
        if (skillLevel <= 0) return baseDamage;
        const skillManager = SkillManager.getInstance();
        if (!skillManager) return baseDamage;
        
        const critDamageBonus = skillManager.getSkillEffectValue('crit_chance', 'critChanceIncrease', skillLevel);
        const critMultiplier = 1 + critDamageBonus;
        return baseDamage * critMultiplier;
    }

    /**
     * 治疗技能效果 - 计算增加后的生命值
     */
    public static calculateHealBonus(baseHealth: number, skillLevel: number): number {
        if (skillLevel <= 0) return baseHealth;
        const skillManager = SkillManager.getInstance();
        if (!skillManager) return baseHealth;
        
        const healthBonus = skillManager.getSkillEffectValue('heal', 'healthIncrease', skillLevel);
        return Math.floor(baseHealth * (1 + healthBonus));
    }
    
    /**
     * 计算治疗技能的即时治疗量
     */
    public static calculateInstantHeal(maxHealth: number, skillLevel: number): number {
        if (skillLevel <= 0) return 0;
        const skillManager = SkillManager.getInstance();
        if (!skillManager) return 0;
        
        const healthBonus = skillManager.getSkillEffectValue('heal', 'healthIncrease', skillLevel);
        return Math.floor(maxHealth * healthBonus);
    }
    
    /**
     * 获取治疗技能的最大血量加成
     */
    public static getHealSkillHealthBonus(skillLevel: number): number {
        if (skillLevel <= 0) return 0;
        const skillManager = SkillManager.getInstance();
        if (!skillManager) return 0;
        
        return skillManager.getSkillEffectValue('heal', 'healthIncrease', skillLevel);
    }

    /**
     * 多重射击技能效果 - 计算多射几率
     */
    public static calculateMultiShotChance(baseMultiShotChance: number, skillLevel: number): number {
        if (skillLevel <= 0) return baseMultiShotChance;
        const skillManager = SkillManager.getInstance();
        if (!skillManager) return baseMultiShotChance;
        
        const bonusChance = skillManager.getSkillEffectValue('multi_shots', 'multiShotChance', skillLevel);
        return Math.min(1.0, baseMultiShotChance + bonusChance);
    }

    /**
     * 多重射击子弹数量计算
     */
    public static calculateMultiShotBulletCount(baseBulletCount: number, skillLevel: number): number {
        if (skillLevel <= 0) return baseBulletCount;
        // 多重射击固定为两发子弹
        return 2;
    }

    /**
     * 能量猎手技能效果 - 计算能量值加成
     */
    public static calculateEnergyBonus(baseEnergy: number, skillLevel: number): number {
        if (skillLevel <= 0) return baseEnergy;
        const skillManager = SkillManager.getInstance();
        if (!skillManager) return baseEnergy;
        
        const energyBonus = skillManager.getSkillEffectValue('energy_hunter', 'energyBonus', skillLevel);
        const energyMultiplier = 1 + energyBonus;
        return baseEnergy * energyMultiplier;
    }

    /**
     * 球速提升技能效果 - 计算新的球速
     */
    public static calculateBallSpeed(baseBallSpeed: number, skillLevel: number): number {
        if (skillLevel <= 0) return baseBallSpeed;
        const skillManager = SkillManager.getInstance();
        if (!skillManager) return baseBallSpeed;
        
        const speedBonus = skillManager.getSkillEffectValue('ball_speed', 'ballSpeedIncrease', skillLevel);
        const speedMultiplier = 1 + speedBonus;
        return baseBallSpeed * speedMultiplier;
    }

    /**
     * 检查是否触发暴击
     */
    public static rollCriticalHit(critChance: number): boolean {
        return Math.random() < critChance;
    }

    /**
     * 检查是否触发多重射击
     */
    public static rollMultiShot(multiShotChance: number): boolean {
        console.log("触发概率",multiShotChance);
        return Math.random() < multiShotChance;
    }

    // ==================== 事件系统 ====================
    
    /**
     * 注册技能变化监听
     */
    public onSkillChanged(skillId: string, callback: (skillId: string, level: number) => void): void {
        if (!this._eventCallbacks.has(skillId)) {
            this._eventCallbacks.set(skillId, []);
        }
        this._eventCallbacks.get(skillId)!.push(callback);
    }

    /**
     * 移除技能变化监听
     */
    public offSkillChanged(skillId: string, callback: Function): void {
        const callbacks = this._eventCallbacks.get(skillId);
        if (callbacks) {
            const index = callbacks.indexOf(callback);
            if (index > -1) {
                callbacks.splice(index, 1);
            }
        }
    }

    /**
     * 通知技能变化
     */
    private notifySkillChanged(skillId: string): void {
        const callbacks = this._eventCallbacks.get(skillId);
        const skill = this._skills.get(skillId);
        if (callbacks && skill) {
            callbacks.forEach(callback => {
                callback(skillId, skill.currentLevel);
            });
        }
    }

    /**
     * 获取技能在指定等级的效果值
     */
    public getSkillEffectValue(skillId: string, effectName: string, level: number): number {
        const skill = this._skills.get(skillId);
        if (!skill || !skill.levelEffects || !skill.levelEffects[effectName]) {
            console.warn(`[SkillManager] 技能 ${skillId} 的效果 ${effectName} 不存在`);
            return 0;
        }
        
        const effectArray = skill.levelEffects[effectName] as number[];
        if (level < 0 || level >= effectArray.length) {
            console.warn(`[SkillManager] 技能 ${skillId} 等级 ${level} 超出范围`);
            return 0;
        }
        
        return effectArray[level];
    }
    
    /**
     * 获取技能在指定等级的描述
     */
    public getSkillDescription(skillId: string, level: number): string {
        const skill = this._skills.get(skillId);
        if (!skill || !skill.levelEffects || !skill.levelEffects.descriptions) {
            return skill?.description || '';
        }
        
        const descriptions = skill.levelEffects.descriptions;
        if (level < 0 || level >= descriptions.length) {
            return skill.description;
        }
        
        return descriptions[level];
    }
    
    /**
     * 获取技能当前等级的描述
     */
    public getCurrentSkillDescription(skillId: string): string {
        const skill = this._skills.get(skillId);
        if (!skill) return '';
        
        return this.getSkillDescription(skillId, skill.currentLevel);
    }

    /**
     * 检查技能是否已满级
     */
    public isSkillMaxLevel(skillId: string): boolean {
        const skill = this._skills.get(skillId);
        if (!skill) return false;
        return skill.currentLevel >= skill.maxLevel;
    }

    /**
     * 获取所有技能数据（用于保存）
     */
    public getAllSkillsData(): SkillData[] {
        return Array.from(this._skills.values());
    }

    /**
     * 重置所有技能等级为0（关卡切换时调用）
     */
    public resetAllSkillLevels(): void {
        this._skills.forEach((skill, skillId) => {
            if (skill.currentLevel > 0) {
                skill.currentLevel = 0;
                this.notifySkillChanged(skillId);
            }
        });
        console.log('[SkillManager] 所有技能等级已重置为0');
    }
}