using System.Collections;
using System.Collections.Generic;
using UnityEngine.SceneManagement;
using UnityEngine;
using Snxxz.UI;
using System;

using UnityEngine.Events;

public class StageLoad : SingletonMonobehaviour<StageLoad>
{
    StageLoadProcessor stageLoadProcessor;
    public float progress {
        get {
            if (stageLoadProcessor != null)
            {
                return stageLoadProcessor.progress;
            }
            else
            {
                return 0f;
            }
        }
    }

    Stage m_CurrentStage;
    public Stage currentStage {
        get { return m_CurrentStage; }
        set { m_CurrentStage = value; }
    }

    public Stage.E_StageType stageType {
        get {
            return (currentStage != null && currentStage is DungeonStage) ? Stage.E_StageType.Dungeon : Stage.E_StageType.MainCity;
        }
    }

    public event Action<int> onStartStageLoadingEvent;
    public UnityAction onStageLoadFinish;

    StageLoadCommand currentCommand;
    Queue<StageLoadCommand> commands = new Queue<StageLoadCommand>();

    bool server0109Ok_Main = false;
    bool server0109Ok_CrossServer;

    float loadStartTime = 0f;
    public bool isLoading { get; private set; }

    public int mapIdRecord { get; private set; }
    public int lineIdRecord { get; private set; }

    public void PushSceneLoadCommand(StageLoadCommand command)
    {
        if (!isLoading && commands.Count == 0)
        {
            currentCommand = command;
            currentCommand.fromMapId = mapIdRecord;
            currentCommand.fromLineId = lineIdRecord;
            ExcuteCommand(currentCommand);
        }
        else
        {
            commands.Enqueue(command);
        }
    }

    private void ExcuteCommand(StageLoadCommand command)
    {
        var tasks = new Queue<StageLoadProcessor.StageLoadTask>();
        var needLoadResource = true;
        if (command.needLoadResource)
        {
            if (command.fromMapId != command.toMapId)
            {
                needLoadResource = true;
            }
            else
            {
                var config1 = MapResourcesConfig.GetConfig(MapUtility.GetDataMapId(command.fromMapId), command.fromLineId);
                var config2 = MapResourcesConfig.GetConfig(MapUtility.GetDataMapId(command.toMapId), command.toLineId);
                if (config1 == null || config2 == null)
                {
                    needLoadResource = true;
                }
                else
                {
                    needLoadResource = config1.MapResources != config2.MapResources;
                }
            }
        }
        else
        {
            needLoadResource = false;
        }

        var assetValid = AssetVersionUtility.IsSceneAssetValid(command.toMapId, command.toLineId);
        if (!assetValid)
        {
            tasks.Enqueue(new StageLoadProcessor.Wait0109Task(command));
            if (command.serverType == ServerType.Main)
            {
                tasks.Enqueue(new StageLoadProcessor.WaitLoginCompleteTask(command));
            }
            tasks.Enqueue(new StageLoadProcessor.WaitSecondsTask(command, 1));
            tasks.Enqueue(new StageLoadProcessor.ReturnToNoviceVillageTask(command));
        }
        else
        {
            if (needLoadResource)
            {
                tasks.Enqueue(new StageLoadProcessor.PreProcessTask(command));
                tasks.Enqueue(new StageLoadProcessor.UnLoadAndGCTask(command));
            }

            if (needLoadResource && command.needEmpty)
            {
                tasks.Enqueue(new StageLoadProcessor.LoadEmptyTask(command));
            }

            if (needLoadResource)
            {
                tasks.Enqueue(new StageLoadProcessor.LoadNewSceneTask(command));
            }

            if (!command.isClientLoadMap)
            {
                tasks.Enqueue(new StageLoadProcessor.Wait0109Task(command));
                if (command.serverType == ServerType.Main)
                {
                    tasks.Enqueue(new StageLoadProcessor.WaitLoginCompleteTask(command));
                }
            }

            if (needLoadResource)
            {
                tasks.Enqueue(new StageLoadProcessor.PostProcessTask(command));
            }
        }

        UpdateServerFlag(command.serverType, false);

        var gameObject = new GameObject("StageLoadProcessor");
        DontDestroyOnLoad(gameObject);
        stageLoadProcessor = gameObject.AddComponent<StageLoadProcessor>();
        stageLoadProcessor.Begin(tasks);

        StageLoadTimeOutCatcher.Begin(command.toMapId);
        WindowCenter.Instance.Close<MainInterfaceWin>();
        loadStartTime = Time.time;
        isLoading = true;
    }

