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

namespace Snxxz.UI
{
    public class AchievementModel : Model, IBeforePlayerDataInitialize
    {
        public event Action<int> achievementProgressUpdateEvent;
        public event Action<int> achievementCompletedEvent;
        public event Action<int> achievementAwardableEvent;

        Dictionary<int, Achievement> achievements = new Dictionary<int, Achievement>();
        Dictionary<int, List<int>> achievementCategorys = new Dictionary<int, List<int>>();

        PackModelInterface packModelInterface { get { return ModelCenter.Instance.GetModel<PackModelInterface>(); } }
        PlayerPackModel playerPack { get { return ModelCenter.Instance.GetModel<PlayerPackModel>(); } }
        PlayerTaskDatas taskmodel { get { return ModelCenter.Instance.GetModel<PlayerTaskDatas>(); } }
        GetItemPathModel getItemPathModel { get { return ModelCenter.Instance.GetModel<GetItemPathModel>(); } }
        DailyQuestModel dailyQuestModel { get { return ModelCenter.Instance.GetModel<DailyQuestModel>(); } }

        Dictionary<int, int> equipQualityItemIdTables = new Dictionary<int, int>() { { 1, 2110 }, { 2, 2111 }, { 3, 2112 }, { 4, 2113 }, { 5, 2114 } };

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

        public override void UnInit()
        {
        }

        public void OnBeforePlayerDataInitialize()
        {
            foreach (var achievement in achievements.Values)
            {
                achievement.ResetAchievementState();
            }
        }

        public void UpdateAchievementProgress(int _achievementId, int _progress)
        {
            if (achievements.ContainsKey(_achievementId))
            {
                if (achievements[_achievementId].progress != _progress)
                {
                    achievements[_achievementId].progress = _progress;
                    if (achievements[_achievementId].completed)
                    {
                        return;
                    }
                    if (achievementProgressUpdateEvent != null)
                    {
                        achievementProgressUpdateEvent(_achievementId);
                    }

                    if (Achievement.IsReach(_achievementId, _progress))
                    {
                        if (achievementAwardableEvent != null)
                        {
                            achievementAwardableEvent(_achievementId);
                        }
                    }
                }
            }
        }

        public bool TryGetAchievement(int _achievementId, out Achievement _achievement)
        {
            return achievements.TryGetValue(_achievementId, out _achievement);
        }

        public void GetAchievementReward(int _achievementId)
        {
            var sendInfo = new CA542_tagMCGetSuccessAward();
            sendInfo.SuccID = (uint)_achievementId;
            GameNetSystem.Instance.SendInfo(sendInfo);
        }

        public void UpdateAchievementCompleteState(int _achievementId, bool _completed)
        {
            Achievement achievement;
            if (TryGetAchievement(_achievementId, out achievement))
            {
                if (achievement.completed != _completed)
                {
                    achievement.completed = _completed;
                    if (achievementCompletedEvent != null)
                    {
                        achievementCompletedEvent(_achievementId);
                    }
                }
            }
        }

        public Dictionary<AchievementCondition, List<int>> achievementConditionDict = new Dictionary<AchievementCondition, List<int>>();
        public bool GetAchievementIdByTypeCondition(int _type, int[] _condition, out List<int> _list)
        {
            AchievementCondition condition = new AchievementCondition()
            {
                type = _type,
                condition = _condition,
            };
            return achievementConditionDict.TryGetValue(condition, out _list);
        }

        public class AchievementCondition
        {
            public int type;
            public int[] condition;

            public override bool Equals(object obj)
            {
                return this == (AchievementCondition)obj;
            }
            public override int GetHashCode()
            {
                var _value = type;
                for (int i = 0; i < condition.Length; i++)
                {
                    _value += condition[i];
                }
                return _value.GetHashCode();
            }
            public static bool operator ==(AchievementCondition x, AchievementCondition y)
            {
                if (x.type != y.type)
                {
                    return false;
                }
                if (x.condition.Length != y.condition.Length)
                {
                    return false;
                }
                for (int i = 0; i < x.condition.Length; i++)
                {
                    if (x.condition[i] != y.condition[i])
                    {
                        return false;
                    }
                }
                return true;
            }
            public static bool operator !=(AchievementCondition x, AchievementCondition y)
            {
                return !(x == y);
            }
        }

