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

using UnityEngine;
namespace vnxbqy.UI
{
    public class KingTreasureModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk
    {
        Dictionary<int, bool> treasureWearDict = new Dictionary<int, bool>();
        Dictionary<int, Dictionary<int, Division>> treasureDivisionDict = new Dictionary<int, Dictionary<int, Division>>();
        Dictionary<int, int> treasureSeasonDict = new Dictionary<int, int>();

        public event Action treasureWearRefresh;

        public int wearCountLimit { get; private set; }
        public string scoreFormula { get; private set; }

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

        CrossServerOneVsOneModel oneVsOneModel
        {
            get { return ModelCenter.Instance.GetModel<CrossServerOneVsOneModel>(); }
        }

        public override void Init()
        {
            ParseConfig();
        }

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

        public void OnPlayerLoginOk()
        {
            if (treasureWearRefresh != null)
            {
                treasureWearRefresh();
            }
        }

        public override void UnInit()
        {

        }

        void ParseConfig()
        {
            var config = FuncConfigConfig.Get("MagicWeaponOfKing");
            if (config != null)
            {
                treasureSeasonDict = ConfigParse.GetDic<int, int>(config.Numerical1);
                wearCountLimit = int.Parse(config.Numerical2);
            }

            config = FuncConfigConfig.Get("KingTreasureScore");
            if (config != null)
            {
                scoreFormula = config.Numerical1;
            }

            var configs = KingTreasureConfig.GetValues();
            for (int i = 0; i < configs.Count; i++)
            {
                Dictionary<int, Division> dict;
                if (!treasureDivisionDict.TryGetValue(configs[i].MWID, out dict))
                {
                    dict = new Dictionary<int, Division>();
                    treasureDivisionDict.Add(configs[i].MWID, dict);
                }
                Division division = new Division();
                division.division = configs[i].LV;
                division.basePropertys = new Dictionary<int, int>();
                division.specialPropertys = new Dictionary<int, int>();
                var propertys = ConfigParse.GetDic<int, int>(configs[i].AddAttr);
                if (propertys != null)
                {
                    foreach (var key in propertys.Keys)
                    {
                        var propertyConfig = PlayerPropertyConfig.Get(key);
                        if (propertyConfig.type == 2)
                        {
                            division.specialPropertys.Add(key, propertys[key]);
                        }
                        else
                        {
                            division.basePropertys.Add(key, propertys[key]);
                        }
                    }
                }
                dict.Add(configs[i].LV, division);
            }
        }

        public bool TryGetDivision(int treasureId, int divisionLevel, out Division division)
        {
            Dictionary<int, Division> dict;
            division = default(Division);
            return treasureDivisionDict.TryGetValue(treasureId, out dict)
                && dict.TryGetValue(divisionLevel, out division);
        }

        public bool IsWear(int treasureId)
        {
            if (treasureWearDict.ContainsKey(treasureId))
            {
                return treasureWearDict[treasureId];
            }
            return false;
        }

        public bool TryGetSeason(int treasureId, out int season)
        {
            return treasureSeasonDict.TryGetValue(treasureId, out season);
        }

        public List<int> GetDisplayList()
        {
            var displays = new List<int>();
            var list = treasureModel.GetTreasureCategory(TreasureCategory.King);
            for (int i = 0; i < list.Count; i++)
            {
                var season = 0;
                if (TryGetSeason(list[i], out season))
                {
                    if (season <= CrossServerOneVsOnePKSeason.Instance.SeasonID + 1)
                    {
                        displays.Add(list[i]);
                    }
                }
            }
            return displays;
        }

