using Snxxz.UI;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using TableConfig;

namespace EnhancedUI.EnhancedScroller
{
    public class ViewFuncCell : ScrollerUI
    {
        RoleParticularModel m_Model;
        RoleParticularModel model
        {
            get
            {
                return m_Model ?? (m_Model = ModelCenter.Instance.GetModel<RoleParticularModel>());
            }
        }

        EquipWashModel m_EquipWashModel;
        EquipWashModel equipWashModel
        {
            get
            {
                return m_EquipWashModel ?? (m_EquipWashModel = ModelCenter.Instance.GetModel<EquipWashModel>());
            }
        }

        TreasureModel m_TreasureModel;
        TreasureModel treasureModel
        {
            get
            {
                return m_TreasureModel ?? (m_TreasureModel = ModelCenter.Instance.GetModel<TreasureModel>());
            }
        }

        PlayerPetDatas m_petModel;
        PlayerPetDatas petmodel
        {
            get
            {
                return m_petModel ?? (m_petModel = ModelCenter.Instance.GetModel<PlayerPetDatas>());
            }
        }

        PlayerSuitModel _suitModel;
        PlayerSuitModel SuitModel
        {
            get { return _suitModel ?? (_suitModel = ModelCenter.Instance.GetModel<PlayerSuitModel>()); }
        }

        PlayerMountDatas m_HorseModel;
        PlayerMountDatas horsemodel
        {
            get
            {
                return m_HorseModel ?? (m_HorseModel = ModelCenter.Instance.GetModel<PlayerMountDatas>());
            }
        }
        PlayerStrengthengDatas m_StrengthengModel;
        PlayerStrengthengDatas strengthengmodel
        {
            get
            {
                return m_StrengthengModel ?? (m_StrengthengModel = ModelCenter.Instance.GetModel<PlayerStrengthengDatas>());
            }
        }

        PlayerPackModel _playerPack;
        PlayerPackModel playerPack
        {
            get { return _playerPack ?? (_playerPack = ModelCenter.Instance.GetModel<PlayerPackModel>()); }
        }

        [SerializeField] Image funcImg;
        [SerializeField] Text targetFightPowerTxt;
        [SerializeField] Text selfFightPowerTxt;
        [SerializeField] Text targetCompareTxt;
        [SerializeField] Text selfCompareTxt;
        [SerializeField] Image targetCompareImg;
        [SerializeField] Image selfCompareImg;

