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

using System.Text;
using System.Linq;
using vnxbqy.UI;

public class PlayerSkillDatas
{
    private Dictionary<int, PlayerSkillData> m_PlayerSkills = new Dictionary<int, PlayerSkillData>();
    private Dictionary<int, PlayerSkillData> m_QuickSkills = new Dictionary<int, PlayerSkillData>();
    private Dictionary<int, List<int>> filterPlayerSkillDic = new Dictionary<int, List<int>>();
    private Dictionary<int, int> filterQuickSkillDic = new Dictionary<int, int>();

    public static event Action OnQuickSkillRefresh;
    public static event Action OnRefreshSkill;
    private bool hasInitQuickSkill = false;

    private bool isServerPrepare = false;

    SkillModel m_Model;
    SkillModel model
    {
        get
        {
            return m_Model ?? (m_Model = ModelCenter.Instance.GetModel<SkillModel>());
        }
    }

    TreasureModel treasureModel { get { return ModelCenter.Instance.GetModel<TreasureModel>(); } }

    public void OnRoleSkillChange(H0310_tagRoleSkillChange vNetData)
    {
        SkillConfig skillCfg = SkillConfig.Get(vNetData.NewSkillID);
        if (skillCfg == null || (skillCfg.UseType != 0 && skillCfg.UseType != Math.Pow(2, PlayerDatas.Instance.baseData.Job)))
        {
            return;
        }

        PlayerSkillData data = null;
        m_PlayerSkills.TryGetValue(vNetData.NewSkillID, out data);
        if (data == null)
        {
            data = new PlayerSkillData(vNetData.NewSkillID, 1);
            m_PlayerSkills.Add(data.id, data);
        }

        model.CheckEquipPassSkill(data);

        bool fitter = GetFilterPlayerSkill(PlayerDatas.Instance.baseData.Job).Contains(data.id);

        
        if (hasInitQuickSkill)
        {
            int pos = ContainsQuickSkillType(data.id);
            if (pos != -1)
            {
                SetQuickSkill(pos, data.id);
            }
        }

        PlayerSkillData olddata = null;
        m_PlayerSkills.TryGetValue(vNetData.OldSkillID, out olddata);
        if (olddata != null)
        {
            m_PlayerSkills.Remove(vNetData.OldSkillID);
            olddata = null;
        }

        UpdateQuickSkill(data);

        for (int i = 0; i < GeneralDefine.EarlierGetTreasure.Count; i++)
        {
            var _treasureId = GeneralDefine.EarlierGetTreasure[i];
            var _mapId = treasureModel.GetMapIdByTreasure(_treasureId);
            if (PlayerDatas.Instance.baseData.MapID == _mapId)
            {
                return;
            }
        }

        if (OnRefreshSkill != null)
        {
            OnRefreshSkill();
        }
    }

    public void SetQuickSkills()
    {
        m_QuickSkills.Clear();
        for (int i = 0; i < SkillModel.QUICK_SKILL_COUNT; i++)
        {
            m_QuickSkills.Add(i, null);
        }
        for (int i = 0; i < SkillModel.QUICK_SKILL_COUNT; i++)
        {
            string str = QuickSetting.Instance.GetQuickSetting(QuickSetting.QuickSettingType.Skill, i);
            if (!string.IsNullOrEmpty(str))
            {
                int id = MathUtils.Convert64To10(str);
                if (id == 0)
                {
                    continue;
                }
                var config = SkillConfig.Get(id);
                if (config == null)
                {
                    continue;
                }
                if (config.FuncType != 1)
                {
                    continue;
                }
                PlayerSkillData data = GetSKillById(id);
                if (data == null)
                {
                    data = new PlayerSkillData(id, 1);
                }
                if (!GetFilterPlayerSkill(PlayerDatas.Instance.baseData.Job).Contains(data.id))
                {
                    m_QuickSkills[i] = data;
                }
            }
        }
        if (OnQuickSkillRefresh != null)
        {
            OnQuickSkillRefresh();
        }
        hasInitQuickSkill = true;
    }

    public void CheckQuickSet()
    {
        if (!isServerPrepare)
        {
            QuickSetting.Instance.SendPackage();
        }
        isServerPrepare = true;
    }

    public void UpdateQuickSkill(PlayerSkillData data)
    {
        if (!hasInitQuickSkill)
        {
            return;
        }
        bool fitter = GetFilterPlayerSkill(PlayerDatas.Instance.baseData.Job).Contains(data.id);
        if (fitter || data.skillCfg.FuncType != SkillModel.ACT_SKILL_TYPE)
        {
            return;
        }
        FuncConfigConfig func = FuncConfigConfig.Get(string.Format("QuickJobSkill{0}", PlayerDatas.Instance.baseData.Job));
        if (func != null)
        {
            int[] intarray = ConfigParse.GetMultipleStr<int>(func.Numerical1);
            for (int i = 0; i < intarray.Length; i++)
            {
                if (intarray[i] == data.id)
                {
                    if (GetQuickSkillByPos(i) == null)
                    {
                        SetQuickSkill(i, data.id);
                    }
                    break;
                }
            }
        }
        for (int i = 0; i < SkillModel.QUICK_SKILL_COUNT; i++)
        {
            if (ContainsQuickSkill(data.id) != -1)
            {
                break;
            }
            PlayerSkillData quick = GetQuickSkillByPos(i);
            if (quick == null)
            {
                SetQuickSkill(i, data.id);
                break;
            }
        }
    }

