//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Monday, October 09, 2017
//--------------------------------------------------------
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using UnityEngine.UI;
using TableConfig;
using System;
using System.Text.RegularExpressions;

namespace Snxxz.UI
{

    public class Treasure
    {
        public int id { get; private set; }

        int m_Level;
        public int level
        {
            get { return m_Level; }
            set { m_Level = value; }
        }

        int m_Stage;
        public int stage
        {
            get { return m_Stage; }
            private set { m_Stage = value; }
        }

        int m_Exp;
        public int exp
        {
            get { return m_Exp; }
            private set { m_Exp = value; }
        }

        bool m_HasClickChallenge = false;
        public bool hasClickChallenge
        {
            get { return m_HasClickChallenge; }
            set { m_HasClickChallenge = value; }
        }

        TreasureState m_State = TreasureState.Locked;
        public TreasureState state
        {
            get { return m_State; }
            set { m_State = value; }
        }

        #region 旧数据
        int m_Progress = 0;
        public int progress
        {
            get { return m_Progress; }
            set { m_Progress = value; }
        }

        public bool isChallengeDungeonAble
        {
            get
            {
                if (state != TreasureState.Collecting)
                {
                    return false;
                }
                var config = ConfigManager.Instance.GetTemplate<TreasureConfig>(id);
                return progress >= config.RequirementTotal;// && config.LastSuccID > 0;
            }
        }

        public int unLockSkill
        {
            get
            {
                var job = PlayerDatas.Instance.baseData.Job;
                var stage = treasureStages.Find((x) =>
                {
                    return x.unlockType == TreasureStageUnlock.Skill;
                });
                return stage != null ? stage.GetSkill(job) : 0;
            }
        }

        public int unLockFunc
        {
            get; private set;
        }

        public int unLockPrivilege
        {
            get; private set;
        }

        Dictionary<int, List<TreasurePotential>> jobToPotentials = new Dictionary<int, List<TreasurePotential>>();

        public List<TreasurePotential> potentials
        {
            get
            {
                if (jobToPotentials.ContainsKey(PlayerDatas.Instance.baseData.Job))
                {
                    return jobToPotentials[PlayerDatas.Instance.baseData.Job];
                }
                else
                {
                    return null;
                }
            }
        }

        public List<int> achievements = new List<int>();
        public Dictionary<int, AchievementGroup> achievementGroups = new Dictionary<int, AchievementGroup>();

        public Item[] needItems { get; private set; }

        public Redpoint skillLevelUpRedpoint { get; private set; }
        public Redpoint achievementRedpoint { get; private set; }

        public Treasure(int _id)
        {
            this.id = _id;
        }

        public Treasure(int _id, int[] _potentialIds, Redpoint _skillLevelUpRedpoint, Redpoint _achievementPoint)
        {
            this.id = _id;
            this.skillLevelUpRedpoint = _skillLevelUpRedpoint;
            this.achievementRedpoint = _achievementPoint;

            var config = ConfigManager.Instance.GetTemplate<TreasureConfig>(this.id);
            List<int> _expAchievements;
            if (SuccessConfig.TryGetTreasureExpAchievements(_id, out _expAchievements))
            {
                achievements.AddRange(_expAchievements);
            }

            foreach (var achievement in achievements)
            {
                var achievementConfig = ConfigManager.Instance.GetTemplate<SuccessConfig>(achievement);

                AchievementGroup group;
                if (achievementGroups.ContainsKey(achievementConfig.Group))
                {
                    group = achievementGroups[achievementConfig.Group];
                }
                else
                {
                    achievementGroups[achievementConfig.Group] = group = new AchievementGroup(achievementConfig.Group);
                }

                group.AddAchievement(achievement);
            }

            foreach (var group in achievementGroups.Values)
            {
                group.Sort();
            }

            for (int i = 0; i < _potentialIds.Length; i++)
            {
                var skillId = _potentialIds[i];
                var skillConfig = ConfigManager.Instance.GetTemplate<SkillConfig>(skillId);
                if (skillConfig == null)
                {
                    continue;
                }

                for (int j = 0; j < GeneralConfig.Instance.openJobs.Length; j++)
                {
                    var job = GeneralConfig.Instance.openJobs[j];
                    List<TreasurePotential> tempPotentials;
                    if (jobToPotentials.ContainsKey(job))
                    {
                        tempPotentials = jobToPotentials[job];
                    }
                    else
                    {
                        jobToPotentials[job] = tempPotentials = new List<TreasurePotential>();
                    }

                    if (skillConfig.UseType == 0 || skillConfig.UseType == 1 << job)
                    {
                        tempPotentials.Add(new TreasurePotential(skillId, 0));
                    }
                }

            }

            if (!string.IsNullOrEmpty(config.NeedItem))
            {
                try
                {
                    var stringSet = config.NeedItem.Split('|');
                    needItems = new Item[stringSet.Length];
                    for (int i = 0; i < needItems.Length; i++)
                    {
                        var itemStrings = stringSet[i].Split('_');
                        needItems[i] = new Item(int.Parse(itemStrings[0]), int.Parse(itemStrings[1]));
                    }
                }
                catch (Exception ex)
                {
                    Debug.Log(ex.StackTrace);
                }
            }
            else
            {
                needItems = null;
            }
        }

