//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Monday, November 20, 2017
//--------------------------------------------------------
using UnityEngine;
using System.Collections;
using UnityEngine.UI;
using System;
using System.Collections.Generic;
using TableConfig;
using Snxxz.UI;
//翅膀精炼红点
namespace Snxxz.UI
{

    public class WingsRedDot : Model, IPlayerLoginOk, IBeforePlayerDataInitialize
    {
        private const int Redpoint_key = 10603;
        public Redpoint redPointStre = new Redpoint(MainRedDot.RedPoint_key1, Redpoint_key);
        private int WingNumber = 0;//翅膀数量标记
        private int Marking = 0;
        private bool IsOk = false;
        private bool IsOnePutOn = true;
        public bool IsBoolOpenWingeWin = false;
        PlayerPackModel _playerPack;
        PlayerPackModel playerPack
        {
            get { return _playerPack ?? (_playerPack = ModelCenter.Instance.GetModel<PlayerPackModel>()); }
        }

        public override void Init()
        {
            playerPack.RefreshItemCountAct += OnItemRefreshEvent;
            FuncOpen.Instance.OnFuncStateChangeEvent += OnFuncStateChange;
        }
        public void OnPlayerLoginOk()
        {
            IsOk = true;
            ItemModel itemModel = playerPack.GetItemModelByIndex(PackType.rptEquip, (int)RoleEquipType.retWing);
            if (itemModel != null)
            {
                IsOnePutOn = false;
            }
        }
        public void OnBeforePlayerDataInitialize()
        {
            IsOk = false;
        }
        private void OnItemRefreshEvent(PackType type, int index, int id)
        {
            if (type == PackType.rptItem && ItemConfig.tag_Wings.ContainsKey(id) && IsOk && IsOnePutOn)
            {
                WingsDot();
                IsOnePutOn = false;
            }
        }

        public override void UnInit()
        {
            playerPack.RefreshItemCountAct -= OnItemRefreshEvent;//背包刷新
            FuncOpen.Instance.OnFuncStateChangeEvent -= OnFuncStateChange;
        }

        private void OnFuncStateChange(int obj)
        {
            if (obj == 90)
            {
                WingsDot();
            }
        }

        public class WingsInformation
        {
            public int WingsID;
            public int WingsCount;
        }
        private Dictionary<int, WingsInformation> _dicWings = new Dictionary<int, WingsInformation>();
        public void WingsDot()
        {
            redPointStre.state = RedPointState.None;
            ItemModel itemModel = playerPack.GetItemModelByIndex(PackType.rptEquip, (int)RoleEquipType.retWing);

            if (itemModel == null || !FuncOpen.Instance.IsFuncOpen(90))
            {
                WingNumber = 0;
                Marking = 0;
                return;
            }
            var WingItemA = ConfigManager.Instance.GetTemplate<WingRefineExpConfig>(itemModel.itemInfo.ItemID);
            if (WingItemA == null)
            {
                WingNumber = 0;
                Marking = 0;
                return;
            }
            SinglePackModel singlePackModel = playerPack.GetSinglePackModel(PackType.rptItem);
            Dictionary<int, ItemModel> backpack_dic = singlePackModel.GetPackModelIndexDict();

            List<int> wingsRefinelist = itemModel.GetUseDataModel((int)ItemUseDataKey.Def_IudetWingProgressValue);
            if (wingsRefinelist != null)
            {
                var config = ConfigManager.Instance.GetTemplate<WingRefineExpConfig>((int)itemModel.itemInfo.ItemID);
                int WingsPhase = config.WingsPhase;//获取翅膀阶数
                var WingRefineAttr = ConfigManager.Instance.GetAllValues<WingRefineAttrConfig>();
                int Max = 0;
                foreach (var value in WingRefineAttr)
                {
                    if (value.wingsPhase == WingsPhase)
                    {
                        Max = value.EXPupper;//最大精炼度
                    }
                }
                int Now = wingsRefinelist[0];
                if (Now >= Max)
                {
                    WingNumber = 0;
                    Marking = 0;
                    return;
                }
            }
            _dicWings.Clear();
            foreach (int index in backpack_dic.Keys)
            {
                var WingItem = ConfigManager.Instance.GetTemplate<WingRefineExpConfig>((int)backpack_dic[index].itemInfo.ItemID);
                if (ItemConfig.tag_Wings.ContainsKey((int)backpack_dic[index].itemInfo.ItemID) && WingItem != null)
                {
                    WingsInformation _WingsInformation = new WingsInformation();
                    _WingsInformation.WingsID = (int)backpack_dic[index].itemInfo.ItemID;
                    _WingsInformation.WingsCount = (int)backpack_dic[index].itemInfo.ItemCount;
                    _dicWings.Add(index, _WingsInformation);
                }
            }
            var config1 = ConfigManager.Instance.GetTemplate<WingRefineExpConfig>((int)itemModel.itemInfo.ItemID);
            foreach (var key in _dicWings.Keys)
            {
                var wings = ConfigManager.Instance.GetTemplate<ItemConfig>(_dicWings[key].WingsID);
                if (wings.EndureReduceType != 0)
                {
                    return;
                }
                var config2 = ConfigManager.Instance.GetTemplate<WingRefineExpConfig>(_dicWings[key].WingsID);
                if (config1.WingsPhase >= config2.WingsPhase)
                {
                    WingNumber += playerPack.GetItemCountByID(PackType.rptItem, _dicWings[key].WingsID);
                }
            }
            if (IsBoolOpenWingeWin)
            {
                return;
            }
            if (WingNumber > Marking && FuncOpen.Instance.IsFuncOpen(90))
            {
                Marking = WingNumber;
                redPointStre.state = RedPointState.Simple;
                return;
            }
            else
            {
                Marking = WingNumber;
            }
        }

        public void WingsItemCount(int WingsItemIndex, int ItemCount)//物品数量刷新
        {
            if (IsBoolOpenWingeWin)
            {
                return;
            }
            if (_dicWings.ContainsKey(WingsItemIndex))
            {
                if (ItemCount > _dicWings[WingsItemIndex].WingsCount)
                {
                    _dicWings[WingsItemIndex].WingsCount = ItemCount;
                    redPointStre.state = RedPointState.Simple;
                }
                else
                {
                    _dicWings[WingsItemIndex].WingsCount = ItemCount;
                }
            }
        }


    }
}