using AyCode.Core.Extensions;
using AyCode.Core.Interfaces;
using System.Buffers;
using System.Runtime.CompilerServices;
using AyCode.Core.Serializers.Jsons;
using JsonIgnoreAttribute = Newtonsoft.Json.JsonIgnoreAttribute;
using STJIgnore = System.Text.Json.Serialization.JsonIgnoreAttribute;

namespace AyCode.Services.SignalRs;

/// <summary>
/// Message container for serialized parameter IDs.
/// Optimized for common primitive types to avoid full JSON overhead.
/// </summary>
public class IdMessage
{
    public List<string> Ids { get; private set; }

    public IdMessage()
    {
        Ids = [];
    }

    /// <summary>
    /// Creates IdMessage with multiple parameters serialized directly as JSON.
    /// </summary>
    public IdMessage(object[] ids)
    {
        Ids = new List<string>(ids.Length);
        for (var i = 0; i < ids.Length; i++)
        {
            Ids.Add(SignalRSerializationHelper.SerializePrimitiveToJson(ids[i]));
        }
    }

    /// <summary>
    /// Creates IdMessage with a single parameter serialized as JSON.
    /// </summary>
    public IdMessage(object id)
    {
        Ids = [SignalRSerializationHelper.SerializePrimitiveToJson(id)];
    }

    /// <summary>
    /// Creates IdMessage with multiple Guid parameters.
    /// </summary>
    public IdMessage(IEnumerable<Guid> ids)
    {
        var idsArray = ids as Guid[] ?? ids.ToArray();
        Ids = new List<string>(idsArray.Length);
        for (var i = 0; i < idsArray.Length; i++)
        {
            Ids.Add(SignalRSerializationHelper.SerializeGuidToJson(idsArray[i]));
        }
    }

    public override string ToString() => string.Join("; ", Ids);
}

/// <summary>
/// Message containing JSON-serialized post data.
/// </summary>
public class SignalPostJsonMessage
{
    public string PostDataJson { get; set; } = "";

    public SignalPostJsonMessage() { }
    protected SignalPostJsonMessage(string postDataJson) => PostDataJson = postDataJson;
}

/// <summary>
/// Generic message containing JSON-serialized post data with typed access.
/// </summary>
public class SignalPostJsonDataMessage<TPostDataType> : SignalPostJsonMessage, ISignalPostMessage<TPostDataType>
{
    [JsonIgnore]
    [STJIgnore]
    private TPostDataType? _postData;

    [JsonIgnore]
    [STJIgnore]
    public TPostDataType PostData
    {
        get => _postData ??= PostDataJson.JsonTo<TPostDataType>()!;
        private init
        {
            _postData = value;
            PostDataJson = _postData.ToJson();
        }
    }

    public SignalPostJsonDataMessage() : base() { }
    public SignalPostJsonDataMessage(TPostDataType postData) => PostData = postData;
    public SignalPostJsonDataMessage(string postDataJson) : base(postDataJson) { }
}

/// <summary>
/// Simple message containing post data.
/// </summary>
public class SignalPostMessage<TPostData>(TPostData postData) : ISignalPostMessage<TPostData>
{
    public TPostData? PostData { get; set; } = postData;
}

public interface ISignalPostMessage<TPostData> : ISignalRMessage
{
    TPostData? PostData { get; }
}

/// <summary>
/// Message for requesting by Guid ID.
/// </summary>
public class SignalRequestByIdMessage(Guid id) : ISignalRequestMessage<Guid>, IId<Guid>
{
    public Guid Id { get; set; } = id;
}

public interface ISignalRequestMessage<TRequestId> : ISignalRMessage
{
    TRequestId Id { get; set; }
}

public interface ISignalRMessage { }

public interface ISignalResponseMessage : ISignalRMessage
{
    int MessageTag { get; set; }
    SignalResponseStatus Status { get; set; }
}

public enum SignalResponseStatus : byte
{
    Error = 0,
    Success = 5
}

/// <summary>
/// Unified signal response message that supports both JSON and Binary serialization.
/// JSON mode uses Brotli compression for reduced payload size.
/// Optimized: uses pooled buffers for decompression, zero-copy deserialization path.
/// </summary>
public sealed class SignalResponseDataMessage : ISignalResponseMessage, IDisposable
{
    public int MessageTag { get; set; }
    public SignalResponseStatus Status { get; set; }
    public AcSerializerType DataSerializerType { get; set; }
    public byte[]? ResponseData { get; set; }

    [JsonIgnore] [STJIgnore] private object? _cachedResponseData;
    [JsonIgnore] [STJIgnore] private byte[]? _rentedDecompressedBuffer;
    [JsonIgnore] [STJIgnore] private int _decompressedLength;

    public SignalResponseDataMessage() { }

    public SignalResponseDataMessage(int messageTag, SignalResponseStatus status)
    {
        MessageTag = messageTag;
        Status = status;
    }

    public SignalResponseDataMessage(int messageTag, SignalResponseStatus status, object? responseData, AcSerializerOptions serializerOptions)
        : this(messageTag, status)
    {
        DataSerializerType = serializerOptions.SerializerType;
        ResponseData = SignalRSerializationHelper.CreateResponseData(responseData, serializerOptions);
    }

    /// <summary>
    /// Deserializes the ResponseData to the specified type.
    /// Uses cached result for repeated calls.
    /// </summary>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public T? GetResponseData<T>()
    {
        if (_cachedResponseData != null) return (T)_cachedResponseData;
        if (ResponseData == null) return default;

        if (DataSerializerType == AcSerializerType.Binary)
            return (T)(_cachedResponseData = ResponseData.BinaryTo<T>()!);

        // Decompress Brotli to pooled buffer and deserialize directly
        EnsureDecompressed();
        var result = AcJsonDeserializer.Deserialize<T>(new ReadOnlySpan<byte>(_rentedDecompressedBuffer, 0, _decompressedLength));
        _cachedResponseData = result;
        return result;
    }

    /// <summary>
    /// Gets the decompressed JSON bytes as a ReadOnlySpan for direct processing.
    /// </summary>
    public ReadOnlySpan<byte> GetDecompressedJsonSpan()
    {
        if (ResponseData == null) return ReadOnlySpan<byte>.Empty;
        if (DataSerializerType == AcSerializerType.Binary) return ReadOnlySpan<byte>.Empty;
        
        EnsureDecompressed();
        return _rentedDecompressedBuffer.AsSpan(0, _decompressedLength);
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private void EnsureDecompressed()
    {
        if (_rentedDecompressedBuffer != null) return;
        
        (_rentedDecompressedBuffer, _decompressedLength) = SignalRSerializationHelper.DecompressToRentedBuffer(ResponseData!);
    }

    public void Dispose()
    {
    }
}

public interface IAcSignalRHubClient : IAcSignalRHubBase
{
    Task SendMessageToServerAsync(int messageTag, ISignalRMessage? message, int? requestId);
}