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

namespace Snxxz.UI
{
    public class TreasureSoulModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk
    {
        Dictionary<int, TreasureSpecialData> treasureSoulDict = new Dictionary<int, TreasureSpecialData>();
        List<int> treasureSouls = new List<int>();
        Dictionary<int, List<int>> soulAchievements = new Dictionary<int, List<int>>();
        public Dictionary<int, int> signAddProperty = new Dictionary<int, int>();
        public int signAddTreasure { get; private set; }

        public event Action<int> treasureSoulEvent;
        public event Action<int> treasureSelectSoulChangeEvent;

        int m_SelectSoul = 0;
        public int selectSoul
        {
            get { return m_SelectSoul; }
            set
            {
                m_SelectSoul = value;
                if (treasureSelectSoulChangeEvent != null)
                {
                    treasureSelectSoulChangeEvent(value);
                }
            }
        }

        public int gotoSoul { get; set; }

        public bool serverInited { get; private set; }

        PlayerPackModel packModel { get { return ModelCenter.Instance.GetModel<PlayerPackModel>(); } }
        TreasureModel treasureModel { get { return ModelCenter.Instance.GetModel<TreasureModel>(); } }
        AchievementModel achievementModel { get { return ModelCenter.Instance.GetModel<AchievementModel>(); } }
        public override void Init()
        {
            packModel.RefreshItemCountAct += RefreshItemCountAct;
            PlayerStrengthengDatas.RefreshEquipUpgradLvAct += RefreshEquipSTRLv;
            achievementModel.achievementProgressUpdateEvent += AchievementUpdate;
            achievementModel.achievementCompletedEvent += AchievementUpdate;
            ParseConfig();
        }

        public void OnBeforePlayerDataInitialize()
        {
            serverInited = false;
            foreach (var special in treasureSoulDict.Values)
            {
                special.presentFinishCount = 0;
                special.presentGetCount = 0;
                special.itemGet = false;
                special.active = false;
            }
        }

        public void OnPlayerLoginOk()
        {
            serverInited = true;
            UpdateRedpoints();
        }

        public override void UnInit()
        {
            packModel.RefreshItemCountAct -= RefreshItemCountAct;
            PlayerStrengthengDatas.RefreshEquipUpgradLvAct -= RefreshEquipSTRLv;
            achievementModel.achievementProgressUpdateEvent -= AchievementUpdate;
            achievementModel.achievementCompletedEvent -= AchievementUpdate;
        }

        void ParseConfig()
        {
            var configs = Config.Instance.GetAllValues<TreasurePrivilegeConfig>();
            for (int i = 0; i < configs.Count; i++)
            {
                var treasureConfig = Config.Instance.Get<TreasureConfig>(configs[i].treasureId);
                if (treasureConfig == null || treasureConfig.Category != (int)TreasureCategory.Human)
                {
                    continue;
                }
                treasureSouls.Add(configs[i].PrivilegeID);
                treasureSoulDict.Add(configs[i].PrivilegeID, new TreasureSpecialData((TreasurePrivilege)configs[i].PrivilegeID));
                soulAchievements.Add(configs[i].PrivilegeID, new List<int>(configs[i].successList));
            }
            var funcConfig = Config.Instance.Get<FuncConfigConfig>("MWSignDayAttr");
            var jsonData = LitJson.JsonMapper.ToObject(funcConfig.Numerical1);
            signAddTreasure = int.Parse(funcConfig.Numerical2);
            foreach (var _key in jsonData.Keys)
            {
                signAddProperty.Add(int.Parse(_key), int.Parse(jsonData[_key].ToString()));
            }
        }

        public List<int> GetTreasureSouls()
        {
            return treasureSouls;
        }

        public bool TryGetRealmAchievement(int _id,out int achievementId)
        {
            achievementId = 0;
            List<int> list;
            if (soulAchievements.TryGetValue(_id, out list))
            {
                for (int i = 0; i < list.Count; i++)
                {
                    var config = Config.Instance.Get<SuccessConfig>(list[i]);
                    if (config != null && config.Type == 50)
                    {
                        achievementId = list[i];
                        return true;
                    }
                }
            }
            return false;
        }