        public TreasurePotential GetPotential(int _potentialId)
        {
            if (potentials == null)
            {
                return null;
            }
            else
            {
                for (int i = 0; i < potentials.Count; i++)
                {
                    var potential = potentials[i];
                    if (potential.id == _potentialId)
                    {
                        return potential;
                    }
                }

                return null;
            }
        }

        public void UpdatePotentialLevel(int _potentialId, int _level)
        {
            for (int i = 0; i < potentials.Count; i++)
            {
                var potential = potentials[i];
                if (potential.id == _potentialId)
                {
                    potential.level = _level;
                    break;
                }
            }
        }

        public AchievementGroup FindAchievementGroup(int _achievementId)
        {
            foreach (var key in achievementGroups.Keys)
            {
                var achievementGroup = achievementGroups[key];
                if (achievementGroup.Contain(_achievementId))
                {
                    return achievementGroup;
                }
            }

            return null;
        }

        private int AchievementCompare(int _lhs, int _rhs)
        {
            var configA = ConfigManager.Instance.GetTemplate<SuccessConfig>(_lhs);
            var configB = ConfigManager.Instance.GetTemplate<SuccessConfig>(_rhs);

            return configA.ReOrder < configB.ReOrder ? -1 : 1;
        }
        #endregion

        public TreasureSpecialData specialData { get; private set; }

        public List<TreasureStage> treasureStages = new List<TreasureStage>();
        public void UpdateTreasureStage(TreasureUpConfig _cfg)
        {
            TreasureStage _stage;
            if (_cfg.UnLockFuncID != 0)
            {
                _stage = new TreasureStage(_cfg.UnLockFuncID);
                unLockFunc = _stage.func;
            }
            else if (_cfg.Privilege != 0)
            {
                _stage = new TreasureStage(_cfg.Privilege, TreasureStageUnlock.Privilege);
                specialData = _stage.specialData;
                unLockPrivilege = _stage.privilege;
            }
            else if (_cfg.UnLockSkill != null && _cfg.UnLockSkill.Length > 1)
            {
                _stage = new TreasureStage(_cfg.UnLockSkill);
            }
            else if (!_cfg.AddAttr.Equals(string.Empty))
            {
                _stage = new TreasureStage(_cfg.AddAttr);
            }
            else
            {
                _stage = new TreasureStage();
            }
            _stage.exp = _cfg.NeedExp;
            _stage.stage = _cfg.LV;
            _stage.limitLevel = _cfg.LVLimit;
            treasureStages.Add(_stage);
        }

        public void UpdateTreasureLevelExp(int _lv, int _exp, bool _hasClickChallenge)
        {
            stage = _lv;
            exp = _exp;
            hasClickChallenge = _hasClickChallenge;
            if ((this is HumanTreasure) && IsMaxStage())
            {
                (this as HumanTreasure).humanState = HumanTreasureState.Potential;
            }
        }

        public bool IsMaxStage()
        {
            return treasureStages.FindIndex((x) =>
            {
                return x.stage >= stage + 1;
            }) == -1;
        }

        public bool IsUnlockStage(TreasureStageUnlock _type)
        {
            var _stage = treasureStages.Find((x) =>
            {
                return x.unlockType == _type;
            });
            if (_stage == null)
            {
                return false;
            }
            return stage >= _stage.stage;
        }