    public void ReportComplete(int mapId, int lineId)
    {
        mapIdRecord = mapId;
        lineIdRecord = lineId;
        isLoading = false;
        StageLoadTimeOutCatcher.Stop();

        if (stageLoadProcessor != null)
        {
            DestroyImmediate(stageLoadProcessor.gameObject);
            stageLoadProcessor = null;
        }
    }

    public void UpdateServerFlag(ServerType serverType, bool ok)
    {
        if (ok)
        {
            if (currentCommand != null && !currentCommand.serverFlag0109)
            {
                currentCommand.serverFlag0109 = true;
            }
            else
            {
                foreach (var command in commands)
                {
                    if (command.serverType == serverType && !command.serverFlag0109)
                    {
                        command.serverFlag0109 = true;
                        break;
                    }
                }
            }
        }

        switch (serverType)
        {
            case ServerType.Main:
                server0109Ok_Main = ok;
                break;
            case ServerType.CrossSever:
                server0109Ok_CrossServer = ok;
                break;
            default:
                break;
        }
    }

    public void BroadcastStageLoadStartEvent(int mapId)
    {
        try
        {
            if (onStartStageLoadingEvent != null)
            {
                onStartStageLoadingEvent(mapId);
            }
        }
        catch (System.Exception ex)
        {
            Debug.LogError(ex);
        }

    }

    public void BroadcastStageLoadEndEvent()
    {
        try
        {
            if (onStageLoadFinish != null)
            {
                onStageLoadFinish();
            }
        }
        catch (System.Exception ex)
        {
            Debug.LogError(ex);
        }

    }

    void Update()
    {
        if (!isLoading && commands.Count > 0)
        {
            currentCommand = commands.Dequeue();
            currentCommand.fromMapId = mapIdRecord;
            currentCommand.fromLineId = lineIdRecord;
            ExcuteCommand(currentCommand);
        }

        if (isLoading)
        {
            if (Time.time - loadStartTime > 25f)
            {
                if (stageLoadProcessor != null)
                {
                    DestroyImmediate(stageLoadProcessor.gameObject);
                    stageLoadProcessor = null;
                }

                currentCommand = null;
                isLoading = false;
                commands.Clear();
                StageLoadTimeOutCatcher.ReportLoadingOverTime();
                GameNetSystem.Instance.Reconnect();
            }
        }
    }

    public class StageLoadCommand
    {
        public int fromMapId;
        public int fromLineId;
        public int toMapId;
        public int toLineId;

        public bool needEmpty;
        public ServerType serverType;
        public bool isClientLoadMap;
        public bool needLoadResource;

        public bool serverFlag0109 = false;
    }

    public bool IsServerPrepareOk(ServerType socketType)
    {
        switch (socketType)
        {
            case ServerType.Main:
                return server0109Ok_Main;
            case ServerType.CrossSever:
                return server0109Ok_CrossServer;
            default:
                return false;
        }
    }

    int m_InitHeroStep = -1;
    public int initHeroStep { get { return m_InitHeroStep; } }

