using MailKit;

namespace Dpz.Core.Service;

public sealed class SerilogProtocolLogger(ILogger<SerilogProtocolLogger> logger) : IProtocolLogger
{
    private readonly EventId _eventId = new(10001, "邮件日志");

    private static readonly byte[] Secret = "********"u8.ToArray();

    private static readonly byte[] DefaultClientPrefix = "Client: "u8.ToArray();
    private static readonly byte[] DefaultServerPrefix = "Server: "u8.ToArray();

    private bool _clientMidline;
    private bool _serverMidline;

    private readonly MemoryStream _stream = new();

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    private bool _disposed;

    private void Dispose(bool disposing)
    {
        if (!_disposed)
        {
            if (disposing)
            {
                _stream.Flush();
                _stream.Position = 0;
                using var reader = new StreamReader(_stream);
                var message = reader.ReadToEnd();
                logger.LogInformation(_eventId, message);
                _stream.Dispose();
            }

            _disposed = true;
        }
    }

    ~SerilogProtocolLogger() => Dispose(false);

    public void LogConnect(Uri uri)
    {
        var bytes = Encoding.ASCII.GetBytes($"{DateTime.Now} Connected to {uri}\r\n");
        if (_clientMidline || _serverMidline)
        {
            _clientMidline = false;
            _serverMidline = false;
        }

        _stream.Write(bytes, 0, bytes.Length);
        _stream.Flush();
    }

    public void LogClient(byte[]? buffer, int offset, int count)
    {
        LogBuffer(buffer, offset, count, DefaultClientPrefix, ref _clientMidline, true);
    }

    public void LogServer(byte[]? buffer, int offset, int count)
    {
        LogBuffer(buffer, offset, count, DefaultServerPrefix, ref _serverMidline, false);
    }

    private void LogBuffer(
        byte[]? buffer,
        int offset,
        int count,
        byte[] prefix,
        ref bool midline,
        bool isClient
    )
    {
        if (buffer == null)
        {
            logger.LogError(_eventId, "buffer is null");
            return;
        }

        if (offset < 0 || offset > buffer.Length)
        {
            logger.LogError(
                _eventId,
                "offset less than 0 or offset greater than {Offset}",
                buffer.Length
            );
            return;
        }

        if (count < 0 || count > buffer.Length - offset)
        {
            logger.LogError(
                _eventId,
                "count less than 0 or count greater than {Offset}",
                buffer.Length - offset
            );
            return;
        }

        Log(prefix, ref midline, buffer, offset, count, isClient);
    }

    private void Log(
        byte[] prefix,
        ref bool midline,
        byte[] buffer,
        int offset,
        int count,
        bool isClient
    )
    {
        var number = offset + count;
        var index = offset;
        while (index < number)
        {
            var offset1 = index;
            while (index < number && buffer[index] != 10)
            {
                ++index;
            }

            if (!midline)
            {
                _stream.Write(prefix, 0, prefix.Length);
            }

            if (index < number && buffer[index] == 10)
            {
                midline = false;
                ++index;
            }
            else
            {
                midline = true;
            }

            if (isClient)
            {
                var authenticationSecrets = AuthenticationSecretDetector?.DetectSecrets(
                    buffer,
                    offset1,
                    index - offset1
                );
                if (authenticationSecrets != null)
                {
                    foreach (var detectSecret in authenticationSecrets)
                    {
                        if (detectSecret.StartIndex > offset1)
                        {
                            _stream.Write(buffer, offset1, detectSecret.StartIndex - offset1);
                        }

                        offset1 = detectSecret.StartIndex + detectSecret.Length;
                        _stream.Write(Secret, 0, Secret.Length);
                    }
                }
            }

            _stream.Write(buffer, offset1, index - offset1);
        }
    }

    public IAuthenticationSecretDetector? AuthenticationSecretDetector { get; set; }
}