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

using System;

namespace vnxbqy.UI
{
    
    
    public class JadeDynastyBossModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk, IAfterPlayerDataInitialize
    {
        List<JadeDynastyBossData> jadeDynastyBosses = new List<JadeDynastyBossData>();
        Dictionary<int, JadeDynastyBossLine> jadeDynastyBossLineDict = new Dictionary<int, JadeDynastyBossLine>();
        Dictionary<int, List<Item>> dropItemDict = new Dictionary<int, List<Item>>();

        public const int JADEDYNASTY_MAP = 31380;
        public const int FUNCTIONID = 163;
        public const int JADEDYNASTY_REDPOINTID = 77003;

        public event Action<int> selectBossRefresh;
        public event Action bossLineRefresh;
        public event Action jadeDynastyScoreRefresh;

        public int challengeLimitCount { get; private set; }
        public int challengeTimes { get; private set; }

        int m_SelectBossId = 0;
        public int selectBossId
        {
            get { return m_SelectBossId; }
            set
            {
                if (m_SelectBossId != value)
                {
                    m_SelectBossId = value;
                    if (selectBossRefresh != null)
                    {
                        selectBossRefresh(value);
                    }
                }
            }
        }

        public int assginSelectBossId { get; set; }

        public readonly Redpoint redpoint = new Redpoint(FindPreciousModel.FINDPRECIOUS_REDPOINTID, JADEDYNASTY_REDPOINTID);

        MapModel mapModel { get { return ModelCenter.Instance.GetModel<MapModel>(); } }
        DungeonModel dungeonModel { get { return ModelCenter.Instance.GetModel<DungeonModel>(); } }
        FindPreciousModel findPreciousModel { get { return ModelCenter.Instance.GetModel<FindPreciousModel>(); } }
        PackModel packModel { get { return ModelCenter.Instance.GetModel<PackModel>(); } }
        public override void Init()
        {
            //ParseConfig();

        }

        public void OnBeforePlayerDataInitialize()
        {
            jadeDynastyBossLineDict.Clear();
            challengeTimes = 0;
        }

        public void OnAfterPlayerDataInitialize()
        {
        }

        public void OnPlayerLoginOk()
        {
            //UpdateRedpoint();

            //var bossId = GetLatestUnLockBoss();
            //AutoSubscribeLastUnLockBoss(bossId);
        }

        public override void UnInit()
        {

        }

        void ParseConfig()
        {
            {
                var configs = JadeDynastyBossConfig.GetValues();
                foreach (var config in configs)
                {
                    var dungeonId = dungeonModel.GetDungeonId(JADEDYNASTY_MAP, config.LineID);
                    var dungeonConfig = DungeonConfig.Get(dungeonId);
                    jadeDynastyBosses.Add(new JadeDynastyBossData()
                    {
                        bossNpcId = config.NPCID,
                        lineId = config.LineID,
                        challengeCondition = new JadeDynastyBossCondition()
                        {
                            level = dungeonConfig.LVLimitMin,
                            realmLevel = config.RealmLV,
                        },
                        conditionSorts = new List<int>(config.conditionSorts),
                    });

                    var itemArray = LitJson.JsonMapper.ToObject<int[][]>(config.dropItems);
                    List<Item> list = new List<Item>();
                    for (int k = 0; k < itemArray.Length; k++)
                    {
                        Item item = new Item()
                        {
                            id = itemArray[k][0],
                            count = itemArray[k][1],
                        };
                        list.Add(item);
                    }
                    dropItemDict.Add(config.NPCID, list);
                }

                jadeDynastyBosses.Sort(SortCompare);
            }

            {
                var config = FuncConfigConfig.Get("ZhuXianBossCntCfg");
                challengeLimitCount = int.Parse(config.Numerical2);
            }
        }

        private void AutoSubscribeLastUnLockBoss(int _bossId)
        {
            if (_bossId == 0)
            {
                return;
            }

            foreach (var boss in jadeDynastyBosses)
            {
                if (findPreciousModel.IsBossAutoSubscribe(boss.bossNpcId) && boss.bossNpcId != _bossId)
                {
                    findPreciousModel.RequestDeSubscribeBoss(boss.bossNpcId);
                }
            }

            if (_bossId != 0 && findPreciousModel.IsBossNeverSubscribe((int)_bossId))
            {
                var condition = 0;
                if (IsBossUnLocked(_bossId, out condition))
                {
                    var config = JadeDynastyBossConfig.Get(_bossId);
                    if (config.AutoAttention == 1)
                    {
                        findPreciousModel.RequestSubscribeBoss((int)_bossId, true);
                        if (findPreciousModel.IsBossAlive((int)_bossId))
                        {
                            findPreciousModel.AddOneBossRebornNotify(_bossId);
                        }
                    }
                }
            }
        }

