using System.Collections;  
 | 
using System.Collections.Generic;  
 | 
using UnityEngine;  
 | 
using System;  
 | 
using UnityEngine.Events;  
 | 
  
 | 
namespace Snxxz.UI  
 | 
{  
 | 
      
 | 
    public class WorldBossModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk  
 | 
    {  
 | 
        public const int WORLDBOSS_REDPOINT = 76001;  
 | 
        public const int WORLDBOSSADDTIMES_REDPOINT = 76010;  
 | 
        public int WorldBossMaxCount { get { return GeneralDefine.bossWearyValues[0]; } }  
 | 
  
 | 
        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;  
 | 
                UpdateRedpoint();  
 | 
                if (bossWearyValueChangeEvent != null)  
 | 
                {  
 | 
                    bossWearyValueChangeEvent();  
 | 
                }  
 | 
            }  
 | 
        }  
 | 
  
 | 
        int m_ExtraBossWearyValue = 0;  
 | 
        public int extraBossWearyValue {  
 | 
            get { return m_ExtraBossWearyValue; }  
 | 
            set {  
 | 
                m_ExtraBossWearyValue = value;  
 | 
                if (bossWearyValueChangeEvent != null)  
 | 
                {  
 | 
                    bossWearyValueChangeEvent();  
 | 
                }  
 | 
            }  
 | 
        }  
 | 
  
 | 
        public bool funcOpenClickSymbol {  
 | 
            get { return LocalSave.GetBool("WorldBossClickSymbol_" + PlayerDatas.Instance.PlayerId); }  
 | 
            set {  
 | 
                LocalSave.SetBool("WorldBossClickSymbol_" + PlayerDatas.Instance.PlayerId, value);  
 | 
            }  
 | 
        }  
 | 
  
 | 
        bool isServerPrepare = false;  
 | 
  
 | 
        List<int> sortedBossIds = new List<int>();  
 | 
        Dictionary<int, WorldBossData> worldBosses = new Dictionary<int, WorldBossData>();  
 | 
  
 | 
        public Redpoint worldBossRedPoint = new Redpoint(FindPreciousModel.FINDPRECIOUS_REDPOINTID, WORLDBOSS_REDPOINT);  
 | 
        public Redpoint worldBossAddTimeRedPoint = new Redpoint(WORLDBOSSADDTIMES_REDPOINT);  
 | 
        FindPreciousModel findPreciousModel { get { return ModelCenter.Instance.GetModel<FindPreciousModel>(); } }  
 | 
        private PackModel m_PackModel { get { return ModelCenter.Instance.GetModel<PackModel>(); } }  
 | 
  
 | 
        public override void Init()  
 | 
        {  
 | 
            ParseConfig();  
 | 
            FuncOpen.Instance.OnFuncStateChangeEvent += OnFunctionChange;  
 | 
            FunctionalGuideCenter.Instance.beginGuideEvent += GuideBeginEvent;  
 | 
        }  
 | 
  
 | 
        public override void UnInit()  
 | 
        {  
 | 
            FuncOpen.Instance.OnFuncStateChangeEvent -= OnFunctionChange;  
 | 
            FunctionalGuideCenter.Instance.beginGuideEvent -= GuideBeginEvent;  
 | 
        }  
 | 
  
 | 
        public int GetWorldBossRemainCount()  
 | 
        {  
 | 
            var wearyValueLimit = WorldBossMaxCount + extraBossWearyValue;  
 | 
            return wearyValueLimit - wearyValue;  
 | 
        }  
 | 
  
 | 
  
 | 
        public void OnBeforePlayerDataInitialize()  
 | 
        {  
 | 
            isServerPrepare = false;  
 | 
        }  
 | 
  
 | 
        public void OnPlayerLoginOk()  
 | 
        {  
 | 
            isServerPrepare = true;  
 | 
        }  
 | 
  
 | 
        public bool TryGetBossData(int _bossId, out WorldBossData _data)  
 | 
        {  
 | 
            return worldBosses.TryGetValue(_bossId, out _data);  
 | 
        }  
 | 
  
 | 
        public void UpdateAddTimesRedPoint()  
 | 
        {  
 | 
            int remainCount = GetWorldBossRemainCount();  
 | 
            if (remainCount == 0)  
 | 
            {  
 | 
                if (m_PackModel.GetItemCountByID(PackType.Item, 4680) > 0 &&  
 | 
                m_PackModel.GetItemTotalUsedTimes(4680) > m_PackModel.GetItemUsedTimesToday(4680))  
 | 
                {  
 | 
                    worldBossAddTimeRedPoint.state = RedPointState.Simple;  
 | 
                }  
 | 
            }  
 | 
            else if(remainCount < WorldBossMaxCount)  
 | 
            {  
 | 
                if (m_PackModel.GetItemCountByID(PackType.Item, 1128) > 0 &&  
 | 
                ItemConfig.Get(1128).MaxSkillCnt > m_PackModel.GetItemUsedTimesToday(1128))  
 | 
                {  
 | 
                    worldBossAddTimeRedPoint.state = RedPointState.Simple;  
 | 
                }  
 | 
                else if (m_PackModel.GetItemCountByID(PackType.Item, 1129) > 0 &&  
 | 
                 ItemConfig.Get(1129).MaxSkillCnt > m_PackModel.GetItemUsedTimesToday(1129))  
 | 
                {  
 | 
                    worldBossAddTimeRedPoint.state = RedPointState.Simple;  
 | 
                }  
 | 
            }  
 | 
        }  
 | 
  
 | 
        public List<int> GetWorldBosses()  
 | 
        {  
 | 
            var activedBossIds = new List<int>();  
 | 
            var lockedCount = 0;  
 | 
            for (int i = 0; i < sortedBossIds.Count; i++)  
 | 
            {  
 | 
                var bossId = sortedBossIds[i];  
 | 
                if (findPreciousModel.IsBossUnlock(bossId))  
 | 
                {  
 | 
                    activedBossIds.Add(bossId);  
 | 
                }  
 | 
                else  
 | 
                {  
 | 
                    if (lockedCount < FindPreciousModel.ShowLockBossCnt)  
 | 
                    {  
 | 
                        activedBossIds.Add(bossId);  
 | 
                        lockedCount++;  
 | 
                    }  
 | 
                }  
 | 
            }  
 | 
  
 | 
            return activedBossIds;  
 | 
        }  
 | 
  
 | 
        public List<int> GetWorldBosses(int _mapId)  
 | 
        {  
 | 
            var bosses = new List<int>();  
 | 
            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 int GetRecommendBoss()  
 | 
        {  
 | 
            var preferBoss = 0;  
 | 
            for (int i = sortedBossIds.Count - 1; i >= 0; i--)  
 | 
            {  
 | 
                var bossId = sortedBossIds[i];  
 | 
                if (findPreciousModel.IsBossUnlock(bossId) && findPreciousModel.IsPlayerLevelLargerOrBiggerThanBoss(bossId))  
 | 
                {  
 | 
                    if (preferBoss == 0)  
 | 
                    {  
 | 
                        preferBoss = bossId;  
 | 
                    }  
 | 
  
 | 
                    if (findPreciousModel.IsBossAlive(bossId) && findPreciousModel.IsSameBigRealmStageBoss(bossId))  
 | 
                    {  
 | 
                        return bossId;  
 | 
                    }  
 | 
                }  
 | 
            }  
 | 
  
 | 
            if (preferBoss == 0)  
 | 
            {  
 | 
                preferBoss = sortedBossIds[0];  
 | 
            }  
 | 
  
 | 
            return preferBoss;  
 | 
        }  
 | 
  
 | 
        private void OnFunctionChange(int id)  
 | 
        {  
 | 
            if (id == 21)  
 | 
            {  
 | 
                UpdateRedpoint();  
 | 
  
 | 
                if (isServerPrepare && FuncOpen.Instance.IsFuncOpen(21))  
 | 
                {  
 | 
                    funcOpenClickSymbol = true;  
 | 
                }  
 | 
            }  
 | 
        }  
 | 
  
 | 
        private void GuideBeginEvent(int guideId)  
 | 
        {  
 | 
            if (guideId == 111)  
 | 
            {  
 | 
                funcOpenClickSymbol = true;  
 | 
            }  
 | 
        }  
 | 
  
 | 
        private void UpdateRedpoint()  
 | 
        {  
 | 
            if (FuncOpen.Instance.IsFuncOpen(21))  
 | 
            {  
 | 
                var count = GeneralDefine.bossWearyValues[0] + extraBossWearyValue - m_WearyValue;  
 | 
                worldBossRedPoint.count = count;  
 | 
                worldBossRedPoint.state = count > 0 ? RedPointState.Quantity : RedPointState.None;  
 | 
            }  
 | 
            else  
 | 
            {  
 | 
                worldBossRedPoint.state = RedPointState.None;  
 | 
            }  
 | 
        }  
 | 
  
 | 
        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(FindPreciousModel.BossCompare);  
 | 
        }  
 | 
    }  
 | 
  
 | 
    public class WorldBossData  
 | 
    {  
 | 
        public int id { get; private set; }  
 | 
        public WorldBossData(int _id)  
 | 
        {  
 | 
            this.id = _id;  
 | 
        }  
 | 
  
 | 
    }  
 | 
  
 | 
}  
 |