using AyCode.Core.Enums;
using AyCode.Core.Helpers;
using AyCode.Core.Loggers;
using AyCode.Entities.LogItems;
using AyCode.Interfaces.Entities;
using AyCode.Utils.Extensions;
using System.Collections.Concurrent;

namespace AyCode.Entities;

public abstract class AcLogItemWriterBase<TLogItem> : AcLogWriterBase where TLogItem : class, IAcLogItem
{
    protected readonly Mutex MutexLock = new();//new(false, "GLOBAL");

    protected AcLogItemWriterBase() : this(null)
    { }

    protected AcLogItemWriterBase(string? categoryName = null) : base(categoryName)
    { }

    protected AcLogItemWriterBase(AppType appType, LogLevel logLevel, string? categoryName = null) : base(appType, logLevel, categoryName)
    {
    }

    protected TLogItem CreateLogItem(int threadId, DateTime utcNow, LogLevel logLevel, string? logText, string? callerMemberName, string? categoryName = null, Exception? ex = null)
    {
        var logItem = Activator.CreateInstance<TLogItem>();
        
        logItem.TimeStampUtc = utcNow;
        logItem.AppType = AppType;
        logItem.LogLevel = logLevel;
        logItem.CategoryName = categoryName;
        logItem.CallerName = callerMemberName;
        logItem.Text = logText;
        logItem.Exception = ex?.Message;
        logItem.ThreadId = threadId;

        return logItem;
    }

    protected override void PrepareToWrite(LogLevel logLevel, string? logText, string? callerMemberName, string? categoryName = null, Exception? ex = null)
    {
        if (logLevel < LogLevel) return;

        var utcNow = DateTime.UtcNow;
        var threadId = Environment.CurrentManagedThreadId;

        TaskHelper.RunOnThreadPool(() => WriteLogItem(CreateLogItem(threadId, utcNow, logLevel, logText, callerMemberName, categoryName)));
    }

    protected virtual void WriteLogItem(TLogItem logItem, Action? callback = null)
    {
        using (MutexLock.UseWaitOne())
        {
            callback?.Invoke();
        }
    }

    //private volatile bool _isLocked = false;
    //private readonly object _forLock = new();
    //private readonly List<TLogItem> _logItemsCahce = new();
    //private readonly List<TLogItem> _logItemsCahce2 = new();

    //protected virtual void WriteLogItem(TLogItem logItem, Action<IEnumerable<TLogItem>>? callback = null)
    //{
    //    lock (_forLock) _logItemsCahce.Add(logItem);

    //    if (_isLocked) return;
        

    //    using (MutexLock.UseWaitOne())
    //    {
    //        _isLocked = true;

    //        _logItemsCahce2.Clear();
            
    //        lock (_forLock)
    //        {
    //            _logItemsCahce2.AddRange(_logItemsCahce);
                
    //            _logItemsCahce.Clear();
    //        }

    //        callback?.Invoke(_logItemsCahce2);
    //    }

    //    _isLocked = false;
    //}
}