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

public class StatusMgr : SingletonMonobehaviour<StatusMgr>
{
    public static event UnityAction<string> OnGainStatus;

    private Dictionary<uint, List<Status_Base>> m_StatusDict = null;
    private List<Status_Base> m_AllStatus = null;
    private List<uint> m_OwnerList = null;

    [HideInInspector]
    public int bossBelongBuffID;
    [HideInInspector]
    public int redNameBuffID;
    [HideInInspector]
    public int yellowNameBuffID;

    public void Init()
    {
        if (m_StatusDict == null)
        {
            m_StatusDict = new Dictionary<uint, List<Status_Base>>();
        }

        if (m_OwnerList == null)
        {
            m_OwnerList = new List<uint>();
        }

        if (m_AllStatus == null)
        {
            m_AllStatus = new List<Status_Base>();
        }

        FuncConfigConfig _funcConfig = Config.Instance.Get<FuncConfigConfig>("BuffCPInterface");
        string[] _pair = _funcConfig.Numerical1.Split('_');
        if (_pair != null && _pair.Length > 0)
        {
            if (_pair[1].Equals("BOSSAscription"))
            {
                bossBelongBuffID = int.Parse(_pair[0]);
            }
        }

        _pair = _funcConfig.Numerical2.Split('_');
        if (_pair != null && _pair.Length > 0)
        {
            if (_pair[1].Equals("RedName"))
            {
                redNameBuffID = int.Parse(_pair[0]);
            }
        }

        _pair = _funcConfig.Numerical3.Split('_');
        if (_pair != null && _pair.Length > 0)
        {
            if (_pair[1].Equals("YellowName"))
            {
                yellowNameBuffID = int.Parse(_pair[0]);
            }
        }
    }

    public void Request(H0605_tagObjAddBuff h0605)
    {
        // 修改目标状态
        GActor _actor = GAMgr.Instance.GetBySID(h0605.ObjID);
        if (_actor != null)
        {
            SkillHelper.EffectValue _effectValue;
            if (SkillHelper.Instance.Get(h0605.SkillID).effectValue.TryGetValue(4012, out _effectValue))
            {
                byte _count = 0;
                if (_actor.ActorInfo.status4012.ContainsKey((byte)_effectValue.value1))
                {
                    _count = _actor.ActorInfo.status4012[(byte)_effectValue.value1];
                }
                _count += 1;
                _actor.ActorInfo.status4012[(byte)_effectValue.value1] = _count;
            }
        }

        Status_Base _status = Get(h0605.ObjID, h0605.SkillID);

        if (_status == null)
        {
            if (IsMockingBuff(h0605.SkillID))
            {
                if (h0605.ObjID == PlayerDatas.Instance.PlayerId)
                {
                    DebugEx.Log("得到了一个嘲讽buff");
                }
                _status = new Status_Mocking();
            }
            else if (bossBelongBuffID == h0605.SkillID)
            {
                _status = new Status_BossBelong();
            }
            else if (redNameBuffID == h0605.SkillID)
            {
                _status = new Status_RedName();
            }
            else if (IsInVisibleStatus(h0605.SkillID))
            {
                _status = new Status_InVisible();
            }
            else if (IsPolymorch(h0605.SkillID))
            {
                _status = new Status_Polymorph();
            }
            else
            {
                _status = new Status_Normal();
            }
        }

        _status.Init(h0605);

        List<Status_Base> _list = null;
        if (!m_StatusDict.ContainsKey(h0605.ObjID))
        {
            _list = new List<Status_Base>();
            m_StatusDict.Add(h0605.ObjID, _list);
        }

        if (!m_StatusDict[h0605.ObjID].Contains(_status))
        {
            m_StatusDict[h0605.ObjID].Add(_status);
        }

        if (!m_AllStatus.Contains(_status))
        {
            m_AllStatus.Add(_status);
        }

        if (!m_OwnerList.Contains(h0605.ObjID))
        {
            m_OwnerList.Add(h0605.ObjID);
        }

        // 显示主英雄获取相应状态
        if (h0605.ObjID == PlayerDatas.Instance.PlayerId)
        {
            if (h0605.BuffType == (int)E_BuffType.bfBuff
             || h0605.BuffType == (int)E_BuffType.bfProcessBuff)
            {
                if (OnGainStatus != null)
                {
                    SkillConfig _skillConfig = Config.Instance.Get<SkillConfig>(h0605.SkillID);
                    if (_skillConfig != null)
                    {
                        OnGainStatus(_skillConfig.SkillName);
                    }
                }
            }
        }
    }

