using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace vnxbqy.UI
{
    
    
    public class RidingPetBossModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk
    {
        Dictionary<int, bool> m_BossAliceStates = new Dictionary<int, bool>();

        public const int RIDINGPETBOSS_MAP = 31200;

        public int[] BossIDArray;
        public int[] Boss1RewardIDArray;
        public int[] Boss2RewardIDArray;

        Dictionary<int, RidingPetBossLine> RidingPetBossLineDict = new Dictionary<int, RidingPetBossLine>();
        private string m_MountsBossID;
        private string m_Boss1RewardID;
        private string m_Boss2RewardID;

        Dictionary<int, List<RidingPetBossReward>> m_PreviewItems = new Dictionary<int, List<RidingPetBossReward>>();

        public readonly Redpoint redpoint = new Redpoint(218, 21801);

        public event Action GetRidingPetBossLineDictAction;
        public event Action onBossStateRefresh;

        DailyQuestModel dailyQuestModel { get { return ModelCenter.Instance.GetModel<DailyQuestModel>(); } }

        public override void Init()
        {
            m_MountsBossID = FuncConfigConfig.Get("QCBOSSID").Numerical1;
            m_Boss1RewardID = FuncConfigConfig.Get("QCBOSSID").Numerical2;
            m_Boss2RewardID = FuncConfigConfig.Get("QCBOSSID").Numerical3;
            BossIDArray = ConfigParse.GetMultipleStr<int>(m_MountsBossID);
            Boss1RewardIDArray = ConfigParse.GetMultipleStr<int>(m_Boss1RewardID);
            Boss2RewardIDArray = ConfigParse.GetMultipleStr<int>(m_Boss2RewardID);

            var configs = RidingPetBossRewardConfig.GetValues();
            foreach (var config in configs)
            {
                List<RidingPetBossReward> bossRewards;
                if (!m_PreviewItems.TryGetValue(config.lineId, out bossRewards))
                {
                    bossRewards = new List<RidingPetBossReward>();
                    m_PreviewItems.Add(config.lineId, bossRewards);
                }
                var worldLevelArea = LitJson.JsonMapper.ToObject<int[]>(config.worldLevel);
                var rankArea = LitJson.JsonMapper.ToObject<int[]>(config.rank);
                var itemArray = LitJson.JsonMapper.ToObject<int[][]>(config.items);
                var items = new List<Item>(itemArray.Length);
                for (int i = 0; i < itemArray.Length; i++)
                {
                    items.Add(new Item()
                    {
                        id = itemArray[i][0],
                        count = itemArray[i][1],
                        quality = itemArray[i].Length > 2 ? itemArray[i][2] : 0,
                    });
                }
                bossRewards.Add(new RidingPetBossReward()
                {
                    worldLevelArea = new Int2(worldLevelArea[0], worldLevelArea[1]),
                    rankArea = new Int2(rankArea[0], rankArea[1]),
                    items = items
                });
            }

            DailyQuestActionTimer.Instance.RefreshDailyQuestState += RefreshDailyQuestState;
        }

        public void OnBeforePlayerDataInitialize()
        {
            m_BossAliceStates.Clear();
        }

        public void OnPlayerLoginOk()
        {
            UpdateRedpoint();
        }

        public override void UnInit()
        {
            DailyQuestActionTimer.Instance.RefreshDailyQuestState -= RefreshDailyQuestState;
        }

        public bool TryGetPreviewItems(int lineId, out List<RidingPetBossReward> bossRewards)
        {
            bossRewards = null;
            if (m_PreviewItems.ContainsKey(lineId))
            {
                var worldLevel = PlayerDatas.Instance.worldLv;
                bossRewards = m_PreviewItems[lineId].FindAll((x) =>
                 {
                     return x.SatisfyCondition((int)worldLevel);
                 });
                return bossRewards != null;
            }
            return false;
        }

        private void RefreshDailyQuestState()
        {
            UpdateRedpoint();
        }

        public void ReceivePackage(HAC07_tagGCHorsePetBossInfo package)
        {
            m_BossAliceStates[0] = !MathUtility.GetBitValue(package.IsEnd, 0);
            m_BossAliceStates[1] = !MathUtility.GetBitValue(package.IsEnd, 1);
            if (onBossStateRefresh != null)
            {
                onBossStateRefresh();
            }

            UpdateRedpoint();
        }

        public void ReceivePackage(HA007_tagGCFBLinePlayerCnt package)
        {
            if (package.MapID != RIDINGPETBOSS_MAP)
            {
                return;
            }

            RidingPetBossLineDict.Clear();

            for (int i = 0; i < package.Count; i++)
            {
                var mapState = package.FBLineInfoList[i];
                RidingPetBossLineDict[mapState.FBLineID] = new RidingPetBossLine()
                {
                    playerCnt = mapState.PlayerCnt,
                    remainedHP = int.Parse(mapState.ExtraStr)
                };
            }
            if (GetRidingPetBossLineDictAction != null)
            {
                GetRidingPetBossLineDictAction();
            }
        }

        public string GetBossName(int index)
        {
            return NPCConfig.Get(BossIDArray[index]).charName;
        }

        public int GetBossRemianedHP(int index)
        {
            if (RidingPetBossLineDict.Count == 0 || !RidingPetBossLineDict.ContainsKey(index))
            {
                return 100;
            }
            else
            {
                return RidingPetBossLineDict[index].remainedHP;
            }
        }

        public bool IsBossAlive(int index)
        {
            return m_BossAliceStates.ContainsKey(index) ? m_BossAliceStates[index] : false;
        }

        void UpdateRedpoint()
        {
            var redpointable = false;
            if (dailyQuestModel.GetQuestState((int)DailyQuestType.RidingPetActivity)
                == DailyQuestModel.DailyQuestState.Normal)
            {
                if (IsBossAlive(0) || IsBossAlive(1))
                {
                    redpointable = true;
                }
            }

            redpoint.state = redpointable ? RedPointState.Simple : RedPointState.None;
        }
    }

    public struct RidingPetBossLine
    {
        public int playerCnt;
        public int remainedHP;
    }

    public struct RidingPetBossReward
    {
        public Int2 worldLevelArea;
        public Int2 rankArea;
        public List<Item> items;

        public bool SatisfyCondition(int worldLevel)
        {
            if (worldLevel < worldLevelArea.x
                || worldLevel > worldLevelArea.y)
            {
                return false;
            }
            return true;
        }
    }
}