using System;
using System.Collections;
using System.Collections.Generic;
using TableConfig;
using UnityEngine;
namespace Snxxz.UI
{
    public class GuardModel : Model, IAfterPlayerDataInitialize
    {
        List<int> fairyLandGuardItems = new List<int>();

        public bool fairyLandGuard { get; set; }
        public ItemModel fairyLandItemModel { get; private set; }

        public event Action onDungeonEquipGuardEvent;

        PlayerPackModel pack { get { return ModelCenter.Instance.GetModel<PlayerPackModel>(); } }
        DungeonModel dungeonModel { get { return ModelCenter.Instance.GetModel<DungeonModel>(); } }
        PackModelInterface packModelInterface { get { return ModelCenter.Instance.GetModel<PackModelInterface>(); } }

        public override void Init()
        {
            ParseConfig();
            StageManager.Instance.onStageLoadFinish += OnStageLoadFinish;
            pack.RefreshItemCountAct += RefreshItemCountAct;
            KnapsackTimeCDMgr.Instance.RefreshItemOverdueAct += RefreshItemOverdueTimeAct;
        }

        public void OnAfterPlayerDataInitialize()
        {
            SnxxzGame.Instance.StartCoroutine(Co_LoadGuard());
        }

        public override void UnInit()
        {

        }

        IEnumerator Co_LoadGuard()
        {
            yield return null;
            GA_Hero _hero = PlayerDatas.Instance.hero;
            if (_hero == null)
            {
                yield break;
            }
            PlayerPackModel _packModel = ModelCenter.Instance.GetModel<PlayerPackModel>();
            SinglePackModel _equipModel = _packModel.GetSinglePackModel(PackType.rptEquip);
            var _itemModel = _equipModel.GetItemModelByIndex((int)RoleEquipType.retSpiritAnimal);
            if (_itemModel != null && _itemModel.itemInfo != null)
            {
                _hero.SwitchGuard((uint)_itemModel.itemInfo.ItemID);
            }
        }

        private void RefreshItemCountAct(PackType type, int arg2, int _id)
        {
            if (fairyLandGuard)
            {
                if (type == PackType.rptEquip || fairyLandGuardItems.Contains(_id))
                {
                    CheckFairyLandGuard();
                }
            }
        }

        IEnumerator Co_DungeonDuardCheck()
        {
            yield return WaitingForSecondConst.WaitMS500;
            CheckFairyLandGuard();
        }

        private void OnStageLoadFinish()
        {
            var _mapId = dungeonModel.GetDungeonDataIdByMapId(PlayerDatas.Instance.baseData.MapID);
            if (_mapId == 31080)
            {
                SnxxzGame.Instance.StartCoroutine(Co_DungeonDuardCheck());
            }
        }

        private void RefreshItemOverdueTimeAct(string _guid)
        {
            if (fairyLandGuard)
            {
                var itemModel = pack.GetItemModelByGUID(_guid);
                if (itemModel != null && fairyLandItemModel != null && itemModel.itemId == fairyLandItemModel.itemId)
                {
                    CheckFairyLandGuard();
                }
            }
        }

        private void CheckFairyLandGuard()
        {
            fairyLandGuard = false;
            var itemModel = pack.GetItemModelByIndex(PackType.rptEquip, (int)RoleEquipType.retSpiritAnimal);
            if (itemModel == null || !fairyLandGuardItems.Contains(itemModel.itemId))
            {
                for (int i = 0; i < fairyLandGuardItems.Count; i++)
                {
                    List<ItemModel> list = null;
                    pack.GetSinglePackModel(PackType.rptItem).GetItemCountByID(fairyLandGuardItems[i], out list);
                    if (list != null && list.Count > 0)
                    {
                        for (int k = 0; k < list.Count; k++)
                        {
                            bool isOverdue = packModelInterface.IsOverdue(list[k].itemInfo.ItemGUID,
                                list[k].itemId, list[k].useDataDict);

                            if (!isOverdue)
                            {
                                fairyLandGuard = true;
                                fairyLandItemModel = list[k];
                                if (onDungeonEquipGuardEvent != null)
                                {
                                    onDungeonEquipGuardEvent();
                                    return;
                                }
                            }
                        }
                    }
                }
            }
            if (onDungeonEquipGuardEvent != null)
            {
                onDungeonEquipGuardEvent();
            }
        }

        void ParseConfig()
        {
            var config = Config.Instance.Get<FuncConfigConfig>("XjmjGuardian");
            fairyLandGuardItems.AddRange(ConfigParse.GetMultipleStr<int>(config.Numerical1));
            fairyLandGuardItems.Sort(Compare);
        }

        int Compare(int x, int y)
        {
            return x.CompareTo(y);
        }
    }
}