        public bool IsJadeDynastyBoss(int bossNpcId)
        {
            var index = jadeDynastyBosses.FindIndex((x) =>
            {
                return x.bossNpcId == bossNpcId;
            });
            return index >= 0;
        }

        public bool IsBossUnLocked(int bossNpcId, out int condition)
        {
            condition = 0;
            var index = jadeDynastyBosses.FindIndex((x) =>
            {
                return x.bossNpcId == bossNpcId;
            });
            if (index != -1)
            {
                var boss = jadeDynastyBosses[index];
                var challengeCondition = jadeDynastyBosses[index].challengeCondition;
                foreach (var code in boss.conditionSorts)
                {
                    switch (code)
                    {
                        case 1:
                            if (PlayerDatas.Instance.baseData.LV < challengeCondition.level)
                            {
                                condition = 1;
                                return false;
                            }
                            break;
                        case 2:
                            if (PlayerDatas.Instance.baseData.realmLevel < challengeCondition.realmLevel)
                            {
                                condition = 2;
                                return false;
                            }
                            break;
                    }
                }
                if (PlayerDatas.Instance.baseData.LV < challengeCondition.level)
                {
                    condition = 1;
                    return false;
                }
                if (PlayerDatas.Instance.baseData.realmLevel < challengeCondition.realmLevel)
                {
                    condition = 2;
                    return false;
                }
            }
            else
            {
                return false;
            }
            return true;
        }

        public List<int> GetJadeDynastyBosses()
        {
            List<int> list = new List<int>();
            foreach (var boss in jadeDynastyBosses)
            {
                list.Add(boss.bossNpcId);
            }
            return list;
        }

        public int GetParticipantCount(int bossId)
        {
            var index = jadeDynastyBosses.FindIndex((x) =>
              {
                  return x.bossNpcId == bossId;
              });
            var lineId = -1;
            if (index != -1)
            {
                lineId = jadeDynastyBosses[index].lineId;
            }
            if (jadeDynastyBossLineDict.ContainsKey(lineId))
            {
                return jadeDynastyBossLineDict[lineId].playerCount;
            }
            return 0;
        }

        public int GetLatestUnLockBoss()
        {
            if (FuncOpen.Instance.IsFuncOpen(FUNCTIONID))
            {
                var latestBossId = jadeDynastyBosses[0].bossNpcId;
                foreach (var boss in jadeDynastyBosses)
                {
                    var condition = 0;
                    if (IsBossUnLocked(boss.bossNpcId, out condition))
                    {
                        latestBossId = boss.bossNpcId;
                    }
                }
                return latestBossId;
            }
            else
            {
                return jadeDynastyBosses[0].bossNpcId;
            }
        }

        public int GetRecommandBoss()
        {
            var bosses = new List<int>();
            foreach (var boss in jadeDynastyBosses)
            {
                bosses.Add(boss.bossNpcId);
            }
            bosses.Sort(FindPreciousModel.BossCompare);

            var preferBoss = 0;
            for (int i = bosses.Count - 1; i >= 0; i--)
            {
                var bossId = bosses[i];
                var condition = 0;
                if (IsBossUnLocked(bossId, out condition)
                    && findPreciousModel.IsPlayerLevelLargerOrBiggerThanBoss(bossId))
                {
                    if (preferBoss == 0)
                    {
                        preferBoss = bossId;
                    }

                    if (findPreciousModel.IsBossAlive(bossId)
                        && findPreciousModel.IsSameBigRealmStageBoss(bossId))
                    {
                        return bossId;
                    }
                }
            }

            if (preferBoss == 0)
            {
                preferBoss = bosses[0];
            }

            return preferBoss;
        }

        public bool TryGetDropItems(int bossId, out List<Item> dropItems)
        {
            return dropItemDict.TryGetValue(bossId, out dropItems);
        }

        public bool TryGetCondition(int bossId, out JadeDynastyBossCondition condition)
        {
            var index = jadeDynastyBosses.FindIndex((x) =>
            {
                return x.bossNpcId == bossId;
            });
            condition = default(JadeDynastyBossCondition);
            if (index != -1)
            {
                condition = jadeDynastyBosses[index].challengeCondition;
            }
            return index != -1;
        }

        public bool TryGetBossLine(int bossId, out JadeDynastyBossLine mapLineState)
        {
            var index = jadeDynastyBosses.FindIndex((x) =>
            {
                return x.bossNpcId == bossId;
            });
            var lineId = -1;
            if (index != -1)
            {
                lineId = jadeDynastyBosses[index].lineId;
            }
            return jadeDynastyBossLineDict.TryGetValue(lineId, out mapLineState);
        }

