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


namespace Snxxz.UI
{
    [XLua.LuaCallCSharp]
	public class ElderGodAreaModel : Model, IMapInitOk
    {

        public const int ELDERGODAREA_MAPID = 31150;

        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 baseTimes = 0;
        public int totalTimes {
            get {
                var times = ModelCenter.Instance.GetModel<VipModel>().GetVipPrivilegeCnt(VipPrivilegeType.ForbiddenArea);
                return times + baseTimes;
            }
        }

        public event Action<int> bossSelectedEvent;
        public event Action<int> surplusTimesChangeEvent;

        List<int> sortedElites = new List<int>();
        List<int> sortedBossIds = new List<int>();
        Dictionary<int, ElderGodBossData> elderGodBosses = new Dictionary<int, ElderGodBossData>();
        Dictionary<int, int> npcAngers = new Dictionary<int, int>();

        DungeonModel dungeonModel;
        FindPreciousModel findPreciousModel;

        public override void Init()
        {
            dungeonModel = ModelCenter.Instance.GetModel<DungeonModel>();
            findPreciousModel = ModelCenter.Instance.GetModel<FindPreciousModel>();
            ParseConfig();
            baseTimes = DungeonOpenTimeConfig.Get(31150).DayTimes;
        }

        public override void UnInit()
        {
        }

        public bool TryGetBossData(int _bossId, out ElderGodBossData _data)
        {
            return elderGodBosses.TryGetValue(_bossId, out _data);
        }

        public bool IsElderGodAreaNPC(int _npcId)
        {
            return npcAngers.ContainsKey(_npcId);
        }

        public int GetElderGodAreaNPCAnger(int _npcId)
        {
            if (npcAngers.ContainsKey(_npcId))
            {
                return npcAngers[_npcId];
            }
            else
            {
                return 0;
            }
        }

        public bool IsBossUnLocked(int _bossId)
        {
            var config = ElderGodAreaConfig.Get(_bossId);
            if (config == null)
            {
                return false;
            }

            if (config.MonsterType == 1)
            {
                return true;
            }
            else
            {
                var playerLevel = PlayerDatas.Instance.baseData.LV;
                return elderGodBosses.ContainsKey(_bossId) && playerLevel >= elderGodBosses[_bossId].unLockLevel;
            }
        }

        public List<int> GetElderGodNpces()
        {
            var bosses = new List<int>();
            bosses.Add(sortedElites[0]);
            bosses.AddRange(sortedBossIds);
            return bosses;
        }

        public List<int> GetElderGodBosses()
        {
            var bosses = new List<int>();
            bosses.AddRange(sortedBossIds);
            return bosses;
        }

        public int GetRecommendNpc()
        {
            foreach (var item in sortedBossIds)
            {
                if (findPreciousModel.IsBossAlive(item))
                {
                    return item;
                }
            }

            return sortedElites[0];
        }

        public int GetRecommendEliteNpc()
        {
            var npc = 0;
            var levelDelta = int.MaxValue;
            var myLevel = PlayerDatas.Instance.baseData.LV;
            foreach (var item in sortedElites)
            {
                var config = NPCConfig.Get(item);
                var delta = Mathf.Abs(myLevel - config.NPCLV);
                if (delta < levelDelta)
                {
                    npc = item;
                    levelDelta = delta;
                }
            }

            return npc;
        }

        private void ParseConfig()
        {
            var bossConfigs = ElderGodAreaConfig.GetValues();
            for (int i = 0; i < bossConfigs.Count; i++)
            {
                var config = bossConfigs[i];
                if (config.MonsterType == 2)
                {
                    elderGodBosses[config.NPCID] = new ElderGodBossData(config.NPCID);
                }
                else
                {
                    sortedElites.Add(config.NPCID);
                }

                npcAngers[config.NPCID] = config.MonsterAnger;
            }

            sortedElites.Sort(EliteMonsterCompare);
            sortedBossIds.AddRange(elderGodBosses.Keys);
            sortedBossIds.Sort(ElderGodBossData.LevelCompare);
        }

        private int EliteMonsterCompare(int lhs, int rhs)
        {
            var config1 = NPCConfig.Get(lhs);
            var config2 = NPCConfig.Get(rhs);

            return config1.NPCLV < config2.NPCLV ? -1 : 1;
        }

        public void OnMapInitOk()
        {
            var dataMapId = dungeonModel.GetDataMapIdByMapId(PlayerDatas.Instance.baseData.MapID);
            if (dataMapId == ELDERGODAREA_MAPID)
            {
                var target = 0;
                if (sortedElites.Contains(selectedBoss))
                {
                    target = GetRecommendEliteNpc();
                }
                else
                {
                    target = selectedBoss;
                }

                MapTransferUtility.Instance.MoveToNPC(target);
            }
        }
    }

    public class ElderGodBossData
    {
        public int id { get; private set; }
        public int unLockLevel { get; set; }

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

        public static int LevelCompare(int _lhs, int _rhs)
        {
            var configA = NPCConfig.Get(_lhs);
            var configB = NPCConfig.Get(_rhs);

            return configA.NPCLV < configB.NPCLV ? -1 : 1;
        }

    }

}