    public void InitHero()
    {
        m_InitHeroStep = 0;

        // 初始化摄像机
        if (!CameraController.Instance)
        {
            UnityEngine.Object.Instantiate(BuiltInLoader.LoadPrefab("GameCamera"));
            CameraController.Instance.AcceptInput = false;
            CameraController.Instance.CameraObject.enabled = false;
        }

        m_InitHeroStep = 1;
        var hero = PlayerDatas.Instance.hero;
        if (hero == null)
        {
            hero = GAMgr.Instance.RequestPlayer<GA_Hero>(PlayerDatas.Instance.PlayerId, E_ActorGroup.User, null);
        }

        m_InitHeroStep = 2;
        hero.State = E_ActorState.Idle;
        hero.ActorInfo.ResetHp((int)PlayerDatas.Instance.baseData.HP, -1, (int)PlayerDatas.Instance.extersion.MaxHP);
        hero.CalculateMoveSpeed((ushort)PlayerDatas.Instance.extersion.SpeedValue);
        hero.CalculateAtkSpeed(PlayerDatas.Instance.extersion.battleValEx1);
        hero.InitBornPos(PlayerDatas.Instance.baseData.PosX, PlayerDatas.Instance.baseData.PosY);
        m_InitHeroStep = 3;
        CameraController.Instance.SetLookTarget(hero.Root);
        CameraController.Instance.Apply();

        var packModel = ModelCenter.Instance.GetModel<PlayerPackModel>();
        var equipModel = packModel.GetSinglePackModel(PackType.rptEquip);

        var itemModel = equipModel.GetItemModelByIndex((int)RoleEquipType.retClothes);
        var fashion = equipModel.GetItemModelByIndex((int)RoleEquipType.retFashionClothes);
        m_InitHeroStep = 4;
        if (fashion != null)
        {
            hero.SwitchClothes((uint)fashion.itemInfo.ItemID, (int)RoleEquipType.retFashionClothes);
        }
        else if (itemModel != null)
        {
            hero.SwitchClothes((uint)itemModel.itemInfo.ItemID);
        }
        else
        {
            hero.SwitchClothes(0);
        }

        m_InitHeroStep = 5;

        itemModel = equipModel.GetItemModelByIndex((int)RoleEquipType.retWeapon);
        fashion = equipModel.GetItemModelByIndex((int)RoleEquipType.retFashionWeapon);

        if (fashion != null)
        {
            hero.SwitchWeapon((uint)fashion.itemInfo.ItemID, (int)RoleEquipType.retFashionWeapon);
        }
        else if (itemModel != null)
        {
            hero.SwitchWeapon((uint)itemModel.itemInfo.ItemID);
        }
        else
        {
            hero.SwitchWeapon(0);
        }

        m_InitHeroStep = 6;
        itemModel = equipModel.GetItemModelByIndex((int)RoleEquipType.retWeapon2);
        fashion = equipModel.GetItemModelByIndex((int)RoleEquipType.retFashionWeapon2);

        if (fashion != null)
        {
            hero.SwitchSecondary((uint)fashion.itemInfo.ItemID, (int)RoleEquipType.retFashionWeapon2);
        }
        else if (itemModel != null)
        {
            hero.SwitchSecondary((uint)itemModel.itemInfo.ItemID);
        }
        else
        {
            hero.SwitchSecondary(0);
        }

        m_InitHeroStep = 7;

        itemModel = equipModel.GetItemModelByIndex((int)RoleEquipType.retWing);
        if (itemModel != null)
        {
            hero.SwitchWing((uint)itemModel.itemInfo.ItemID);
        }

        m_InitHeroStep = 8;
        var mapConfig = MapConfig.Get(PlayerDatas.Instance.baseData.MapID);
        if (mapConfig.CanRide == 1)
        {
            itemModel = equipModel.GetItemModelByIndex((int)RoleEquipType.mount);
            if (itemModel != null)
            {
                var mountModel = ModelCenter.Instance.GetModel<PlayerMountDatas>();
                if (mountModel.HorseRidingBool)
                {
                    hero.OnHorse(1);
                }
            }
        }

        m_InitHeroStep = 9;

        itemModel = equipModel.GetItemModelByIndex((int)RoleEquipType.retSpiritAnimal);
        if (itemModel != null)
        {
            hero.SwitchGuard((uint)itemModel.itemInfo.ItemID);
        }

        m_InitHeroStep = 10;

        hero.SyncSuitEffect();

        m_InitHeroStep = 11;
        hero.IdleImmediate();

        hero.SetFairyLeagueHeadUp(PlayerDatas.Instance.baseData.MapID == FairyLeagueModel.FAIRY_LEAGUE_DUNGEON);
        hero.CheckAncientHeadUp();

        m_InitHeroStep = 12;
        var titleId = 0;
        if (PlayerDatas.Instance.baseData.MapID != 31160)
        {
            var titelModel = ModelCenter.Instance.GetModel<TitleModel>();
            var title = titelModel.GetTitleEquip();
            titleId = title != null && titelModel.IsTitleGain(title.id) ? title.id : 0;
        }
        hero.SwitchTitle((uint)titleId);

        m_InitHeroStep = 13;
        // 判断buff
        if (StatusMgr.Instance.IsExist(PlayerDatas.Instance.PlayerId, StatusMgr.Instance.redNameBuffID))
        {
            hero.SwitchRedName(true);
        }

        hero.RequestLight();

        m_InitHeroStep = 14;
        PlayerDatas.Instance.hero = hero;

        var preLoadSkillEffects = GeneralDefine.PreloadSkillEffect[hero.JobSetup.Job - 1];
        if (preLoadSkillEffects != null && preLoadSkillEffects.Length > 0)
        {
            foreach (var _id in preLoadSkillEffects)
            {
                InstanceResourcesLoader.PreloadSkillEffect(_id);
            }
        }

        m_InitHeroStep = 15;
    }

}