namespace Voile.Common.Logging;

public class VoileLogManager
{
    private VoileLogManager()
    {
    }
    
    private static VoileLogManager instance;
    public static VoileLogManager GetInstance()
    {
        if (instance == null)
        {
            instance = new VoileLogManager();
        }
        return instance;
    }

    private List<IVoileLogSink> _sinks;
    private Dictionary<string, VoileLogger> _producers;

    public void AddSink(IVoileLogSink sink)
    {
        if (_sinks == null)
            _sinks = new List<IVoileLogSink>();
        _sinks.Add(sink);
    }

    public void RemoveSink(IVoileLogSink sink)
    {
        if (_sinks == null)
            return;
        else
            _sinks.Remove(sink);
    }

    public static VoileLogger GetLogger(Type type)
    {
        return GetLogger(type.Name);
    }

    public static VoileLogger GetLogger(string name)
    {
        VoileLogManager instance = GetInstance();
        
        if (instance._producers == null)
            instance._producers = new Dictionary<string, VoileLogger>();
        
        if (instance._producers.ContainsKey(name))
            return instance._producers[name];

        VoileLogger child = new VoileLogger(name, instance);
        instance._producers.Add(name, child);
        return child;
    }

    internal void ProcessMessage(VoileLogMessage produced)
    {
        if (_sinks == null)
            return;

        foreach (IVoileLogSink sink in _sinks)
        {
            sink.OnLogMessage(produced);
        }
    }
}