        public void GotoCompleteByJump(int _jump)
        {
            WindowJumpMgr.Instance.WindowJumpTo((JumpUIType)_jump);
        }

        public void GotoCompleteAchievement(int _achievementId)
        {
            var config = Config.Instance.Get<SuccessConfig>(_achievementId);
            if (config == null)
            {
                return;
            }

            //在这里先处理成就前往之后的一些指引
            AchievementGoto.guideAchievementId = 0;
            AchievementGoto.achievementType = 0;
            ProcessAchievementGotoGuide(_achievementId);
            if (config.Jump != 0)
            {
                GotoCompleteByJump(config.Jump);
            }
            else
            {

                switch (config.Type)
                {
                    case 3:
                        WindowCenter.Instance.Close<TreasureLevelUpWin>();
                        WindowCenter.Instance.Open<MainInterfaceWin>();

                        var hasTask = taskmodel.GetQuestState(config.Condition[0]) != -1;
                        if (hasTask)
                        {
                            taskmodel.AutomaticTripToTask(config.Condition[0]);
                        }
                        else
                        {
                            var paramSet = config.Condition2.Split('|');
                            if (paramSet.Length > 1)
                            {
                                var level = int.Parse(paramSet[1]);
                                if (PlayerDatas.Instance.baseData.LV >= level)
                                {
                                    MapTransferUtility.Instance.MoveToNPC(int.Parse(paramSet[0]));
                                }
                                else
                                {
                                    SysNotifyMgr.Instance.ShowTip("AchievementLVLimit", level);
                                }
                            }
                            else
                            {
                                MapTransferUtility.Instance.MoveToNPC(int.Parse(config.Condition2));
                            }
                        }

                        break;
                    case 5:
                    case 29:
                        if (!FuncOpen.Instance.IsFuncOpen(34))
                        {
                            var functionConfig = Config.Instance.Get<FuncOpenLVConfig>(34);
                            FuncOpen.Instance.ProcessorFuncErrorTip(34);
                        }
                        else
                        {
                            var dailyQuestState = dailyQuestModel.GetQuestState((int)DailyQuestType.BountyMission);
                            if (dailyQuestState == DailyQuestModel.DailyQuestState.Completed)
                            {
                                SysNotifyMgr.Instance.ShowTip("Cmwd_CompleteMark");
                            }
                            else
                            {
                                var mapId = PlayerDatas.Instance.baseData.MapID;
                                var mapConfig = Config.Instance.Get<MapConfig>(mapId);

                                if (mapConfig != null && mapConfig.MapFBType != 0)
                                {
                                    SysNotifyMgr.Instance.ShowTip("InDungeon_CantGo");
                                }
                                else
                                {
                                    taskmodel.DailyBountyMove();
                                    WindowCenter.Instance.Close<TreasureLevelUpWin>();
                                    WindowCenter.Instance.Open<MainInterfaceWin>();
                                }
                            }
                        }
                        break;
                    case 1:
                        getItemPathModel.SetChinItemModel(2103);
                        break;
                    case 13:
                        getItemPathModel.SetChinItemModel(2100);
                        break;
                    case 4:
                    case 86:
                        WindowCenter.Instance.Close<TreasureLevelUpWin>();

                        var mapModel = ModelCenter.Instance.GetModel<MapModel>();
                        var pointId = mapModel.GetRecommendHangPoint();
                        var mapEventConfig = Config.Instance.Get<MapEventPointConfig>(pointId);
                        mapModel.wannaLookLocalMap = mapEventConfig.MapID;
                        WindowCenter.Instance.Open<LocalMapWin>();
                        break;
                    case 36:
                        WindowCenter.Instance.Close<TreasureLevelUpWin>();

                        WindowCenter.Instance.Open<MainInterfaceWin>();
                        MapTransferUtility.Instance.MoveToNPC(config.Condition[0]);
                        break;
                    case 37:
                        WindowCenter.Instance.Close<TreasureLevelUpWin>();

                        WindowCenter.Instance.Open<MainInterfaceWin>();
                        MapTransferUtility.Instance.MoveToLocalMapPosition(config.Condition2.Vector3Parse());
                        break;
                    case 38:
                        var guid = GetHighestSorceEquipByPlace(new List<int>() { config.Condition[0] });
                        if (string.IsNullOrEmpty(guid))
                        {
                            getItemPathModel.SetChinItemModel(2108);
                        }
                        else
                        {
                            playerPack.SetLookIndex(guid);
                            GotoCompleteByJump(144);
                        }
                        break;
                    case 39:
                        var guid39 = GetBetterEquipByPlace();
                        if (string.IsNullOrEmpty(guid39))
                        {
                            var itemQuality = config.Condition[1];
                            if (equipQualityItemIdTables.ContainsKey(itemQuality))
                            {
                                getItemPathModel.SetChinItemModel(equipQualityItemIdTables[itemQuality]);
                            }
                            else
                            {
                                getItemPathModel.SetChinItemModel(2108);
                            }
                        }
                        else
                        {
                            playerPack.SetLookIndex(guid39);
                            GotoCompleteByJump(144);
                        }
                        break;
                    case 82:
                        var guid82 = GetBetterEquipByPlace(new List<int>() { 3, 4, 5, 6, 7 });
                        if (string.IsNullOrEmpty(guid82))
                        {
                            var itemQuality = config.Condition[0];
                            if (equipQualityItemIdTables.ContainsKey(itemQuality))
                            {
                                getItemPathModel.SetChinItemModel(equipQualityItemIdTables[itemQuality]);
                            }
                            else
                            {
                                getItemPathModel.SetChinItemModel(2108);
                            }
                        }
                        else
                        {
                            WindowCenter.Instance.Close<TreasureLevelUpWin>();

                            playerPack.SetLookIndex(guid82);
                            WindowCenter.Instance.Close<MainInterfaceWin>();
                            WindowCenter.Instance.Open<KnapSackWin>();
                        }
                        break;
                    case 83:
                        var guid83 = GetBetterEquipByPlace(new List<int>() { 1, 2 });
                        if (string.IsNullOrEmpty(guid83))
                        {
                            var itemQuality = config.Condition[0];
                            if (equipQualityItemIdTables.ContainsKey(itemQuality))
                            {
                                getItemPathModel.SetChinItemModel(equipQualityItemIdTables[itemQuality]);
                            }
                            else
                            {
                                getItemPathModel.SetChinItemModel(2108);
                            }
                        }
                        else
                        {
                            playerPack.SetLookIndex(guid83);
                            WindowCenter.Instance.Close<TreasureLevelUpWin>();
                            WindowCenter.Instance.Close<MainInterfaceWin>();
                            WindowCenter.Instance.Open<KnapSackWin>();
                        }
                        break;
                    case 84:
                        var guid84 = GetBetterEquipByPlace(new List<int>() { 9, 10 });
                        if (string.IsNullOrEmpty(guid84))
                        {
                            var itemQuality = config.Condition[0];
                            if (equipQualityItemIdTables.ContainsKey(itemQuality))
                            {
                                getItemPathModel.SetChinItemModel(equipQualityItemIdTables[itemQuality]);
                            }
                            else
                            {
                                getItemPathModel.SetChinItemModel(2108);
                            }
                        }
                        else
                        {
                            WindowCenter.Instance.Close<TreasureLevelUpWin>();

                            playerPack.SetLookIndex(guid84);
                            WindowCenter.Instance.Close<MainInterfaceWin>();
                            WindowCenter.Instance.Open<KnapSackWin>();
                        }
                        break;
                    case 85:
                        var guid85 = GetBetterEquipByPlace(new List<int>() { 8 });
                        if (string.IsNullOrEmpty(guid85))
                        {
                            var itemQuality = config.Condition[0];
                            if (equipQualityItemIdTables.ContainsKey(itemQuality))
                            {
                                getItemPathModel.SetChinItemModel(equipQualityItemIdTables[itemQuality]);
                            }
                            else
                            {
                                getItemPathModel.SetChinItemModel(2108);
                            }
                        }
                        else
                        {
                            WindowCenter.Instance.Close<TreasureLevelUpWin>();

                            playerPack.SetLookIndex(guid85);
                            WindowCenter.Instance.Close<MainInterfaceWin>();
                            WindowCenter.Instance.Open<KnapSackWin>();
                        }
                        break;
                    case 90:
                        var guid90 = GetBetterEquipByPlace(new List<int>() { 11 });
                        if (string.IsNullOrEmpty(guid90))
                        {
                            getItemPathModel.SetChinItemModel(2108);
                        }
                        else
                        {
                            WindowCenter.Instance.Close<TreasureLevelUpWin>();

                            playerPack.SetLookIndex(guid90);
                            WindowCenter.Instance.Close<MainInterfaceWin>();
                            WindowCenter.Instance.Open<KnapSackWin>();
                        }
                        break;
                    case 109:
                        WindowCenter.Instance.Close<TreasureLevelUpWin>();

                        var skillId = FindSkillByJob(config.Condition, PlayerDatas.Instance.baseData.Job);
                        if (skillId != 0)
                        {
                            if (ModelCenter.Instance.GetModel<SkillModel>().GetXpSkillID() == skillId)
                            {
                                WindowCenter.Instance.Open<MainInterfaceWin>();
                                break;
                            }
                            if (PlayerDatas.Instance.skill.ContainsQuickSkill(skillId) == -1)
                            {
                                WindowCenter.Instance.Open<SkillPanel>();
                            }
                            else
                            {
                                WindowCenter.Instance.Open<MainInterfaceWin>();
                            }
                        }
                        break;
                    case 116:
                        getItemPathModel.SetChinItemModel(config.Condition[0]);
                        break;
                    default:
                        WindowCenter.Instance.Close<TreasureLevelUpWin>();

                        WindowCenter.Instance.Open<MainInterfaceWin>();
                        break;
                }

            }

        }

