/********************************************************************
	文件: EventCenter.cs
	作者: 梦语
	邮箱: 1982614048@qq.com
	创建时间: 2024/03/29 17:28:19
	最后修改: 梦语
	最后修改时间: 2024/04/03 16:06:58
	功能: 事件处理中心
    使用方法:
        AddListener:
            EventCenter.AddListener<NetProtoType, IOCPServerSession, byte[]>(NetProtoType.IOCPReceive, IOCPMsgReceive);
            EventCenter.AddListener<MsgId, HttpListenerResponse, MsgData>(MsgId.Regist, RegistEventDispose);
        RemoveListener:
            EventCenter.RemoveListener<NetProtoType, IOCPServerSession, byte[]>(NetProtoType.IOCPReceive, IOCPMsgReceive);
            EventCenter.RemoveListener<MsgId, HttpListenerResponse, MsgData>(MsgId.Regist, RegistEventDispose);
        BroadCast:
            EventCenter.BroadCast((MsgId)msgData.msgId, session, msgData);
            EventCenter.BroadCast(NetProtoType.HTTPPostReceive, response, content);
*********************************************************************/
using System;
using System.Collections;
using System.Collections.Generic;

/// <summary>
/// 事件处理
/// </summary>
public class EventCenter
{
    #region 普通事件

    private static Dictionary<string, Delegate> normalEventDic = new Dictionary<string, Delegate>();

    private static void OnListenerAdding(string eventType, Delegate callBack)
    {
        normalEventDic.TryAdd(eventType, null);

        Delegate d = normalEventDic[eventType];

        if (!string.IsNullOrEmpty(eventType) && d != null && d.GetType() != callBack.GetType())
        {
            throw new Exception($"尝试为事件{eventType}添加不同类型的委托，当前事件所对应的委托为{d.GetType()},要添加的委托类型为{callBack.GetType()}");
        }
    }

    private static void OnListenerRemoving(string eventType, Delegate callBack)
    {
        if (normalEventDic.ContainsKey(eventType))
        {
            Delegate d = normalEventDic[eventType];
            if (d == null)
            {
                throw new Exception($"移除监听错误:事件{eventType}没有对应的委托");
            }
            else if (d.GetType() != callBack.GetType())
            {
                throw new Exception(
                    $"移除监听错误:尝试为事件{eventType}移除不同类型的委托，当前委托类型为{d.GetType()}，要移除的委托类型为{callBack.GetType()}");
            }
            return;
        }

        throw new Exception($"移除监听错误:没有事件码{eventType}");
    }

    private static void OnListenerRemoved(string eventType)
    {
        if (normalEventDic[eventType] == null)
        {
            normalEventDic.Remove(eventType);
        }
    }

    //==================================================监听事件========================================================

    /// <summary>
    /// 无参数监听
    /// </summary>
    /// <param name="eventType">事件</param>
    /// <param name="callBack">回调</param>
    public static void AddListener(string eventType, Action callBack)
    {
        OnListenerAdding(eventType, callBack);
        normalEventDic[eventType] = (Action)normalEventDic[eventType] + callBack;
    }

    /// <summary>
    /// 一个参数监听
    /// </summary>
    /// <param name="eventType">事件</param>
    /// <param name="callBack">回调</param>
    public static void AddListener<K>(string eventType, Action<K> callBack)
    {
        OnListenerAdding(eventType, callBack);
        normalEventDic[eventType] = (Action<K>)normalEventDic[eventType] + callBack;
    }

    /// <summary>
    /// 两个参数监听
    /// </summary>
    /// <param name="eventType">事件</param>
    /// <param name="callBack">回调</param>
    public static void AddListener<K, X>(string eventType, Action<K, X> callBack)
    {
        OnListenerAdding(eventType, callBack);
        normalEventDic[eventType] = (Action<K, X>)normalEventDic[eventType] + callBack;
    }

    /// <summary>
    /// 三个参数监听
    /// </summary>
    /// <param name="eventType">事件</param>
    /// <param name="callBack">回调</param>
    public static void AddListener<K, X, Y>(string eventType, Action<K, X, Y> callBack)
    {
        OnListenerAdding(eventType, callBack);
        normalEventDic[eventType] = (Action<K, X, Y>)normalEventDic[eventType] + callBack;
    }

    /// <summary>
    /// 四个参数监听
    /// </summary>
    /// <param name="eventType">事件</param>
    /// <param name="callBack">回调</param>
    public static void AddListener<K, X, Y, Z>(string eventType, Action<K, X, Y, Z> callBack)
    {
        OnListenerAdding(eventType, callBack);
        normalEventDic[eventType] = (Action<K, X, Y, Z>)normalEventDic[eventType] + callBack;
    }

