tanqiu/assets/scripts/Core/ConfigManager.ts

import { _decorator, resources, JsonAsset } from 'cc';
import { BaseSingleton } from './BaseSingleton';
import { JsonConfigLoader } from './JsonConfigLoader';
import { BundleLoader } from './BundleLoader';
const { ccclass, property } = _decorator;

// 局内金币花费配置接口
export interface InGameCostConfig {
    baseCost: number;
    shapeCosts: {
        [shapeId: string]: number;
    };
}

// 弹道配置接口
export interface BulletTrajectoryConfig {
    type: string;
    speed: number;
    gravity: number;
    arcHeight: number;
    homingStrength: number;
    homingDelay: number;
    rotateSpeed?: number;  // 旋转速率 (0~1)，仅在 arc 弹道中使用
}

// 弹药数量配置接口
export interface BulletCountConfig {
    type: string;
    amount: number;
    spreadAngle: number;
    burstCount: number;
    burstDelay: number;
}

// 命中效果配置接口
export interface HitEffectConfig {
    type: string;
    priority: number;
    damage?: number;
    pierceCount?: number;
    radius?: number;
    delay?: number;
    duration?: number;
    tickInterval?: number;
    ricochetCount?: number;
    ricochetAngle?: number;
    [key: string]: any;
}

// 弹药生命周期配置接口
export interface BulletLifecycleConfig {
    type: string;
    maxLifetime: number;
    penetration: number;
    ricochetCount: number;
    returnToOrigin: boolean;
    returnDelay?: number;     // 返回延迟（秒）
    maxRange?: number;        // 最大射程
    effectDuration?: number;  // 效果持续时间（用于地面效果）
}

// 武器配置接口
export interface WeaponConfig {
    id: string;
    name: string;
    type: string;
    rarity?: string; // 可选字段，支持动态稀有度（合成时可变）
    stats: {
        damage: number;
        fireRate: number;
        range: number;
        bulletSpeed: number;
        accuracy?: number;
    };
    bulletConfig: {
        count: BulletCountConfig;
        trajectory: BulletTrajectoryConfig;
        hitEffects: HitEffectConfig[];
        lifecycle: BulletLifecycleConfig;
        visual: {
            bulletImages: string;
            hitEffect: string;
            trailEffect?: string;
            explosionEffect?: string;
        };
        shouldRotate?: boolean; // 是否旋转，默认为true
    };
    visualConfig: {
        weaponSprites: {
            [shapeId: string]: string;
        };
        attackSound: string;
    };
    upgradeConfig: {
        maxLevel: number;
        levels: {
            [level: string]: {
                cost: number;
                damage?: number;
            };
        };
    };
    rarityDamageMultipliers?: number[]; // 稀有度伤害倍率数组
    // 运行时计算的实际数值（应用技能加成后）
    runtimeStats?: {
        finalDamage: number;
        finalCritDamage: number;
        critChance: number;
    };
    inGameCostConfig?: InGameCostConfig;
}

// 球控制器配置接口
export interface BallControllerConfig {
    baseSpeed: number;
    maxReflectionRandomness: number;
    antiTrapTimeWindow: number;
    antiTrapHitThreshold: number;
    deflectionAttemptThreshold: number;
    antiTrapDeflectionMultiplier: number;
    FIRE_COOLDOWN: number;
    ballRadius: number;
    gravityScale: number;
    linearDamping: number;
    angularDamping: number;
    colliderGroup: number;
    colliderTag: number;
    friction: number;
    restitution: number;
    safeDistance: number;
    edgeOffset: number;
    sensor: boolean;
    maxAttempts: number;
}

