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


namespace Snxxz.UI
{
    [XLua.LuaCallCSharp]
	public class WorldBossModel : Model
    {

        public const int WORLDBOSS_REDPOINT = 76001;

        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);
                    }
                }
            }
        }

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

        int m_WearyValue = 0;
        public int wearyValue {
            get { return m_WearyValue; }
            set {
                m_WearyValue = value;
                var count = GeneralDefine.bossWearyValues[0] + extraBossWearyValue - m_WearyValue;
                worldBossRedPoint.count = count;
                worldBossRedPoint.state = count > 0 ? RedPointState.Quantity : RedPointState.None;
                if (bossWearyValueChangeEvent != null)
                {
                    bossWearyValueChangeEvent();
                }
            }
        }

        int m_ExtraBossWearyValue = 0;
        public int extraBossWearyValue {
            get { return m_ExtraBossWearyValue; }
            set {
                m_ExtraBossWearyValue = value;
                if (bossWearyValueChangeEvent != null)
                {
                    bossWearyValueChangeEvent();
                }
            }
        }

        List<int> sortedBossIds = new List<int>();
        Dictionary<int, WorldBossData> worldBosses = new Dictionary<int, WorldBossData>();

        public Redpoint worldBossRedPoint = new Redpoint(FindPreciousModel.FINDPRECIOUS_REDPOINTID, WORLDBOSS_REDPOINT);
        FindPreciousModel findPreciousModel { get { return ModelCenter.Instance.GetModel<FindPreciousModel>(); } }

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

        public override void UnInit()
        {
        }

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

        public List<int> GetWorldBosses()
        {
            var activedBossIds = new List<int>();
            var mapModel = ModelCenter.Instance.GetModel<MapModel>();
            for (int i = 0; i < sortedBossIds.Count; i++)
            {
                var bossId = sortedBossIds[i];
                var config = WorldBossConfig.Get(bossId);
                var mapId = config.MapID;
                if (mapModel.IsMapUnlocked(mapId))
                {
                    activedBossIds.Add(bossId);
                }
            }

            return activedBossIds;
        }

        public List<int> GetWorldBosses(int _mapId)
        {
            var bosses = new List<int>();
            var mapModel = ModelCenter.Instance.GetModel<MapModel>();
            for (int i = 0; i < sortedBossIds.Count; i++)
            {
                var bossId = sortedBossIds[i];
                var config = WorldBossConfig.Get(bossId);
                var mapId = config.MapID;
                if (mapId == _mapId)
                {
                    bosses.Add(bossId);
                }
            }

            return bosses;
        }

        public bool IsBossUnLocked(int _bossId)
        {
            return worldBosses.ContainsKey(_bossId) && worldBosses[_bossId].isUnLocked;
        }

        public int GetLatestUnLockBoss()
        {
            var playerLevel = PlayerDatas.Instance.baseData.LV;
            for (int i = sortedBossIds.Count - 1; i >= 0; i--)
            {
                var bossId = sortedBossIds[i];
                var npcConfig = NPCConfig.Get(bossId);
                if (IsBossUnLocked(bossId) && findPreciousModel.IsBossAlive(bossId) && playerLevel >= npcConfig.NPCLV)
                {
                    return bossId;
                }
            }

            return sortedBossIds[0];
        }

        private void ParseConfig()
        {
            var worldBossConfigs = WorldBossConfig.GetValues();
            foreach (var config in worldBossConfigs)
            {
                var bossData = worldBosses[config.NPCID] = new WorldBossData(config.NPCID);
            }

            sortedBossIds.AddRange(worldBosses.Keys);
            sortedBossIds.Sort(WorldBossData.LevelCompare);
        }
    }

    public class WorldBossData
    {
        MapModel mapModel { get { return ModelCenter.Instance.GetModel<MapModel>(); } }

        public int id { get; private set; }
        public bool isUnLocked {
            get {
                var config = WorldBossConfig.Get(id);
                var mapUnLocked = mapModel.IsMapUnlocked(config.MapID);
                return mapUnLocked;
            }
        }

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

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

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

    }

}