    /// <summary>
    /// 五个参数监听
    /// </summary>
    /// <param name="eventType">事件</param>
    /// <param name="callBack">回调</param>
    public static void AddListener<K, X, Y, Z, W>(string eventType, Action<K, X, Y, Z, W> callBack)
    {
        OnListenerAdding(eventType, callBack);
        normalEventDic[eventType] = (Action<K, X, Y, Z, W>)normalEventDic[eventType] + callBack;
    }



    //==================================================移除监听========================================================

    /// <summary>
    /// 无参移除监听
    /// </summary>
    /// <param name="eventType">事件</param>
    /// <param name="callBack">回调</param>
    public static void RemoveListener(string eventType, Action callBack)
    {
        OnListenerRemoving(eventType, callBack);
        normalEventDic[eventType] = (Action)normalEventDic[eventType] - callBack;
        OnListenerRemoved(eventType);
    }

    /// <summary>
    /// 一个参数移除监听
    /// </summary>
    /// <param name="eventType">事件</param>
    /// <param name="callBack">回调</param>
    public static void RemoveListener<K>(string eventType, Action<K> callBack)
    {
        OnListenerRemoving(eventType, callBack);
        normalEventDic[eventType] = (Action<K>)normalEventDic[eventType] - callBack;
        OnListenerRemoved(eventType);
    }

    /// <summary>
    /// 两个参数移除监听
    /// </summary>
    /// <param name="eventType">事件</param>
    /// <param name="callBack">回调</param>
    public static void RemoveListener<K, X>(string eventType, Action<K, X> callBack)
    {
        OnListenerRemoving(eventType, callBack);
        normalEventDic[eventType] = (Action<K, X>)normalEventDic[eventType] - callBack;
        OnListenerRemoved(eventType);
    }

    /// <summary>
    /// 三个参数移除监听
    /// </summary>
    /// <param name="eventType">事件</param>
    /// <param name="callBack">回调</param>
    public static void RemoveListener<K, X, Y>(string eventType, Action<K, X, Y> callBack)
    {
        OnListenerRemoving(eventType, callBack);
        normalEventDic[eventType] = (Action<K, X, Y>)normalEventDic[eventType] - callBack;
        OnListenerRemoved(eventType);
    }

    /// <summary>
    /// 四个参数移除监听
    /// </summary>
    /// <param name="eventType">事件</param>
    /// <param name="callBack">回调</param>
    public static void RemoveListener<K, X, Y, Z>(string eventType, Action<K, X, Y, Z> callBack)
    {
        OnListenerRemoving(eventType, callBack);
        normalEventDic[eventType] = (Action<K, X, Y, Z>)normalEventDic[eventType] - callBack;
        OnListenerRemoved(eventType);
    }

    /// <summary>
    /// 五个参数移除监听
    /// </summary>
    /// <param name="eventType">事件</param>
    /// <param name="callBack">回调</param>
    public static void RemoveListener<K, X, Y, Z, W>(string eventType, Action<K, X, Y, Z, W> callBack)
    {
        OnListenerRemoving(eventType, callBack);
        normalEventDic[eventType] = (Action<K, X, Y, Z, W>)normalEventDic[eventType] - callBack;
        OnListenerRemoved(eventType);
    }


    //==================================================广播事件========================================================

    /// <summary>
    /// 无参广播事件
    /// </summary>
    /// <param name="eventType">事件</param>
    public static void BroadCast(string eventType)
    {
        Delegate d;
        if (normalEventDic.TryGetValue(eventType, out d))
        {
            if (d is Action callBack)
            {
                callBack();
            }
            else
            {
                throw new Exception($"广播事件错误:事件{eventType}对应委托具有不同的类型");
            }
        }
    }

    /// <summary>
    /// 一个参数广播事件
    /// </summary>
    /// <param name="eventType">事件</param>
    public static void BroadCast<K>(string eventType, K arg)
    {
        Delegate d;
        if (normalEventDic.TryGetValue(eventType, out d))
        {
            if (d is Action<K> callBack)
            {
                callBack(arg);
            }
            else
            {
                throw new Exception($"广播事件错误:事件{eventType}对应委托具有不同的类型");
            }
        }
    }

    /// <summary>
    /// 两个参数广播事件
    /// </summary>
    /// <param name="eventType">事件</param>
    public static void BroadCast<K, X>(string eventType, K arg1, X arg2)
    {
        Delegate d;
        if (normalEventDic.TryGetValue(eventType, out d))
        {
            if (d is Action<K, X> callBack)
            {
                callBack(arg1, arg2);
            }
            else
            {
                throw new Exception($"广播事件错误:事件{eventType}对应委托具有不同的类型");
            }
        }
    }

