using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using UnityEngine;
namespace Snxxz.UI
{
    public class HazyRegionModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk
    {
        Dictionary<int, Incident> m_Incidents = new Dictionary<int, Incident>();
        Dictionary<int, AdventureInfo> m_AdventureInfos = new Dictionary<int, AdventureInfo>();

        public int limitPoint { get; private set; }
        public int point { get; private set; }
        public int processingIncidentId { get; private set; }
        public int adventureDialogueId { get; private set; }
        public bool playing { get; private set; }
        public bool satisfyFakeOpen { get; private set; }
        public int hazyRegionOpenTimes { get; private set; }
        public int fakeOpenTimes { get; private set; }
        public bool isServerPrepare { get; private set; }
        public bool requireIncidentAnimation { get; set; }

        int m_SelectIncident;
        public int selectIncident
        {
            get { return m_SelectIncident; }
            set
            {
                if (m_SelectIncident != value)
                {
                    m_SelectIncident = value;
                    if (selectIncidentRefresh != null)
                    {
                        selectIncidentRefresh();
                    }
                }
            }
        }

        public bool InFakeHazyRegion
        {
            get
            {
                return hazyRegionOpenTimes <= fakeOpenTimes
                  || !FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.HazyRegion);
            }
        }

        int cacheMapId = 0;

        public event Action selectIncidentRefresh;
        public event Action<int> onHazyRegionStateRefresh;  //0-结束拜访 1-开始拜访 2-强制刷新
        public event Action onHazyRegionIncidentRefresh;

        DungeonModel dungeonModel { get { return ModelCenter.Instance.GetModel<DungeonModel>(); } }
        DailyQuestModel dailyQuestModel { get { return ModelCenter.Instance.GetModel<DailyQuestModel>(); } }
        HazyDemonKingModel hazyDemonKingModel { get { return ModelCenter.Instance.GetModel<HazyDemonKingModel>(); } }
        HazyGrassModel hazyGrassModel { get { return ModelCenter.Instance.GetModel<HazyGrassModel>(); } }

        public override void Init()
        {
            ParseConfig();

            StageLoad.Instance.onStageLoadFinish += OnStageLoadFinish;
            AdventureStage.Instance.onLoadAdventureStage += OnLoadAdventureStage;
            AdventureStage.Instance.onExitAdventureStage += OnExitAdventureStage;
        }

        public void OnBeforePlayerDataInitialize()
        {
            isServerPrepare = false;
            point = 0;
            playing = false;
            hazyRegionOpenTimes = 0;
            m_Incidents.Clear();
            m_AdventureInfos.Clear();
        }

        public void OnPlayerLoginOk()
        {
            isServerPrepare = true;
        }

        public override void UnInit()
        {
            StageLoad.Instance.onStageLoadFinish -= OnStageLoadFinish;
            AdventureStage.Instance.onExitAdventureStage -= OnExitAdventureStage;
            AdventureStage.Instance.onLoadAdventureStage -= OnLoadAdventureStage;
        }

        private void OnLoadAdventureStage()
        {
            WindowCenter.Instance.Open<HazyAdventureHintWin>();
        }

        private void OnExitAdventureStage()
        {
            SnxxzGame.Instance.StartCoroutine(Co_TryOpenHazyRegionWin());
            WindowCenter.Instance.Close<HazyAdventureHintWin>();
        }

        private void OnStageLoadFinish()
        {
            if (!(StageLoad.Instance.currentStage is DungeonStage))
            {
                cacheMapId = 0;
            }
            else
            {
                var mapId = PlayerDatas.Instance.baseData.MapID;
                if (!MapUtility.IsDungeon(mapId))
                {
                    if (IsIncidentDungeon(cacheMapId))
                    {
                        SnxxzGame.Instance.StartCoroutine(Co_TryOpenHazyRegionWin());
                    }
                }
                cacheMapId = mapId;
            }
        }

        IEnumerator Co_TryOpenHazyRegionWin()
        {
            yield return WaitingForSecondConst.WaitMS1000;
            if (NewBieCenter.Instance.inGuiding ||
                ModelCenter.Instance.GetModel<TreasureModel>().newGotShowing)
            {
                yield break;
            }
            if (WindowCenter.Instance.IsOpen<MainInterfaceWin>())
            {
                WindowCenter.Instance.Open<CrossServerWin>(false, 2);
            }
        }

        void ParseConfig()
        {
            var funcConfig = FuncConfigConfig.Get("ImmortalDomainStrength");
            limitPoint = int.Parse(funcConfig.Numerical1);

            funcConfig = FuncConfigConfig.Get("FakeImmortalCount");
            fakeOpenTimes = int.Parse(funcConfig.Numerical1);
        }

        public bool TryGetIncident(int id, out Incident incident)
        {
            return m_Incidents.TryGetValue(id, out incident);
        }