        public override void Refresh(CellView cell)
        {
            RoleParticularModel.ViewPlayerData viewPlayerData = model.GetViewPlayerData(model.viewPlayer);
            int key = cell.index;
            ViewRoleFuncConfig viewRoleFuncModel = Config.Instance.Get<ViewRoleFuncConfig>(key);
            if (viewPlayerData != null && viewRoleFuncModel != null)
            {
                funcImg.SetSprite(viewRoleFuncModel.Icon);
                targetFightPowerTxt.text = StringUtility.Contact(Language.Get("RoleParticularWin_4"), UIHelper.ReplaceLargeNum(viewPlayerData.rolePlusData.GetFightPower(key)));
                selfFightPowerTxt.text = StringUtility.Contact(Language.Get("RoleParticularWin_5"), UIHelper.ReplaceLargeNum(model.GetFuncFightPower(key)));
                int targetValue = 0;
                int selfValue = 0;
                bool handled = false;
                selfCompareImg.gameObject.SetActive(false);
                targetCompareImg.gameObject.SetActive(false);
                switch ((FuncPowerType)key)
                {
                    case FuncPowerType.Equip:
                        {
                            foreach (var itemData in viewPlayerData.roleEquipDataDic.Values)
                            {
                                ItemConfig _tagChinItemModel = Config.Instance.Get<ItemConfig>(itemData.ItemID);
                                if (_tagChinItemModel != null && (_tagChinItemModel.ItemColor > viewRoleFuncModel.condition[0]
                                    || (_tagChinItemModel.ItemColor == viewRoleFuncModel.condition[0]
                                    && (viewRoleFuncModel.condition.Length < 2 || _tagChinItemModel.StarLevel >= viewRoleFuncModel.condition[1]))))
                                {
                                    targetValue++;
                                }
                            }
                            var packTypeModel = playerPack.GetSinglePackModel(PackType.rptEquip);
                            if (packTypeModel == null || packTypeModel.GetPackModelIndexDict() == null)
                                break;
                            foreach (var itemData in packTypeModel.GetPackModelIndexDict().Values)
                            {
                                ItemConfig _tagChinItemModel = Config.Instance.Get<ItemConfig>((int)itemData.itemInfo.ItemID);
                                if (_tagChinItemModel != null && (_tagChinItemModel.ItemColor > viewRoleFuncModel.condition[0]
                                    || (_tagChinItemModel.ItemColor == viewRoleFuncModel.condition[0]
                                    && (viewRoleFuncModel.condition.Length < 2 || _tagChinItemModel.StarLevel >= viewRoleFuncModel.condition[1]))))
                                {
                                    selfValue++;
                                }
                            }
                        }
                        break;
                    case FuncPowerType.Plus:
                        {
                            targetValue = viewPlayerData.rolePlusData.GetAllEquipStarLV();
                            var packTypeModel = playerPack.GetSinglePackModel(PackType.rptEquip);
                            if (packTypeModel == null || packTypeModel.GetPackModelIndexDict() == null)
                                break;
                            foreach (var itemPlace in packTypeModel.GetPackModelIndexDict().Keys)
                            {
                                selfValue += strengthengmodel.StrengthenTheCeiling(itemPlace);
                            }
                        }
                        break;
                    case FuncPowerType.Stone:
                        targetValue = GetAllStoneLv(viewPlayerData.rolePlusData.GetAllEquipStone());
                        selfValue = GetAllStoneLv(PlayerStoneData.Instance.GetAllStone());
                        break;
                    case FuncPowerType.Suit:
                        handled = true;
                        var _targetSuitCount0 = viewPlayerData.GetSuitTypeCount(SuitType.LowSuit);
                        var _targetSuitCount1 = viewPlayerData.GetSuitTypeCount(SuitType.HighSuit);
                        var _selfSuitCount0 = SuitModel.GetSameSuitCntByType(SuitType.LowSuit);
                        var _selfSuitCount1 = SuitModel.GetSameSuitCntByType(SuitType.HighSuit);
                        targetCompareTxt.text = UIHelper.ReplaceNewLine(Language.Get("ViewFuncSuit_0", _targetSuitCount0, _targetSuitCount1));
                        selfCompareTxt.text = UIHelper.ReplaceNewLine(Language.Get("ViewFuncSuit_0", _selfSuitCount0, _selfSuitCount1));
                        break;
                    case FuncPowerType.Wing:
                        {
                            handled = true;
                            RoleParticularModel.ItemData itemData = model.GetItemData(RoleEquipType.retWing);
                            if (itemData!=null)
                            {
                                ItemConfig _tagChinItemModel = Config.Instance.Get<ItemConfig>(itemData.ItemID);
                                targetCompareTxt.text = string.Format(viewRoleFuncModel.compareTip, _tagChinItemModel.ItemName);
                            }
                            else
                            {
                                targetCompareTxt.text = string.Format(viewRoleFuncModel.compareTip, Language.Get("RoleParticularWin_7"));
                            }
                            ItemModel itemModel = playerPack.GetItemModelByIndex(PackType.rptEquip, (int)RoleEquipType.retWing);
                            if (itemModel != null)
                            {
                                ItemConfig _tagChinItemModel = Config.Instance.Get<ItemConfig>((int)itemModel.itemInfo.ItemID);
                                selfCompareTxt.text = string.Format(viewRoleFuncModel.compareTip, _tagChinItemModel.ItemName);
                            }
                            else
                            {
                                selfCompareTxt.text = string.Format(viewRoleFuncModel.compareTip, Language.Get("RoleParticularWin_7"));
                            }
                        }
                        break;
                    case FuncPowerType.Wash:
                        foreach (WashProCount wash in equipWashModel.GetWashInfoDict().Values)
                        {
                            if (wash == null)
                                continue;
                            selfValue += wash.XLAttrLV;
                        }
                        targetValue = viewPlayerData.rolePlusData.GetAllEquipWashLv();
                        break;
                    case FuncPowerType.Pet:
                        selfValue = petmodel._DicPetBack.Count;
                        targetValue = viewPlayerData.rolePlusData.Pet;
                        break;
                    case FuncPowerType.Horse:
                        selfValue = horsemodel._DicHorse.Count;
                        targetValue = viewPlayerData.rolePlusData.Horse;
                        break;
                    case FuncPowerType.Prestige:
                        handled = true;
                        RealmConfig _tagRealmModel = Config.Instance.Get<RealmConfig>(PlayerDatas.Instance.baseData.realmLevel);
                        if (_tagRealmModel != null && _tagRealmModel.Lv != 0)
                        {
                            selfCompareImg.gameObject.SetActive(true);
                            selfCompareImg.SetSprite(_tagRealmModel.Img);
                            selfCompareImg.SetNativeSize();
                            selfCompareTxt.text = viewRoleFuncModel.compareTip;
                        }
                        else
                        {
                            selfCompareTxt.text = StringUtility.Contact(viewRoleFuncModel.compareTip, Language.Get("RoleParticularWin_6"));
                        }
                        _tagRealmModel = Config.Instance.Get<RealmConfig>(viewPlayerData.rolePropData.RealmLV);
                        if (_tagRealmModel != null && _tagRealmModel.Lv != 0)
                        {
                            targetCompareImg.gameObject.SetActive(true);
                            targetCompareImg.SetSprite(_tagRealmModel.Img);
                            targetCompareImg.SetNativeSize();
                            targetCompareTxt.text = viewRoleFuncModel.compareTip;
                        }
                        else
                        {
                            targetCompareTxt.text = StringUtility.Contact(viewRoleFuncModel.compareTip, Language.Get("RoleParticularWin_6"));
                        }
                        break;
                    case FuncPowerType.GodWeapon:
                        MagicianData data = ModelCenter.Instance.GetModel<MagicianModel>().GetMagicianData((int)MagicianType.AttackMag);
                        if (data != null)
                            selfValue = data.level;
                        targetValue = viewPlayerData.rolePlusData.GetGodWeaponLevel((int)MagicianType.AttackMag);
                        break;
                    case FuncPowerType.Rune:
                        selfValue = ModelCenter.Instance.GetModel<RuneModel>().GetHoleRuneCnt();
                        targetValue = viewPlayerData.rolePlusData.Rune;
                        break;
                    case FuncPowerType.Human:
                        selfValue += treasureModel.GetActiveTreasureCategory(TreasureCategory.Human);
                        targetValue = viewPlayerData.rolePlusData.GetTreasureCount((int)TreasureCategory.Human);
                        break;
                    case FuncPowerType.Demon:
                        selfValue += treasureModel.GetActiveTreasureCategory(TreasureCategory.Demon);
                        targetValue = viewPlayerData.rolePlusData.GetTreasureCount((int)TreasureCategory.Demon);
                        break;
                    case FuncPowerType.Fairy:
                        selfValue += treasureModel.GetActiveTreasureCategory(TreasureCategory.Fairy);
                        targetValue = viewPlayerData.rolePlusData.GetTreasureCount((int)TreasureCategory.Fairy);
                        break;
                }
                if (!handled)
                {
                    targetCompareTxt.text = string.Format(viewRoleFuncModel.compareTip, targetValue);
                    selfCompareTxt.text = string.Format(viewRoleFuncModel.compareTip, selfValue);
                }
                if (viewRoleFuncModel.func != 0 && !FuncOpen.Instance.IsFuncOpen(viewRoleFuncModel.func))
                {
                    selfCompareTxt.text = Language.Get("RoleParticularWin_8");
                }
            }
        }

        public int GetAllStoneLv(Dictionary<int, uint[]> dict)
        {
            int allStoneLv = 0;
            foreach (uint[] array in dict.Values)
            {
                if (array == null || array.Length == 0)
                    continue;
                for (int i = 0; i < array.Length; i++)
                {
                    if (array[i] == 0)
                        continue;
                    ItemConfig _tagChinItemModel = Config.Instance.Get<ItemConfig>((int)array[i]);
                    if (_tagChinItemModel == null)
                        continue;
                    allStoneLv += _tagChinItemModel.EffectValueB1;
                }
            }
            return allStoneLv;
        }
    }
}