using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;
using TableConfig;
using LitJson;

namespace Snxxz.UI
{
    public class RuneTowerModel : Model, IMapInitOk, IBeforePlayerDataInitialize, IPlayerLoginOk
    {
        public const int RUNETOWER_MAPID = 31130;

        int m_YesterdayPassFloor = 0;
        public int yesterdayPassFloor {
            get { return m_YesterdayPassFloor; }
            set {
                m_YesterdayPassFloor = value;
                UpdateRedpoint();
            }
        }

        public int currentTower {
            get {
                var config = Config.Instance.Get<RuneTowerFloorConfig>(currentFloor);
                return config.TowerId;
            }
        }

        public bool allTowerCompleted {
            get { return (int)runeModel.RuneTowerOpenLV == sortedFloors[sortedFloors.Count - 1]; }
        }

        public int currentFloor {
            get {
                var floor = sortedFloors[sortedFloors.Count - 1];
                for (int i = 0; i < sortedFloors.Count; i++)
                {
                    if (sortedFloors[i] > (int)runeModel.RuneTowerOpenLV)
                    {
                        floor = sortedFloors[i];
                        break;
                    }
                }

                return floor;
            }
        }

        int m_SelectedFloor;
        public int selectedFloor {
            get {
                return this.m_SelectedFloor;
            }
            set {
                if (this.m_SelectedFloor != value)
                {
                    this.m_SelectedFloor = value;
                    if (selectedFloorEvent != null)
                    {
                        selectedFloorEvent(this.m_SelectedFloor);
                    }
                }
            }
        }

        List<int> sortedFloors = new List<int>();

        Dictionary<int, Dictionary<int, int>> towerFloors = new Dictionary<int, Dictionary<int, int>>();
        Dictionary<int, int> runeCategoryUnLockFloor = new Dictionary<int, int>();

        public List<TowerSweepResult> towerSweepResults = new List<TowerSweepResult>();