    /// <summary>
    /// 三个参数广播事件
    /// </summary>
    /// <param name="eventType">事件</param>
    public static void BroadCast<K, X, Y>(string eventType, K arg1, X arg2, Y arg3)
    {
        Delegate d;
        if (normalEventDic.TryGetValue(eventType, out d))
        {
            if (d is Action<K, X, Y> callBack)
            {
                callBack(arg1, arg2, arg3);
            }
            else
            {
                throw new Exception($"广播事件错误:事件{eventType}对应委托具有不同的类型");
            }
        }
    }

    /// <summary>
    /// 四个参数广播事件
    /// </summary>
    /// <param name="eventType">事件</param>
    public static void BroadCast<K, X, Y, Z>(string eventType, K arg1, X arg2, Y arg3, Z arg4)
    {
        Delegate d;
        if (normalEventDic.TryGetValue(eventType, out d))
        {
            if (d is Action<K, X, Y, Z> callBack)
            {
                callBack(arg1, arg2, arg3, arg4);
            }
            else
            {
                throw new Exception($"广播事件错误:事件{eventType}对应委托具有不同的类型");
            }
        }
    }

    /// <summary>
    /// 五个参数广播事件
    /// </summary>
    /// <param name="eventType">事件</param>
    public static void BroadCast<K, X, Y, Z, W>(string eventType, K arg1, X arg2, Y arg3, Z arg4, W arg5)
    {
        Delegate d;
        if (normalEventDic.TryGetValue(eventType, out d))
        {
            if (d is Action<K, X, Y, Z, W> callBack)
            {
                callBack(arg1, arg2, arg3, arg4, arg5);
            }
            else
            {
                throw new Exception($"广播事件错误:事件{eventType}对应委托具有不同的类型");
            }
        }
    }


    #endregion

    
    #region 枚举事件
    
    //==================================================监听事件========================================================

    /// <summary>
    /// 无参数监听
    /// </summary>
    /// <param name="eventType">事件</param>
    /// <param name="callBack">回调</param>
    public static void AddListener<T>(T eventType, Action callBack) where T : Enum
    {
        string eventName = $"{eventType.GetType()}_{eventType.ToString()}";
        AddListener(eventName, callBack);
    }

    /// <summary>
    /// 一个参数监听
    /// </summary>
    /// <param name="eventType">事件</param>
    /// <param name="callBack">回调</param>
    public static void AddListener<T, K>(T eventType, Action<K> callBack) where T : Enum
    {
        string eventName = $"{eventType.GetType()}_{eventType.ToString()}";
        AddListener(eventName, callBack);
    }

    /// <summary>
    /// 两个参数监听
    /// </summary>
    /// <param name="eventType">事件</param>
    /// <param name="callBack">回调</param>
    public static void AddListener<T, K, X>(T eventType, Action<K, X> callBack) where T : Enum
    {
        string eventName = $"{eventType.GetType()}_{eventType.ToString()}";
        AddListener(eventName, callBack);
    }

    /// <summary>
    /// 三个参数监听
    /// </summary>
    /// <param name="eventType">事件</param>
    /// <param name="callBack">回调</param>
    public static void AddListener<T, K, X, Y>(T eventType, Action<K, X, Y> callBack) where T : Enum
    {
        string eventName = $"{eventType.GetType()}_{eventType.ToString()}";
        AddListener(eventName, callBack);
    }

    /// <summary>
    /// 四个参数监听
    /// </summary>
    /// <param name="eventType">事件</param>
    /// <param name="callBack">回调</param>
    public static void AddListener<T, K, X, Y, Z>(T eventType, Action<K, X, Y, Z> callBack) where T : Enum
    {
        string eventName = $"{eventType.GetType()}_{eventType.ToString()}";
        AddListener(eventName, callBack);
    }

    /// <summary>
    /// 五个参数监听
    /// </summary>
    /// <param name="eventType">事件</param>
    /// <param name="callBack">回调</param>
    public static void AddListener<T, K, X, Y, Z, W>(T eventType, Action<K, X, Y, Z, W> callBack) where T : Enum
    {
        string eventName = $"{eventType.GetType()}_{eventType.ToString()}";
        AddListener(eventName, callBack);
    }



    //==================================================移除监听========================================================

    /// <summary>
    /// 无参移除监听
    /// </summary>
    /// <param name="eventType">事件</param>
    /// <param name="callBack">回调</param>
    public static void RemoveListener<T>(T eventType, Action callBack) where T : Enum
    {
        string eventName = $"{eventType.GetType()}_{eventType.ToString()}";
        RemoveListener(eventName, callBack);
    }

