/**
 * 墙体血量为0失败场景调试测试
 * 模拟实际游戏中墙体血量为0的情况，检查GameEnd动画是否正常触发
 */

// 模拟事件系统
class MockEventBus {
    constructor() {
        this.listeners = new Map();
        this.eventLog = [];
    }
    
    on(event, callback, context) {
        if (!this.listeners.has(event)) {
            this.listeners.set(event, []);
        }
        this.listeners.get(event).push({ callback, context });
        console.log(`[EventBus] 注册事件监听器: ${event}`);
    }
    
    emit(event, ...args) {
        console.log(`[EventBus] 触发事件: ${event}`);
        this.eventLog.push({ event, timestamp: Date.now(), args });
        
        if (this.listeners.has(event)) {
            const listeners = this.listeners.get(event);
            listeners.forEach(({ callback, context }) => {
                try {
                    callback.call(context, ...args);
                } catch (error) {
                    console.error(`[EventBus] 事件处理错误 ${event}:`, error);
                }
            });
        }
    }
    
    getEventLog() {
        return this.eventLog;
    }
}

// 模拟GameEvents
const GameEvents = {
    GAME_DEFEAT: 'GAME_DEFEAT',
    GAME_RESUME: 'GAME_RESUME',
    GAME_START: 'GAME_START'
};

// 模拟Wall组件
class MockWall {
    constructor(eventBus) {
        this.eventBus = eventBus;
        this.currentHealth = 100;
        this.maxHealth = 100;
    }
    
    takeDamage(damage) {
        console.log(`[Wall] 受到伤害: ${damage}, 当前血量: ${this.currentHealth}`);
        this.currentHealth -= damage;
        
        if (this.currentHealth <= 0) {
            console.log('[Wall] 墙体血量为0，调用onWallDestroyed');
            this.onWallDestroyed();
        }
    }
    
    onWallDestroyed() {
        console.log('[Wall] 墙体被摧毁，触发GAME_DEFEAT事件');
        this.eventBus.emit(GameEvents.GAME_DEFEAT);
    }
}

// 模拟GameEnd组件
class MockGameEnd {
    constructor(eventBus) {
        this.eventBus = eventBus;
        this.animationCount = 0;
        this.isVisible = false;
        this.setupEventListeners();
    }
    
    setupEventListeners() {
        console.log('[GameEnd] 设置事件监听器');
        this.eventBus.on(GameEvents.GAME_DEFEAT, this.onGameDefeat, this);
        this.eventBus.on(GameEvents.GAME_START, this.onGameStart, this);
    }
    
    onGameDefeat() {
        console.log('[GameEnd] 接收到GAME_DEFEAT事件');
        console.log('[GameEnd] 游戏失败事件处理，开始统一处理流程');
        
        // 模拟GameEnd的处理逻辑
        this.calculateAndShowRewards();
    }
    
    calculateAndShowRewards() {
        console.log('[GameEnd] 计算和显示奖励');
        this.showEndPanelWithAnimation();
    }
    
    showEndPanelWithAnimation() {
        console.log('[GameEnd] 开始显示结算面板动画');
        this.animationCount++;
        this.isVisible = true;
        console.log(`[GameEnd] GameEnd面板弹出动画第${this.animationCount}次执行`);
    }
    
    onGameStart() {
        console.log('[GameEnd] 收到游戏开始事件，重置奖励显示');
        this.animationCount = 0;
        this.isVisible = false;
    }
    
    getStatus() {
        return {
            animationCount: this.animationCount,
            isVisible: this.isVisible
        };
    }
}

// 模拟其他可能干扰的组件
class MockGameManager {
    constructor(eventBus) {
        this.eventBus = eventBus;
        this.gameState = 'PLAYING';
        this.setupEventListeners();
    }
    
    setupEventListeners() {
        this.eventBus.on(GameEvents.GAME_DEFEAT, this.onGameDefeat, this);
    }
    