    public void Release(uint objID, byte type)
    {
        List<Status_Base> _list = null;

        GActor _actor = GAMgr.Instance.GetBySID(objID);

        if (m_StatusDict.TryGetValue(objID, out _list))
        {
            for (int i = _list.Count - 1; i >= 0; --i)
            {
                if (_list[i].h0605.BuffType == type)
                {
                    if (_actor != null)
                    {
                        SkillHelper.EffectValue _effectValue;
                        if (SkillHelper.Instance.Get(_list[i].h0605.SkillID).effectValue.TryGetValue(4012, out _effectValue))
                        {
                            byte _count = 0;
                            if (_actor.ActorInfo.status4012.TryGetValue((byte)_effectValue.value1, out _count))
                            {
                                _count -= 1;
                            }
                            if (_count < 0)
                            {
                                _count = 0;
                            }
                            _actor.ActorInfo.status4012[(byte)_effectValue.value1] = _count;
                        }
                    }

                    if (m_AllStatus.Contains(_list[i]))
                    {
                        m_AllStatus.Remove(_list[i]);
                    }

                    _list[i].UnInit(objID, type);
                    _list.RemoveAt(i);
                }
            }
        }
    }

    public void Release(H0606_tagObjDelBuff h0606)
    {
        // 修改目标状态
        GActor _actor = GAMgr.Instance.GetBySID(h0606.ObjID);
        if (_actor != null)
        {
            SkillHelper.EffectValue _effectValue;
            if (SkillHelper.Instance.Get(h0606.SkillID).effectValue.TryGetValue(4012, out _effectValue))
            {
                byte _count = 0;
                if (_actor.ActorInfo.status4012.TryGetValue((byte)_effectValue.value1, out _count))
                {
                    _count -= 1;
                }
                if (_count < 0)
                {
                    _count = 0;
                }
                _actor.ActorInfo.status4012[(byte)_effectValue.value1] = _count;
            }
        }

        Status_Base _status = Get(h0606.ObjID, h0606.SkillID);
        var _skillInfo = SkillHelper.Instance.Get(h0606.SkillID);

        if (_status == null)
        {
            Debug.LogWarningFormat("删除 {0} 的 buff: {1} 的时候发现这个在客户端不存在.", h0606.ObjID, h0606.SkillID);
            return;
        }

        _status.UnInit(h0606.ObjID, h0606.BuffType);

        if (m_AllStatus.Contains(_status))
        {
            m_AllStatus.Remove(_status);
        }

        if (m_StatusDict.ContainsKey(h0606.ObjID)
         && m_StatusDict[h0606.ObjID].Contains(_status))
        {
            m_StatusDict[h0606.ObjID].Remove(_status);
        }

        if (m_OwnerList.Contains(h0606.ObjID))
        {
            m_OwnerList.Remove(h0606.ObjID);
        }

        if (_skillInfo.effectValue.ContainsKey(2004))
        {
            if (PlayerDatas.Instance.hero != null
             && PlayerDatas.Instance.hero.SelectTarget == _actor)
            {
                PlayerDatas.Instance.ReCheckAttackTarget();
            }
        }
    }

    public void ReleaseActor(uint sid)
    {
        List<Status_Base> _list = null;

        if (m_StatusDict.TryGetValue(sid, out _list))
        {
            for (int i = 0; i < _list.Count; ++i)
            {
                _list[i].UnInit(sid, 0);

                if (m_AllStatus.Contains(_list[i]))
                {
                    m_AllStatus.Remove(_list[i]);
                }
            }

            m_StatusDict[sid].Clear();
            m_StatusDict.Remove(sid);
        }

        if (m_OwnerList.Contains(sid))
        {
            m_OwnerList.Remove(sid);
        }
    }