        public bool TryGetAchievements(int _id,out List<int> list)
        {
            return soulAchievements.TryGetValue(_id, out list);
        }

        public bool IsCompleteRealmAchievement(int _id)
        {
            TreasureSpecialData special;
            if (TryGetTreasureSoul(_id, out special))
            {
                if (special.active)
                {
                    return true;
                }
                int achievementId;
                if (TryGetRealmAchievement(_id, out achievementId))
                {
                    Achievement achievement;
                    return achievementModel.TryGetAchievement(achievementId, out achievement) && achievement.completed;
                }
            }
            return true;
        }

        public bool IsCompleteAllAchievement(int _id)
        {
            if (soulAchievements.ContainsKey(_id))
            {
                var list = soulAchievements[_id];
                bool allCompleted = true;
                for (int i = 0; i < list.Count; i++)
                {
                    Achievement achievement;
                    achievementModel.TryGetAchievement(list[i], out achievement);
                    if (achievement == null || (!achievement.completed && !Achievement.IsReach(achievement.id, achievement.progress)))
                    {
                        allCompleted = false;
                    }
                }
                return allCompleted;
            }
            return false;
        }

        public bool TryGetTreasureSoul(int _id, out TreasureSpecialData special)
        {
            return treasureSoulDict.TryGetValue(_id, out special);
        }

        public void ActiveTreasureSoul(int _id)
        {
            if (IsCompleteAllAchievement(_id))
            {
                CA512_tagCMActiveMWSoul pak = new CA512_tagCMActiveMWSoul();
                pak.ID = (byte)_id;
                GameNetSystem.Instance.SendInfo(pak);
            }
        }

        public int GetTreasureSoulValue(int _soulId)
        {
            if (treasureSoulDict.ContainsKey(_soulId))
            {
                if (IsGetTreasureSoul(_soulId))
                {
                    var _specialData = treasureSoulDict[_soulId];
                    return _specialData.GetPrivilegeValue();
                }
            }
            return 0;
        }

        public bool IsGetTreasureSoul(int _soulId)
        {
            TreasureSpecialData special;
            return TryGetTreasureSoul(_soulId, out special) && special.active;
        }

        public bool IsOpenTreasureSoul(int _soulId)
        {
            TreasureSpecialData special;
            if (TryGetTreasureSoul(_soulId, out special))
            {
                Treasure treasure;
                return treasureModel.TryGetTreasure(special.treasureId, out treasure) && treasure.state == TreasureState.Collected;
            }
            return false;
        }

        private void RefreshEquipSTRLv(int obj)
        {
            UpdateTreasureSoulStrenthen();
        }

        private void RefreshItemCountAct(PackType packType, int arg2, int arg3)
        {
            if (packType == PackType.rptEquip)
            {
                UpdateTreasureSoulStrenthen();
            }
        }

        private void AchievementUpdate(int _id)
        {
            foreach (var soulId in soulAchievements.Keys)
            {
                if (soulAchievements[soulId].Contains(_id))
                {
                    UpdateAchievementRedpoint(soulId);
                }
            }
        }

        public void UpdateTreasureSoulStrenthen()
        {
            UpdateRedpoint((int)TreasurePrivilege.StrengthenAdd);
            if (treasureSoulEvent != null)
            {
                treasureSoulEvent((int)TreasurePrivilege.StrengthenAdd);
            }
        }