    onGameDefeat() {
        console.log('[GameManager] 接收到GAME_DEFEAT事件');
        this.gameState = 'DEFEAT';
        console.log('[GameManager] 游戏状态切换为DEFEAT');
    }
}

// 模拟InGameManager
class MockInGameManager {
    constructor(eventBus) {
        this.eventBus = eventBus;
        this.currentState = 'PLAYING';
        this.setupEventListeners();
    }
    
    setupEventListeners() {
        this.eventBus.on(GameEvents.GAME_DEFEAT, this.onGameDefeat, this);
    }
    
    onGameDefeat() {
        console.log('[InGameManager] 接收到GAME_DEFEAT事件');
        this.currentState = 'DEFEAT';
        console.log('[InGameManager] 游戏状态切换为DEFEAT');
    }
    
    getCurrentState() {
        return this.currentState;
    }
}

// 测试函数
function testWallDefeatScenario() {
    console.log('\n=== 墙体血量为0失败场景测试 ===');
    
    // 创建事件系统
    const eventBus = new MockEventBus();
    
    // 创建组件
    const wall = new MockWall(eventBus);
    const gameEnd = new MockGameEnd(eventBus);
    const gameManager = new MockGameManager(eventBus);
    const inGameManager = new MockInGameManager(eventBus);
    
    console.log('\n--- 初始状态 ---');
    console.log('墙体血量:', wall.currentHealth);
    console.log('GameEnd状态:', gameEnd.getStatus());
    
    console.log('\n--- 模拟墙体受到致命伤害 ---');
    wall.takeDamage(100); // 造成致命伤害
    
    console.log('\n--- 检查结果 ---');
    const gameEndStatus = gameEnd.getStatus();
    console.log('GameEnd动画执行次数:', gameEndStatus.animationCount);
    console.log('GameEnd是否可见:', gameEndStatus.isVisible);
    console.log('GameManager状态:', gameManager.gameState);
    console.log('InGameManager状态:', inGameManager.getCurrentState());
    
    console.log('\n--- 事件日志 ---');
    const eventLog = eventBus.getEventLog();
    eventLog.forEach((log, index) => {
        console.log(`${index + 1}. 事件: ${log.event}, 时间: ${new Date(log.timestamp).toLocaleTimeString()}`);
    });
    
    console.log('\n--- 测试结果分析 ---');
    if (gameEndStatus.animationCount === 1 && gameEndStatus.isVisible) {
        console.log('✅ 墙体血量为0成功触发GameEnd动画');
    } else if (gameEndStatus.animationCount === 0) {
        console.log('❌ 墙体血量为0未触发GameEnd动画');
    } else if (gameEndStatus.animationCount > 1) {
        console.log(`❌ GameEnd动画被重复触发${gameEndStatus.animationCount}次`);
    }
    
    const defeatEvents = eventLog.filter(log => log.event === GameEvents.GAME_DEFEAT);
    console.log(`GAME_DEFEAT事件触发次数: ${defeatEvents.length}`);
    
    const resumeEvents = eventLog.filter(log => log.event === GameEvents.GAME_RESUME);
    console.log(`GAME_RESUME事件触发次数: ${resumeEvents.length}`);
    
    return {
        success: gameEndStatus.animationCount === 1 && gameEndStatus.isVisible,
        animationCount: gameEndStatus.animationCount,
        defeatEventCount: defeatEvents.length,
        resumeEventCount: resumeEvents.length
    };
}

// 运行测试
const result = testWallDefeatScenario();
console.log('\n=== 最终测试结果 ===');
console.log('测试通过:', result.success);
console.log('动画执行次数:', result.animationCount);
console.log('GAME_DEFEAT事件次数:', result.defeatEventCount);
console.log('GAME_RESUME事件次数:', result.resumeEventCount);

if (result.success) {
    console.log('\n🎉 墙体血量为0的失败处理流程正常工作！');
} else {
    console.log('\n⚠️  墙体血量为0的失败处理流程存在问题，需要进一步调试。');
}