        public bool TryGotoIncident(int id, out int error)
        {
            error = 0;
            var config = HazyRegionConfig.Get(id);
            if (config == null)
            {
                return false;
            }
            if (!TryGotoDungeon(id, out error))
            {
                return false;
            }
            Incident incident;
            if (TryGetIncident(id, out incident))
            {
                if (incident.state != IncidentState.Processing)
                {
                    switch (incident.state)
                    {
                        case IncidentState.UnStart:
                            if (!InFakeHazyRegion && point < config.point)
                            {
                                error = 3;
                                return false;
                            }
                            break;
                        case IncidentState.Complete:
                            error = 4;
                            return false;
                    }
                }
            }
            return true;
        }

        public bool TryGotoDungeon(int id, out int error)
        {
            error = 0;
            if (CrossServerUtility.IsCrossServer())
            {
                error = 1;
                return false;
            }
            var mapId = PlayerDatas.Instance.baseData.MapID;
            if (MapUtility.IsDungeon(mapId))
            {
                error = 2;
                return false;
            }
            if (AdventureStage.Instance.IsInAdventureStage)
            {
                error = 2;
                return false;
            }
            return true;
        }

        public bool TryAddTimes()
        {
            var config = DailyQuestConfig.Get((int)DailyQuestType.HazyRegion);
            var dailyQuestOpenTime = DailyQuestOpenTimeConfig.Get(config.RelatedID);
            var limitTimes = dailyQuestOpenTime.DayTimes;

            var totalTimes = dailyQuestModel.GetDailyQuestTotalTimes((int)DailyQuestType.HazyRegion);
            var completedTimes = dailyQuestModel.GetDailyQuestCompletedTimes((int)DailyQuestType.HazyRegion);
            var times = Mathf.Clamp(totalTimes - completedTimes, 0, limitTimes);

            if (times >= limitTimes)
            {
                return false;
            }

            return true;
        }

        public bool TryGetAdventureInfo(int id, out AdventureInfo adventureInfo)
        {
            return m_AdventureInfos.TryGetValue(id, out adventureInfo);
        }

        public ICollection<int> GetAllIncidents()
        {
            return m_Incidents.Keys;
        }

        public int GetIncidentId(int mapId, int lineId)
        {
            var configs = HazyRegionConfig.GetValues();
            foreach (var config in configs)
            {
                if (config.dungeonId == mapId && config.lineId == lineId)
                {
                    return config.id;
                }
            }
            return 0;
        }

        public int GetAdventureNpcId()
        {
            var dialogueConfig = AdventureDialogueConfig.Get(adventureDialogueId);
            if (dialogueConfig != null)
            {
                return dialogueConfig.npcId;
            }
            return 0;
        }

        public bool IsIncidentDungeon(int mapId)
        {
            if (mapId == 0)
            {
                return false;
            }
            if (mapId == HazyDemonKingModel.Client_MapID
                || mapId == HazyGrassModel.Client_FairyGrassMapID
                || mapId == HazyGrassModel.Client_ReikiGrassMapID)
            {
                return true;
            }
            var configs = HazyRegionConfig.GetValues();
            foreach (var config in configs)
            {
                if (config.dungeonId == mapId)
                {
                    return true;
                }
            }
            return false;
        }

        public bool IsIncidentDungeon()
        {
            if (AdventureStage.Instance.IsInAdventureStage)
            {
                return true;
            }
            if (IsIncidentDungeon(PlayerDatas.Instance.baseData.MapID))
            {
                return true;
            }
            return false;
        }

        public void DisplayErrorRemind(int error)
        {
            switch (error)
            {
                default:
                    break;
            }
        }

        public void StartAdventureDialogue()
        {
            WindowCenter.Instance.Close<MainInterfaceWin>();
            HazyRegionDialogueWin.adventureDialogueId = adventureDialogueId;
            WindowCenter.Instance.Open<HazyRegionDialogueWin>();
        }

        void InitializeAdventure()
        {
            var config = HazyRegionConfig.Get(processingIncidentId);
            if (config != null)
            {
                var gear = 0;
                AdventureInfo adventureInfo;
                if (TryGetAdventureInfo(processingIncidentId, out adventureInfo))
                {
                    switch (config.lineId)
                    {
                        case 1:
                            gear = PlayerDatas.Instance.baseData.LV >= adventureInfo.condition ? adventureInfo.gear : 0;
                            break;
                        case 2:
                            gear = PlayerDatas.Instance.baseData.realmLevel >= adventureInfo.condition ? adventureInfo.gear : 0;
                            break;
                        case 3:
                            gear = PlayerDatas.Instance.baseData.FightPoint >= adventureInfo.condition ? adventureInfo.gear : 0;
                            break;
                        case 4:
                            gear = PlayerDatas.Instance.extersion.luckValue >= adventureInfo.condition ? adventureInfo.gear : 0;
                            break;
                    }
                }
                var dialogueConfig = AdventureDialogueConfig.Get(config.lineId, gear);
                if (dialogueConfig != null)
                {
                    adventureDialogueId = dialogueConfig.id;
                }
            }
        }

