import { _decorator, Component, Node } from 'cc';
import { EGAME_STATE, GameDefine } from '../config/GameDefine';
import { HeroData } from '../game_data/HeroData';
import { EnemyData } from '../game_data/EnemyData';
import { director } from 'cc';
import { Tween } from 'cc';
import { UmClientEvent } from '../../../cc-common/cc-util/UmOneToMultiListener';
import { ActiveSkillData, GameDataConfig, LevelDesignInfo, PassiveSkillInfo } from '../game_data/GameDataConfig';
import { UmLog } from '../../../cc-common/cc-util/UmLog';
import { Vec3 } from 'cc';
import { UserDataSaver } from '../game_data/UserDataSaver';
import { CCClass } from 'cc';
import { SkillInfo } from './GameInterface';
import { UmUtil } from '../../../cc-common/cc-util/UmUtil';
const { ccclass, property } = _decorator;

@ccclass('GameGlobalData')
export class GameGlobalData extends Component {
    @property(UserDataSaver) public userDataSaver: UserDataSaver = null!;
    @property(GameDataConfig) public gameDataConfig: GameDataConfig = null!;

    public static Instance: GameGlobalData = null;
    public gameState = EGAME_STATE.INIT;
    public isHeroManaReady: boolean = false;
    public currentActiveSkill: number = 0;
    public lastHeroMoveDirection: Vec3 = new Vec3(0, 1, 0);
    public level = 1;
    private levelDesignConfigData: LevelDesignInfo = null;
    public expCollected = 0;

    public killedData = { creep: 0, boss: 0 };
    public passiveSkillCollected = {};
    public HERO_CONTROL_CONFIG = { heroMoveSpeed : 5};

    protected onLoad(): void {
        GameGlobalData.Instance = this;
        this.userDataSaver.loadData();
        this.prepareDataOnStartNewStage();
        UmLog.log("skill_collected = ", JSON.stringify(this.userDataSaver.activeSkillCollected));

    }

    protected start(): void {
        this.checkLevelUp();
    }

    public changeState(state: EGAME_STATE) {
        this.gameState = state;
    }

    public isStatePlay(): boolean {
        return this.gameState == EGAME_STATE.PLAY;
    }

    public isStateWait(): boolean {
        return this.gameState == EGAME_STATE.WAIT;
    }

    public get skillSpecialDataInfo(): any {
        return GameDefine.SKILL_SPECIAL_DATA_INFO;
    }

    public newGame() {
        UmClientEvent.offAll();
        Tween.stopAll();
        director.loadScene("mainscene");
    }

    public manaToTime(mana: number) {
        return mana / GameDefine.MANA_UNIT;
    }

    public timeToMana(time: number) {
        return time * GameDefine.MANA_UNIT;
    }

    resetDataSaveBeforeStartNewStage() {
        this.expCollected = 0;
        this.passiveSkillCollected = {};
        this.killedData = { creep: 0, boss: 0 };
        this.HERO_CONTROL_CONFIG = { heroMoveSpeed : 5};
    }

    listActiveSkillData: ActiveSkillData[];
    listActiveSkillUses = new Array();

    public prepareDataOnStartNewStage() {
        this.HERO_CONTROL_CONFIG = UmUtil.clone(this.gameDataConfig.HERO_CONTROL_CONFIG);
        this.resetDataSaveBeforeStartNewStage();
        this.userDataSaver.resetData();
        this.level = this.userDataSaver.level;
        this.loadActiveSkillData();
    }

    loadActiveSkillData() {
        var listSkillCollected = this.userDataSaver.activeSkillCollected;
        var listKeys = UmUtil.clone(GameDefine.ACTIVE_SKILL_KEY);

        for (var i = 0; i < listKeys.length; i++) {
            var key = listKeys[i];
            listKeys[i] = `${key}|${listSkillCollected[key]}`;
        }

        this.listActiveSkillData = this.gameDataConfig.getActiveSkillConfig(listKeys);
        UmLog.log("listActiveSkillData => ", JSON.stringify(this.listActiveSkillData));
        this.listActiveSkillUses = this.gameDataConfig.ACTIVE_SKILL_USE_INFO;

        for (var i = 0; i < this.listActiveSkillData.length; i++) {
            var data = this.listActiveSkillData[i];
            this.listActiveSkillUses[i].mana = data.Mana;

            if (i == 2)
            {
                this.listActiveSkillUses[i].useTime = data.Range;
            }
        }

        UmLog.log("listActiveSkillUses => ", JSON.stringify(this.listActiveSkillUses));
    }