        public void UpdateTreasurePrivilege(HA353_tagMCMWPrivilegeDataInfo package)
        {
            for (int i = 0; i < package.Count; i++)
            {
                var _data = package.InfoList[i];
                TreasureSpecialData special;
                if (!treasureSoulDict.TryGetValue((int)_data.PriID, out special))
                {
                    continue;
                }
                bool beforeActived = special.active;
                special.active = _data.State == 1;
                if (!beforeActived && special.active && serverInited && WindowCenter.Instance.CheckOpen<TreasureSoulWin>()
                    && !WindowCenter.Instance.CheckOpen<TreasureSoulActiveWin>() && !NewBieCenter.Instance.inGuiding)
                {
                    TreasureSoulActiveWin.treasureSoulId = (int)_data.PriID;
                    WindowCenter.Instance.Open<TreasureSoulActiveWin>();
                }
                if ((TreasurePrivilege)_data.PriID == TreasurePrivilege.StrengthenAdd)
                {
                    if (treasureSoulEvent != null)
                    {
                        treasureSoulEvent((int)_data.PriID);
                    }
                    continue;
                }

                int beforeFinishCount = special.presentFinishCount;

                special.presentFinishCount = (int)_data.GotValue;
                special.presentGetCount = (int)_data.CurValue;
                special.itemGet = _data.ItemAwardState == 1;
                UpdateRedpoint((int)_data.PriID);
                UpdateAchievementRedpoint((int)_data.PriID);
                if (treasureSoulEvent != null)
                {
                    treasureSoulEvent((int)_data.PriID);
                }

                if (beforeFinishCount < special.presentFinishCount && serverInited && special.active
                    && !WindowCenter.Instance.CheckOpen<TreasureSoulActiveWin>()
                    && WindowCenter.Instance.CheckOpen<TreasureSoulWin>()
                    && !WindowCenter.Instance.CheckOpen<RealmPropertyUpWin>()
                    && !NewBieCenter.Instance.inGuiding)
                {
                    ActivateShow.TreasureSoulGetReward((int)_data.PriID, beforeFinishCount, special.presentFinishCount);
                }
            }
        }

        public void UpdateTreasurePrivilege(HA317_tagMCAllEquipAttrActiveInfo package)
        {
            for (int i = 0; i < package.ActiveInfo.Length; i++)
            {
                var _data = package.ActiveInfo[i];
                if (_data.Type == 0)
                {
                    if (treasureSoulDict.ContainsKey((int)TreasurePrivilege.StrengthenAdd))
                    {
                        var _specialData = treasureSoulDict[(int)TreasurePrivilege.StrengthenAdd];
                        int beforeFinishCount = _specialData.presentFinishCount;
                        _specialData.presentFinishCount = (int)_data.Cnt;
                        UpdateRedpoint((int)TreasurePrivilege.StrengthenAdd);
                        if (beforeFinishCount < _specialData.presentFinishCount && serverInited && _specialData.active
                             && !WindowCenter.Instance.CheckOpen<TreasureSoulActiveWin>()
                             && WindowCenter.Instance.CheckOpen<TreasureSoulWin>()
                             && !WindowCenter.Instance.CheckOpen<RealmPropertyUpWin>())
                        {
                            ActivateShow.TreasureSoulGetReward((int)TreasurePrivilege.StrengthenAdd, 
                                beforeFinishCount, _specialData.presentFinishCount);
                        }
                    }
                    if (treasureSoulEvent != null)
                    {
                        treasureSoulEvent((int)TreasurePrivilege.StrengthenAdd);
                    }

                }
            }
        }

        private void UpdateRedpoint(int _id)
        {
            if (treasureSoulDict.ContainsKey(_id))
            {
                var special = treasureSoulDict[_id];
                special.UpdateState();
                if (special.privilegeRedpoint != null)
                {
                    special.privilegeRedpoint.state = RedPointState.None;
                    if (!FuncOpen.Instance.IsFuncOpen(126) || !IsOpenTreasureSoul(_id)
                        || !IsGetTreasureSoul(_id))
                    {
                        return;
                    }
                    switch (special.type)
                    {
                        case TreasurePrivilege.StrengthenAdd:
                        case TreasurePrivilege.DemonJarAtk:
                        case TreasurePrivilege.MountAtk:
                        case TreasurePrivilege.PetHp:
                        case TreasurePrivilege.Sp:
                            special.privilegeRedpoint.state = special.state == TreasurePrivilegeState.Reward ?
                                RedPointState.Simple : RedPointState.None;
                            break;
                        case TreasurePrivilege.Wash:
                            special.privilegeRedpoint.state = special.itemGet ?
                               RedPointState.None : RedPointState.Simple;
                            break;
                    }
                }
            }
        }

