using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Collections.Concurrent;
using System.Text;
namespace BITKit
{
    /// <summary>泛型事件，简单的事件接口</summary>
    public interface IGenericEvent<TKey>
    {
        void AddListener<T>(Action<T> action);
        void Invoke<T>(T value);
        void Invoke<T>() where T : new();
        void RemoveListener<T>(Action<T> action);
        void AddListener<T>(TKey key, Action<T> action);
        void Invoke<T>(TKey key, T value);
        void RemoveListener<T>(TKey key, Action<T> action);
    }
    /// <summary>泛型数据库，主要使用方式为Get和Set</summary>
    public interface IDatabase
    {
        T Get<T>(string key = Constant.System.Internal);
        void Set<T>(T value);
        void Set<T>(string key = Constant.System.Internal, T value = default);
    }
    public class GenericEvent : IGenericEvent<string>, IDatabase, IDiagnostics
    {
        Dictionary<string, List<object>> events = new();
        Dictionary<string, object> dictionary = new();
        public const string defaultEventName = nameof(GenericEvent);
        public void AddListener<T>(Action<T> action) =>
            AddListener<T>(defaultEventName, action);
        public void Invoke<T>(T value) =>
            Invoke<T>(defaultEventName, value);
        public void RemoveListener<T>(Action<T> action) =>
            RemoveListener<T>(defaultEventName, action);
        public void AddListener<T>(string key, Action<T> action)
        {
            key = key.GetType<T>();
            var list = events.Get(key);
            list.Add(action);
        }
        public void Invoke<T>(string key, T value)
        {
            key = key.GetType<T>();
            var list = events.Get(key);
            dictionary.Set(key, value);
            list.ToArray().ForEach(x =>
            {
                if (x is Action<T> action)
                {
                    action.Invoke(value);
                }
            });
        }
        public void Invoke(string typeName, object value)
        {
            var key = $"{typeName}.{defaultEventName}";
            var list = events.Get(key);
            //BIT4Log.Log<GenericEvent>($"{key}\t@\t{list.Count}");
            foreach (var item in list.ToArray())
            {
                //BIT4Log.Log<GenericEvent>($"event:{item}");
                item.GetType().GetMethod("Invoke").Invoke(item, new object[] { value });
            }
        }
        public T Get<T>(string key = Constant.System.Internal)
        {
            key = key.GetType<T>();
            var value = dictionary.Get(key);
            if (value is T t)
            {
                return t;
            }
            return default;
        }
        public object Get(string key = Constant.System.Internal)
        {
            return dictionary[key];
        }
        public void Set<T>(T value) => dictionary.Set(Constant.System.Internal.GetType<T>(), value);
        public void Set<T>(string key, T value) => dictionary.Set(key.GetType<T>(), value);
        public void RemoveListener<T>(string key, Action<T> action)
        {
            key = key.GetType<T>();
            var list = events.Get(key);
            list.TryRemove(action);
        }
        public void DebugAllValues()
        {
            StringBuilder stringBuilder = new();
            stringBuilder.AppendLine($"Event Count:{events.Count}");
            foreach (var x in events)
            {
                stringBuilder.AppendLine(x.ToString());
            }
            BIT4Log.Log<GenericEvent>(stringBuilder);
        }

        public string GetName() => nameof(GenericEvent);

        public object GetDiagnostics()
        {
            StringBuilder stringBuilder = new("——————Dictionary");
            foreach (var x in dictionary)
            {
                stringBuilder.AppendLine(x.ToString());
            }
            stringBuilder.AppendLine("——————Events");
            foreach (var x in events)
            {
                stringBuilder.AppendLine($"{x.Key}\t{x.Value.Count}");
            }
            return stringBuilder;
        }

        public void Invoke<T>() where T : new() => Invoke(new T());
    }
}