tanqiu/assets/scripts/FourUI/UpgradeSystem/UpgradeController.ts

import { _decorator, Component, Node, Button, Label, Sprite, SpriteFrame, Texture2D, resources, ScrollView, Layout, Prefab, instantiate, find, UIOpacity, Color } from 'cc';
import { JsonConfigLoader } from '../../Core/JsonConfigLoader';
import { BundleLoader } from '../../Core/BundleLoader';
import { SaveDataManager, WeaponData } from '../../LevelSystem/SaveDataManager';
import EventBus, { GameEvents } from '../../Core/EventBus';
import { UpgradeAni } from './UpgradeAni';
import { PopUPAni } from '../../Animations/PopUPAni';

const { ccclass, property } = _decorator;

/**
 * 武器配置接口（从weapons.json加载）
 */
interface WeaponConfig {
    id: string;
    name: string;
    type: string;
    rarity: string;
    weight: number;
    unlockLevel?: number; // 解锁条件关卡
    stats: {
        damage: number;
        fireRate: number;
        range: number;
        bulletSpeed: number;
    };
    visualConfig: {
        weaponSprites: string | {
            "I": string;
            "H-I": string;
            "L": string;
            "S": string;
            "D-T": string;
        };
    };
    upgradeConfig?: {
        maxLevel: number;
        levels: {
            [level: string]: {
                cost: number;
                damage?: number;
            };
        };
    };
    rarityDamageMultipliers?: number[]; // 稀有度伤害倍率数组
}

/**
 * 武器升级系统控制器
 * 负责管理武器升级UI和逻辑
 */
@ccclass('UpgradeController')
export class UpgradeController extends Component {
    // UI节点引用
    @property(Node) upgradeUI: Node = null;                    // Canvas/UpgradeUI
    @property(ScrollView) weaponScrollView: ScrollView = null; // Canvas/UpgradeUI/ScrollView
    @property(Layout) weaponLayout: Layout = null;             // Canvas/UpgradeUI/ScrollView/view/content/Layout
    @property(Node) upgradePanel: Node = null;                 // Canvas/UpgradeUI/UpgradePanel
    @property(Button) closePanelBtn: Button = null;            // Canvas/UpgradeUI/UpgradePanel/CloseBtn
    
    // 升级面板UI组件
    @property(Sprite) panelWeaponSprite: Sprite = null;        // Canvas/UpgradeUI/UpgradePanel/WeaponSprite
    @property(Label) panelLevelLabel: Label = null;            // Canvas/UpgradeUI/UpgradePanel/LevelLabel
    @property(Label) panelCurrentDamage: Label = null;         // Canvas/UpgradeUI/UpgradePanel/NumberBack/CurrentDamage
    @property(Label) panelCostLabel: Label = null;             // Canvas/UpgradeUI/UpgradePanel/UpgradeBtn/CostLabel
    @property(Button) panelUpgradeBtn: Button = null;          // Canvas/UpgradeUI/UpgradePanel/UpgradeBtn
    
    // 武器节点预制体
    @property(Prefab) lockedWeaponPrefab: Prefab = null;    // Lock.prefab
    @property(Prefab) unlockedWeaponPrefab: Prefab = null;  // Unlock.prefab
    
    // 动画控制器
    @property(PopUPAni) upgradeAni: PopUPAni = null;    // Canvas/UpgradeUI/UpgradePanel上的PopUPAni组件
    @property(UpgradeAni) weaponUpgradeAni: UpgradeAni = null;    // 武器升级动画组件
    
    // 满级按钮图片
    @property(SpriteFrame) maxLevelBtnSprite: SpriteFrame = null;    // 武器满级时的灰色按钮图片
    @property(SpriteFrame) normalUpgradeBtnSprite: SpriteFrame = null;    // 正常升级按钮图片
    
    // 数据管理
    private saveDataManager: SaveDataManager = null;
    private weaponsConfig: any = null;
    private currentSelectedWeapon: string = null;
    private levelConfigs: any[] = [];
    private bundleLoader: BundleLoader = null;
    
    // 武器节点列表
    private weaponNodes: Node[] = [];
    
    onLoad() {
        this.saveDataManager = SaveDataManager.getInstance();
        this.bundleLoader = BundleLoader.getInstance();
        this.bindEvents();
    }
    
    async start() {
        // 先加载武器配置
        await this.loadWeaponsConfig();
        
        // 为UpgradeAni组件加载武器配置
        if (this.weaponUpgradeAni) {
            try {
                await this.weaponUpgradeAni.loadWeaponsConfig();
                console.log('[UpgradeController] UpgradeAni武器配置加载完成');
            } catch (error) {
                console.error('[UpgradeController] UpgradeAni武器配置加载失败:', error);
            }
        }
        
        // 加载关卡配置
        await this.loadLevelConfigs();
        
        // 初始化武器数据
        this.initializeWeapons();
        
        // 初始化时检查武器解锁状态
        this.checkInitialWeaponUnlocks();
        
        // 刷新UI
        await this.refreshWeaponList();
        
        // 初始化升级面板状态
        if (this.upgradeAni) {
            this.upgradeAni.hidePanelImmediate();
        } else {
            this.upgradePanel.active = false;
        }
        
        console.log('[UpgradeController] 初始化完成');
    }
    
    /**
     * 绑定事件
     */
    private bindEvents() {
        // 关闭升级面板
        this.closePanelBtn?.node.on(Button.EventType.CLICK, this.closeUpgradePanel, this);
        
        // 升级按钮
        this.panelUpgradeBtn?.node.on(Button.EventType.CLICK, this.onUpgradeWeapon, this);
        
        // 监听关卡完成事件，自动解锁武器
        EventBus.getInstance().on(GameEvents.GAME_SUCCESS, this.onLevelComplete, this);
        
        // 监听货币变化事件，更新升级按钮闪烁状态
        EventBus.getInstance().on(GameEvents.CURRENCY_CHANGED, this.onCurrencyChanged, this);
    }
    
    /**
     * 加载武器配置
     */
    private async loadWeaponsConfig() {
        try {
            this.weaponsConfig = await JsonConfigLoader.getInstance().loadConfig('weapons');
            console.log('[UpgradeController] 武器配置加载成功:', this.weaponsConfig);
        } catch (error) {
            console.error('[UpgradeController] 加载武器配置失败:', error);
        }
    }
    
