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

using System;
using System.Linq;

namespace vnxbqy.UI
{
    
	public class TalentModel : Model, IPlayerLoginOk, IBeforePlayerDataInitialize
    {
        Dictionary<int, TalentSkill> talentSkills = new Dictionary<int, TalentSkill>();
        Dictionary<int, TalentTree> talentTreeDict = new Dictionary<int, TalentTree>();

        int m_SelectSeries;
        public int selectSeries
        {
            get { return m_SelectSeries; }
            set
            {
                if (m_SelectSeries != value && selectSeriesEvent != null)
                {
                    m_SelectSeries = value;
                    selectSeriesEvent();
                }
                m_SelectSeries = value;
            }
        }
        int m_SelectTalentType;
        public int selectTalentType
        {
            get { return m_SelectTalentType; }
            set
            {
                if (m_SelectTalentType != value && selectTalentTypeEvnet != null)
                {
                    m_SelectTalentType = value;
                    selectTalentTypeEvnet();
                }
                m_SelectTalentType = value;
            }
        }
        int m_SelectSkill;
        public int selectSkill
        {
            get { return m_SelectSkill; }
            set
            {
                if (m_SelectSkill != value && selectSkillEvent != null)
                {
                    m_SelectSkill = value;
                    selectSkillEvent();
                }
                m_SelectSkill = value;
            }
        }

        bool serverInited = false;

        public event Action selectTalentTypeEvnet;
        public event Action selectSeriesEvent;
        public event Action selectSkillEvent;
        public event Action talentPointUpdate;
        public event Action<int> talentSkillUpdate;
        public event Action<int> talentSkillLevelUp;

        public override void Init()
        {
            ParseConfig();
            FuncOpen.Instance.OnFuncStateChangeEvent += OnFuncStateChangeEvent;
            PlayerDatas.Instance.playerDataRefreshEvent += PlayerDataRefreshInfoEvent;
        }

        public void OnBeforePlayerDataInitialize()
        {
            foreach (var talent in talentSkills.Values)
            {
                talent.level = 0;
            }
            serverInited = false;
        }

        public void OnPlayerLoginOk()
        {
            serverInited = true;
            if (WindowCenter.Instance.IsOpen<TalentWin>())
            {
                foreach (var talent in talentSkills.Values)
                {
                    if (talentSkillUpdate != null)
                    {
                        talentSkillUpdate(talent.skillId);
                    }
                }
            }
            UpdateRedpoint();
        }

        public override void UnInit()
        {
            FuncOpen.Instance.OnFuncStateChangeEvent -= OnFuncStateChangeEvent;
            PlayerDatas.Instance.playerDataRefreshEvent -= PlayerDataRefreshInfoEvent;
        }

        private void OnFuncStateChangeEvent(int _id)
        {
            if (_id == (int)FuncOpenEnum.Talent)
            {
                UpdateRedpoint();
            }
        }

        public int talentResetBook { get; private set; }
        public int talentResetBookCost { get; private set; }
        Dictionary<int, List<int>> jobTalentTypeDict = new Dictionary<int, List<int>>();
        void ParseConfig()
        {
            var configs = TalentConfig.GetValues();
            for (int i = 0; i < configs.Count; i++)
            {
                var skillId = configs[i].skillId;
                var skillConfig = SkillConfig.Get(skillId);
                TalentSkill talent;
                if (!TryGetTalent(skillConfig.SkillTypeID, out talent))
                {
                    talent = new TalentSkill(skillConfig.SkillTypeID, skillConfig.SkillMaxLV);
                    talent.level = 0;
                    talentSkills.Add(skillConfig.SkillTypeID, talent);

                    TalentTree talentTree;
                    if (!talentTreeDict.TryGetValue(skillConfig.UseType, out talentTree))
                    {
                        talentTree = new TalentTree();
                        talentTreeDict.Add(skillConfig.UseType, talentTree);
                    }
                    talentTree.Add(configs[i], skillConfig.SkillTypeID);

                    List<int> list = null;
                    if (!jobTalentTypeDict.TryGetValue(skillConfig.UseType, out list))
                    {
                        list = new List<int>();
                        jobTalentTypeDict.Add(skillConfig.UseType, list);
                    }
                    if (!list.Contains(configs[i].type))
                    {
                        list.Add(configs[i].type);
                    }
                }
            }
            var jobs = jobTalentTypeDict.Keys.ToList();
            for (int i = 0; i < jobs.Count; i++)
            {
                var list = jobTalentTypeDict[jobs[i]];
                list.Sort((x, y) =>
                {
                    return x.CompareTo(y);
                });
            }


            var config = FuncConfigConfig.Get("TalentResetBook");
            talentResetBook = int.Parse(config.Numerical1);
            talentResetBookCost = int.Parse(config.Numerical2);
        }