// 敌人配置接口
export interface EnemyConfig {
    id: string;
    name: string;
    type: string;
    stats: {
        health: number;
        maxHealth: number;
        defense: number;
        speed: number;
        dropEnergy: number;
    };
    movement: {
        pattern: string;
        speed: number;
        patrolRange: number;
        rotationSpeed: number;
        moveType: string;
        swingAmplitude: number;
        swingFrequency: number;
        speedVariation: number;
    };
    combat: {
        attackDamage: number;
        attackRange: number;
        attackSpeed: number;
        canBlock: boolean;
        blockChance: number;
        blockDamageReduction: number;
        attackCooldown: number;
        attackType: string;
        attackDelay: number;
        weaponType: string;
        projectileType: string;
        projectileSpeed: number;
    };
    visualConfig: {
        spritePath: string;
        scale: number;
        animationSpeed: number;
        flipX: boolean;
        tint: string;
        animations: {
            [state: string]: string;
        };
        weaponProp: string;
    };
    audioConfig: {
        attackSound: string;
        deathSound: string;
        hitSound: string;
        walkSound: string;
        blockSound: string;
        stealthSound: string;
        armorBreakSound: string;
        fuseSound: string;
        volume: number;
    };
    visual?: {
        sprite_path: string;
        scale: number;
        animation_speed: number;
        flip_horizontal: boolean;
        animations: {
            [state: string]: string;
        };
        weapon_prop: string;
    };
    audio?: {
        attack_sound: string;
        death_sound: string;
        hit_sound: string;
        walk_sound: string;
        block_sound: string;
        stealth_sound: string;
        armor_break_sound: string;
        fuse_sound: string;
    };
    boss: {
        is_boss: boolean;
        phases: number;
        rage_threshold: number;
        rage_damage_multiplier: number;
        rage_speed_multiplier: number;
    };
    special_abilities: Array<{
        type: string;
        damage: number;
        range: number;
        cooldown: number;
    }>
}

@ccclass('ConfigManager')
export class ConfigManager extends BaseSingleton {
    // 仅用于类型声明，实例由 BaseSingleton 在运行时动态维护
    public static _instance: ConfigManager;
    
    private weaponsConfig: any = null;
    private enemiesConfig: any = null;
    private configLoaded: boolean = false;
    

    

    /**
     * BaseSingleton 首次实例化回调
     */
    protected init() {
        console.log('[ConfigManager] 开始初始化配置管理器');
        this.loadConfigs();
    }

    // 加载所有配置文件
    private async loadConfigs() {
        console.log('[ConfigManager] 开始加载配置文件');
        this.configLoaded = false;
        
        try {
            // 确保resources bundle已经准备好
            await this.ensureResourcesBundle();
            
            // 加载武器配置
            console.log('[ConfigManager] 开始加载武器配置');
            await this.loadWeaponsConfig();
            console.log('[ConfigManager] 武器配置加载完成');
            
            // 加载敌人配置
            console.log('[ConfigManager] 开始加载敌人配置');
            await this.loadEnemiesConfig();
            console.log('[ConfigManager] 敌人配置加载完成');
            
            // 注意：球控制器配置现在通过BallController组件的装饰器直接加载
            console.log('[ConfigManager] 球控制器配置通过装饰器加载，跳过ConfigManager加载');
            
            this.configLoaded = true;
            console.log('[ConfigManager] ✅ 所有配置文件加载成功，配置管理器初始化完成');
        } catch (error) {
            console.error('[ConfigManager] ❌ 配置文件加载失败:', error);
            this.configLoaded = false;
            
            // 延迟重试加载
            console.log('[ConfigManager] 将在3秒后重试加载配置');
            setTimeout(() => {
                console.log('[ConfigManager] 开始重试加载配置');
                this.loadConfigs();
            }, 3000);
        }
    }

    // 确保data bundle已经准备好
    private async ensureResourcesBundle(): Promise<void> {
        console.log('[ConfigManager] 检查data bundle状态...');
        
        try {
            // 确保BundleLoader已经加载了data bundle
            const bundleLoader = BundleLoader.getInstance();
            await bundleLoader.loadBundle('data');
            console.log('[ConfigManager] data bundle加载完成');
        } catch (error) {
            console.error('[ConfigManager] data bundle加载失败:', error);
            throw error;
        }
    }