        public int GetStageIndex(int _stage)
        {
            if (treasureStages[0].unlockType == TreasureStageUnlock.None)
            {
                return Mathf.Max(_stage - 1, 0);
            }
            return _stage;
        }

        public int StageCount
        {
            get { return treasureStages.Count; }
        }
    }

    public class HumanTreasure : Treasure
    {
        HumanTreasureState m_State = HumanTreasureState.Locked;
        public HumanTreasureState humanState
        {
            get
            {
                return m_State;
            }
            set
            {
                m_State = value;
                if (value == HumanTreasureState.CastSoul)
                {
                    if (IsMaxStage())
                    {
                        m_State = HumanTreasureState.Potential;
                    }
                }
                ModelCenter.Instance.GetModel<TreasureModel>().HumanTreasureStateChange(base.id);
            }
        }

        public HumanTreasure(int _id)
            : base(_id)
        {

        }

        public HumanTreasure(int _id, int[] _potentialIds, Redpoint _skillLevelUpRedpoint, Redpoint _achievementPoint
            , Redpoint _castSoulPoint)
            : base(_id, _potentialIds, _skillLevelUpRedpoint, _achievementPoint)
        {
            castSoulRedpoint = _castSoulPoint;
        }

        public Redpoint castSoulRedpoint { get; private set; }
    }

    public class AchievementGroup
    {
        AchievementModel model { get { return ModelCenter.Instance.GetModel<AchievementModel>(); } }
        public int group { get; private set; }
        List<int> achievements = new List<int>();

        public AchievementGroup(int _category)
        {
            group = _category;
        }

        public void AddAchievement(int _achievement)
        {
            if (!achievements.Contains(_achievement))
            {
                achievements.Add(_achievement);
            }
        }

        public void Sort()
        {
            achievements.Sort(AchievementCompare);
        }

        public bool Contain(int _achievementId)
        {
            return achievements.Contains(_achievementId);
        }

        public bool IsAwardable()
        {
            var doingAchievement = GetDoingAchievement();
            if (doingAchievement > 0)
            {
                Achievement achievement;
                if (model.TryGetAchievement(doingAchievement, out achievement) && !achievement.completed)
                {
                    return Achievement.IsReach(doingAchievement, achievement.progress);
                }
            }
            return false;
        }

        public bool IsCompleted()
        {
            var achievementId = GetDoingAchievement();
            Achievement doingAchievement;
            if (model.TryGetAchievement(achievementId, out doingAchievement) && doingAchievement.completed)
            {
                return true;
            }
            for (int i = 0; i < achievements.Count; i++)
            {
                var id = achievements[i];
                Achievement achievement;
                if (model.TryGetAchievement(id, out achievement) && !achievement.completed)
                {
                    return false;
                }
            }

            return true;
        }

        public int GetDoingAchievement()
        {
            var achievementId = 0;
            for (int i = 0; i < achievements.Count; i++)
            {
                var id = achievements[i];
                Achievement achievement;

                var config = ConfigManager.Instance.GetTemplate<SuccessConfig>(id);
                if (config == null || PlayerDatas.Instance.baseData.LV < config.Condition3)
                {
                    continue;
                }

                if (model.TryGetAchievement(id, out achievement) && !achievement.completed)
                {
                    return id;
                }

                achievementId = id;
            }

            return achievementId;
        }

        public int GetLastAchievement()
        {
            if (achievements.Count == 0)
            {
                return 0;
            }
            else
            {
                var achievementId = GetDoingAchievement();
                Achievement doingAchievement;
                if (model.TryGetAchievement(achievementId, out doingAchievement) && doingAchievement.completed)
                {
                    return achievementId;
                }
                return achievements[achievements.Count - 1];
            }
        }

        private int AchievementCompare(int _lhs, int _rhs)
        {
            var configA = ConfigManager.Instance.GetTemplate<SuccessConfig>(_lhs);
            var configB = ConfigManager.Instance.GetTemplate<SuccessConfig>(_rhs);

            return configA.ReOrder.CompareTo(configB.ReOrder);
        }