        public int GetTalentType(int index)
        {
            var job = (int)Math.Pow(2, PlayerDatas.Instance.baseData.Job);
            if (jobTalentTypeDict.ContainsKey(job))
            {
                var list = jobTalentTypeDict[job];
                return index < list.Count ? list[index] : list[0];
            }
            return 1;
        }

        public int talentTypeCount
        {
            get
            {
                var job = (int)Math.Pow(2, PlayerDatas.Instance.baseData.Job);
                if (jobTalentTypeDict.ContainsKey(job))
                {
                    var list = jobTalentTypeDict[job];
                    return list.Count;
                }
                return 0;
            }
        }

        public bool TryGetTalents(int job, int talentType, int talentSeries, out List<int> talents)
        {
            talents = null;
            TalentTree talentTree = null;
            var _job = (int)Math.Pow(2, job);
            talentTreeDict.TryGetValue(_job, out talentTree);
            if (null != talentTree)
            {
                return talentTree.TryGetTalents(talentType, talentSeries, out talents);
            }
            return false;
        }

        public bool TryGetTalent(int talentId, out TalentSkill talent)
        {
            return talentSkills.TryGetValue(talentId, out talent);
        }

        public int GetTalentTypePoint(int talentType)
        {
            var point = 0;
            for (int i = 1; i <= 3; i++)
            {
                point += GetSeriesPoint(talentType, i);
            }
            return point;
        }

        public int GetAllTalentPoint()
        {
            var point = 0;
            var job = (int)Math.Pow(2, PlayerDatas.Instance.baseData.Job);
            if (jobTalentTypeDict.ContainsKey(job))
            {
                var list = jobTalentTypeDict[job];
                for (int i = 0; i < list.Count; i++)
                {
                    point += GetTalentTypePoint(list[i]);
                }
            }
            return point;
        }

        public int GetSeriesPoint(int talentType, int talentSeries)
        {
            var job = PlayerDatas.Instance.baseData.Job;
            List<int> list;
            var point = 0;
            if (TryGetTalents(job, talentType, talentSeries, out list))
            {
                for (int i = 0; i < list.Count; i++)
                {
                    TalentSkill talent;
                    if (TryGetTalent(list[i], out talent))
                    {
                        point += talent.level;
                    }
                }
            }
            return point;
        }