    public void DoUpdate()
    {
        for (int i = m_AllStatus.Count - 1; i >= 0; --i)
        {
            m_AllStatus[i].Update();
        }
    }

    public Status_Base Get(uint sid, int buffID)
    {
        List<Status_Base> _list = null;
        if (m_StatusDict.TryGetValue(sid, out _list))
        {
            for (int i = 0; i < _list.Count; ++i)
            {
                if (_list[i].h0605.SkillID == buffID)
                {
                    return _list[i];
                }
            }
        }
        return null;
    }

    public bool IsExistBossBelong(uint sid)
    {
        return IsExist(sid, bossBelongBuffID);
    }

    public bool IsExist(uint sid, int buffID)
    {
        List<Status_Base> _list = null;
        if (m_StatusDict.TryGetValue(sid, out _list))
        {
            for (int i = 0; i < _list.Count; ++i)
            {
                if (_list[i].h0605.SkillID == buffID)
                {
                    return true;
                }
            }
        }
        return false;
    }

    public void GetBuffIds(uint sid, ref List<int> buffList)
    {
        if (buffList == null)
        {
            return;
        }

        List<Status_Base> _list = null;
        if (m_StatusDict.TryGetValue(sid, out _list))
        {
            for (int i = 0; i < _list.Count; ++i)
            {
                buffList.Add(_list[i].h0605.SkillID);
            }
        }
    }

    public bool CanMove(uint sid)
    {
        List<Status_Base> _list = null;
        if (m_StatusDict.TryGetValue(sid, out _list))
        {
            for (int i = 0; i < _list.Count; ++i)
            {
                if (!_list[i].CanMove())
                {
                    return false;
                }
            }
        }
        return true;
    }

    public bool CanRide(uint sid)
    {
        List<Status_Base> _list = null;
        if (m_StatusDict.TryGetValue(sid, out _list))
        {
            for (int i = 0; i < _list.Count; ++i)
            {
                if (!_list[i].CanRide())
                {
                    return false;
                }
            }
        }
        return true;
    }

    public bool CanCollect(uint sid)
    {
        List<Status_Base> _list = null;
        if (m_StatusDict.TryGetValue(sid, out _list))
        {
            for (int i = 0; i < _list.Count; ++i)
            {
                if (!_list[i].CanCollect())
                {
                    return false;
                }
            }
        }
        return true;
    }

    public bool CanSit(uint sid)
    {
        List<Status_Base> _list = null;
        if (m_StatusDict.TryGetValue(sid, out _list))
        {
            for (int i = 0; i < _list.Count; ++i)
            {
                if (!_list[i].CanSit())
                {
                    return false;
                }
            }
        }
        return true;
    }

    public bool CanCatch(uint sid)
    {
        List<Status_Base> _list = null;
        if (m_StatusDict.TryGetValue(sid, out _list))
        {
            for (int i = 0; i < _list.Count; ++i)
            {
                if (!_list[i].CanCatch())
                {
                    return false;
                }
            }
        }
        return true;
    }

    public bool CanFish(uint sid)
    {
        List<Status_Base> _list = null;
        if (m_StatusDict.TryGetValue(sid, out _list))
        {
            for (int i = 0; i < _list.Count; ++i)
            {
                if (!_list[i].CanFish())
                {
                    return false;
                }
            }
        }
        return true;
    }

    public bool CanDance(uint sid)
    {
        List<Status_Base> _list = null;
        if (m_StatusDict.TryGetValue(sid, out _list))
        {
            for (int i = 0; i < _list.Count; ++i)
            {
                if (!_list[i].CanDance())
                {
                    return false;
                }
            }
        }
        return true;
    }