        public static int Compare(AchievementGroup _lhs, AchievementGroup _rhs)
        {
            var awardableA = _lhs.IsAwardable();
            var awardableB = _rhs.IsAwardable();

            if (awardableA != awardableB)
            {
                return awardableA ? -1 : 1;
            }
            else
            {
                var completedA = _lhs.IsCompleted();
                var completedB = _rhs.IsCompleted();
                if (completedA != completedB)
                {
                    return completedA.CompareTo(completedB);
                }
                else if (completedA && completedB)
                {
                    return _lhs.group < _rhs.group ? -1 : 1;
                }
                else
                {
                    var idA = _lhs.GetDoingAchievement();
                    var idB = _rhs.GetDoingAchievement();

                    var configA = ConfigManager.Instance.GetTemplate<SuccessConfig>(idA);
                    var configB = ConfigManager.Instance.GetTemplate<SuccessConfig>(idB);

                    if (configA == null)
                    {
                        return 1;
                    }
                    else if (configB == null)
                    {
                        return -1;
                    }
                    else if (configA == null && configB == null)
                    {
                        return 0;
                    }
                    else
                    {
                        return configA.ReOrder < configB.ReOrder ? -1 : 1;
                    }
                }
            }
        }

    }

    public class TreasurePotential
    {
        public int id { get; private set; }
        public int level { get; set; }

        public TreasurePotential(int _id, int _level)
        {
            this.id = _id;
            this.level = _level;
        }
    }

    public struct PotentialBook
    {
        public int itemId;
        public int needCount;
        public int successRate;
        public int levelUpId;

        public PotentialBook(int _itemId, int _needCount, int _successRate,int _levelUpId)
        {
            this.itemId = _itemId;
            this.needCount = _needCount;
            this.successRate = _successRate;
            this.levelUpId = _levelUpId;
        }

    }

    public struct VIPKillNPCTreasure
    {
        public int level;
        public long currentExp;
    }

    public class TreasureStage
    {
        public int stage { get; set; }
        public TreasureStageUnlock unlockType { get; private set; }
        public Dictionary<int, int> propertyDict { get; private set; }
        public Dictionary<int, int> skillDict { get; private set; }
        public int func { get; private set; }
        public int privilege { get; private set; }
        public int exp { get; set; }
        public TreasureSpecialData specialData { get; private set; }
        public int stateSfxId { get; private set; }
        public const int selectedSfxId = 5144;
        public string sfxGotState { get; private set; }
        public string sfxUnGotState { get; private set; }
        public int limitLevel { get; set; }

        public TreasureStage()
        {
            unlockType = TreasureStageUnlock.None;
        }

        public TreasureStage(int _value, TreasureStageUnlock _type = TreasureStageUnlock.Func)
        {
            unlockType = _type;
            func = _type == TreasureStageUnlock.Func ? _value : 0;
            privilege = _type == TreasureStageUnlock.Privilege ? _value : 0;
            stateSfxId = 5141;
            sfxGotState = "Effect_FaBao_Icon_JiNeng_01";
            sfxUnGotState = "Effect_FaBao_Icon_JiNeng_02";
            //stateSfxId = _type == TreasureStageUnlock.Func ? 5140 : 5143;
            //sfxGotState = _type == TreasureStageUnlock.Func ? "Effect_FaBao_Icon_GongNeng_01" : "Effect_FaBao_Icon_TeQuan_02";
            //sfxUnGotState = _type == TreasureStageUnlock.Func ? "Effect_FaBao_Icon_GongNeng" : "Effect_FaBao_Icon_TeQuan";
            if (_type == TreasureStageUnlock.Privilege)
            {
                SetSpecial();
            }
        }

        public TreasureStage(string _property)
        {
            unlockType = TreasureStageUnlock.Property;
            propertyDict = ConfigParse.GetDic<int, int>(_property);
            stateSfxId = propertyDict.ContainsKey(6) ? 5142 : 5139;
            sfxGotState = propertyDict.ContainsKey(6) ? "Effect_FaBao_Icon_ShengMing" : "Effect_FaBao_Icon_GongJi";
            sfxUnGotState = propertyDict.ContainsKey(6) ? "Effect_FaBao_Icon_ShengMing" : "Effect_FaBao_Icon_GongJi";
        }

        public TreasureStage(int[] _skills)
        {
            unlockType = TreasureStageUnlock.Skill;
            stateSfxId = 5141;
            sfxGotState = "Effect_FaBao_Icon_JiNeng_01";
            sfxUnGotState = "Effect_FaBao_Icon_JiNeng_02";
            skillDict = new Dictionary<int, int>();
            for (int i = 0; i < _skills.Length; i++)
            {
                skillDict.Add(i + 1, _skills[i]);
            }
        }

