import { sys } from 'cc';

/**
 * 关卡管理器
 * 负责关卡数据的保存、加载和切换
 * 注意：这是一个纯数据管理类，不需要挂载到节点上
 */
export class LevelManager {
    private static instance: LevelManager = null;
    
    private currentLevel: number = 1;
    private maxUnlockedLevel: number = 1;
    private levelData: any = {};
    private initialized: boolean = false;

    private constructor() {
        // 私有构造函数，确保单例模式
    }

    public static getInstance(): LevelManager {
        if (LevelManager.instance === null) {
            LevelManager.instance = new LevelManager();
            LevelManager.instance.initialize();
        }
        return LevelManager.instance;
    }

    // 初始化关卡管理器
    private initialize() {
        if (this.initialized) return;
        
        this.loadLevelData();
        this.initialized = true;
    }

    // 加载关卡数据
    private loadLevelData() {
        const savedData = sys.localStorage.getItem('levelData');
        if (savedData) {
            try {
                const data = JSON.parse(savedData);
                this.currentLevel = data.currentLevel || 1;
                this.maxUnlockedLevel = data.maxUnlockedLevel || 1;
                this.levelData = data.levelData || {};
            } catch (error) {
                this.resetLevelData();
            }
        } else {
            this.resetLevelData();
        }
    }

    // 保存关卡数据
    private saveLevelData() {
        const data = {
            currentLevel: this.currentLevel,
            maxUnlockedLevel: this.maxUnlockedLevel,
            levelData: this.levelData
        };
        
        try {
            sys.localStorage.setItem('levelData', JSON.stringify(data));
        } catch (error) {
            // 静默处理保存错误
        }
    }

    // 重置关卡数据
    private resetLevelData() {
        this.currentLevel = 1;
        this.maxUnlockedLevel = 1;
        this.levelData = {};
        this.saveLevelData();
    }

    // 获取当前关卡
    public getCurrentLevel(): number {
        return this.currentLevel;
    }

    // 获取最大解锁关卡
    public getMaxUnlockedLevel(): number {
        return this.maxUnlockedLevel;
    }

    // 设置当前关卡
    public setCurrentLevel(level: number) {
        if (level <= this.maxUnlockedLevel && level >= 1) {
            this.currentLevel = level;
            this.saveLevelData();
        }
    }

    // 完成关卡
    public completeLevel(level: number, score: number = 0) {
        // 解锁下一关
        if (level === this.maxUnlockedLevel) {
            this.maxUnlockedLevel = level + 1;
        }

        // 保存关卡成绩
        if (!this.levelData[level]) {
            this.levelData[level] = {};
        }

        const currentData = this.levelData[level];
        if (!currentData.bestScore || score > currentData.bestScore) {
            currentData.bestScore = score;
        }

        currentData.completed = true;
        currentData.completionTime = Date.now();

        this.saveLevelData();
    }

    // 获取关卡数据
    public getLevelData(level: number): any {
        return this.levelData[level] || {
            completed: false,
            bestScore: 0
        };
    }

    // 检查关卡是否已解锁
    public isLevelUnlocked(level: number): boolean {
        return level <= this.maxUnlockedLevel;
    }

    // 检查关卡是否已完成
    public isLevelCompleted(level: number): boolean {
        const data = this.getLevelData(level);
        return data.completed || false;
    }

    // 获取关卡最佳成绩
    public getLevelBestScore(level: number): number {
        const data = this.getLevelData(level);
        return data.bestScore || 0;
    }



    // 重置所有关卡进度
    public resetAllProgress() {
        this.resetLevelData();
    }

    // 解锁所有关卡（调试用）
    public unlockAllLevels(maxLevel: number = 100) {
        this.maxUnlockedLevel = maxLevel;
        this.saveLevelData();
    }
}