        public bool TryEnterDungeon(int bossId,out int error)
        {
            var condition = 0;
            error = 0;
            if (!IsBossUnLocked(bossId, out condition))
            {
                switch (condition)
                {
                    case 1:
                        error = 1;
                        break;
                    case 2:
                        error = 2;
                        break;
                    case 3:
                        error = 3;
                        break;
                }
                return false;
            }

            var totalTimes = dungeonModel.GetTotalTimes(JADEDYNASTY_MAP);
            var enterTimes = dungeonModel.GetEnterTimes(JADEDYNASTY_MAP);
            if (enterTimes >= totalTimes)
            {
                error = 4;
                return false;
            }

            if (!findPreciousModel.IsBossAlive(bossId))
            {
                error = 5;
                return false;
            }

            if (CrossServerUtility.IsCrossServer())
            {
                error = 6;
                return false;
            }
            return true;
        }

        public void DisplayErrorTip(int error)
        {
            switch (error)
            {
                case 1:
                    SysNotifyMgr.Instance.ShowTip("TryEnterJadeDynastyBossError_1");
                    break;
                case 2:
                    SysNotifyMgr.Instance.ShowTip("TryEnterJadeDynastyBossError_2");
                    break;
                case 3:
                    SysNotifyMgr.Instance.ShowTip("TryEnterJadeDynastyBossError_3");
                    break;
                case 4:
                    SysNotifyMgr.Instance.ShowTip("TryEnterJadeDynastyBossError_4");
                    break;
                case 5:
                    SysNotifyMgr.Instance.ShowTip("TryEnterJadeDynastyBossError_5");
                    break;
                case 6:
                    SysNotifyMgr.Instance.ShowTip("CrossMap10");
                    break;
            }
        }

        public void OnReceivePackage(HA007_tagGCFBLinePlayerCnt package)
        {
            if (package.MapID != JADEDYNASTY_MAP)
            {
                return;
            }

            jadeDynastyBossLineDict.Clear();
            for (int i = 0; i < package.Count; i++)
            {
                var mapState = package.FBLineInfoList[i];
                jadeDynastyBossLineDict[mapState.FBLineID] = new JadeDynastyBossLine()
                {
                    playerCount = mapState.PlayerCnt,
                    belongToPlayerName = mapState.ExtraStr,
                };
            }

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

        public static int SortCompare(JadeDynastyBossData lhs, JadeDynastyBossData rhs)
        {
            if (lhs.challengeCondition.level != rhs.challengeCondition.level)
            {
                return lhs.challengeCondition.level.CompareTo(rhs.challengeCondition.level);
            }
            if (lhs.challengeCondition.realmLevel != rhs.challengeCondition.realmLevel)
            {
                return lhs.challengeCondition.realmLevel.CompareTo(rhs.challengeCondition.realmLevel);
            }
            return 0;
        }

        private void OnDungeonRecordUpdate(int _dataMapId)
        {
            if (JADEDYNASTY_MAP == _dataMapId)
            {
                UpdateRedpoint();
            }
        }

        private void OnDungeonBuyCount()
        {
            UpdateRedpoint();
        }

        private void OnFuncStateChangeEvent(int id)
        {
            if (id == FUNCTIONID)
            {
                UpdateRedpoint();
                var bossId = GetLatestUnLockBoss();
                AutoSubscribeLastUnLockBoss(bossId);
            }
        }

        private void PlayerDataRefreshInfoEvent(PlayerDataType refreshType)
        {
            if(refreshType==PlayerDataType.RealmLevel
                || refreshType == PlayerDataType.LV)
            {
                UpdateRedpoint();
                if (FuncOpen.Instance.IsFuncOpen(FUNCTIONID))
                {
                    var bossId = GetLatestUnLockBoss();
                    AutoSubscribeLastUnLockBoss(bossId);
                }
            }
        }

        private void RefreshItemCountAct(PackType packType, int arg2, int arg3)
        {
        }

        void UpdateRedpoint()
        {
            if (FuncOpen.Instance.IsFuncOpen(FUNCTIONID))
            {
                var existAnyChallengeable = false;
                var condition = 0;
                foreach (var boss in jadeDynastyBosses)
                {
                    if (IsBossUnLocked(boss.bossNpcId, out condition))
                    {
                        existAnyChallengeable = true;
                        break;
                    }
                }
                if (existAnyChallengeable)
                {
                    var count = dungeonModel.GetTotalTimes(JADEDYNASTY_MAP) - dungeonModel.GetEnterTimes(JADEDYNASTY_MAP);
                    redpoint.count = count;
                }
                else
                {
                    redpoint.count = 0;
                }
            }
            else
            {
                redpoint.count = 0;
            }

            redpoint.state = redpoint.count > 0 ? RedPointState.Quantity : RedPointState.None;
        }
    }

    public struct JadeDynastyBossData
    {
        public int bossNpcId;
        public int lineId;
        public JadeDynastyBossCondition challengeCondition;
        public List<int> conditionSorts;
    }

    public struct JadeDynastyBossCondition
    {
        public int level;
        public int realmLevel;
    }

    public struct JadeDynastyBossLine
    {
        public int playerCount;
        public string belongToPlayerName;
    }
}