        public bool SatisfyLevelUp(int talentId, out int error)
        {
            error = 0;
            TalentSkill talent;
            if (TryGetTalent(talentId, out talent))
            {
                if (talent.level >= talent.maxLevel)
                {
                    error = 1;
                    return false;
                }
                if (talentPoint <= 0)
                {
                    error = 2;
                    return false;
                }
                var talentConfig = talent.GetTalentConfig(talent.level + 1);
                var skillConfig = talent.GetSkillConfig(talent.level + 1);
                var requireSeriesPoint = skillConfig.RequireTalentSeriesPoint();
                if (requireSeriesPoint != 0)
                {
                    var requireSeries = skillConfig.RequireTalentSeries();
                    if (GetSeriesPoint(talentConfig.type, requireSeries) < requireSeriesPoint)
                    {
                        error = 3;
                        return false;
                    }
                }
                if (skillConfig.LearnSkillReq != 0)
                {
                    var reqSkillConfig = SkillConfig.Get(skillConfig.LearnSkillReq);
                    if (reqSkillConfig.FuncType == 1)
                    {
                        if (PlayerDatas.Instance.skill.GetSKillById(skillConfig.LearnSkillReq) == null)
                        {
                            error = 6;
                            return false;
                        }
                    }
                    else
                    {
                        TalentSkill learnTalent;
                        if (TryGetTalent(skillConfig.LearnSkillReq, out learnTalent))
                        {
                            if (learnTalent.level < skillConfig.LearnSkillLV)
                            {
                                error = 4;
                                return false;
                            }
                        }
                    }
                }
                var requireProperty = skillConfig.RequireProperty();
                if (requireProperty != 0)
                {
                    var requirePropertyValue = skillConfig.RequirePropertyValue();
                    if (UIHelper.GetPropertyValue((PropertyType)requireProperty) < (ulong)requirePropertyValue)
                    {
                        error = 5;
                        return false;
                    }
                }
            }
            return true;
        }

        public void ProcessLevelUpError(int talentId, int error)
        {
            switch (error)
            {
                case 1:
                    SysNotifyMgr.Instance.ShowTip("TalentHighestLevel");
                    break;
                case 2:
                    SysNotifyMgr.Instance.ShowTip("LackTalentPoint");
                    break;
                case 3:
                    SysNotifyMgr.Instance.ShowTip("LackTalentSeriesPoint");
                    break;
                case 4:
                    SysNotifyMgr.Instance.ShowTip("PreTalentLevelLimit");
                    break;
                case 5:
                    SysNotifyMgr.Instance.ShowTip("TalentRequirePropertyLimit");
                    break;
                case 6:
                    TalentSkill talent;
                    if (TryGetTalent(talentId, out talent))
                    {
                        var skillConfig = talent.GetSkillConfig();
                        var treasureModel = ModelCenter.Instance.GetModel<TreasureModel>();
                        var treasureId = treasureModel.GetTreasureBySkillId(skillConfig.LearnSkillReq);
                        var treasureConfig = TreasureConfig.Get(treasureId);
                        SysNotifyMgr.Instance.ShowTip("PreTreasureSkillLimit", treasureConfig.Name);
                    }
                    break;
            }
        }

        #region 服务端数据
        public int talentPoint { get { return PlayerDatas.Instance.extersion.talentPoint; } }

        private void PlayerDataRefreshInfoEvent(PlayerDataType refreshType)
        {
            if (refreshType == PlayerDataType.CDBPlayerRefresh_TalentPoint)
            {
                if (talentPointUpdate != null)
                {
                    talentPointUpdate();
                }
                UpdateRedpoint();
            }
            else if (refreshType == PlayerDataType.STR
                || refreshType == PlayerDataType.PNE
                || refreshType == PlayerDataType.PHY
                || refreshType == PlayerDataType.CON)
            {
                UpdateRedpoint();
            }
        }

        public void UpdateTalentSkill(int _oldSkillId, int _newSkillId)
        {
            var config = SkillConfig.Get(_newSkillId);
            if (config == null)
            {
                return;
            }
            if (talentSkills.ContainsKey(config.SkillTypeID))
            {
                var talentSkill = talentSkills[config.SkillTypeID];
                bool levelUp = talentSkill.level < config.SkillLV;
                talentSkill.level = config.SkillLV;
                if (talentSkillUpdate != null)
                {
                    talentSkillUpdate(config.SkillTypeID);
                }
                if (levelUp && serverInited)
                {
                    if (talentSkillLevelUp != null)
                    {
                        talentSkillLevelUp(config.SkillTypeID);
                    }
                }
            }
            UpdateRedpoint();
        }