        public void SendGotoIncident(int id)
        {
            processingIncidentId = id;

            var config = HazyRegionConfig.Get(id);
            switch ((HazyRegionIncidentType)config.incidentType)
            {
                case HazyRegionIncidentType.Adventure:
                    InitializeAdventure();

                    WindowCenter.Instance.CloseAll(WindowCenter.CloseAllIgnoreType.BaseAndCustom);

                    AdventureStage.Instance.Enter();

                    Incident incident;
                    if(TryGetIncident(id,out incident))
                    {
                        if (incident.state == IncidentState.UnStart)
                        {
                            SendSwitchAdventureState(id, 2);
                        }
                    }
                    break;
                case HazyRegionIncidentType.DemonKing:
                    if (InFakeHazyRegion)
                    {
                        hazyDemonKingModel.RequestEnterClientDungeon();
                    }
                    else
                    {
                        SendGotoIncidentDungeon(config);
                    }
                    break;
                case HazyRegionIncidentType.FairyGrass:
                case HazyRegionIncidentType.ReikiGrass:
                    if (InFakeHazyRegion)
                    {
                        hazyGrassModel.RequestEnterClientDungeon();
                    }
                    else
                    {
                        SendGotoIncidentDungeon(config);
                    }
                    break;
                case HazyRegionIncidentType.Precious:
                    SendGotoIncidentDungeon(config);
                    break;
            }
        }

        void SendGotoIncidentDungeon(HazyRegionConfig config)
        {
            if (config.crossServer == 1)
            {
                var pak = new CC105_tagCMEnterCrossServer();
                pak.DataMapID = (uint)config.dungeonId;
                pak.LineID = (ushort)config.lineId;
                GameNetSystem.Instance.SendInfo(pak);
            }
            else
            {
                dungeonModel.SingleChallenge(config.dungeonId, config.lineId);
            }
        }

        public void SendBackHazyRegion()
        {
            var pak = new CA526_tagCMVisitFairyDomain();
            pak.Type = 1;
            GameNetSystem.Instance.SendInfo(pak);
        }

        public void SendOpenHazyRegion()
        {
            var pak = new CA526_tagCMVisitFairyDomain();
            pak.Type = 0;
            GameNetSystem.Instance.SendInfo(pak);
        }

        public void SendSwitchAdventureState(int id, int state)
        {
            var pak = new CA504_tagCMPlayerGetReward();
            pak.RewardType = (byte)GotServerRewardType.Def_RewardType_FairyAdventuresAward;
            pak.DataEx = (uint)id;
            pak.DataExStr = state.ToString();
            pak.DataExStrLen = (byte)Encoding.UTF8.GetBytes(pak.DataExStr).Length;
            GameNetSystem.Instance.SendInfo(pak);
        }

        public void ReceivePackage(HA306_tagMCFairyDomainInfo package)
        {
            var preplaying = playing;

            playing = package.State == 1;

            satisfyFakeOpen = package.State == 2;

            hazyRegionOpenTimes = (int)package.VisitCnt;

            point = package.Energy;

            if (package.IsAll == 1)
            {
                m_Incidents.Clear();
            }

            for (int i = 0; i < package.Count; i++)
            {
                var data = package.InfoList[i];
                m_Incidents[data.EventID] = new Incident()
                {
                    id = data.EventID,
                    state = (IncidentState)data.EventState,
                };
            }

            if (onHazyRegionIncidentRefresh != null)
            {
                onHazyRegionIncidentRefresh();
            }

            if (isServerPrepare)
            {
                if (preplaying != playing)
                {
                    if (onHazyRegionStateRefresh != null)
                    {
                        onHazyRegionStateRefresh(playing ? 1 : 0);
                    }
                }
            }
            else
            {
                if (onHazyRegionStateRefresh != null)
                {
                    onHazyRegionStateRefresh(2);
                }
            }
        }

        public void ReceivePackage(HA307_tagMCFairyAdventuresInfo package)
        {
            m_AdventureInfos.Clear();
            for (int i = 0; i < package.Cnt; i++)
            {
                var data = package.InfoList[i];

                m_AdventureInfos[data.EventID] = new AdventureInfo()
                {
                    gear = data.Gear,
                    condition = (int)data.Condition,
                };
            }
        }

        public enum IncidentState
        {
            UnStart = 1,
            Processing = 2,
            Complete = 3,
        }

        public struct Incident
        {
            public int id;
            public IncidentState state;
        }

        public struct AdventureInfo
        {
            public int gear;
            public int condition;
        }
    }

    public enum HazyRegionIncidentType
    {
        Adventure,
        Precious,
        FairyGrass,
        DemonKing,
        ReikiGrass,
    }
}