        public List<int> GetAchievementsByCategory(int _type)
        {
            if (achievementCategorys.ContainsKey((int)_type))
            {
                return new List<int>(achievementCategorys[(int)_type]);
            }
            else
            {
                return null;
            }
        }

        private string GetHighestSorceEquipByPlace(List<int> _places)
        {
            var package = playerPack.GetSinglePackModel(PackType.rptItem);
            var allItems = package.GetPackModelIndexDict();

            var guid = string.Empty;
            var equips = new List<string>();
            var score = 0;
            var job = PlayerDatas.Instance.baseData.Job;
            foreach (var item in allItems.Values)
            {
                if (_places.Contains(item.chinItemModel.EquipPlace))
                {
                    if (!packModelInterface.IsOverdue(item.itemInfo.ItemGUID, item.itemId)
                        && (item.chinItemModel.JobLimit == 0 || (item.chinItemModel.JobLimit / 100) == job) && item.equipScore > score)
                    {
                        guid = item.itemInfo.ItemGUID;
                    }
                }
            }

            return guid;
        }

        private string GetBetterEquipByPlace(List<int> _places)
        {
            var package = playerPack.GetSinglePackModel(PackType.rptItem);
            var allItems = package.GetPackModelIndexDict();

            var equipPackage = playerPack.GetSinglePackModel(PackType.rptEquip);

            var guid = string.Empty;
            var equips = new List<string>();
            var score = 0;
            var job = PlayerDatas.Instance.baseData.Job;
            foreach (var item in allItems.Values)
            {
                var overdue = packModelInterface.IsOverdue(item.itemInfo.ItemGUID, item.itemId, item.useDataDict);

                if (!overdue && _places.Contains(item.chinItemModel.EquipPlace) && (item.chinItemModel.JobLimit == 0 || (item.chinItemModel.JobLimit / 100) == job))
                {
                    var equipedItem = equipPackage.GetItemModelByIndex(item.chinItemModel.EquipPlace);
                    var equipdItemScore = equipedItem == null ? 0 : equipedItem.equipScore;
                    if (item.equipScore > equipdItemScore && item.equipScore > score)
                    {
                        guid = item.itemInfo.ItemGUID;
                    }
                }
            }

            return guid;
        }

