/*
 * 强化系统测试脚本
 * 用于验证强化系统是否正常工作
 */

import { 
    getRandomEnhancementOptions, 
    getLevelAdjustedEnhancementOptions,
    getEnhancementOptionByType,
    EnhancementType,
    EnhancementOptions,
    EnhancementQualityWeight
} from "./LevelUpEnhancement"
import { Quality } from "./CardSet"

// 测试函数
export function testEnhancementSystem(): void {
    console.log("=== 强化系统测试开始 ===");
    
    // 测试1: 基础随机生成
    testBasicRandomGeneration();
    
    // 测试2: 等级调整功能
    testLevelAdjustment();
    
    // 测试3: 特定选项获取
    testSpecificOptionRetrieval();
    
    // 测试4: 品质权重验证
    testQualityWeights();
    
    // 测试5: 配置完整性
    testConfigurationIntegrity();
    
    console.log("=== 强化系统测试完成 ===");
}

// 测试基础随机生成
function testBasicRandomGeneration(): void {
    console.log("\n--- 测试基础随机生成 ---");
    
    try {
        const options = getRandomEnhancementOptions(3);
        console.log(`✓ 成功生成 ${options.length} 个强化选项`);
        
        options.forEach((option, index) => {
            console.log(`  选项 ${index + 1}: ${option.name} (${option.rarity}) - ${option.description}`);
        });
        
        // 验证选项完整性
        options.forEach(option => {
            if (!option.name || !option.description || !option.buffType || !option.value) {
                throw new Error(`选项数据不完整: ${JSON.stringify(option)}`);
            }
        });
        
        console.log("✓ 所有选项数据完整");
        
    } catch (error) {
        console.error("✗ 基础随机生成测试失败:", error);
    }
}

// 测试等级调整功能
function testLevelAdjustment(): void {
    console.log("\n--- 测试等级调整功能 ---");
    
    try {
        const testLevels = [1, 10, 20, 30];
        
        testLevels.forEach(level => {
            const options = getLevelAdjustedEnhancementOptions(level, 3);
            console.log(`✓ 等级 ${level} 生成 ${options.length} 个选项`);
            
            // 验证高等级是否有更多稀有品质
            const rareCount = options.filter(option => 
                option.rarity === "rare" || 
                option.rarity === "epic" || 
                option.rarity === "legendary"
            ).length;
            
            console.log(`  稀有品质数量: ${rareCount}`);
        });
        
        console.log("✓ 等级调整功能正常");
        
    } catch (error) {
        console.error("✗ 等级调整功能测试失败:", error);
    }
}

// 测试特定选项获取
function testSpecificOptionRetrieval(): void {
    console.log("\n--- 测试特定选项获取 ---");
    
    try {
        // 测试攻击力强化
        const attackWhite = getEnhancementOptionByType(EnhancementType.ATTACK, Quality.WHITE);
        const attackBlue = getEnhancementOptionByType(EnhancementType.ATTACK, Quality.BLUE);
        
        if (attackWhite && attackBlue) {
            console.log(`✓ 攻击力强化选项获取成功`);
            console.log(`  白色: ${attackWhite.name} - ${attackWhite.description}`);
            console.log(`  蓝色: ${attackBlue.name} - ${attackBlue.description}`);
        } else {
            throw new Error("无法获取攻击力强化选项");
        }
        
        // 测试生命值强化
        const healthPurple = getEnhancementOptionByType(EnhancementType.HEALTH, Quality.PURPLE);
        if (healthPurple) {
            console.log(`✓ 生命值强化选项获取成功: ${healthPurple.name}`);
        }
        
        // 测试攻击速度强化
        const speedOrange = getEnhancementOptionByType(EnhancementType.ATTACK_SPEED, Quality.ORANGE);
        if (speedOrange) {
            console.log(`✓ 攻击速度强化选项获取成功: ${speedOrange.name}`);
        }
        
        console.log("✓ 特定选项获取功能正常");
        
    } catch (error) {
        console.error("✗ 特定选项获取测试失败:", error);
    }
}

// 测试品质权重验证
function testQualityWeights(): void {
    console.log("\n--- 测试品质权重验证 ---");
    
    try {
        const totalWeight = Object.values(EnhancementQualityWeight).reduce((sum, weight) => sum + weight, 0);
        
        if (Math.abs(totalWeight - 1.0) < 0.001) {
            console.log(`✓ 品质权重总和为 1.0 (实际: ${totalWeight.toFixed(3)})`);
        } else {
            throw new Error(`品质权重总和不为 1.0: ${totalWeight}`);
        }
        
        // 验证权重分布
        console.log("品质权重分布:");
        Object.entries(EnhancementQualityWeight).forEach(([quality, weight]) => {
            const qualityName = getQualityName(parseInt(quality));
            console.log(`  ${qualityName}: ${(weight * 100).toFixed(1)}%`);
        });
        
        console.log("✓ 品质权重验证通过");
        
    } catch (error) {
        console.error("✗ 品质权重验证失败:", error);
    }
}

// 测试配置完整性
function testConfigurationIntegrity(): void {
    console.log("\n--- 测试配置完整性 ---");
    
    try {
        const enhancementTypes = Object.values(EnhancementType);
        const qualities = [Quality.WHITE, Quality.GREEN, Quality.BLUE, Quality.PURPLE, Quality.ORANGE];
        
        let totalOptions = 0;
        let missingOptions = 0;
        
        enhancementTypes.forEach(type => {
            qualities.forEach(quality => {
                totalOptions++;
                const option = EnhancementOptions[type]?.[quality];
                if (!option) {
                    missingOptions++;
                    console.log(`  缺失: 类型${type} 品质${quality}`);
                }
            });
        });
        
        console.log(`✓ 总选项数: ${totalOptions}`);
        console.log(`✓ 缺失选项数: ${missingOptions}`);
        console.log(`✓ 完整度: ${((totalOptions - missingOptions) / totalOptions * 100).toFixed(1)}%`);
        
        if (missingOptions === 0) {
            console.log("✓ 配置完整性验证通过");
        } else {
            console.log("⚠ 存在缺失配置，但不影响基本功能");
        }
        
    } catch (error) {
        console.error("✗ 配置完整性测试失败:", error);
    }
}

// 辅助函数：获取品质名称
function getQualityName(quality: number): string {
    switch (quality) {
        case Quality.WHITE: return "白色";
        case Quality.GREEN: return "绿色";
        case Quality.BLUE: return "蓝色";
        case Quality.PURPLE: return "紫色";
        case Quality.ORANGE: return "橙色";
        default: return "未知";
    }
}

// 性能测试
export function testPerformance(): void {
    console.log("\n=== 性能测试开始 ===");
    
    const iterations = 1000;
    const startTime = Date.now();
    
    for (let i = 0; i < iterations; i++) {
        getRandomEnhancementOptions(3);
    }
    
    const endTime = Date.now();
    const duration = endTime - startTime;
    
    console.log(`生成 ${iterations} 次强化选项耗时: ${duration}ms`);
    console.log(`平均每次耗时: ${(duration / iterations).toFixed(2)}ms`);
    
    if (duration < 1000) {
        console.log("✓ 性能测试通过");
    } else {
        console.log("⚠ 性能较慢，建议优化");
    }
}

// 导出测试函数
export function runAllTests(): void {
    testEnhancementSystem();
    testPerformance();
}