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

namespace Snxxz.UI
{
    public class BossHomeModel : Model, IMapInitOk
    {
        public const int BOSSHOME_MAPID = 31020;
        public const int BOSSHOME_REDPOINT = 76002;

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

        int m_SelectedBoss = 0;
        public int selectedBoss {
            get {
                return this.m_SelectedBoss;
            }
            set {
                if (this.m_SelectedBoss != value)
                {
                    this.m_SelectedBoss = value;
                    if (bossSelectedEvent != null)
                    {
                        bossSelectedEvent(value);
                    }
                }
            }
        }

        int m_WearyValue = 0;
        public int wearyValue {
            get { return m_WearyValue; }
            set {
                m_WearyValue = value;

                var count = vipModel.GetVipPrivilegeCnt(VipPrivilegeType.BossHomeAwardLimit) - m_WearyValue;
                bossHomeRedpoint.count = count;
                bossHomeRedpoint.state = count > 0 ? RedPointState.Quantity : RedPointState.None;

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

        public event Action<int> bossHomeFloorSelectedEvent;
        public event Action<int> bossSelectedEvent;
        public event Action bossWearyValueChangeEvent;

        public Redpoint bossHomeRedpoint = new Redpoint(FindPreciousModel.FINDPRECIOUS_REDPOINTID, BOSSHOME_REDPOINT);
        Dictionary<int, BossHomeData> bossHomes = new Dictionary<int, BossHomeData>();
        Dictionary<int, int> vipLackFloorCost = new Dictionary<int, int>();
        List<int> sortedBosses = new List<int>();
        VipModel vipModel { get { return ModelCenter.Instance.GetModel<VipModel>(); } }

        public override void Init()
        {
            ParseConfig();
        }

        public override void UnInit()
        {
        }

        public bool TryGetBossHomeData(int _layer, out BossHomeData _data)
        {
            return bossHomes.TryGetValue(_layer, out _data);
        }

        public int GetRecommendFloor()
        {
            var vipLevel = PlayerDatas.Instance.baseData.VIPLv;
            var vipNeedFloor1 = GetFloorVipRequirement(1);
            var myLevel = PlayerDatas.Instance.baseData.LV;

            var maxFloor = 1;
            for (int i = 0; i < sortedBosses.Count; i++)
            {
                var bossId = sortedBosses[i];
                var config = Config.Instance.Get<NPCConfig>(bossId);
                var bossHomeConfig = Config.Instance.Get<BossHomeConfig>(bossId);
                if (vipLevel < vipNeedFloor1)
                {
                    if (config.NPCLV > myLevel)
                    {
                        return bossHomeConfig.FloorNum;
                    }
                }
                else
                {
                    if (vipLevel >= GetFloorVipRequirement(bossHomeConfig.FloorNum) && myLevel < config.NPCLV)
                    {
                        return bossHomeConfig.FloorNum;
                    }
                }

                if (bossHomeConfig.FloorNum > maxFloor)
                {
                    maxFloor = bossHomeConfig.FloorNum;
                }
            }

            return maxFloor;
        }

        public int GetFloorVipRequirement(int _floor)
        {
            var vipFloors = VipPrivilegeConfig.GetVipPrivilegeDic(VipPrivilegeType.BossHome);
            foreach (var key in vipFloors.Keys)
            {
                if (vipFloors[key] == _floor)
                {
                    return key;
                }
            }

            return 16;
        }

        public int GetVipLackCost(int _floor)
        {
            if (vipLackFloorCost.ContainsKey(_floor))
            {
                return vipLackFloorCost[_floor];
            }
            else
            {
                return 0;
            }
        }

        private void ParseConfig()
        {
            var bossHomeConfigs = Config.Instance.GetAllValues<BossHomeConfig>();
            foreach (var config in bossHomeConfigs)
            {
                BossHomeData bossHomeData;
                if (bossHomes.ContainsKey(config.FloorNum))
                {
                    bossHomeData = bossHomes[config.FloorNum];
                }
                else
                {
                    bossHomeData = bossHomes[config.FloorNum] = new BossHomeData(config.FloorNum);
                }

                bossHomeData.bossIds.Add(config.NPCID);
                if (config.MonsterType == 2)
                {
                    sortedBosses.Add(config.NPCID);
                }
            }

            sortedBosses.Sort((int a, int b) =>
            {
                var npcConfigA = Config.Instance.Get<NPCConfig>(a);
                var npcConfigB = Config.Instance.Get<NPCConfig>(b);
                if (npcConfigA.NPCLV == npcConfigB.NPCLV)
                {
                    var bossHomeConfigA = Config.Instance.Get<BossHomeConfig>(a);
                    var bossHomeConfigB = Config.Instance.Get<BossHomeConfig>(b);

                    return bossHomeConfigA.FloorNum > bossHomeConfigB.FloorNum ? -1 : 1;
                }
                else
                {
                    return npcConfigA.NPCLV < npcConfigB.NPCLV ? -1 : 1;
                }
            });

            foreach (var bossHomeData in bossHomes.Values)
            {
                bossHomeData.bossIds.Sort(
                    (int a, int b) =>
                    {
                        var bossHomeConfigA = Config.Instance.Get<BossHomeConfig>(a);
                        var bossHomeConfigB = Config.Instance.Get<BossHomeConfig>(b);
                        if (bossHomeConfigA.MonsterType != bossHomeConfigB.MonsterType)
                        {
                            return bossHomeConfigA.MonsterType < bossHomeConfigB.MonsterType ? -1 : 1;
                        }

                        var npcConfigA = Config.Instance.Get<NPCConfig>(a);
                        var npcConfigB = Config.Instance.Get<NPCConfig>(b);
                        return npcConfigA.NPCLV < npcConfigB.NPCLV ? -1 : 1;
                    });
            }

            var configString = Config.Instance.Get<FuncConfigConfig>("BossHomeCost").Numerical1;
            var keyValues = configString.Split('|');
            for (int i = 0; i < keyValues.Length; i++)
            {
                var stringArray = keyValues[i].Split('_');
                var floor = int.Parse(stringArray[0]);
                var cost = int.Parse(stringArray[1]);
                vipLackFloorCost[floor] = cost;
            }

        }

        public void OnMapInitOk()
        {
            var dataMapId = ModelCenter.Instance.GetModel<DungeonModel>().GetDungeonDataIdByMapId(PlayerDatas.Instance.baseData.MapID);
            if (dataMapId == BOSSHOME_MAPID)
            {
                MapTransferUtility.Instance.MoveToNPC(selectedBoss);
            }
        }
    }

    public class BossHomeData
    {
        public int id { get; private set; }
        public List<int> bossIds = new List<int>();

        public BossHomeData(int _id)
        {
            this.id = _id;
        }

        public int GetRecommendNpc()
        {
            var playerLevel = PlayerDatas.Instance.baseData.LV;
            var recommendNpc = bossIds[bossIds.Count - 1];

            for (int i = 0; i < bossIds.Count; i++)
            {
                var bossHomeConfig = Config.Instance.Get<BossHomeConfig>(bossIds[i]);
                var npcConfig = Config.Instance.Get<NPCConfig>(bossIds[i]);
                if (bossHomeConfig.MonsterType == 2 && playerLevel < npcConfig.NPCLV)
                {
                    recommendNpc = bossIds[i];
                    break;
                }
            }
            return recommendNpc;
        }

    }

}