        public string GetBetterEquipByPlace()
        {
            var package = playerPack.GetSinglePackModel(PackType.rptItem);
            var allItems = package.GetPackModelIndexDict();

            var equipPackage = playerPack.GetSinglePackModel(PackType.rptEquip);

            var guid = string.Empty;
            var equips = new List<string>();
            var score = 0;
            var job = PlayerDatas.Instance.baseData.Job;
            foreach (var item in allItems.Values)
            {
                var config = Config.Instance.Get<ItemConfig>(item.itemId);
                if (config.EquipPlace > 10)
                {
                    continue;
                }

                var equipedItem = equipPackage.GetItemModelByIndex(item.chinItemModel.EquipPlace);
                var equipdItemScore = equipedItem == null ? 0 : equipedItem.equipScore;
                var overdue = packModelInterface.IsOverdue(item.itemInfo.ItemGUID, item.itemId, item.useDataDict);

                if (!overdue && (item.chinItemModel.JobLimit == 0 || (item.chinItemModel.JobLimit / 100) == job) && item.equipScore > equipdItemScore && item.equipScore > score)
                {
                    score = item.equipScore;
                    guid = item.itemInfo.ItemGUID;
                }
            }

            return guid;
        }

        public int FindSkillByJob(int[] _skillIds, int _job)
        {
            foreach (var skill in _skillIds)
            {
                var config = Config.Instance.Get<SkillConfig>(skill);

                if (config != null && (config.UseType == 0 || config.UseType == 1 << _job))
                {
                    return skill;
                }
            }

            return 0;
        }