    /// <summary>
    /// 一个参数移除监听
    /// </summary>
    /// <param name="eventType">事件</param>
    /// <param name="callBack">回调</param>
    public static void RemoveListener<T, K>(T eventType, Action<K> callBack) where T : Enum
    {
        string eventName = $"{eventType.GetType()}_{eventType.ToString()}";
        RemoveListener(eventName, callBack);
    }

    /// <summary>
    /// 两个参数移除监听
    /// </summary>
    /// <param name="eventType">事件</param>
    /// <param name="callBack">回调</param>
    public static void RemoveListener<T, K, X>(T eventType, Action<K, X> callBack) where T : Enum
    {
        string eventName = $"{eventType.GetType()}_{eventType.ToString()}";
        RemoveListener(eventName, callBack);
    }

    /// <summary>
    /// 三个参数移除监听
    /// </summary>
    /// <param name="eventType">事件</param>
    /// <param name="callBack">回调</param>
    public static void RemoveListener<T, K, X, Y>(T eventType, Action<K, X, Y> callBack) where T : Enum
    {
        string eventName = $"{eventType.GetType()}_{eventType.ToString()}";
        RemoveListener(eventName, callBack);
    }

    /// <summary>
    /// 四个参数移除监听
    /// </summary>
    /// <param name="eventType">事件</param>
    /// <param name="callBack">回调</param>
    public static void RemoveListener<T, K, X, Y, Z>(T eventType, Action<K, X, Y, Z> callBack) where T : Enum
    {
        string eventName = $"{eventType.GetType()}_{eventType.ToString()}";
        RemoveListener(eventName, callBack);
    }

    /// <summary>
    /// 五个参数移除监听
    /// </summary>
    /// <param name="eventType">事件</param>
    /// <param name="callBack">回调</param>
    public static void RemoveListener<T, K, X, Y, Z, W>(T eventType, Action<K, X, Y, Z, W> callBack) where T : Enum
    {
        string eventName = $"{eventType.GetType()}_{eventType.ToString()}";
        RemoveListener(eventName, callBack);
    }


    //==================================================广播事件========================================================

    /// <summary>
    /// 无参广播事件
    /// </summary>
    /// <param name="eventType">事件</param>
    public static void BroadCast<T>(T eventType) where T : Enum
    {
        string eventName = $"{eventType.GetType()}_{eventType.ToString()}";
        BroadCast(eventName);
    }

    /// <summary>
    /// 一个参数广播事件
    /// </summary>
    /// <param name="eventType">事件</param>
    public static void BroadCast<T, K>(T eventType, K arg) where T : Enum
    {
        string eventName = $"{eventType.GetType()}_{eventType.ToString()}";
        BroadCast(eventName, arg);
    }

    /// <summary>
    /// 两个参数广播事件
    /// </summary>
    /// <param name="eventType">事件</param>
    public static void BroadCast<T, K, X>(T eventType, K arg1, X arg2) where T : Enum
    {
        string eventName = $"{eventType.GetType()}_{eventType.ToString()}";
        BroadCast(eventName, arg1, arg2);
    }

    /// <summary>
    /// 三个参数广播事件
    /// </summary>
    /// <param name="eventType">事件</param>
    public static void BroadCast<T, K, X, Y>(T eventType, K arg1, X arg2, Y arg3) where T : Enum
    {
        string eventName = $"{eventType.GetType()}_{eventType.ToString()}";
        BroadCast(eventName, arg1, arg2, arg3);
    }

    /// <summary>
    /// 四个参数广播事件
    /// </summary>
    /// <param name="eventType">事件</param>
    public static void BroadCast<T, K, X, Y, Z>(T eventType, K arg1, X arg2, Y arg3, Z arg4) where T : Enum
    {
        string eventName = $"{eventType.GetType()}_{eventType.ToString()}";
        BroadCast(eventName, arg1, arg2, arg3, arg4);
    }

    /// <summary>
    /// 五个参数广播事件
    /// </summary>
    /// <param name="eventType">事件</param>
    public static void BroadCast<T, K, X, Y, Z, W>(T eventType, K arg1, X arg2, Y arg3, Z arg4, W arg5) where T : Enum
    {
        string eventName = $"{eventType.GetType()}_{eventType.ToString()}";
        BroadCast(eventName, arg1, arg2, arg3, arg4, arg5);
    }

    #endregion

    /// <summary>
    /// 清理
    /// </summary>
    public static void Clear()
    {
        normalEventDic.Clear();
    }
}