    // 加载武器配置
    private async loadWeaponsConfig(): Promise<void> {
        console.log('[ConfigManager] 开始加载武器配置...');
        
        try {
            this.weaponsConfig = await JsonConfigLoader.getInstance().loadConfig('weapons');
            
            // 验证配置完整性
            console.log('[ConfigManager] 验证武器配置完整性...');
            if (!this.weaponsConfig.weapons || !Array.isArray(this.weaponsConfig.weapons)) {
                throw new Error('武器配置格式错误：缺少weapons数组');
            }
            
            console.log(`[ConfigManager] 武器配置加载成功，共${this.weaponsConfig.weapons.length}个武器`);
            
            // 检查blockSizes配置
            if (this.weaponsConfig.blockSizes && Array.isArray(this.weaponsConfig.blockSizes)) {
                console.log(`[ConfigManager] ✅ blockSizes配置加载成功，共${this.weaponsConfig.blockSizes.length}个形状`);
                this.weaponsConfig.blockSizes.forEach(shape => {
                    console.log(`[ConfigManager] - 形状: ${shape.id} (${shape.name})`);
                });
            } else {
                console.warn('[ConfigManager] ⚠️ blockSizes配置缺失或格式错误');
            }
        } catch (error) {
            console.error('[ConfigManager] 武器配置文件加载失败:', error);
            throw error;
        }
    }

    // 加载敌人配置
    private async loadEnemiesConfig(): Promise<void> {
        console.log('[ConfigManager] 开始加载敌人配置...');
        
        try {
            this.enemiesConfig = await JsonConfigLoader.getInstance().loadConfig('enemies');
            
            // 验证配置完整性
            console.log('[ConfigManager] 验证敌人配置完整性...');
            if (!Array.isArray(this.enemiesConfig)) {
                throw new Error('敌人配置格式错误：应该是数组结构');
            }
            
            console.log(`[ConfigManager] ✅ 敌人配置加载成功，共${this.enemiesConfig.length}个敌人`);
            
            // 打印前几个敌人的ID用于调试
            if (this.enemiesConfig.length > 0) {
                const enemyIds = this.enemiesConfig.slice(0, 5).map(enemy => enemy.id);
                console.log(`[ConfigManager] 敌人ID示例: ${enemyIds.join(', ')}${this.enemiesConfig.length > 5 ? '...' : ''}`);
            }
        } catch (error) {
            console.error('[ConfigManager] 敌人配置文件加载失败:', error);
            throw error;
        }
    }

    // 随机获取武器配置
    public getRandomWeapon(): WeaponConfig | null {
        if (!this.weaponsConfig || !this.weaponsConfig.weapons || this.weaponsConfig.weapons.length === 0) {
            console.warn('武器配置未加载或为空');
            return null;
        }

        // 直接从武器列表中随机选择
        const randomIndex = Math.floor(Math.random() * this.weaponsConfig.weapons.length);
        const selectedWeapon = this.weaponsConfig.weapons[randomIndex];
        
        console.log(`随机选择武器: ${selectedWeapon.name}`);
        return selectedWeapon;
    }
    // 随机获取敌人配置（仅作为备用机制，正常情况下敌人类型和数量由关卡JSON配置决定）
    public getRandomEnemy(): EnemyConfig | null {
        // 修复：enemies.json是直接的数组结构，不需要.enemies包装
        if (!this.enemiesConfig || !Array.isArray(this.enemiesConfig) || this.enemiesConfig.length === 0) {
            console.warn('敌人配置未加载或为空');
            return null;
        }

        // 直接从敌人列表中随机选择（仅在关卡配置缺失时使用）
        const randomIndex = Math.floor(Math.random() * this.enemiesConfig.length);
        console.warn('[ConfigManager] 使用随机敌人选择，这通常表示关卡配置存在问题');
        return this.enemiesConfig[randomIndex];
    }