    public bool CanLook(uint sid)
    {
        List<Status_Base> _list = null;
        if (m_StatusDict.TryGetValue(sid, out _list))
        {
            for (int i = 0; i < _list.Count; ++i)
            {
                if (!_list[i].CanLook())
                {
                    return false;
                }
            }
        }
        return true;
    }

    public bool CanUseItem(uint sid)
    {
        List<Status_Base> _list = null;
        if (m_StatusDict.TryGetValue(sid, out _list))
        {
            for (int i = 0; i < _list.Count; ++i)
            {
                if (!_list[i].CanUseItem())
                {
                    return false;
                }
            }
        }
        return true;
    }

    public bool CanAttack(uint sid, int skillSeries)
    {
        List<Status_Base> _list = null;
        if (m_StatusDict.TryGetValue(sid, out _list))
        {
            for (int i = 0; i < _list.Count; ++i)
            {
                if (!_list[i].CanAttack(skillSeries))
                {
                    return false;
                }
            }
        }
        return true;
    }

    private bool IsMockingBuff(int id)
    {
        SkillConfig _config = Config.Instance.Get<SkillConfig>(id);

        if (_config != null
         && ((_config.Effect1 == 4012 && _config.EffectValue11 == 6)
          || (_config.Effect2 == 4012 && _config.EffectValue21 == 6)
          || (_config.Effect3 == 4012 && _config.EffectValue31 == 6)
          || (_config.Effect4 == 4012 && _config.EffectValue41 == 6)
          || (_config.Effect5 == 4012 && _config.EffectValue51 == 6)
          || (_config.Effect6 == 4012 && _config.EffectValue61 == 6)))
        {
            return true;
        }

        return false;
    }

    private bool IsPolymorch(int id)
    {
        SkillConfig _config = Config.Instance.Get<SkillConfig>(id);
        if (_config != null
        && (_config.Effect1 == 1063
         || _config.Effect2 == 1063
         || _config.Effect3 == 1063
         || _config.Effect4 == 1063
         || _config.Effect5 == 1063
         || _config.Effect6 == 1063))
        {
            return true;
        }
        return false;
    }

    private bool IsInVisibleStatus(int id)
    {
        SkillHelper.SkillInfo _skillInfo = SkillHelper.Instance.Get(id);

        if (_skillInfo != null
         && _skillInfo.effectValue.ContainsKey(1302))
        {
            return true;
        }

        return false;
    }

    public bool IsInvincible(uint sid)
    {
        List<Status_Base> _list = null;
        if (m_StatusDict.TryGetValue(sid, out _list))
        {
            SkillHelper.SkillInfo _skillInfo = null;
            for (int i = 0; i < _list.Count; ++i)
            {
                _skillInfo = SkillHelper.Instance.Get(_list[i].h0605.SkillID);
                if (_skillInfo.effectValue.ContainsKey(2004))
                {
                    return true;
                }
            }
        }
        return false;
    }

    public bool IsInvisible(uint sid)
    {
        List<Status_Base> _list = null;
        if (m_StatusDict.TryGetValue(sid, out _list))
        {
            SkillHelper.SkillInfo _skillInfo = null;
            for (int i = 0; i < _list.Count; ++i)
            {
                _skillInfo = SkillHelper.Instance.Get(_list[i].h0605.SkillID);
                if (_skillInfo.effectValue.ContainsKey(1302))
                {
                    return true;
                }
            }
        }
        return false;
    }

    public bool TryGetSkillEffectValue(uint sid, int skillEffectID, out SkillHelper.EffectValue effectValue)
    {
        effectValue = default(SkillHelper.EffectValue);
        List<Status_Base> _list = null;
        if (m_StatusDict.TryGetValue(sid, out _list))
        {
            for (int i = 0; i < _list.Count; ++i)
            {
                if (SkillHelper.Instance.Get(_list[i].h0605.SkillID).effectValue.ContainsKey(skillEffectID))
                {
                    effectValue = SkillHelper.Instance.Get(_list[i].h0605.SkillID).effectValue[skillEffectID];
                    return true;
                }
            }
        }
        return false;
    }

}