        public void TryWearTreasure(int treasureId)
        {
            var config = TreasureConfig.Get(treasureId);
            if (config == null || (TreasureCategory)config.Category != TreasureCategory.King)
            {
                return;
            }
            Treasure treasure;
            if (treasureModel.TryGetTreasure(treasureId, out treasure))
            {
                if (treasure.state == TreasureState.Collected)
                {
                    if (IsWear(treasureId))
                    {
                        CA51D_tagCMWearMagicWeapon pak = new CA51D_tagCMWearMagicWeapon();
                        pak.MWID = (uint)treasureId;
                        pak.State = 0;
                        GameNetSystem.Instance.SendInfo(pak);
                    }
                    else
                    {
                        if (GetWearTreasureCount() >= wearCountLimit)
                        {
                            var countDisplay = string.Empty;
                            if (wearCountLimit == 2)
                            {
                                countDisplay = Language.Get("Num_CHS_Two");
                            }
                            else
                            {
                                countDisplay = Language.Get(StringUtility.Contact("Num_CHS_", wearCountLimit));
                            }
                            SysNotifyMgr.Instance.ShowTip("KingTreasureWearLimit", countDisplay);
                            return;
                        }
                        CA51D_tagCMWearMagicWeapon pak = new CA51D_tagCMWearMagicWeapon();
                        pak.MWID = (uint)treasureId;
                        pak.State = 1;
                        GameNetSystem.Instance.SendInfo(pak);
                    }
                }
            }
        }

        public int GetWearTreasureCount()
        {
            var count = 0;
            var list = treasureModel.GetTreasureCategory(TreasureCategory.King);
            for (int i = 0; i < list.Count; i++)
            {
                if (IsWear(list[i]))
                {
                    count++;
                }
            }
            return count;
        }

        public int GetSeasonScore(int treasureId, int rewardLevel = -1)
        {
            var score = 0;
            if (scoreFormula != null)
            {
                if (rewardLevel == -1)
                {
                    var season = 0;
                    if (TryGetSeason(treasureId, out season))
                    {
                        CrossServerOneVsOneModel.CrossServerOneVsOneHistory history;
                        if (oneVsOneModel.TryGetOneVsOneHistory(season, out history))
                        {
                            rewardLevel = history.rewardLevel;
                        }
                    }
                }
                Division division;
                if (TryGetDivision(treasureId, rewardLevel, out division))
                {
                    Equation.Instance.Clear();
                    foreach (var key in division.basePropertys.Keys)
                    {
                        var config = PlayerPropertyConfig.Get(key);
                        if (config != null)
                        {
                            Equation.Instance.AddKeyValue(config.Parameter, division.basePropertys[key]);
                        }
                    }
                    foreach (var key in division.specialPropertys.Keys)
                    {
                        var config = PlayerPropertyConfig.Get(key);
                        if (config != null)
                        {
                            Equation.Instance.AddKeyValue(config.Parameter, division.specialPropertys[key]);
                        }
                    }
                    score = Equation.Instance.Eval<int>(scoreFormula);
                }
            }
            return score;
        }


        public void OnReceivePackage(HA352_tagMCMagicWeaponLVInfo package)
        {
            for (int i = 0; i < package.Count; i++)
            {
                var data = package.InfoList[i];
                var config = TreasureConfig.Get((int)data.MWID);
                if (config == null || config.Category != (int)TreasureCategory.King)
                {
                    continue;
                }
                treasureWearDict[(int)data.MWID] = data.IsWear == 1;
            }
            if (treasureWearRefresh != null)
            {
                treasureWearRefresh();
            }
        }

        public int GetSeasonState(int treasureId)
        {
            var season = 0;
            if (TryGetSeason(treasureId, out season))
            {
                if (season < CrossServerOneVsOnePKSeason.Instance.SeasonID
                    || (season == CrossServerOneVsOnePKSeason.Instance.SeasonID
                 && CrossServerOneVsOnePKSeason.Instance.SeasonState == 2))
                {
                    return 2;
                }
                if((season == CrossServerOneVsOnePKSeason.Instance.SeasonID
                 && CrossServerOneVsOnePKSeason.Instance.SeasonState == 1))
                {
                    return 1;
                }
                if (season > CrossServerOneVsOnePKSeason.Instance.SeasonID
                    || (season == CrossServerOneVsOnePKSeason.Instance.SeasonID
                 && CrossServerOneVsOnePKSeason.Instance.SeasonState == 0))
                {
                    return 0;
                }
            }
            return 0;
        }

        public struct Division
        {
            public int division;
            public Dictionary<int, int> basePropertys;
            public Dictionary<int, int> specialPropertys;
        }
    }
}