    // 根据ID获取武器配置
    public getWeaponById(id: string): WeaponConfig | null {
        if (!this.weaponsConfig) return null;
        return this.weaponsConfig.weapons.find(weapon => weapon.id === id) || null;
    }

    // 根据ID获取敌人配置
    public getEnemyById(id: string): EnemyConfig | null {
        // 修复：enemies.json是直接的数组结构，不需要.enemies包装
        if (!this.enemiesConfig || !Array.isArray(this.enemiesConfig)) return null;
        return this.enemiesConfig.find(enemy => enemy.id === id) || null;
    }

    /**
     * 获取敌人名称到ID的映射
     */
    public getNameToIdMapping(): { [key: string]: string } | null {
        if (!this.enemiesConfig) return null;
        return this.enemiesConfig.nameToIdMapping || null;
    }

    // 获取所有武器配置
    public getAllWeapons(): WeaponConfig[] {
        return this.weaponsConfig?.weapons || [];
    }

    // 获取所有敌人配置
    public getAllEnemies(): EnemyConfig[] {
        // 修复：enemies.json是直接的数组结构，不需要.enemies包装
        return Array.isArray(this.enemiesConfig) ? this.enemiesConfig : [];
    }

    // 根据稀有度获取武器列表（已废弃，武器稀有度现在通过方块合成系统管理）
    public getWeaponsByRarity(rarity: string): WeaponConfig[] {
        console.warn('[ConfigManager] getWeaponsByRarity已废弃，武器稀有度现在通过方块合成系统管理');
        return [];
    }

    // 获取完整的武器配置对象
    public getWeaponsConfig(): any {
        return this.weaponsConfig;
    }

    // 获取方块尺寸列表（已更新为形状ID）
    public getBlockSizes(): string[] {
        if (!this.weaponsConfig || !this.weaponsConfig.blockSizes) {
            return ['I', 'H-I', 'L', 'S', 'D-T'];
        }
        // 从blockSizes配置中提取形状ID
        return this.weaponsConfig.blockSizes.map((shape: any) => shape.id);
    }
    
    // 获取方块形状配置列表
    public getBlockShapes(): any[] {
        if (!this.weaponsConfig) {
            console.warn('[ConfigManager] 武器配置未加载，无法获取方块形状配置');
            console.warn('[ConfigManager] 配置加载状态:', this.configLoaded);
            return [];
        }
        
        if (!this.weaponsConfig.blockSizes) {
            console.warn('[ConfigManager] 方块形状配置(blockSizes)未找到');
            console.warn('[ConfigManager] 可用的配置字段:', Object.keys(this.weaponsConfig));
            return [];
        }
        
        if (!Array.isArray(this.weaponsConfig.blockSizes)) {
            console.error('[ConfigManager] blockSizes不是数组格式:', typeof this.weaponsConfig.blockSizes);
            return [];
        }
        
        console.log(`[ConfigManager] 成功获取${this.weaponsConfig.blockSizes.length}个方块形状配置`);
        return this.weaponsConfig.blockSizes;
    }

    // 获取波次进展配置（已废弃，波次配置现在通过关卡系统管理）
    public getWaveProgression(): any {
        console.warn('[ConfigManager] getWaveProgression已废弃，波次配置现在通过关卡系统管理');
        return {};
    }

    // 根据波次获取合适的敌人（简化版本，直接返回随机敌人）
    public getEnemyForWave(waveNumber: number): EnemyConfig | null {
        // 修复：波次配置现在通过关卡系统管理，这里简化为返回随机敌人
        // 具体的波次敌人配置由EnemyController通过关卡配置处理
        console.log(`[ConfigManager] 为波次 ${waveNumber} 获取随机敌人`);
        return this.getRandomEnemy();
    }

    // 检查配置是否已加载
    public isConfigLoaded(): boolean {
        return this.configLoaded;
    }

    // 获取球控制器配置
    // getBallControllerConfig方法已移除，球控制器配置现在通过装饰器直接在BallController中加载
}