        private void ProcessAchievementGotoGuide(int _achievementId)
        {
            var config = Config.Instance.Get<SuccessConfig>(_achievementId);
            switch (config.Type)
            {
                case 8:
                    AchievementGoto.Goto8(_achievementId);
                    break;
                case 16:
                    AchievementGoto.Goto16(_achievementId);
                    break;
                case 20:
                    AchievementGoto.Goto20(_achievementId);
                    break;
                case 21:
                    AchievementGoto.Goto21(_achievementId);
                    break;
                case 31:
                    AchievementGoto.Goto31(_achievementId);
                    break;
                case 35:
                    AchievementGoto.Goto35(_achievementId);
                    break;
                case 36:
                    AchievementGoto.GotoKillNpc(_achievementId);
                    break;
                case 37:
                    AchievementGoto.GotoExploreMap(_achievementId);
                    break;
                case 41:
                    AchievementGoto.Goto41(_achievementId);
                    break;
                case 42:
                    AchievementGoto.GotoRuneTower(_achievementId);
                    break;
                case 44:
                    AchievementGoto.Goto44(_achievementId);
                    break;
                case 45:
                    AchievementGoto.Goto45(_achievementId);
                    break;
                case 46:
                case 62:
                    AchievementGoto.GotoFairyLand(_achievementId);
                    break;
                case 7:
                case 49:
                    AchievementGoto.GotoKylin(_achievementId);
                    break;
                case 50:
                    AchievementGoto.Goto50(_achievementId);
                    break;
                case 51:
                    AchievementGoto.Goto3051(_achievementId, config);
                    break;
                case 52:
                    //AchievementGoto.GotoGetDailyActiveValueAward(_achievementId);
                    break;
                case 4:
                case 54:
                    AchievementGoto.GotoTrial(_achievementId);
                    break;
                case 60:
                    AchievementGoto.Goto60(_achievementId);
                    break;
                case 61:
                    AchievementGoto.Goto61(_achievementId);
                    break;
                case 63:
                    AchievementGoto.GotoNuwa(_achievementId);
                    break;
                case 66:
                    AchievementGoto.Goto3066(_achievementId, config);
                    break;
                case 68:
                    AchievementGoto.Goto68(_achievementId);
                    break;
                case 69:
                    AchievementGoto.Goto3069(_achievementId, config);
                    break;
                case 79:
                    AchievementGoto.Goto79(_achievementId);
                    break;
                case 81:
                    AchievementGoto.GotoDungeonInspire(_achievementId);
                    break;
                case 91:
                    AchievementGoto.GotoSpSkillLevelUp(_achievementId);
                    break;
                case 92:
                    AchievementGoto.Goto3092(_achievementId, config);
                    break;
                case 93:
                    AchievementGoto.Goto93(_achievementId);
                    break;
                case 94:
                    AchievementGoto.Goto3094(_achievementId, config);
                    break;
                case 95:
                    AchievementGoto.Goto3095(_achievementId, config);
                    break;
                case 96:
                    AchievementGoto.Goto3096(_achievementId, config);
                    break;
                case 97:
                    AchievementGoto.Goto3097(_achievementId, config);
                    break;
                case 99:
                    AchievementGoto.GotoBuyDungeonTimes(_achievementId);
                    break;
                case 110:
                    AchievementGoto.Goto3110(_achievementId, config);
                    break;
                case 103:
                    AchievementGoto.Goto103(_achievementId);
                    break;
                case 104:
                    AchievementGoto.Goto104(_achievementId);
                    break;
                case 109:
                    AchievementGoto.Goto109(_achievementId);
                    break;
                case 113:
                    AchievementGoto.Goto113(_achievementId);
                    break;
                case 114:
                    AchievementGoto.Goto3114(_achievementId, config);
                    break;
                case 115:
                    AchievementGoto.GotoStove(_achievementId);
                    break;
                case 10:
                    AchievementGoto.Goto10(_achievementId);
                    break;
                case 58:
                    AchievementGoto.Goto58(_achievementId);
                    break;
                case 100:
                    AchievementGoto.Goto100(_achievementId);
                    break;
                case 106:
                    AchievementGoto.Goto106(_achievementId);
                    break;
                case 108:
                    AchievementGoto.Goto108(_achievementId);
                    break;
                case 125:
                    AchievementGoto.GotoIceCrystal(_achievementId);
                    break;
            }
        }