        private void UpdateAchievementRedpoint(int _id)
        {
            if (treasureSoulDict.ContainsKey(_id) && soulAchievements.ContainsKey(_id))
            {
                var special = treasureSoulDict[_id];
                special.activeRedpoint.state = RedPointState.None;
                if (!FuncOpen.Instance.IsFuncOpen(126) || !IsOpenTreasureSoul(_id) || special.active)
                {
                    return;
                }
                var list = soulAchievements[_id];
                bool allCompleted = true;
                for (int i = 0; i < list.Count; i++)
                {
                    Achievement achievement;
                    achievementModel.TryGetAchievement(list[i], out achievement);
                    if (achievement == null || (!achievement.completed && !Achievement.IsReach(achievement.id, achievement.progress)))
                    {
                        allCompleted = false;
                    }
                }
                special.activeRedpoint.state = allCompleted ? RedPointState.Simple : RedPointState.None;
            }
        }

        private void UpdateRedpoints()
        {
            foreach (var special in treasureSoulDict.Keys)
            {
                UpdateRedpoint(special);
                UpdateAchievementRedpoint(special);
            }
        }
    }

    public class TreasureSpecialData
    {
        public TreasurePrivilege type { get; private set; }
        public int progress { get; private set; }
        public int totalProgress { get; private set; }
        public int effectValue { get; private set; }
        public List<AwardItem> items { get; private set; }
        public Dictionary<int, int> propertyDict { get; private set; }
        public Redpoint redpoint { get; private set; }
        public Redpoint privilegeRedpoint { get; private set; }
        public Redpoint activeRedpoint { get; private set; }

        public int treasureId { get; set; }
        public bool active { get; set; }

        private TreasurePrivilegeState m_State = TreasurePrivilegeState.Doing;
        public TreasurePrivilegeState state
        {
            get { return m_State; }
            set { m_State = value; }
        }

        public int presentFinishCount { get; set; }
        public int presentGetCount { get; set; }
        public bool itemGet { get; set; }

        public TreasureSpecialData(TreasurePrivilege _type)
        {
            type = _type;
            var config = Config.Instance.Get<TreasurePrivilegeConfig>((int)_type);
            progress = Mathf.Max(1, config.singleValue);
            totalProgress = config.maxValue;
            var _effectValue = 0;
            int.TryParse(config.EffectValue, out _effectValue);
            effectValue = _effectValue;
            treasureId = config.treasureId;

            if (!string.IsNullOrEmpty(config.attr))
            {
                var propertyJson = LitJson.JsonMapper.ToObject(config.attr);
                propertyDict = new Dictionary<int, int>();
                foreach (var _key in propertyJson.Keys)
                {
                    var _property = int.Parse(_key);
                    var _value = int.Parse(propertyJson[_key].ToJson());
                    propertyDict.Add(_property, _value);
                }
            }
            if (!string.IsNullOrEmpty(config.itemAward))
            {
                var itemArray = LitJson.JsonMapper.ToObject<int[][]>(config.itemAward);
                if (itemArray != null && itemArray.Length > 0)
                {
                    items = new List<AwardItem>();
                    for (int i = 0; i < itemArray.Length; i++)
                    {
                        var _array = itemArray[i];
                        items.Add(new AwardItem()
                        {
                            isBind = _array[2],
                            item = new Item()
                            {
                                id = _array[0],
                                count = _array[1],
                            },
                        });
                    }
                }
            }

            if (type == TreasurePrivilege.PetHp)
            {
                var petCount = Config.Instance.GetAllValues<PetInfoConfig>().Count;
                totalProgress = petCount;
            }
            else if (type == TreasurePrivilege.MountAtk)
            {
                var mountConfigs = Config.Instance.GetAllValues<HorseConfig>();
                var maxlv = 0;
                for (int i = 0; i < mountConfigs.Count; i++)
                {
                    maxlv += mountConfigs[i].MaxLV;
                }
                totalProgress = maxlv;
            }
            else if (type == TreasurePrivilege.StrengthenAdd)
            {
                var configs = Config.Instance.GetAllValues<ItemPlusSumAttrConfig>();
                totalProgress = configs[configs.Count - 1].countNeed;
            }

            redpoint = new Redpoint(TreasureModel.TREASURE_SOUL_ID, TreasureModel.TREASURE_SOUL_ID * 100 + (int)type);
            activeRedpoint = new Redpoint(redpoint.id, redpoint.id * 100 + 1);
            switch (_type)
            {
                case TreasurePrivilege.DemonJarAtk:
                case TreasurePrivilege.StrengthenAdd:
                case TreasurePrivilege.MountAtk:
                case TreasurePrivilege.PetHp:
                case TreasurePrivilege.Sp:
                case TreasurePrivilege.Wash:
                    privilegeRedpoint = new Redpoint(redpoint.id, redpoint.id * 100 + 2);
                    break;
            }
        }

