import { _decorator, Component, Node, Prefab, instantiate, resources, Vec3 } from 'cc';
import { GroundBurnArea } from './GroundBurnArea';
import { HitEffectConfig } from '../../Core/ConfigManager';
import { WeaponBullet } from '../WeaponBullet';
import { PhysicsManager } from '../../Core/PhysicsManager';
const { ccclass, property } = _decorator;

/**
 * 地面燃烧区域管理器
 * 单例模式，统一管理所有地面燃烧区域的创建和销毁
 */
@ccclass('GroundBurnAreaManager')
export class GroundBurnAreaManager extends Component {
    private static _instance: GroundBurnAreaManager = null;
    
    @property({
        type: Node,
        tooltip: '游戏区域节点，燃烧区域将在此节点下创建'
    })
    public gameArea: Node = null;
    
    @property({
        type: Prefab,
        tooltip: '地面燃烧区域预制体'
    })
    public groundBurnAreaPrefab: Prefab = null;
    
    
    private activeBurnAreas: Node[] = [];
    
    /**
     * 组件加载时设置单例
     */
    protected onLoad(): void {
        if (GroundBurnAreaManager._instance === null) {
            GroundBurnAreaManager._instance = this;
            console.log('[GroundBurnAreaManager] 单例初始化成功');
        } else {
            console.warn('[GroundBurnAreaManager] 单例已存在，销毁重复实例');
            this.node.destroy();
        }
    }
    
    /**
     * 组件启动时验证配置
     */
    protected start(): void {
        if (!this.gameArea) {
            console.error('[GroundBurnAreaManager] gameArea未设置，请在Inspector中拖拽GameArea节点');
        }
        if (!this.groundBurnAreaPrefab) {
            console.error('[GroundBurnAreaManager] groundBurnAreaPrefab未设置，请在Inspector中拖拽GroundBurnArea预制体');
        }

        console.log('[GroundBurnAreaManager] 管理器配置验证完成');
    }
    
    onDestroy() {
        if (GroundBurnAreaManager._instance === this) {
            GroundBurnAreaManager._instance = null;
        }
        
        // 清理所有活跃的燃烧区域
        this.clearAllBurnAreas();
    }
    
    /**
     * 获取单例实例
     */
    public static getInstance(): GroundBurnAreaManager | null {
        return GroundBurnAreaManager._instance;
    }
    
    /**
     * 创建地面燃烧区域
     * @param position 燃烧区域位置
     * @param effect 效果配置
     * @param weaponBullet 武器子弹组件（用于获取最终伤害）
     * @param defaultBurnEffectPath 默认燃烧特效路径
     */
    public createGroundBurnArea(
        position: Vec3, 
        effect: HitEffectConfig, 
        weaponBullet: WeaponBullet | null,
        defaultBurnEffectPath?: string
    ): Node | null {
        if (!this.groundBurnAreaPrefab) {
            console.error('[GroundBurnAreaManager] 地面燃烧区域预制体未设置');
            return null;
        }
        
        if (!this.gameArea) {
            console.error('[GroundBurnAreaManager] 游戏区域节点未设置');
            return null;
        }
        
        // 检查物理系统状态
        const physicsManager = PhysicsManager.getInstance();
        if (!physicsManager) {
            console.warn('[GroundBurnAreaManager] 物理系统未初始化，无法创建燃烧区域');
            return null;
        }

        const physicsSystem = physicsManager.getSystem();
        if (!physicsSystem || !physicsSystem.enable) {
            console.warn('[GroundBurnAreaManager] 物理系统未启用，无法创建燃烧区域');
            return null;
        }
        
        try {
            // 实例化预制体
            const burnAreaNode = instantiate(this.groundBurnAreaPrefab);

             // 添加到游戏区域
            this.gameArea.addChild(burnAreaNode);
            
            // 获取地面燃烧区域组件
            const groundBurnArea = burnAreaNode.getComponent(GroundBurnArea);
            if (!groundBurnArea) {
                console.error('[GroundBurnAreaManager] 预制体中未找到 GroundBurnArea 组件');
                burnAreaNode.destroy();
                return null;
            }
            
            // 计算燃烧伤害：DPS = (effect.damage 或 5) + 武器等级；每次伤害 = DPS * tickInterval
            const weaponId = weaponBullet?.getWeaponConfig()?.id || 'unknown';
            const weaponLevel = weaponBullet?.getWeaponInfo()?.getWeaponLevel?.() ?? 1;
            const baseDps = (typeof effect.damage === 'number' ? effect.damage : 5);
            const tickInterval = (typeof effect.tickInterval === 'number' ? effect.tickInterval : 0.5);
            const burnDps = baseDps + weaponLevel;
            const perTickDamage = Math.max(0, burnDps * tickInterval);

            console.log(`[GroundBurnAreaManager] 计算燃烧伤害: weapon=${weaponId}, level=${weaponLevel}, baseDPS=${baseDps}, tick=${tickInterval}, DPS=${burnDps}, perTick=${perTickDamage.toFixed(2)}`);
            
            // 初始化燃烧区域
            groundBurnArea.initGroundBurnArea(
                position,
                effect.duration || 3,
                perTickDamage,
                tickInterval
            );
            
            // 添加到活跃列表
            this.activeBurnAreas.push(burnAreaNode);
            
            console.log(`[GroundBurnAreaManager] 地面燃烧区域已创建，位置: (${position.x.toFixed(1)}, ${position.y.toFixed(1)})`);
            
            return burnAreaNode;
            
        } catch (error) {
            console.error('[GroundBurnAreaManager] 创建地面燃烧区域失败:', error);
            return null;
        }
    }
    

    
    /**
     * 移除燃烧区域
     */
    public removeBurnArea(burnAreaNode: Node) {
        const index = this.activeBurnAreas.indexOf(burnAreaNode);
        if (index !== -1) {
            this.activeBurnAreas.splice(index, 1);
            console.log(`[GroundBurnAreaManager] 燃烧区域已从活跃列表中移除`);
        }
    }
    
    /**
     * 清理所有燃烧区域
     */
    public clearAllBurnAreas() {
        console.log(`[GroundBurnAreaManager] 清理所有燃烧区域，数量: ${this.activeBurnAreas.length}`);
        
        for (const burnArea of this.activeBurnAreas) {
            if (burnArea && burnArea.isValid) {
                const groundBurnArea = burnArea.getComponent(GroundBurnArea);
                if (groundBurnArea) {
                    groundBurnArea.destroyBurnArea();
                } else {
                    burnArea.destroy();
                }
            }
        }
        
        this.activeBurnAreas = [];
    }
    
    /**
     * 获取活跃燃烧区域数量
     */
    public getActiveBurnAreaCount(): number {
        return this.activeBurnAreas.length;
    }
    
    /**
     * 获取所有活跃的燃烧区域
     */
    public getActiveBurnAreas(): Node[] {
        return [...this.activeBurnAreas];
    }
}