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


namespace vnxbqy.UI
{
    
    public class BossHomeModel : Model
    {
        public const int BOSSHOME_MAPID = 31270;
        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;
                UpdateRedpoint();
                if (bossWearyValueChangeEvent != null)
                {
                    bossWearyValueChangeEvent();
                }
            }
        }

        int m_BoughtTimes = 0;
        public int boughtTimes {
            get { return m_BoughtTimes; }
            set {
                m_BoughtTimes = value;
                UpdateRedpoint();
                if (boughtTimeChangeEvent != null)
                {
                    boughtTimeChangeEvent();
                }
            }
        }

        public int remindTimes {
            get {
                var wearyValueLimit = vipModel.GetVipPrivilegeCnt(VipPrivilegeType.BossHomeAwardLimit);
                return wearyValueLimit + boughtTimes - wearyValue;
            }
        }

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

        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>(); } }
        FindPreciousModel findPreciousModel { get { return ModelCenter.Instance.GetModel<FindPreciousModel>(); } }

        public override void Init()
        {
            ParseConfig();
            PlayerDatas.Instance.playerDataRefreshEvent += OnPlayerDataChange;
            FuncOpen.Instance.OnFuncStateChangeEvent += OnFunctionOpenChange;
        }

        public override void UnInit()
        {
            PlayerDatas.Instance.playerDataRefreshEvent -= OnPlayerDataChange;
            FuncOpen.Instance.OnFuncStateChangeEvent -= OnFunctionOpenChange;
        }

        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);
            if (vipLevel < vipNeedFloor1)
            {
                return 1;
            }

            if (PlayerDatas.Instance.baseData.MapID == BOSSHOME_MAPID)
                return PlayerDatas.Instance.baseData.FBID + 1;


            for (int i = sortedBosses.Count - 1; i >= 0; i--)
            {
                var bossId = sortedBosses[i];
                var bossHomeConfig = BossHomeConfig.Get(bossId);
                if (!findPreciousModel.IsBossUnlock(bossId))
                    continue;

                if (vipLevel < GetFloorVipRequirement(bossHomeConfig.FloorNum))
                    continue;

                if (NPCConfig.Get(bossId).NPCLV > PlayerDatas.Instance.baseData.LV)
                    continue;

                return bossHomeConfig.FloorNum;
            }

            return 1;
        }

        public int GetFloorVipRequirement(int _floor)
        {
            return -1;
            //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 OnPlayerDataChange(PlayerDataType _type)
        {
            if (_type == PlayerDataType.VIPLv)
            {
                UpdateRedpoint();
            }
        }

        private void OnFunctionOpenChange(int id)
        {
            if (id == 23)
            {
                UpdateRedpoint();
            }
        }

        private void UpdateRedpoint()
        {
            if (FuncOpen.Instance.IsFuncOpen(23))
            {
                var count = remindTimes;
                bossHomeRedpoint.count = count;
                bossHomeRedpoint.state = count > 0 ? RedPointState.Quantity : RedPointState.None;
            }
            else
            {
                bossHomeRedpoint.count = 0;
                bossHomeRedpoint.state = RedPointState.None;
            }
        }

        private void ParseConfig()
        {
            var bossHomeConfigs = BossHomeConfig.GetValues();
            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 = NPCConfig.Get(a);
                var npcConfigB = NPCConfig.Get(b);
                if (npcConfigA.NPCLV == npcConfigB.NPCLV)
                {
                    var bossHomeConfigA = BossHomeConfig.Get(a);
                    var bossHomeConfigB = BossHomeConfig.Get(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 = BossHomeConfig.Get(a);
                        var bossHomeConfigB = BossHomeConfig.Get(b);
                        if (bossHomeConfigA.MonsterType != bossHomeConfigB.MonsterType)
                        {
                            return bossHomeConfigA.MonsterType < bossHomeConfigB.MonsterType ? -1 : 1;
                        }

                        return FindPreciousModel.BossCompare(a, b);
                    });
            }

            var configString = FuncConfigConfig.Get("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 = MapUtility.GetDataMapId(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>();

        FindPreciousModel findPreciousModel { get { return ModelCenter.Instance.GetModel<FindPreciousModel>(); } }

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

        public List<int> GetShowBosses()
        {
            var bosses = new List<int>();
            var lockedCount = 0;
            for (var i = 0; i < bossIds.Count; i++)
            {
                var bossId = bossIds[i];
                var bossHomeConfig = BossHomeConfig.Get(bossId);
                if (bossHomeConfig.MonsterType == 1)
                {
                    bosses.Add(bossId);
                }
                else
                {
                    if (findPreciousModel.IsBossUnlock(bossId))
                    {
                        bosses.Add(bossId);
                    }
                    else
                    {
                        if (lockedCount < FindPreciousModel.ShowLockBossCnt)
                        {
                            bosses.Add(bossId);
                            lockedCount++;
                        }
                    }
                }
            }

            if (bosses.Count == 0)
            {
                bosses.Add(bossIds[0]);
            }

            return bosses;
        }

        public int GetRecommendNpc()
        {
            for (var i = bossIds.Count - 1; i >= 0; i--)
            {
                var bossId = bossIds[i];
                var bossHomeConfig = BossHomeConfig.Get(bossId);
                if (bossHomeConfig.MonsterType == 2
                    && findPreciousModel.IsBossUnlock(bossId)
                    && findPreciousModel.IsPlayerLevelLargerOrBiggerThanBoss(bossId))
                {
                    return bossIds[i];
                }
            }

            return bossIds[0];
        }
    }

}