        public int GetPrivilegeValue(int _index = 0)
        {
            switch (type)
            {
                case TreasurePrivilege.RuneBreakExpAdd:
                    return effectValue;
                case TreasurePrivilege.DemonJarAtk:
                case TreasurePrivilege.Suit:
                    return effectValue;
                case TreasurePrivilege.Wing:
                case TreasurePrivilege.StrengthenAdd:
                    return effectValue;
            }
            return 0;
        }

        public void UpdateState()
        {
            switch (type)
            {
                case TreasurePrivilege.Property:
                case TreasurePrivilege.RuneBreakExpAdd:
                case TreasurePrivilege.Wing:
                case TreasurePrivilege.Suit:
                    state = TreasurePrivilegeState.Complete;
                    break;
                case TreasurePrivilege.Sp:
                case TreasurePrivilege.DemonJarAtk:
                case TreasurePrivilege.PetHp:
                case TreasurePrivilege.MountAtk:
                    if (presentFinishCount >= totalProgress && (presentGetCount / progress) >= (totalProgress / progress))
                    {
                        state = TreasurePrivilegeState.Complete;
                    }
                    else if (presentGetCount > 0 && presentFinishCount / progress < presentGetCount / progress)
                    {
                        state = TreasurePrivilegeState.Reward;
                    }
                    else
                    {
                        state = TreasurePrivilegeState.Doing;
                    }
                    break;
                case TreasurePrivilege.Wash:
                    state = itemGet ? TreasurePrivilegeState.Doing : TreasurePrivilegeState.Reward;
                    break;
                case TreasurePrivilege.StrengthenAdd:
                    var strengthen = ModelCenter.Instance.GetModel<PlayerStrengthengDatas>();
                    var playerpack = ModelCenter.Instance.GetModel<PlayerPackModel>();
                    presentGetCount = 0;
                    foreach (var value in strengthen._EqInfo.Values)
                    {
                        ItemModel itemModel = playerpack.GetItemModelByIndex(PackType.rptEquip, value.EquipIndex);
                        if (itemModel != null)
                        {
                            presentGetCount += value.EquipPartStarLV;
                        }
                    }
                    var configs = Config.Instance.GetAllValues<ItemPlusSumAttrConfig>();
                    bool contains = configs.FindIndex((x) =>
                    {
                        return x.countNeed > presentFinishCount && presentGetCount >= x.countNeed;
                    }) != -1;
                    if (presentFinishCount >= totalProgress && presentGetCount >= totalProgress)
                    {
                        state = TreasurePrivilegeState.Complete;
                    }
                    else if (contains)
                    {
                        state = TreasurePrivilegeState.Reward;
                    }
                    else
                    {
                        state = TreasurePrivilegeState.Doing;
                    }
                    break;
            }
        }