    public PlayerSkillData GetQuickSkillByPos(int pos)
    {
        PlayerSkillData data = null;
        m_QuickSkills.TryGetValue(pos, out data);
        return data;
    }

    public PlayerSkillData GetSKillById(int id)
    {
        PlayerSkillData data = null;
        m_PlayerSkills.TryGetValue(id, out data);
        return data;
    }

    public Dictionary<int, PlayerSkillData> GetQuickSkills()
    {
        return m_QuickSkills;
    }

    public void SetQuickSkill(int pos, int id)
    {

        PlayerSkillData data = GetSKillById(id);
        if (data == null)
        {
            ServerTipDetails.DisplayNormalTip(Language.Get("ThisSkillIsNotObtained_Z"));
            return;
        }
        if (data.skillCfg.UseType == 0)
        {
            return;
        }
        if (data.skillCfg == null || data.skillCfg.FuncType != SkillModel.ACT_SKILL_TYPE)
        {
            ServerTipDetails.DisplayNormalTip(Language.Get("L1009"));
            return;
        }
        bool change = false;
        for (int i = 0; i < m_QuickSkills.Count; i++)
        {
            PlayerSkillData skill = null;
            m_QuickSkills.TryGetValue(i, out skill);
            if (skill == null)
            {
                continue;
            }
            if (skill.id == id && i == pos)
            {
                return;
            }
            else if (skill.id == id)
            {
                change = true;
                PlayerSkillData temp = m_QuickSkills[pos];
                m_QuickSkills[pos] = skill;
                m_QuickSkills[i] = temp;
                break;
            }
        }
        if (!change)
        {
            m_QuickSkills[pos] = data;
        }

        for (int i = 0; i < m_QuickSkills.Count; i++)
        {
            PlayerSkillData skill = null;
            m_QuickSkills.TryGetValue(i, out skill);
            if (skill != null)
            {
                string val = MathUtils.Convert10To64(skill.id);
                QuickSetting.Instance.SetQuickSetting(QuickSetting.QuickSettingType.Skill, val, i);
            }
        }
        if (isServerPrepare)
        {
            QuickSetting.Instance.SendPackage();
        }

        if (OnQuickSkillRefresh != null)
        {
            OnQuickSkillRefresh();
        }
    }

    public Dictionary<int, PlayerSkillData> GetAllSkill()
    {
        return m_PlayerSkills;
    }

    public int ContainsQuickSkill(int id)
    {
        foreach (int pos in m_QuickSkills.Keys)
        {
            if (m_QuickSkills[pos] == null) continue;
            if (m_QuickSkills[pos].id == id) return pos;
        }
        return -1;
    }

    public int ContainsQuickSkillType(int id)
    {
        foreach (int pos in m_QuickSkills.Keys)
        {
            if (m_QuickSkills[pos] == null)
            {
                continue;
            }
            var quickSkillConfig = SkillConfig.Get(m_QuickSkills[pos].id);
            var skillConfig = SkillConfig.Get(id);
            if (quickSkillConfig != null && skillConfig != null
                && quickSkillConfig.SkillTypeID == skillConfig.SkillTypeID)
            {
                return pos;
            }
        }
        return -1;
    }

    public List<int> GetFilterPlayerSkill(int job)
    {
        List<int> list = null;
        if (filterPlayerSkillDic.Count == 0)
        {
            FuncConfigConfig funcCfg = FuncConfigConfig.Get("JobFitterSkill");
            if (funcCfg != null)
            {
                int[] intarray = null;
                intarray = ConfigParse.GetMultipleStr<int>(funcCfg.Numerical1);
                list = new List<int>(); list.AddRange(intarray);
                filterPlayerSkillDic.Add(1, list);
                intarray = ConfigParse.GetMultipleStr<int>(funcCfg.Numerical2);
                list = new List<int>(); list.AddRange(intarray);
                filterPlayerSkillDic.Add(2, list);
                intarray = ConfigParse.GetMultipleStr<int>(funcCfg.Numerical3);
                list = new List<int>(); list.AddRange(intarray);
                filterPlayerSkillDic.Add(3, list);
            }
        }
        filterPlayerSkillDic.TryGetValue(job, out list);
        return list;
    }

    public PlayerSkillData GetSkillBySkillTypeID(int typeID)
    {
        foreach (var skill in m_PlayerSkills.Values)
        {
            if (skill.typeID == typeID)
                return skill;
        }
        return null;
    }

    public int GetSkillCountByType(int _type)
    {
        var count = 0;
        foreach (var _skill in m_PlayerSkills.Values)
        {
            if (_skill.skillCfg.FuncType == _type)
            {
                count++;
            }
        }
        return count;
    }

    public void ClearSkillData()
    {
        hasInitQuickSkill = false;
        isServerPrepare = false;
        m_QuickSkills.Clear();
        m_PlayerSkills.Clear();
    }
}

public class PlayerSkillData
{
    private int _typeID;
    public int typeID
    {
        get
        {
            return _typeID;
        }
    }
    /**技能ID*/
    private int _id;
    public int id
    {
        get { return _id; }
    }

    public int level
    {
        get { return skillCfg.SkillLV; }
    }

    public SkillConfig skillCfg
    {
        private set;
        get;
    }

    public PlayerSkillData(int id, int level)
    {
        _id = id;

        skillCfg = SkillConfig.Get(id);

        _typeID = skillCfg.SkillTypeID;
    }
}