        public void SetSpecial()
        {
            var _priviligeCfg = ConfigManager.Instance.GetTemplate<TreasurePrivilegeConfig>(privilege);
            specialData = new TreasureSpecialData((TreasurePrivilege)_priviligeCfg.PrivilegeID);
        }

        public int GetSkill(int _job)
        {
            if (skillDict.ContainsKey(_job))
            {
                return skillDict[_job];
            }
            return 0;
        }

        public int GetFightPower()
        {
            switch (unlockType)
            {
                case TreasureStageUnlock.Property:
                    return UIHelper.GetFightPower(propertyDict);
                case TreasureStageUnlock.Skill:
                    var _job = PlayerDatas.Instance.baseData.Job;
                    var _skillCfg = ConfigManager.Instance.GetTemplate<SkillConfig>(GetSkill(_job));
                    if (_skillCfg != null)
                    {
                        return _skillCfg.FightPower;
                    }
                    break;
                case TreasureStageUnlock.Privilege:
                    return specialData.GetFightPower();
            }
            return 0;
        }
    }

    public enum TreasureStageUnlock
    {
        None,
        Property,
        Skill,
        Func,
        Privilege,
    }

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

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

    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 privilegeRedpoint { get; private 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 = ConfigManager.Instance.GetTemplate<TreasurePrivilegeConfig>((int)_type);
            progress = Mathf.Max(1, config.singleValue);
            totalProgress = config.maxValue;
            var _effectValue = 0;
            int.TryParse(config.EffectValue, out _effectValue);
            effectValue = _effectValue;
            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 = ConfigManager.Instance.GetAllValues<PetInfoConfig>().Count;
                totalProgress = petCount;
            }
            else if (type == TreasurePrivilege.MountAtk)
            {
                var mountConfigs = ConfigManager.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 = ConfigManager.Instance.GetAllValues<ItemPlusSumAttrConfig>();
                totalProgress = configs[configs.Count - 1].countNeed;
            }

            switch (_type)
            {
                case TreasurePrivilege.DemonJarAtk:
                case TreasurePrivilege.StrengthenAdd:
                case TreasurePrivilege.MountAtk:
                case TreasurePrivilege.PetHp:
                case TreasurePrivilege.Boss:
                case TreasurePrivilege.Wash:
                    privilegeRedpoint = new Redpoint(TreasureModel.TREASURE_SOUL_ID, TreasureModel.TREASURE_SOUL_ID * 100 + (int)type);
                    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.Boss:
                case TreasurePrivilege.DemonJarAtk:
                case TreasurePrivilege.PetHp:
                case TreasurePrivilege.MountAtk:
                    privilegeRedpoint.state = RedPointState.None;
                    if (presentFinishCount >= totalProgress && (presentGetCount / progress) >= (totalProgress / progress))
                    {
                        state = TreasurePrivilegeState.Complete;
                    }
                    else if (presentGetCount > 0 && presentFinishCount / progress < presentGetCount / progress)
                    {
                        state = TreasurePrivilegeState.Reward;
                        privilegeRedpoint.state = RedPointState.Simple;
                    }
                    else
                    {
                        state = TreasurePrivilegeState.Doing;
                    }
                    break;
                case TreasurePrivilege.Wash:
                    privilegeRedpoint.state = itemGet ? RedPointState.None : RedPointState.Simple;
                    state = itemGet ? TreasurePrivilegeState.Doing : TreasurePrivilegeState.Reward;
                    break;
                case TreasurePrivilege.StrengthenAdd:
                    privilegeRedpoint.state = RedPointState.None;
                    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 = ConfigManager.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;
                        privilegeRedpoint.state = RedPointState.Simple;
                    }
                    else
                    {
                        state = TreasurePrivilegeState.Doing;
                    }
                    break;
            }
        }

        public string ProgressDisplay()
        {
            switch (type)
            {
                case TreasurePrivilege.DemonJarAtk:
                case TreasurePrivilege.PetHp:
                case TreasurePrivilege.MountAtk:
                case TreasurePrivilege.Boss:
                    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 = ConfigManager.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.Boss:
                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 = ConfigManager.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;
        }
    }
}