        public int newPassFloor {
            get { return LocalSave.GetInt(StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "_NewPassTower")); }
            set { LocalSave.SetInt(StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "_NewPassTower"), value); }
        }

        public int unLockShowTower {
            get { return LocalSave.GetInt(StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "_UnLockShowTower")); }
            set { LocalSave.SetInt(StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "_UnLockShowTower"), value); }
        }

        int m_SweepBoughtTimes = 0;
        public int sweepBoughtTimes {
            get { return m_SweepBoughtTimes; }
            set {
                if (m_SweepBoughtTimes != value)
                {
                    m_SweepBoughtTimes = value;
                    if (sweepBoughtTimesChangeEvent != null)
                    {
                        sweepBoughtTimesChangeEvent(m_SweepBoughtTimes);
                    }
                }
            }

        }

        public event Action<int> selectedFloorEvent;
        public event Action<int> sweepBoughtTimesChangeEvent;

        RuneModel runeModel { get { return ModelCenter.Instance.GetModel<RuneModel>(); } }
        DailyQuestModel dailyModel { get { return ModelCenter.Instance.GetModel<DailyQuestModel>(); } }
        Redpoint redpoint = new Redpoint(37);

        bool serverInited = false;

        public override void Init()
        {
            ParseConfig();

            runeModel.OnRefreshRuneTowerLv += OnPassNewTowerFloor;
            dailyModel.dailyQuestProgressUpdateEvent += OnRuneTowerSweepTimeChange;
        }

        public override void UnInit()
        {
            runeModel.OnRefreshRuneTowerLv -= OnPassNewTowerFloor;
            dailyModel.dailyQuestProgressUpdateEvent -= OnRuneTowerSweepTimeChange;
        }

        public void RequestChallengeTower()
        {
            var dungeonModel = ModelCenter.Instance.GetModel<DungeonModel>();
            dungeonModel.SingleChallenge(RUNETOWER_MAPID, 0);
        }

        public void RequestSetDungeonAction()
        {
            var sendInfo = new CA508_tagCMDoFBAction();
            sendInfo.ActionType = 0;
            sendInfo.ActionInfo = (uint)currentFloor;
            GameNetSystem.Instance.SendInfo(sendInfo);
        }

        public int GetFloorCount(int _towerId)
        {
            if (towerFloors.ContainsKey(_towerId))
            {
                return towerFloors[_towerId].Count;
            }
            else
            {
                return 0;
            }
        }

        public int GetFloorId(int _towerId, int _floorIndex)
        {
            if (towerFloors.ContainsKey(_towerId) && towerFloors[_towerId].ContainsKey(_floorIndex))
            {
                return towerFloors[_towerId][_floorIndex];
            }
            else
            {
                return 0;
            }
        }

        public bool IsTowerLastFloor(int _floorId)
        {
            var index = sortedFloors.IndexOf(_floorId);
            if (sortedFloors.Count - 1 == index)
            {
                return true;
            }
            else
            {
                var config = Config.Instance.Get<RuneTowerFloorConfig>(_floorId);
                var nextConfig = Config.Instance.Get<RuneTowerFloorConfig>(sortedFloors[index + 1]);
                return nextConfig.TowerId > config.TowerId;
            }
        }

        public List<int> GetUnLockedRuneCategorys()
        {
            var categorys = new List<int>();
            foreach (var key in runeCategoryUnLockFloor.Keys)
            {
                var floor = runeCategoryUnLockFloor[key];
                if (floor <= currentFloor)
                {
                    categorys.Add(key);
                }
            }

            return categorys;
        }

        public List<int> GetSweepableTowers()
        {
            var passedTowers = new List<int>();

            for (int i = 0; i < sortedFloors.Count; i++)
            {
                var floor = sortedFloors[i];
                if (floor <= (int)ModelCenter.Instance.GetModel<RuneModel>().RuneTowerOpenLV)
                {
                    var config = Config.Instance.Get<RuneTowerFloorConfig>(floor);
                    if (!passedTowers.Contains(config.TowerId))
                    {
                        passedTowers.Add(config.TowerId);
                    }
                }
                else
                {
                    break;
                }
            }

            return passedTowers;
        }

        public void OnGetSweepResult(string _json)
        {
            var resultJson = JsonMapper.ToObject<TowerSweepResultJsonParser>(_json);

            var itemJson = resultJson.SDTowerItem;
            var pointJson = resultJson.SDTowerPoint;
            var fusionJson = resultJson.SDTowerYsog;

            var towerItems = new Dictionary<int, List<Item>>();
            foreach (var key in itemJson.Keys)
            {
                var items = towerItems[int.Parse(key)] = new List<Item>();
                var itemJsons = itemJson[key];
                for (int i = 0; i < itemJsons.Length; i++)
                {
                    var item = new Item(itemJsons[i].ItemID, itemJsons[i].Count);
                    items.Add(item);
                }
            }

            var towerPoints = new Dictionary<int, int>();
            foreach (var key in pointJson.Keys)
            {
                towerPoints[int.Parse(key)] = pointJson[key];
            }

            var towerYsogs = new Dictionary<int, int>();
            foreach (var key in fusionJson.Keys)
            {
                towerYsogs[int.Parse(key)] = fusionJson[key];
            }

            var tempSweepResults = new Dictionary<int, TowerSweepResult>();
            towerSweepResults.Clear();
            var latestPassedFloor = (int)yesterdayPassFloor;
            var latestPassedFloorConfig = Config.Instance.Get<RuneTowerFloorConfig>(latestPassedFloor);

            for (int i = 0; i < sortedFloors.Count; i++)
            {
                var floor = sortedFloors[i];
                if (floor <= latestPassedFloor)
                {
                    var config = Config.Instance.Get<RuneTowerFloorConfig>(floor);
                    if (!tempSweepResults.ContainsKey(config.TowerId))
                    {
                        var tempFloorId = 0;
                        if (latestPassedFloorConfig.TowerId != config.TowerId)
                        {
                            var floors = this.towerFloors[config.TowerId];
                            tempFloorId = floors[floors.Count];
                        }
                        else
                        {
                            tempFloorId = latestPassedFloor;
                        }

                        tempSweepResults[config.TowerId] = new TowerSweepResult()
                        {
                            towerId = config.TowerId,
                            floorId = tempFloorId,
                            items = new Item[] { },
                        };
                    }
                }
                else
                {
                    break;
                }
            }

            foreach (var towerId in towerItems.Keys)
            {
                var result = tempSweepResults[towerId];
                towerItems[towerId].Sort(RuneCompare);
                result.items = towerItems[towerId].ToArray();
                tempSweepResults[towerId] = result;
            }

            foreach (var towerId in towerPoints.Keys)
            {
                var result = tempSweepResults[towerId];
                result.essence = towerPoints[towerId];
                tempSweepResults[towerId] = result;
            }

            foreach (var towerId in towerYsogs.Keys)
            {
                var result = tempSweepResults[towerId];
                result.magicEssence = towerYsogs[towerId];
                tempSweepResults[towerId] = result;
            }

            towerSweepResults.Clear();
            towerSweepResults.AddRange(tempSweepResults.Values);

            WindowCenter.Instance.Open<RuneTowerSweepResultWin>();
        }

        public int GetNextUnLockFloor(int _floor)
        {
            var index = sortedFloors.IndexOf(_floor);

            for (int i = index; i < sortedFloors.Count; i++)
            {
                var floorId = sortedFloors[i];
                var config = Config.Instance.Get<RuneTowerFloorConfig>(floorId);

                if (config.UnLockRune > 0 || config.UnLockHole > 0 || config.UnLockCompose > 0)
                {
                    return floorId;
                }
            }

            return sortedFloors[sortedFloors.Count - 1];
        }

        public int GetAccumulativeUnLockHoleCount(int _floor)
        {
            var index = sortedFloors.IndexOf(_floor);
            var countSum = 1;
            for (int i = 0; i <= index; i++)
            {
                var floorId = sortedFloors[i];
                var config = Config.Instance.Get<RuneTowerFloorConfig>(floorId);
                countSum += config.UnLockHole;
            }

            return countSum;
        }

        private void OnPassNewTowerFloor()
        {
            if (serverInited && runeModel.RuneTowerOpenLV != 0)
            {
                var config = Config.Instance.Get<RuneTowerFloorConfig>((int)runeModel.RuneTowerOpenLV);

                if (config.UnLockRune > 0)
                {
                    newPassFloor = (int)runeModel.RuneTowerOpenLV;
                }

                if (!allTowerCompleted && config.TowerId != currentTower)
                {
                    unLockShowTower = config.TowerId;
                }
            }

        }

        private void OnRuneTowerSweepTimeChange(int _dailyQuestId)
        {
            if (_dailyQuestId == 11)
            {
                UpdateRedpoint();
            }
        }

        private void UpdateRedpoint()
        {
            var sweepTimes = dailyModel.GetDailyQuestCompletedTimes((int)DailyQuestType.RuneTowerSweep);
            redpoint.state = yesterdayPassFloor > 0 && sweepTimes < 1 ? RedPointState.Simple : RedPointState.None;
        }

        private void ParseConfig()
        {
            var allTowerFloors = Config.Instance.GetAllValues<RuneTowerFloorConfig>();
            foreach (var config in allTowerFloors)
            {
                Dictionary<int, int> floors;
                if (towerFloors.ContainsKey(config.TowerId))
                {
                    floors = towerFloors[config.TowerId];
                }
                else
                {
                    towerFloors[config.TowerId] = floors = new Dictionary<int, int>();
                }

                floors[config.FloorIndex] = config.ID;
                sortedFloors.Add(config.ID);
            }

            sortedFloors.Sort((int a, int b) => { return a < b ? -1 : 1; });

            var allRuneConfigs = Config.Instance.GetAllValues<RuneConfig>();
            foreach (var config in allRuneConfigs)
            {
                var itemConfig = Config.Instance.Get<ItemConfig>(config.ID);
                runeCategoryUnLockFloor[itemConfig.Effect1] = config.TowerID;
            }

        }

        public void OnMapInitOk()
        {
            switch (PlayerDatas.Instance.baseData.MapID)
            {
                case RuneTowerModel.RUNETOWER_MAPID:
                    ModelCenter.Instance.GetModel<RuneTowerModel>().RequestSetDungeonAction();
                    break;
            }
        }

        public void OnPlayerLoginOk()
        {
            serverInited = true;
        }

        public void OnBeforePlayerDataInitialize()
        {
            serverInited = false;
        }

        private int RuneCompare(Item _lhs, Item _rhs)
        {
            var configA = Config.Instance.Get<ItemConfig>(_lhs.id);
            var configB = Config.Instance.Get<ItemConfig>(_rhs.id);

            return configA.ItemColor > configB.ItemColor ? -1 : 1;
        }

    }

}