        public void DeleteTalentSkill(int _skillId)
        {
            var config = SkillConfig.Get(_skillId);
            if (config == null)
            {
                return;
            }
            if (talentSkills.ContainsKey(config.SkillTypeID))
            {
                var talentSkill = talentSkills[config.SkillTypeID];
                talentSkill.level = 0;
                if (talentSkillUpdate != null)
                {
                    talentSkillUpdate(config.SkillTypeID);
                }
            }
            UpdateRedpoint();
        }
        #endregion

        #region 红点
        public Redpoint talentRedpoint = new Redpoint(103, 10303);
        void UpdateRedpoint()
        {
            talentRedpoint.state = RedPointState.None;
            if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Talent))
            {
                return;
            }
            if (talentPoint == 0)
            {
                return;
            }
            var error = 0;
            foreach (var talent in talentSkills.Values)
            {
                if (SatisfyLevelUp(talent.skillId, out error))
                {
                    talentRedpoint.state = RedPointState.Simple;
                    break;
                }
            }
        }
        #endregion
    }

    public class TalentSkill
    {
        public int skillId { get; private set; }
        public int level { get; set; }
        public int maxLevel { get; private set; }

        public TalentSkill(int skillId, int maxLevel)
        {
            this.skillId = skillId;
            this.maxLevel = maxLevel;
        }

        public SkillConfig GetSkillConfig(int level = 0)
        {
            if (level > 0)
            {
                return SkillConfig.Get(skillId + level - 1);
            }
            else
            {
                return SkillConfig.Get(skillId + level);
            }
        }

        public TalentConfig GetTalentConfig(int level = 0)
        {
            return TalentConfig.Get(skillId);
        }
    }

    public class TalentSeries
    {
        public int series { get; private set; }
        public List<int> talentSkills { get; private set; }

        public TalentSeries(int series)
        {
            this.series = series;
            talentSkills = new List<int>();
        }

        public void Add(int skillId)
        {
            if (talentSkills.Contains(skillId))
            {
                return;
            }
            talentSkills.Add(skillId);
        }
    }

    public class TalentTree
    {
        Dictionary<int, List<TalentSeries>> talentSeriesDict = new Dictionary<int, List<TalentSeries>>();

        public void Add(TalentConfig config, int skillId)
        {
            List<TalentSeries> list = null;
            if (!talentSeriesDict.TryGetValue(config.type, out list))
            {
                list = new List<TalentSeries>();
                talentSeriesDict.Add(config.type, list);
            }
            TalentSeries talentSeries = list.Find((x) =>
             {
                 return x.series == config.series;
             });
            if (talentSeries == null)
            {
                talentSeries = new TalentSeries(config.series);
                list.Add(talentSeries);
            }
            talentSeries.Add(skillId);
        }

        public bool TryGetTalents(int type, int series, out List<int> list)
        {
            list = null;
            if (talentSeriesDict.ContainsKey(type))
            {
                var talentSeries = talentSeriesDict[type].Find((x) =>
                 {
                     return x.series == series;
                 });
                if (talentSeries != null)
                {
                    list = talentSeries.talentSkills;
                    return true;
                }
            }
            return false;
        }
    }

    public static class TalentHelper
    {
        public static int RequireTalentSeries(this SkillConfig config)
        {
            if (config == null)
            {
                return 0;
            }
            return config.LearnSkillPointReq / 10000;
        }

        public static int RequireTalentSeriesPoint(this SkillConfig config)
        {
            if (config == null)
            {
                return 0;
            }
            return config.LearnSkillPointReq % 10000;
        }

        public static int RequireProperty(this SkillConfig config)
        {
            if (config == null)
            {
                return 0;
            }
            return config.StateSkillLV / 100000;
        }

        public static int RequirePropertyValue(this SkillConfig config)
        {
            if (config == null)
            {
                return 0;
            }
            return config.StateSkillLV % 100000;
        }
    }
}