    /**
     * 加载关卡配置
     */
    private async loadLevelConfigs() {
        try {
            this.levelConfigs = [];
            
            // 加载Level1到Level5的配置
            for (let i = 1; i <= 5; i++) {
                try {
                    const levelData = await BundleLoader.getInstance().loadDataJson(`levels/Level${i}`);
                    
                    this.levelConfigs.push({
                        level: i,
                        ...levelData
                    });
                } catch (error) {
                    console.warn(`加载Level${i}配置失败:`, error);
                }
            }
            
            console.log('关卡配置加载成功:', this.levelConfigs);
        } catch (error) {
            console.error('加载关卡配置失败:', error);
            this.levelConfigs = [];
        }
    }
    
    /**
     * 初始化武器数据（确保所有武器都在存档中）
     */
    private initializeWeapons() {
        if (!this.weaponsConfig) return;

        const maxUnlockedLevel = this.saveDataManager.getMaxUnlockedLevel();
        console.log(`[UpgradeController] 初始化武器数据，当前最大解锁关卡: ${maxUnlockedLevel}`);

        // 为每个武器创建初始数据（如果不存在）
        this.weaponsConfig.weapons.forEach(weaponConfig => {
            const existingWeapon = this.saveDataManager.getWeapon(weaponConfig.id);
            if (!existingWeapon) {
                const requiredLevel = this.getWeaponUnlockLevelById(weaponConfig.id);
                const shouldBeUnlocked = maxUnlockedLevel >= requiredLevel;
                const initialLevel = shouldBeUnlocked ? 1 : 0;
                
                this.saveDataManager.addWeapon(weaponConfig.id, weaponConfig.rarity, initialLevel);
                
                if (shouldBeUnlocked) {
                    console.log(`[UpgradeController] 初始化时自动解锁武器: ${weaponConfig.name} (${weaponConfig.id})`);
                } else {
                    console.log(`[UpgradeController] 初始化武器为未解锁状态: ${weaponConfig.name} (${weaponConfig.id}), 需要关卡${requiredLevel}`);
                }
            }
        });
    }
    
    /**
     * 初始化时检查武器解锁状态
     */
    private checkInitialWeaponUnlocks() {
        if (!this.saveDataManager || !this.weaponsConfig) return;
        
        const maxUnlockedLevel = this.saveDataManager.getMaxUnlockedLevel();
        console.log(`[UpgradeController] 初始化检查武器解锁状态，当前最大解锁关卡: ${maxUnlockedLevel}`);
        
        let hasUpdates = false;
        
        for (const weaponConfig of this.weaponsConfig.weapons) {
            const weaponId = weaponConfig.id;
            const weaponData = this.saveDataManager.getWeapon(weaponId);
            const requiredLevel = this.getWeaponUnlockLevelById(weaponId);
            
            // 检查武器是否应该根据关卡进度解锁
            const shouldBeUnlocked = maxUnlockedLevel >= requiredLevel;
            const isCurrentlyUnlocked = weaponData && weaponData.level > 0;
            
            // 如果武器应该解锁但还未解锁，则自动解锁
            if (shouldBeUnlocked && !isCurrentlyUnlocked && weaponData) {
                weaponData.level = 1;
                // 由于WeaponData类型中没有unlockTime属性,这里先注释掉
                // weaponData.unlockTime = weaponData.unlockTime || Date.now();
                
                console.log(`[UpgradeController] 初始化时自动解锁武器: ${weaponConfig.name} (${weaponId})`);
                hasUpdates = true;
            }
        }
        
        // 如果有更新，保存数据
        if (hasUpdates) {
            this.saveDataManager.savePlayerData();
            console.log(`[UpgradeController] 初始化武器解锁状态更新完成`);
        }
    }
    
    /**
     * 刷新武器列表UI
     */
    private async refreshWeaponList() {
        if (!this.weaponsConfig || !this.weaponLayout) {
            console.warn('武器配置或武器布局未初始化');
            return;
        }
        
        // 清除现有节点
        this.clearWeaponNodes();
        
        // 为每个武器创建UI节点
        for (let index = 0; index < this.weaponsConfig.weapons.length; index++) {
            const weaponConfig = this.weaponsConfig.weapons[index];
            await this.createWeaponNode(weaponConfig, index);
        }
    }
    
    /**
     * 切换武器节点状态（从锁定到解锁或反之）
     */
    private async switchWeaponNodeState(weaponId: string) {
        const weaponConfig = this.weaponsConfig.weapons.find(w => w.id === weaponId);
        if (!weaponConfig) {
            console.warn(`未找到武器配置: ${weaponId}`);
            return;
        }
        
        // 找到对应的武器节点
        const weaponNodeIndex = this.weaponNodes.findIndex(node => node.name === `WeaponNode_${weaponId}`);
        if (weaponNodeIndex === -1) {
            console.warn(`未找到武器节点: ${weaponId}`);
            return;
        }
        
        const oldNode = this.weaponNodes[weaponNodeIndex];
        const isUnlocked = this.saveDataManager.isWeaponUnlocked(weaponId);
        const weaponData = this.saveDataManager.getWeapon(weaponId);
        
        // 创建新节点
        let newNode: Node = null;
        if (isUnlocked) {
            if (this.unlockedWeaponPrefab) {
                newNode = instantiate(this.unlockedWeaponPrefab);
                await this.setupUnlockedWeaponNode(newNode, weaponConfig, weaponData);
            }
        } else {
            if (this.lockedWeaponPrefab) {
                newNode = instantiate(this.lockedWeaponPrefab);
                this.setupLockedWeaponNode(newNode, weaponConfig);
            }
        }
        
        if (newNode) {
            newNode.name = `WeaponNode_${weaponId}`;
            
            // 获取旧节点的位置
            const siblingIndex = oldNode.getSiblingIndex();
            
            // 移除旧节点
            oldNode.removeFromParent();
            
            // 添加新节点到相同位置
            this.weaponLayout.node.insertChild(newNode, siblingIndex);
            
            // 更新节点数组
            this.weaponNodes[weaponNodeIndex] = newNode;
            
            console.log(`武器 ${weaponId} 状态切换完成: ${isUnlocked ? '解锁' : '锁定'}`);
        }
    }
    
