import { _decorator, Component, Node, Sprite, SpriteFrame, resources, find, assetManager } from 'cc';
import { LevelConfigManager } from './LevelConfigManager';
import { SaveDataManager } from './SaveDataManager';
import EventBus, { GameEvents } from '../Core/EventBus';
import { BundleLoader } from '../Core/BundleLoader';
import { ResourcePreloader } from '../Core/ResourcePreloader';

const { ccclass, property } = _decorator;

/**
 * 背景管理器 - 负责根据关卡配置动态设置游戏背景
 */
@ccclass('BackgroundManager')
export class BackgroundManager extends Component {
    @property(Node)
    backgroundNode: Node = null; // Canvas/GameLevelUI/Background节点

    private backgroundSprite: Sprite = null;
    private levelConfigManager: LevelConfigManager = null;
    private saveDataManager: SaveDataManager = null;
    private bundleLoader: BundleLoader = null;
    private resourcePreloader: ResourcePreloader = null;

    onLoad() {
        // 获取关卡配置管理器
        this.levelConfigManager = LevelConfigManager.getInstance();
        // 获取SaveDataManager实例
        this.saveDataManager = SaveDataManager.getInstance();
        // 获取BundleLoader实例
        this.bundleLoader = BundleLoader.getInstance();
        // 获取ResourcePreloader实例
        this.resourcePreloader = ResourcePreloader.getInstance();
        // 监听关卡开始事件
        EventBus.getInstance().on(GameEvents.GAME_START, this.onGameStart, this);
    }

    start() {
        this.initBackgroundSprite();
    }

    /**
     * 初始化背景Sprite组件
     */
    private initBackgroundSprite() {
        // 如果编辑器中没有设置backgroundNode，尝试自动查找
        if (!this.backgroundNode) {
            this.backgroundNode = find('Canvas/GameLevelUI/Background');
            if (!this.backgroundNode) {
                console.warn('[BackgroundManager] 未找到Canvas/GameLevelUI/Background节点，请检查节点路径');
                return;
            }
        }

        // 获取Sprite组件
        this.backgroundSprite = this.backgroundNode.getComponent(Sprite);
        if (!this.backgroundSprite) {
            console.warn('[BackgroundManager] 背景节点上未找到Sprite组件，请为节点添加Sprite组件');
        } else {
            console.log('[BackgroundManager] 背景Sprite组件初始化成功');
        }
    }



    onDestroy() {
        // 移除事件监听
        EventBus.getInstance().off(GameEvents.GAME_START, this.onGameStart, this);
    }

    /**
     * 游戏开始时设置背景
     */
    private async onGameStart() {
        await this.setBackgroundForCurrentLevel();
    }

    /**
     * 根据当前关卡设置背景图片
     */
    public async setBackgroundForCurrentLevel() {
        if (!this.levelConfigManager || !this.saveDataManager) {
            console.warn('[BackgroundManager] LevelConfigManager或SaveDataManager未初始化');
            return;
        }

        const currentLevel = this.saveDataManager.getCurrentLevel();
        const levelConfig = await this.levelConfigManager.getLevelConfig(currentLevel);
        
        console.log(`[BackgroundManager] 当前关卡: ${currentLevel}`);
        console.log(`[BackgroundManager] 关卡配置:`, levelConfig);
        
        if (levelConfig && levelConfig.backgroundImage) {
            console.log(`[BackgroundManager] 关卡${currentLevel}配置的背景图片: ${levelConfig.backgroundImage}`);
            // 转换路径格式：从 "images/LevelBackground/BG1" 转换为 "LevelBackground/BG1"
            const bundlePath = levelConfig.backgroundImage.replace('images/', '');
            await this.setBackground(bundlePath);
        } else {
            // 使用默认背景
            await this.setBackground('LevelBackground/BG1');
            console.log(`[BackgroundManager] 关卡${currentLevel}未配置背景图片，使用默认背景`);
            if (levelConfig) {
                console.log(`[BackgroundManager] 关卡配置中backgroundImage字段值:`, levelConfig.backgroundImage);
            }
        }
    }

    /**
     * 设置背景图片
     * @param imagePath 图片路径（相对于images Bundle根目录）
     */
    public async setBackground(imagePath: string) {
        if (!this.backgroundSprite) {
            console.warn('[BackgroundManager] 背景Sprite组件未找到，无法设置背景');
            return;
        }

        console.log(`[BackgroundManager] 开始设置背景图片: ${imagePath}`);
        
        try {
            // 优先使用预加载的资源
            let spriteFrame = this.resourcePreloader.getPreloadedBackground(imagePath);
            
            if (!spriteFrame) {
                console.log(`[BackgroundManager] 预加载资源未找到，动态加载 ${imagePath}`);
                // 如果预加载资源不存在，则动态加载
                spriteFrame = await this.bundleLoader.loadSpriteFrame(`${imagePath}/spriteFrame`);
            } else {
                console.log(`[BackgroundManager] 使用预加载的背景图片 ${imagePath}`);
            }
            
            if (spriteFrame && this.backgroundSprite && this.backgroundSprite.isValid) {
                this.backgroundSprite.spriteFrame = spriteFrame;
                console.log(`[BackgroundManager] 背景图片设置成功: ${imagePath}`);
            }
        } catch (error) {
            console.error(`[BackgroundManager] 背景图片加载失败: ${imagePath}`, error);
            
            // 如果不是默认背景，尝试加载默认背景
            if (imagePath !== 'LevelBackground/BG1') {
                console.log('[BackgroundManager] 尝试加载默认背景');
                await this.setBackground('LevelBackground/BG1');
            }
        }
    }



    /**
     * 根据指定关卡设置背景图片
     * @param levelId 关卡ID
     */
    public async setBackgroundForLevel(levelId: number) {
        if (!this.levelConfigManager) {
            console.warn('[BackgroundManager] LevelConfigManager未初始化');
            return;
        }

        const levelConfig = await this.levelConfigManager.getLevelConfig(levelId);
        
        if (levelConfig && levelConfig.backgroundImage) {
            // 转换路径格式：从 "images/LevelBackground/BG1" 转换为 "LevelBackground/BG1"
            const bundlePath = levelConfig.backgroundImage.replace('images/', '');
            await this.setBackground(bundlePath);
        } else {
            // 使用默认背景
            await this.setBackground('LevelBackground/BG1');
            console.log(`[BackgroundManager] 关卡${levelId}未配置背景图片，使用默认背景`);
        }
    }
}