    get heroDataConfig(): any {
        var result = this.gameDataConfig.getHeroDataByLevel(this.level);
        result.Atk = 50;
        result.Hp = 400;
        return result;
    }

    getEnemyDataConfigAfterRatioById(enemyId: string) {
        var enemyData = this.gameDataConfig.getEnemyDataConfigById(enemyId);
        var levelData = this.getLevelDesignConfigData();
        enemyData.atk *= levelData.atkratio;
        enemyData.hp *= levelData.hpratio;
        enemyData.exp *= levelData.expratio;
        return enemyData;
    }

    getBossDataConfigAfterRaitoById(enemyId: string) {
        var bossData = this.gameDataConfig.getBossDataConfigById(enemyId);
        var levelData = this.getLevelDesignConfigData();
        bossData.atk *= levelData.atkratio;
        bossData.hp *= levelData.hpratio;
        bossData.exp *= levelData.expratio;
        return bossData;
    }

    getLevelDesignConfigData(): LevelDesignInfo {
        if (!this.levelDesignConfigData || this.levelDesignConfigData.level != this.level) {
            this.levelDesignConfigData = this.gameDataConfig.getLevelDesignByLevel(this.level);
        }

        return this.levelDesignConfigData;
    }

    getExpInlevelNeed(): number {
        return this.heroDataConfig.Exp;
    }

    checkLevelUp(): boolean {
        var userDataSaver = GameGlobalData.Instance.userDataSaver;
        var levelExp = GameGlobalData.Instance.getExpInlevelNeed();

        UmLog.log("checkLevelUp => user exp = ", userDataSaver.expInLevel);
        UmLog.log("checkLevelUp => level exp = ", levelExp);

        if (userDataSaver.expInLevel < levelExp)
            return false;

        userDataSaver.expInLevel -= levelExp;
        userDataSaver.level++;
        this.level = userDataSaver.level;
        userDataSaver.saveData();
        return true;
    }

    checkLevelUpWithSessionExpCollected(expCollect: number): boolean {
        var userDataSaver = GameGlobalData.Instance.userDataSaver;
        var levelExp = GameGlobalData.Instance.getExpInlevelNeed();        
        var expCheck = userDataSaver.expInLevel + expCollect;

        UmLog.log("checkLevelUp => user exp = ", userDataSaver.expInLevel);
        UmLog.log("checkLevelUp => check exp = ", expCheck);
        UmLog.log("checkLevelUp => level exp = ", levelExp);

        if (expCheck < levelExp)
            return false;

        userDataSaver.expInLevel = expCheck - levelExp;
        userDataSaver.level++;
        this.level = userDataSaver.level;
        userDataSaver.saveData();
        this.expCollected = 0;
        return true;
    }

    getListSkillReward(level: number = this.level): SkillInfo[] {
        var skillConfig: string = this.gameDataConfig.getSkillUnlockDataByLevel(level);

        var skillSplits = skillConfig.split("_");
        var skillRewards = new Array();

        for (var i = 0; i < skillSplits.length; i++) {
            var skillls = skillSplits[i].split("|");
            if (skillls.length < 2)
                continue;
            
            var skillInfo: SkillInfo = { skillName: skillls[0], level: Number(skillls[1]) };
            skillRewards.push(skillInfo);
        }

        skillRewards.shuffleArray();
        skillRewards.splice(3, skillRewards.length - 3);
        return skillRewards;
    }

    //Passive Skill

    collectPassiveSkill(skillName: string, plusLevel: number): PassiveSkillInfo {
        var skillLevel = 0;
        if (this.passiveSkillCollected.hasOwnProperty((skillName)))
            skillLevel = this.passiveSkillCollected[skillName];

        skillLevel += plusLevel;
        skillLevel = Math.min(skillLevel, GameDefine.MAX_PASSIVE_SKILL_LEVEL);
        this.passiveSkillCollected[skillName] = skillLevel;
        return this.gameDataConfig.getPassiveSkillDataByNameAndLevel(skillName, skillLevel);
    }

    isActiveSkill(skillName: string)
    {
        return skillName.includes("AS");
    }

    // getHeroDataAfterApplyPassiveSkill()
    // {
    //     var listNameCollected = Object.keys(this.passiveSkillCollected);
    //     var passiveMapCollected = {};
    //     for (var skillName in listNameCollected)
    //     {
    //         //Skill ID = skill name + skill level
    //         var skillID = `${skillName}|${this.passiveSkillCollected[skillName]}`;
    //         // passiveMapCollected[]
    //     }
    // }


}