        public string ProgressDisplay()
        {
            switch (type)
            {
                case TreasurePrivilege.DemonJarAtk:
                case TreasurePrivilege.PetHp:
                case TreasurePrivilege.MountAtk:
                case TreasurePrivilege.Sp:
                    if (state == TreasurePrivilegeState.Complete) { return UIHelper.GetTextColorByItemColor(TextColType.Green, totalProgress.ToString(), true); }
                    else if (state == TreasurePrivilegeState.Doing)
                    {
                        return StringUtility.Contact(UIHelper.GetTextColorByItemColor(TextColType.Red, presentGetCount.ToString(), true), "/", (presentFinishCount / progress + 1) * progress);
                    }
                    else if (state == TreasurePrivilegeState.Reward)
                    {
                        var _completeCount = (presentFinishCount / progress + 1) * progress;
                        return StringUtility.Contact(UIHelper.GetTextColorByItemColor(TextColType.Green, presentGetCount.ToString(), true), "/", _completeCount);
                    }
                    break;
                case TreasurePrivilege.StrengthenAdd:
                    var configs = Config.Instance.GetAllValues<ItemPlusSumAttrConfig>();
                    var next = configs.Count - 1;
                    for (int i = 0; i < configs.Count; i++)
                    {
                        if (configs[i].countNeed > presentFinishCount)
                        {
                            next = i;
                            break;
                        }
                    }
                    if (state == TreasurePrivilegeState.Complete) { return totalProgress.ToString(); }
                    else if (state == TreasurePrivilegeState.Doing
                        || state == TreasurePrivilegeState.Reward)
                    {
                        var colortype = presentGetCount >= configs[next].countNeed ? TextColType.Green : TextColType.Red;
                        return StringUtility.Contact(UIHelper.GetTextColorByItemColor(colortype, presentGetCount.ToString(), true), "/", configs[next].countNeed);
                    }
                    break;
            }
            return string.Empty;
        }

        public void GetReward()
        {
            switch (type)
            {
                case TreasurePrivilege.MountAtk:
                case TreasurePrivilege.DemonJarAtk:
                case TreasurePrivilege.PetHp:
                case TreasurePrivilege.Sp:
                case TreasurePrivilege.Wash:
                    var _pak = new CA504_tagCMPlayerGetReward();
                    _pak.RewardType = (int)GotServerRewardType.Def_RewardType_TreasureSoul;
                    _pak.DataEx = (uint)type;
                    _pak.DataExStrLen = 0;
                    _pak.DataExStr = string.Empty;
                    GameNetSystem.Instance.SendInfo(_pak);
                    break;
                case TreasurePrivilege.StrengthenAdd:
                    var configs = Config.Instance.GetAllValues<ItemPlusSumAttrConfig>();
                    var present = 0;
                    for (int i = 0; i < configs.Count; i++)
                    {
                        if (presentGetCount >= configs[i].countNeed)
                        {
                            present = i;
                        }
                    }
                    CA503_tagCMActiveAllEquipAttr pak = new CA503_tagCMActiveAllEquipAttr();
                    pak.Type = 0;
                    pak.Cnt = (uint)configs[present].countNeed;
                    GameNetSystem.Instance.SendInfo(pak);
                    break;
            }
        }

        public int GetFightPower()
        {
            var _fightPower = 0;
            if (propertyDict != null)
            {
                _fightPower += UIHelper.GetFightPower(propertyDict);
            }
            return _fightPower;
        }
    }

    public enum TreasurePrivilegeState
    {
        Doing = 0,
        Reward = 1,
        Complete = 2
    }

    public enum TreasurePrivilege
    {
        Property = 1,
        DemonJarAtk = 2,
        StrengthenAdd = 3,
        RuneBreakExpAdd = 4,
        MountAtk = 5,
        PetHp = 6,
        Sp = 7,
        Wing = 8,
        Suit = 9,
        Wash = 10,
        Sign = 11,
    }
}