//--------------------------------------------------------
//    [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_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; }
        }

        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 = Config.Instance.Get<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 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 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 = Config.Instance.Get<TreasureConfig>(this.id);
            List<int> _expAchievements;
            if (SuccessConfig.TryGetTreasureExpAchievements(_id, out _expAchievements))
            {
                achievements.AddRange(_expAchievements);
            }

            foreach (var achievement in achievements)
            {
                var achievementConfig = Config.Instance.Get<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 = Config.Instance.Get<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));
                    }
                }
            }
        }

        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 = Config.Instance.Get<SuccessConfig>(_lhs);
            var configB = Config.Instance.Get<SuccessConfig>(_rhs);

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

        public List<TreasureStage> treasureStages = new List<TreasureStage>();
        public void UpdateTreasureStage(TreasureUpConfig _cfg)
        {
            TreasureStage _stage = new TreasureStage(_cfg);
            treasureStages.Add(_stage);
        }



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

        public bool IsHighestStage
        {
            get
            {
                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 GetStageId(int _stageIndex)
        {
            foreach (var item in treasureStages)
            {
                if (item.stage == _stageIndex)
                {
                    return item.id;
                }
            }

            return 0;
        }

        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;
            }
            private set
            {
                m_State = value;
                ModelCenter.Instance.GetModel<TreasureModel>().HumanTreasureStateChange(base.id);
            }
        }

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

        public void UpdateTreasureState()
        {
            if (state == TreasureState.Locked)
            {
                humanState = HumanTreasureState.Locked;
                return;
            }
            if (state == TreasureState.Collecting)
            {
                humanState = HumanTreasureState.Challenge;
                return;
            }
            if (IsHighestStage && FuncOpen.Instance.IsFuncOpen(82))
            {
                humanState = HumanTreasureState.Potential;
            }
            else
            {
                humanState = HumanTreasureState.CastSoul;
            }
        }

        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;

                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 = Config.Instance.Get<SuccessConfig>(_lhs);
            var configB = Config.Instance.Get<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 = Config.Instance.Get<SuccessConfig>(idA);
                    var configB = Config.Instance.Get<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 id { get; private set; }

        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 Item item { get; private set; }
        public int treasure { get; private set; }
        public int treasureSoul { get; private set; }
        public int exp { get; 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 TreasureStage(TreasureUpConfig _config)
        {
            id = _config.ID;
            unlockType = TreasureStageUnlock.None;
            if (_config.UnLockFuncID != 0)
            {
                unlockType = TreasureStageUnlock.Func;
                func = _config.UnLockFuncID;
            }
            else if (_config.UnLockSkill != null && _config.UnLockSkill.Length > 1)
            {
                unlockType = TreasureStageUnlock.Skill;
                skillDict = new Dictionary<int, int>();
                for (int i = 0; i < _config.UnLockSkill.Length; i++)
                {
                    skillDict.Add(i + 1, _config.UnLockSkill[i]);
                }
            }
            else if (!string.IsNullOrEmpty(_config.AddAttr))
            {
                unlockType = TreasureStageUnlock.Property;
                propertyDict = ConfigParse.GetDic<int, int>(_config.AddAttr);
            }
            else if (_config.ActiveMWID != 0)
            {
                unlockType = TreasureStageUnlock.Treasure;
                treasure = _config.ActiveMWID;
            }
            else if (_config.SoulID != 0)
            {
                unlockType = TreasureStageUnlock.TreasureSoul;
                treasureSoul = _config.SoulID;
            }
            else if (!string.IsNullOrEmpty(_config.ItemAward))
            {
                unlockType = TreasureStageUnlock.Item;
                var itemArray = LitJson.JsonMapper.ToObject<int[]>(_config.ItemAward);
                if (itemArray != null && itemArray.Length > 0)
                {
                    item = new Item()
                    {
                        id = itemArray[0],
                        count = itemArray.Length > 1 ? itemArray[1] : 1,
                        bind = itemArray.Length > 2 ? (itemArray[2] == 1) : false,
                    };
                }
            }

            exp = _config.NeedExp;
            stage = _config.LV;

            switch (unlockType)
            {
                case TreasureStageUnlock.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";
                    break;
                default:
                    stateSfxId = 5141;
                    sfxGotState = "Effect_FaBao_Icon_JiNeng_01";
                    sfxUnGotState = "Effect_FaBao_Icon_JiNeng_02";
                    break;
            }
        }

        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 = Config.Instance.Get<SkillConfig>(GetSkill(_job));
                    if (_skillCfg != null)
                    {
                        return _skillCfg.FightPower;
                    }
                    break;
            }
            return 0;
        }
    }

    public enum TreasureStageUnlock
    {
        None,
        Property,
        Skill,
        Func,
        Item,
        Treasure,
        TreasureSoul,
    }
}