        private void ParseAchievementConfig()
        {
            var allconfig = Config.Instance.GetAllValues<SuccessConfig>();
            foreach (var config in allconfig)
            {
                this.achievements[config.ID] = new Achievement(config.ID, config.AwardItemList, config.Money, config.Exp);

                List<int> achievements;
                if (achievementCategorys.ContainsKey(config.Type))
                {
                    achievements = achievementCategorys[config.Type];
                }
                else
                {
                    achievementCategorys[config.Type] = achievements = new List<int>();
                }
                achievements.Add(config.ID);

                List<int> _list;
                var _condition = config.Condition;
                if (config.Condition.Length == 0)
                {
                    _condition = new int[1] { 0 };
                }
                AchievementCondition achievementCondition = new AchievementCondition()
                {
                    type = config.Type,
                    condition = _condition,
                };
                if (achievementConditionDict.ContainsKey(achievementCondition))
                {
                    _list = achievementConditionDict[achievementCondition];
                }
                else
                {
                    achievementConditionDict[achievementCondition] = _list = new List<int>();
                }
                _list.Add(config.ID);

            }
        }

        const string conditionPattern = "@Condition@";
        const string needCntPattern = "@NeedCnt@";
        const string skillPattern = "@SkillName@";

        public static string ParseAchievementDescription(int _achievementId)
        {
            var config = Config.Instance.Get<SuccessConfig>(_achievementId);
            var description = config.Describe;
            switch (config.Type)
            {
                case 1:
                    description = description.Replace(needCntPattern, config.NeedCnt.ToString());
                    description = description.Replace(conditionPattern, config.Condition.ToString());
                    break;
                case 91:
                    try
                    {
                        var job = PlayerDatas.Instance.baseData.Job;
                        var skillId = 0;
                        skillId = config.Condition[job - 1];
                        var skillConfig = Config.Instance.Get<SkillConfig>(skillId);
                        description = description.Replace(skillPattern, skillConfig.SkillName);
                    }
                    catch (Exception ex)
                    {
                        Debug.Log(ex);
                    }
                    break;
                default:
                    description = description.Replace(needCntPattern, config.NeedCnt.ToString());
                    description = description.Replace(conditionPattern, config.Condition.ToString());
                    break;
            }

            return description;
        }

    }

}