using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using System;
using TableConfig;
using System.Text;
using System.Linq;
using Snxxz.UI;

public class PlayerSkillDatas
{
    private Dictionary<int, PlayerSkillData> _playerSkills = new Dictionary<int, PlayerSkillData>();
    private Dictionary<int, PlayerSkillData> _quickSkills = new Dictionary<int, PlayerSkillData>();
    public static event Action OnQuickSkillRefresh;
    public static event Action OnRefreshSkill;
    private Dictionary<int, List<int>> filterPlayerSkillDic = new Dictionary<int, List<int>>();
    private Dictionary<int, int> filterQuickSkillDic = new Dictionary<int, int>();
    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 = Config.Instance.Get<SkillConfig>(vNetData.NewSkillID);
        if (skillCfg == null || (skillCfg.UseType != 0 && skillCfg.UseType != Math.Pow(2, PlayerDatas.Instance.baseData.Job)))
        {
            return;
        }

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

        model.CheckEquipPassSkill(data);

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

        PlayerSkillData olddata = null;
        _playerSkills.TryGetValue(vNetData.OldSkillID, out olddata);
        if (olddata != null)
        {
            if (hasInitQuickSkill)
            {
                int pos = ContainsQuickSkill(olddata.id);
                if (pos != -1 && !fitter)
                {
                    SetQuickSkill(pos, data.id);
                }
            }
            _playerSkills.Remove(vNetData.OldSkillID);
            olddata = null;
        }

        UpdateQuickSkill(data);

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

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

    public void SetQuickSkills()
    {
        _quickSkills.Clear();
        for (int i = 0; i < SkillModel.QUICK_SKILL_COUNT; i++)
        {
            _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;
                }
                PlayerSkillData data = GetSKillById(id);
                if (data == null)
                {
                    data = new PlayerSkillData(id, 1);
                }
                if (!GetFilterPlayerSkill(PlayerDatas.Instance.baseData.Job).Contains(data.id))
                {
                    _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 = Config.Instance.Get<FuncConfigConfig>(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;
        _quickSkills.TryGetValue(pos, out data);
        return data;
    }

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

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

    public void SetQuickSkill(int pos, int id)
    {
        if (model.GetXpSkillID() == id)
        {
            return;
        }
        PlayerSkillData data = GetSKillById(id);
        if (data == null)
        {
            MessageWin.Inst.ShowFixedTip(Language.Get("ThisSkillIsNotObtained_Z"));
            return;
        }
        if (data.skillCfg.UseType == 0)
        {
            return;
        }
        if (data.skillCfg == null || PlayerDatas.Instance.baseData.LV < data.skillCfg.LearnLVReq
            || data.skillCfg.FuncType != SkillModel.ACT_SKILL_TYPE)
        {
            MessageWin.Inst.ShowFixedTip(Language.Get("L1009"));
            return;
        }
        bool change = false;
        for (int i = 0; i < _quickSkills.Count; i++)
        {
            PlayerSkillData skill = null;
            _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 = _quickSkills[pos];
                _quickSkills[pos] = skill;
                _quickSkills[i] = temp;
                break;
            }
        }
        if (!change)
        {
            _quickSkills[pos] = data;
        }

        for (int i = 0; i < _quickSkills.Count; i++)
        {
            PlayerSkillData skill = null;
            _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 _playerSkills;
    }

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

    public List<int> GetFilterPlayerSkill(int job)
    {
        List<int> list = null;
        if (filterPlayerSkillDic.Count == 0)
        {
            FuncConfigConfig funcCfg = Config.Instance.Get<FuncConfigConfig>("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 _playerSkills.Values)
        {
            if (skill.typeID == typeID)
                return skill;
        }
        return null;
    }

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

    public void ClearSkillData()
    {
        _quickSkills.Clear();
        _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 = Config.Instance.Get<SkillConfig>(id);

        _typeID = skillCfg.SkillTypeID;
    }
}