    /**
     * 清除武器节点
     */
    private clearWeaponNodes() {
        this.weaponNodes.forEach(node => {
            if (node && node.isValid) {
                node.destroy();
            }
        });
        this.weaponNodes = [];
    }
    
    /**
     * 创建武器节点
     */
    private async createWeaponNode(weaponConfig: WeaponConfig, index: number) {
        // 获取武器数据
        const weaponData = this.saveDataManager.getWeapon(weaponConfig.id);
        const isUnlocked = this.saveDataManager.isWeaponUnlocked(weaponConfig.id);
        
        console.log(`设置武器节点 ${index}: ${weaponConfig.name}, 等级: ${weaponData?.level || 0}, 已解锁: ${isUnlocked}`);
        
        // 根据解锁状态选择合适的预制体
        let weaponNode: Node = null;
        if (isUnlocked) {
            if (this.unlockedWeaponPrefab) {
                weaponNode = instantiate(this.unlockedWeaponPrefab);
                await this.setupUnlockedWeaponNode(weaponNode, weaponConfig, weaponData);
            }
        } else {
            if (this.lockedWeaponPrefab) {
                weaponNode = instantiate(this.lockedWeaponPrefab);
                this.setupLockedWeaponNode(weaponNode, weaponConfig);
            }
        }
        
        // 如果没有预制体，记录警告
        if (!weaponNode) {
            console.warn(`无法创建武器节点 ${weaponConfig.name}: 缺少对应的预制体`);
            return;
        }
        
        // 设置节点名称
        weaponNode.name = `WeaponNode_${weaponConfig.id}`;
        
        // 添加到布局中
        this.weaponLayout.node.addChild(weaponNode);
        this.weaponNodes.push(weaponNode);
    }
    
    /**
     * 加载武器图标
     */
    private async loadWeaponSprite(sprite: Sprite, spritePath: string) {
        // 转换路径格式，去除"images/"前缀
        const bundlePath = spritePath.replace(/^images\//, '');
        
        try {
            // 使用BundleLoader从images Bundle加载SpriteFrame，需要添加/spriteFrame后缀
            const spriteFrame = await this.bundleLoader.loadSpriteFrame(bundlePath + '/spriteFrame');
            
            if (spriteFrame && sprite && sprite.isValid) {
                sprite.spriteFrame = spriteFrame;
                console.log(`武器图标加载成功: ${spritePath}`);
            }
        } catch (err) {
            console.warn(`加载武器图标失败: ${spritePath}`, err);
        }
    }
    

    
    /**
     * 设置已解锁武器节点（适配Unlock.prefab）
     */
    private async setupUnlockedWeaponNode(weaponNode: Node, weaponConfig: WeaponConfig, weaponData: any) {
        // 获取公共的Sprite节点，避免重复查找
        const spriteNode = weaponNode.getChildByName('Sprite');
        if (!spriteNode) {
            console.warn('未找到Sprite节点:', weaponConfig.id);
            return;
        }
        
        // 设置武器图标 - 查找专门的武器图标Sprite节点，避免影响背景
        const weaponSprite = spriteNode.getChildByName('WeaponSprite')?.getComponent(Sprite);
        if (weaponSprite && weaponConfig.visualConfig.weaponSprites) {
            let spritePath: string;
            // 检查weaponSprites是字符串还是对象
            if (typeof weaponConfig.visualConfig.weaponSprites === 'string') {
                spritePath = weaponConfig.visualConfig.weaponSprites;
            } else {
                // 如果是对象，按优先级选择路径
                spritePath = weaponConfig.visualConfig.weaponSprites['I'] || 
                           weaponConfig.visualConfig.weaponSprites['H-I'] || 
                           weaponConfig.visualConfig.weaponSprites['L'] || 
                           weaponConfig.visualConfig.weaponSprites['S'] || 
                           weaponConfig.visualConfig.weaponSprites['D-T'];
            }
            if (spritePath) {
                await this.loadWeaponSprite(weaponSprite, spritePath);
            }
        }
        
        // 设置武器名称 - Unlock.prefab中的Name节点下的Label（只显示武器名称）
        const nameLabel = spriteNode.getChildByName('Name')?.getComponent(Label);
        if (nameLabel) {
            nameLabel.string = weaponConfig.name;
        }
        
        // 设置武器等级 - should_hide_in_hierarchy/Unlock/Sprite/Level/Label节点（显示等级）    
        const levelNode = spriteNode.getChildByName('Level');
        console.log(`[PreviewInEditor] 处理武器等级显示: ${weaponConfig.name}, weaponData:`, weaponData);
        if (levelNode) {         
            // 先尝试Level节点本身的Label组件
            let levelLabel = levelNode.getComponent(Label);
            if (!levelLabel) {
                // 如果Level节点本身没有Label，尝试查找子节点Label
                const labelNode = levelNode.getChildByName('Label');
                if (labelNode) {
                    levelLabel = labelNode.getComponent(Label);
                }
            }
            if (levelLabel) {
                const actualLevel = weaponData ? weaponData.level : 0;
                levelLabel.string = `${actualLevel}`;
            } else {
                console.warn(`[PreviewInEditor] 未找到Level Label组件: ${weaponConfig.name}`);
            }
        } else {
            console.warn(`[PreviewInEditor] 未找到Level节点: ${weaponConfig.name}`);
        }
        
        // 设置升级按钮 - Unlock.prefab中的Button节点
        const upgradeButton = weaponNode.getChildByName('Upgrade')?.getComponent(Button);
        if (upgradeButton) {
            // 清除之前的事件监听
            upgradeButton.node.off(Button.EventType.CLICK);
            
            // 添加升级事件
            upgradeButton.node.on(Button.EventType.CLICK, () => {
                this.openUpgradePanel(weaponConfig.id);
            }, this);
            
            // 设置按钮文本和状态
            const buttonLabel = upgradeButton.node.getChildByName('Label')?.getComponent(Label);
            if (buttonLabel) {
                const maxLevel = weaponConfig.upgradeConfig?.maxLevel || 10;
                
                if (weaponData && weaponData.level >= maxLevel) {
                    buttonLabel.string = '已满级';
                } else {
                    // 只显示"升级"，不显示费用，费用在升级面板中显示
                    buttonLabel.string = '升  级';
                }
            }
        }
        
        // Unlock.prefab已经有正常的视觉效果，确保节点激活
        weaponNode.active = true;
    }
    
    /**
     * 设置未解锁武器节点（适配Lock.prefab）
     */
    private setupLockedWeaponNode(weaponNode: Node, weaponConfig: WeaponConfig) {
        // 设置解锁信息文本 - Lock.prefab中的Label节点
        const unlockLabel = weaponNode.getChildByName('Label')?.getComponent(Label);
        if (unlockLabel) {
            const unlockLevel = this.getWeaponUnlockLevel(weaponConfig.name);
            unlockLabel.string = `通关第${unlockLevel}关解锁`;
        }
        
        // Lock.prefab已经有合适的视觉效果，不需要额外设置透明度
        weaponNode.active = true;
        
        // 锁定武器节点保持可点击状态以显示解锁提示
        
        // 添加点击事件监听（显示解锁提示）
        weaponNode.on(Node.EventType.TOUCH_END, () => {
            const unlockLevel = this.getWeaponUnlockLevel(weaponConfig.name);
            console.log(`${weaponConfig.name} 需要通关第${unlockLevel}关才能解锁`);
        }, this);
    }
    

    
   
    /**
     * 打开升级面板
     */
    private async openUpgradePanel(weaponId: string) {
        const weaponConfig = this.weaponsConfig.weapons.find(config => config.id === weaponId);
        if (!weaponConfig) {
            console.error(`未找到武器配置: ${weaponId}`);
            return;
        }
        
        const weaponData = this.saveDataManager.getWeapon(weaponId);
        if (!weaponData) {
            console.error(`未找到武器数据: ${weaponId}`);
            return;
        }
        
        this.currentSelectedWeapon = weaponId;
        
        console.log(`打开升级面板: ${weaponConfig.name}, 当前等级: ${weaponData.level}`);
        
        // 刷新面板内容
        this.refreshUpgradePanel();
        
        // 使用动画显示升级面板
        if (this.upgradeAni) {
            await this.upgradeAni.showPanel();
        } else {
            // 如果没有动画组件，直接显示
            this.upgradePanel.active = true;
        }
    }
    
    /**
     * 关闭升级面板
     */
    private async closeUpgradePanel() {
        // 使用动画隐藏升级面板
        if (this.upgradeAni) {
            await this.upgradeAni.hidePanel();
        } else {
            // 如果没有动画组件，直接隐藏
            this.upgradePanel.active = false;
        }
        this.currentSelectedWeapon = null;
    }
    
    /**
     * 刷新升级面板
     */
    private refreshUpgradePanel() {
        if (!this.currentSelectedWeapon || !this.weaponsConfig) return;
        
        const weaponConfig = this.weaponsConfig.weapons.find(w => w.id === this.currentSelectedWeapon);
        const weaponData = this.saveDataManager.getWeapon(this.currentSelectedWeapon);
        
        if (!weaponConfig || !weaponData) {
            console.error(`刷新升级面板失败: 武器配置或数据不存在 ${this.currentSelectedWeapon}`);
            return;
        }
        
        console.log(`刷新升级面板: ${weaponConfig.name}, 等级: ${weaponData.level}`);
        
        // 设置武器图标 - Canvas/UpgradeUI/UpgradePanel/WeaponSprite
        if (this.panelWeaponSprite && weaponConfig.visualConfig.weaponSprites) {
            let spritePath: string;
            // 检查weaponSprites是字符串还是对象
            if (typeof weaponConfig.visualConfig.weaponSprites === 'string') {
                spritePath = weaponConfig.visualConfig.weaponSprites;
            } else {
                // 如果是对象，按优先级选择路径
                spritePath = weaponConfig.visualConfig.weaponSprites['I'] || 
                           weaponConfig.visualConfig.weaponSprites['H-I'] || 
                           weaponConfig.visualConfig.weaponSprites['L'] || 
                           weaponConfig.visualConfig.weaponSprites['S'] || 
                           weaponConfig.visualConfig.weaponSprites['D-T'];
            }
            if (spritePath) {
                this.loadWeaponSprite(this.panelWeaponSprite, spritePath);
            }
        }
        
        // 设置武器名称和等级 - Canvas/UpgradeUI/UpgradePanel/LevelLabel
        if (this.panelLevelLabel) {
            this.panelLevelLabel.string = `${weaponConfig.name} 等级 ${weaponData.level}`;
        }
        
        // 计算当前伤害（基础伤害 + 等级加成）- Canvas/UpgradeUI/UpgradePanel/NumberBack/CurrentDamage
        const baseDamage = weaponConfig.stats.damage;
        const currentDamage = this.calculateWeaponDamage(baseDamage, weaponData.level, this.currentSelectedWeapon);
        const nextLevelDamage = this.calculateWeaponDamage(baseDamage, weaponData.level + 1, this.currentSelectedWeapon);
        const damageIncrease = nextLevelDamage - currentDamage;
        
        if (this.panelCurrentDamage) {
            // 只显示当前伤害数值，不显示增量
            this.panelCurrentDamage.string = currentDamage.toString();
        }
        
        // 同时更新UpgradeAni组件中的伤害显示
        if (this.weaponUpgradeAni && this.weaponUpgradeAni.currentDamageLabel) {
            this.weaponUpgradeAni.updateCurrentDamageDisplay(this.currentSelectedWeapon, weaponData.level);
        }
        
        // 设置升级费用 - Canvas/UpgradeUI/UpgradePanel/UpgradeBtn/CostLabel
        // 优先从武器配置的upgradeConfig字段获取升级费用
        let upgradeCost = 0;
        const maxLevel = weaponConfig.upgradeConfig?.maxLevel || 10;
        
        if (weaponData.level >= maxLevel) {
            // 已达到最大等级，显示"已满级"
            if (this.panelCostLabel) {
                this.panelCostLabel.string = "已满级";
            }
            
            // 替换升级按钮为灰色图片
            if (this.panelUpgradeBtn && this.maxLevelBtnSprite) {
                const btnSprite = this.panelUpgradeBtn.getComponent(Sprite);
                if (btnSprite) {
                    btnSprite.spriteFrame = this.maxLevelBtnSprite;
                }
            }
        } else {
            // 恢复正常升级按钮图片
            if (this.panelUpgradeBtn && this.normalUpgradeBtnSprite) {
                const btnSprite = this.panelUpgradeBtn.getComponent(Sprite);
                if (btnSprite) {
                    btnSprite.spriteFrame = this.normalUpgradeBtnSprite;
                }
            }
            
            // 从upgradeConfig获取升级费用
            if (weaponConfig.upgradeConfig?.levels) {
                const levelConfig = weaponConfig.upgradeConfig.levels[weaponData.level.toString()];
                if (levelConfig && levelConfig.cost) {
                    upgradeCost = levelConfig.cost;
                } else {
                    // 如果upgradeConfig中没有对应等级的费用，使用SaveDataManager的计算方法作为后备
                    upgradeCost = this.saveDataManager.getWeaponUpgradeCost(this.currentSelectedWeapon);
                }
            } else {
                // 如果没有upgradeConfig，使用SaveDataManager的计算方法
                upgradeCost = this.saveDataManager.getWeaponUpgradeCost(this.currentSelectedWeapon);
            }
            
            if (this.panelCostLabel) {
                // 将数字转换为字符串，并在每个数字之间添加空格
                const costString = upgradeCost.toString();
                const spacedCostString = costString.split('').join(' ');
                this.panelCostLabel.string = spacedCostString;
            }
        }
        
        // 升级按钮始终保持可点击状态，通过Toast显示各种提示
        console.log(`[UpgradeController] 升级按钮保持可交互状态`);
        
        // 检查并更新升级按钮闪烁状态
        this.updateUpgradeBtnBlinkState();
    }
    
    /**
     * 计算武器伤害
     */
    private calculateWeaponDamage(baseDamage: number, level: number, weaponId?: string): number {
        if (level === 0) return 0; // 未解锁武器伤害为0
        
        // 优先从武器配置的upgradeConfig中获取伤害值
        if (weaponId && this.weaponsConfig && this.weaponsConfig.weapons) {
            const weaponConfig = this.weaponsConfig.weapons.find(w => w.id === weaponId);
            if (weaponConfig && weaponConfig.upgradeConfig && weaponConfig.upgradeConfig.levels) {
                const levelConfig = weaponConfig.upgradeConfig.levels[level.toString()];
                if (levelConfig && typeof levelConfig.damage === 'number') {
                    console.log(`[UpgradeController] 从upgradeConfig获取伤害: ${weaponId} 等级${level} 伤害${levelConfig.damage}`);
                    return levelConfig.damage;
                }
            }
            
            // 如果upgradeConfig中没有伤害值，使用基础伤害 + 等级加成作为后备
            if (weaponConfig && weaponConfig.stats && weaponConfig.stats.damage) {
                const damage = baseDamage + (level - 1);
                console.log(`[UpgradeController] 使用基础伤害计算: ${weaponId} 等级${level} 伤害${damage}`);
                return damage;
            }
        }
        
        // 如果配置不存在，使用默认公式作为最后后备
        return baseDamage + (level - 1);
    }
    
    /**
     * 根据武器名称查找解锁关卡
     */
    private getWeaponUnlockLevel(weaponName: string): number {
        // 从武器配置中查找对应的武器
        if (this.weaponsConfig && this.weaponsConfig.weapons) {
            const weapon = this.weaponsConfig.weapons.find((w: WeaponConfig) => w.name === weaponName);
            if (weapon && weapon.unlockLevel) {
                return weapon.unlockLevel;
            }
        }
        
        // 如果没有找到配置，返回默认值1
        console.warn(`未找到武器 ${weaponName} 的解锁关卡配置，使用默认值1`);
        return 1;
    }
    
    /**
     * 根据武器ID查找解锁关卡
     */
    private getWeaponUnlockLevelById(weaponId: string): number {
        // 从武器配置中查找对应的武器
        if (this.weaponsConfig && this.weaponsConfig.weapons) {
            const weapon = this.weaponsConfig.weapons.find((w: WeaponConfig) => w.id === weaponId);
            if (weapon && weapon.unlockLevel) {
                return weapon.unlockLevel;
            }
        }
        
        // 如果没有找到配置，返回默认值1
        console.warn(`未找到武器 ${weaponId} 的解锁关卡配置，使用默认值1`);
        return 1;
    }
    
    /**
     * 升级武器
     */
    private async onUpgradeWeapon() {
        console.log(`[UpgradeController] onUpgradeWeapon方法被调用`);
        
        if (!this.currentSelectedWeapon) {
            console.log(`[UpgradeController] currentSelectedWeapon为空，退出`);
            return;
        }
        
        console.log(`[UpgradeController] 开始升级武器: ${this.currentSelectedWeapon}`);
        
        // 检查升级条件并显示相应提示
        const weapon = this.saveDataManager.getWeapon(this.currentSelectedWeapon);
        console.log(`[UpgradeController] 获取到的武器数据:`, weapon);
        
        if (!weapon) {
            console.log(`[UpgradeController] 武器不存在: ${this.currentSelectedWeapon}`);
            EventBus.getInstance().emit(GameEvents.SHOW_TOAST, { message: "武器不存在", duration: 2.0 });
            return;
        }
        
        console.log(`[UpgradeController] 武器等级: ${weapon.level}`);
        if (weapon.level === 0) {
            console.log(`[UpgradeController] 武器未解锁: ${this.currentSelectedWeapon}`);
            EventBus.getInstance().emit(GameEvents.SHOW_TOAST, { message: "请先解锁武器", duration: 2.0 });
            return;
        }
        
        // 检查是否已达到最大等级
        const weaponConfig = this.weaponsConfig.weapons.find(w => w.id === this.currentSelectedWeapon);
        const maxLevel = weaponConfig?.upgradeConfig?.maxLevel || 10;
        if (weapon.level >= maxLevel) {
            console.log(`[UpgradeController] 武器已达到最大等级: ${this.currentSelectedWeapon}`);
            EventBus.getInstance().emit(GameEvents.SHOW_TOAST, { message: "武器已达到最大等级", duration: 2.0 });
            return;
        }
        
        const cost = this.saveDataManager.getWeaponUpgradeCost(this.currentSelectedWeapon);
        const playerMoney = this.saveDataManager.getMoney();
        
        console.log(`[UpgradeController] 升级检查 - 武器: ${this.currentSelectedWeapon}, 费用: ${cost}, 当前金币: ${playerMoney}`);
        console.log(`[UpgradeController] 费用类型: ${typeof cost}, 金币类型: ${typeof playerMoney}`);
        console.log(`[UpgradeController] 条件判断: ${playerMoney} < ${cost} = ${playerMoney < cost}`);
        
        if (playerMoney < cost) {
            console.log(`[UpgradeController] 金币不足 - 需要: ${cost}, 当前: ${playerMoney}`);
            EventBus.getInstance().emit(GameEvents.SHOW_RESOURCE_TOAST, { message: `金币不足，需要${cost}金币`, duration: 2.0 });
            return;
        }
        
        console.log(`[UpgradeController] 金币充足，继续升级流程`);
        
        // 记录升级前的金币数量
        const coinsBeforeUpgrade = this.saveDataManager.getMoney();
        console.log(`[UpgradeController] 升级前金币: ${coinsBeforeUpgrade}`);
        
        const success = this.saveDataManager.upgradeWeapon(this.currentSelectedWeapon);
        
        if (success) {
            const coinsAfterUpgrade = this.saveDataManager.getMoney();
            console.log(`[UpgradeController] 武器 ${this.currentSelectedWeapon} 升级成功`);
            console.log(`[UpgradeController] 升级后金币: ${coinsAfterUpgrade}, 消耗: ${coinsBeforeUpgrade - coinsAfterUpgrade}`);
            
            // 播放武器升级成功动画
            this.playWeaponUpgradeSuccessAnimation();
            
            // 刷新升级面板
            this.refreshUpgradePanel();
            
            // 更新UpgradeAni组件中的伤害显示
            if (this.weaponUpgradeAni && this.weaponUpgradeAni.currentDamageLabel) {
                const upgradedWeapon = this.saveDataManager.getWeapon(this.currentSelectedWeapon);
                if (upgradedWeapon) {
                    this.weaponUpgradeAni.updateCurrentDamageDisplay(this.currentSelectedWeapon, upgradedWeapon.level);
                    console.log(`[UpgradeController] 升级后更新UpgradeAni伤害显示: ${this.currentSelectedWeapon} 等级${upgradedWeapon.level}`);
                }
            }
            
            // 使用新的状态切换方法更新武器节点
            await this.switchWeaponNodeState(this.currentSelectedWeapon);
            
            // 更新升级按钮闪烁状态（升级后钞票可能不足继续升级）
            this.updateUpgradeBtnBlinkState();
            
            // 保存数据
            this.saveDataManager.savePlayerData();
        } else {
            console.log(`[UpgradeController] 武器 ${this.currentSelectedWeapon} 升级失败`);
            EventBus.getInstance().emit(GameEvents.SHOW_TOAST, { message: "升级失败，请重试", duration: 1.0 });
            // 升级失败时不更新UI
        }
    }
    
    /**
     * 播放武器升级成功动画
     */
    private async playWeaponUpgradeSuccessAnimation(): Promise<void> {
        if (!this.weaponUpgradeAni || !this.panelWeaponSprite) {
            console.warn('[UpgradeController] weaponUpgradeAni 或 panelWeaponSprite 未设置，跳过升级动画');
            return;
        }
        
        try {
            // 获取武器图标节点
            const weaponIconNode = this.panelWeaponSprite.node;
            
            // 播放升级动画
            await this.weaponUpgradeAni.playWeaponUpgradeAnimation(weaponIconNode);
            
            console.log('[UpgradeController] 武器升级动画播放完成');
        } catch (error) {
            console.error('[UpgradeController] 播放武器升级动画时出错:', error);
        }
    }
    
    /**
     * 解锁武器
     */
    public async unlockWeapon(weaponId: string): Promise<boolean> {
        const success = this.saveDataManager.unlockWeapon(weaponId);
        
        if (success) {
            console.log(`武器 ${weaponId} 解锁成功`);
            
            // 使用新的状态切换方法更新武器节点
            await this.switchWeaponNodeState(weaponId);
            
            // 保存数据
            this.saveDataManager.savePlayerData();
        }
        
        return success;
    }
    
    /**
     * 获取武器当前伤害
     */
    public getWeaponDamage(weaponId: string): number {
        if (!this.weaponsConfig) return 0;
        
        const weaponConfig = this.weaponsConfig.weapons.find(w => w.id === weaponId);
        const weaponData = this.saveDataManager.getWeapon(weaponId);
        
        if (!weaponConfig || !weaponData) return 0;
        
        return this.calculateWeaponDamage(weaponConfig.stats.damage, weaponData.level, weaponId);
    }
    
    /**
     * 刷新UI
     */
    public async refreshUI() {
        await this.refreshWeaponList();
    }
    
    /**
     * 处理关卡完成事件，自动解锁相应武器
     */
    private async onLevelComplete() {
        if (!this.saveDataManager || !this.weaponsConfig) return;
        
        // 获取当前关卡数据
        const currentLevel = this.saveDataManager.getCurrentLevel();
        const maxUnlockedLevel = this.saveDataManager.getMaxUnlockedLevel();
        const playerData = this.saveDataManager.getPlayerData();
        
        console.log(`[UpgradeController] 关卡完成事件触发`);
        console.log(`[UpgradeController] 当前关卡: ${currentLevel}, 最大解锁关卡: ${maxUnlockedLevel}`);
        console.log(`[UpgradeController] 玩家数据:`, {
            coins: playerData?.money || 0,
            currentLevel: playerData?.currentLevel || 1,
            maxUnlockedLevel: playerData?.maxUnlockedLevel || 1
        });
        
        // 遍历所有武器，检查是否有新解锁的武器
        let hasNewUnlocks = false;
        const newlyUnlockedWeapons: string[] = [];
        
        for (const weaponConfig of this.weaponsConfig.weapons) {
            const weaponId = weaponConfig.id;
            const weaponData = this.saveDataManager.getWeapon(weaponId);
            const requiredLevel = this.getWeaponUnlockLevelById(weaponId);
            
            // 检查武器是否应该根据关卡进度解锁
            const shouldBeUnlocked = maxUnlockedLevel >= requiredLevel;
            const isCurrentlyUnlocked = weaponData && weaponData.level > 0;
            
            console.log(`[UpgradeController] 武器检查: ${weaponConfig.name} (${weaponId})`);
            console.log(`  - 需要关卡: ${requiredLevel}, 当前最大解锁: ${maxUnlockedLevel}`);
            console.log(`  - 应该解锁: ${shouldBeUnlocked}, 当前已解锁: ${isCurrentlyUnlocked}`);
            console.log(`  - 武器数据:`, weaponData);
            
            // 如果武器应该解锁但还未解锁，则自动解锁
            if (shouldBeUnlocked && !isCurrentlyUnlocked) {
                // 确保武器数据存在
                if (!weaponData) {
                    this.saveDataManager.addWeapon(weaponId, weaponConfig.rarity, 1);
                } else {
                    // 武器数据存在但未解锁，直接设置为解锁状态
                    weaponData.level = 1;
                }
                
                console.log(`[UpgradeController] 自动解锁武器: ${weaponConfig.name} (${weaponId})`);
                newlyUnlockedWeapons.push(weaponConfig.name);
                hasNewUnlocks = true;
            }
        }
        
        // 如果有新解锁的武器，刷新UI并保存数据
        if (hasNewUnlocks) {
            await this.refreshWeaponList();
            this.saveDataManager.savePlayerData();
            
            console.log(`[UpgradeController] 关卡完成后解锁了 ${newlyUnlockedWeapons.length} 个武器:`, newlyUnlockedWeapons);
            
            // 通知系统有新武器解锁（供 GainUI 等组件使用）
            EventBus.getInstance().emit(GameEvents.NEW_WEAPONS_UNLOCKED, newlyUnlockedWeapons);
            
            // 可以在这里添加解锁提示UI
            this.showWeaponUnlockNotification(newlyUnlockedWeapons);
        } else {
            console.log(`[UpgradeController] 关卡完成后没有新武器解锁`);
        }
    }
    
    /**
     * 显示武器解锁通知
     */
    private showWeaponUnlockNotification(weaponNames: string[]) {
        if (weaponNames.length === 0) return;
        
        // 这里可以实现解锁通知UI
        // 目前先用console输出
        console.log(`🎉 恭喜解锁新武器: ${weaponNames.join(', ')}!`);
        
        // TODO: 实现实际的UI通知
        // 可以显示一个弹窗或者顶部通知条
    }
    
    /**
     * 获取当前关卡数据（用于调试和UI显示）
     */
    public getCurrentLevelData() {
        if (!this.saveDataManager) return null;
        
        return {
            currentLevel: this.saveDataManager.getCurrentLevel(),
            maxUnlockedLevel: this.saveDataManager.getMaxUnlockedLevel(),
            coins: this.saveDataManager.getMoney(),
                diamonds: this.saveDataManager.getDiamonds(),
            wallLevel: this.saveDataManager.getWallLevel()
        };
    }
    
    /**
     * 手动检查并解锁武器（用于调试或特殊情况）
     */
    public async checkAndUnlockWeapons() {
        console.log('[UpgradeController] 手动检查武器解锁状态');
        await this.onLevelComplete();
    }
    
    /**
     * 获取所有武器的解锁状态信息（用于调试和UI显示）
     */
    public getWeaponUnlockStatus() {
        if (!this.saveDataManager || !this.weaponsConfig) {
            return { error: '数据管理器或武器配置未初始化' };
        }
        
        const maxUnlockedLevel = this.saveDataManager.getMaxUnlockedLevel();
        const weaponStatus = [];
        
        for (const weaponConfig of this.weaponsConfig.weapons) {
            const weaponId = weaponConfig.id;
            const weaponData = this.saveDataManager.getWeapon(weaponId);
            const requiredLevel = this.getWeaponUnlockLevelById(weaponId);
            const shouldBeUnlocked = maxUnlockedLevel >= requiredLevel;
            const isCurrentlyUnlocked = weaponData && weaponData.level > 0;
            
            weaponStatus.push({
                id: weaponId,
                name: weaponConfig.name,
                requiredLevel: requiredLevel,
                shouldBeUnlocked: shouldBeUnlocked,
                isCurrentlyUnlocked: isCurrentlyUnlocked,
                currentLevel: weaponData?.level || 0,
                // 由于WeaponData类型中没有unlockTime属性,暂时移除该字段
                unlocked: weaponData?.level > 0,
                needsUpdate: shouldBeUnlocked && !isCurrentlyUnlocked
            });
        }
        
        return {
            maxUnlockedLevel: maxUnlockedLevel,
            weapons: weaponStatus,
            summary: {
                total: weaponStatus.length,
                unlocked: weaponStatus.filter(w => w.isCurrentlyUnlocked).length,
                shouldBeUnlocked: weaponStatus.filter(w => w.shouldBeUnlocked).length,
                needsUpdate: weaponStatus.filter(w => w.needsUpdate).length
            }
        };
    }
    
    /**
     * 强制同步所有武器解锁状态（用于修复数据不一致问题）
     */
    public async forceSyncWeaponUnlocks() {
        if (!this.saveDataManager || !this.weaponsConfig) {
            console.error('[UpgradeController] 无法强制同步：数据管理器或武器配置未初始化');
            return false;
        }
        
        const maxUnlockedLevel = this.saveDataManager.getMaxUnlockedLevel();
        let syncCount = 0;
        
        console.log(`[UpgradeController] 开始强制同步武器解锁状态，基于最大解锁关卡: ${maxUnlockedLevel}`);
        
        for (const weaponConfig of this.weaponsConfig.weapons) {
            const weaponId = weaponConfig.id;
            const weaponData = this.saveDataManager.getWeapon(weaponId);
            const requiredLevel = this.getWeaponUnlockLevelById(weaponId);
            const shouldBeUnlocked = maxUnlockedLevel >= requiredLevel;
            const isCurrentlyUnlocked = weaponData && weaponData.level > 0;
            
            if (shouldBeUnlocked && !isCurrentlyUnlocked && weaponData) {
                weaponData.level = 1;
                // 由于WeaponData类型中没有unlockTime属性,暂时注释掉这行代码
                // weaponData.unlockTime = weaponData.unlockTime || Date.now();
                syncCount++;
                console.log(`[UpgradeController] 强制解锁武器: ${weaponConfig.name} (${weaponId})`);
            }
        }
        
        if (syncCount > 0) {
            this.saveDataManager.savePlayerData();
            await this.refreshWeaponList();
            console.log(`[UpgradeController] 强制同步完成，解锁了 ${syncCount} 个武器`);
        } else {
            console.log(`[UpgradeController] 强制同步完成，没有需要更新的武器`);
        }
        
        return syncCount > 0;
    }
    
    /**
     * 诊断武器解锁问题（用于调试）
     */
    public diagnoseWeaponUnlockIssue() {
        console.log('=== 武器解锁问题诊断 ===');
        
        if (!this.saveDataManager) {
            console.error('SaveDataManager未初始化');
            return;
        }
        
        if (!this.weaponsConfig) {
            console.error('武器配置未加载');
            return;
        }
        
        const currentLevel = this.saveDataManager.getCurrentLevel();
        const maxUnlockedLevel = this.saveDataManager.getMaxUnlockedLevel();
        const playerData = this.saveDataManager.getPlayerData();
        
        console.log(`当前关卡: ${currentLevel}`);
        console.log(`最大解锁关卡: ${maxUnlockedLevel}`);
        console.log(`金钱: ${playerData?.money || 0}`);
        
        console.log('\n=== 关卡完成状态 ===');
        for (let i = 1; i <= 5; i++) {
            const progress = this.saveDataManager.getLevelProgress(i);
            const isCompleted = this.saveDataManager.isLevelCompleted(i);
            console.log(`关卡${i}: 完成=${isCompleted}, 尝试次数=${progress?.attempts || 0}`);
        }
        
        console.log('\n=== 武器解锁状态 ===');
        
        for (const weaponConfig of this.weaponsConfig.weapons) {
            const weaponId = weaponConfig.id;
            const weaponData = this.saveDataManager.getWeapon(weaponId);
            const requiredLevel = this.getWeaponUnlockLevelById(weaponId);
            const shouldBeUnlocked = maxUnlockedLevel >= requiredLevel;
            const isCurrentlyUnlocked = weaponData && weaponData.level > 0;
            
            console.log(`${weaponConfig.name} (${weaponId}):`);
            console.log(`  需要关卡: ${requiredLevel}`);
            console.log(`  应该解锁: ${shouldBeUnlocked}`);
            console.log(`  当前状态: ${isCurrentlyUnlocked ? '已解锁' : '未解锁'}`);
            console.log(`  武器等级: ${weaponData?.level || 0}`);
            
            if (shouldBeUnlocked && !isCurrentlyUnlocked) {
                console.log(`  ❌ 问题：应该解锁但未解锁`);
            } else if (shouldBeUnlocked && isCurrentlyUnlocked) {
                console.log(`  ✅ 正常：已正确解锁`);
            } else {
                console.log(`  ⏳ 等待：尚未达到解锁条件`);
            }
        }
        
        console.log('\n=== 修复建议 ===');
        console.log('如果发现武器解锁状态不正确，请运行以下命令：');
        console.log('1. 在控制台运行: window.upgradeController.forceSyncWeaponUnlocks()');
        console.log('2. 或者刷新页面重新初始化');
        
        // 将实例暴露到全局，方便调试
        (window as any).upgradeController = this;
    }
    
    /**
     * 货币变化事件处理
     */
    private onCurrencyChanged() {
        console.log('[UpgradeController] 货币发生变化，检查升级按钮闪烁状态');
        // 如果升级面板打开，更新闪烁状态
        if (this.upgradePanel && this.upgradePanel.active && this.currentSelectedWeapon) {
            this.updateUpgradeBtnBlinkState();
        }
    }
    
    /**
     * 更新升级按钮闪烁状态
     */
    private updateUpgradeBtnBlinkState() {
        if (!this.weaponUpgradeAni || !this.currentSelectedWeapon) {
            return;
        }
        
        const weaponConfig = this.weaponsConfig.weapons.find(w => w.id === this.currentSelectedWeapon);
        const weaponData = this.saveDataManager.getWeapon(this.currentSelectedWeapon);
        
        if (!weaponConfig || !weaponData) {
            return;
        }
        
        const maxLevel = weaponConfig.upgradeConfig?.maxLevel || 10;
        
        // 如果武器已达到最大等级，停止闪烁
        if (weaponData.level >= maxLevel) {
            this.weaponUpgradeAni.stopUpgradeBtnBlink();
            console.log(`[UpgradeController] 武器已满级，停止闪烁: ${this.currentSelectedWeapon}`);
            return;
        }
        
        // 检查钞票是否足够升级
        const canUpgrade = this.saveDataManager.canUpgradeWeapon(this.currentSelectedWeapon);
        
        if (canUpgrade) {
            // 钞票足够，开始闪烁
            if (!this.weaponUpgradeAni.isUpgradeBtnBlinking()) {
                this.weaponUpgradeAni.startUpgradeBtnBlink();
                console.log(`[UpgradeController] 钞票足够，开始闪烁: ${this.currentSelectedWeapon}`);
            }
        } else {
            // 钞票不够，停止闪烁
            if (this.weaponUpgradeAni.isUpgradeBtnBlinking()) {
                this.weaponUpgradeAni.stopUpgradeBtnBlink();
                console.log(`[UpgradeController] 钞票不足，停止闪烁: ${this.currentSelectedWeapon}`);
            }
        }
    }
    
    /**
     * 组件销毁时清理事件监听
     */
    onDestroy() {
        EventBus.getInstance().off(GameEvents.GAME_SUCCESS, this.onLevelComplete, this);
        EventBus.getInstance().off(GameEvents.CURRENCY_CHANGED, this.onCurrencyChanged, this);
    }
}