using AyCode.Core.Enums;
using AyCode.Core.Helpers;
using AyCode.Core.Loggers;
using AyCode.Entities.LogItems;
using AyCode.Services.Loggers;
using AyCode.Services.SignalRs;
using MessagePack;
using Microsoft.AspNetCore.SignalR.Client;
using Microsoft.Extensions.DependencyInjection;
using TIAM.Entities.Transfers;
using TIAMWebApp.Shared.Application.Models.ClientSide;
using TIAMWebApp.Shared.Application.Utility;

namespace TIAMWebApp.Shared.Application.Services
{
    public class DevAdminSignalClient(IEnumerable<IAcLogWriterClientBase> logWriters) : AcSignalRClientBase("DevAdminHub", logWriters);

    public abstract class AcSignalRClientBase : IAcSignalRHubClient
    {
        protected readonly HubConnection HubConnection;
        protected readonly LoggerClient Logger;

        public event Action<int, byte[]?> OnMessageReceived;

        protected AcSignalRClientBase(string hubName, IEnumerable<IAcLogWriterClientBase> logWriters)
        {
            Logger = new LoggerClient(GetType().Name, logWriters.ToArray());

            HubConnection = new HubConnectionBuilder()
                .WithUrl($"{Setting.BaseUrl}/{hubName}")
                //.AddMessagePackProtocol(options => options.SerializerOptions = MessagePackSerializerOptions.Standard.WithSecurity(MessagePackSecurity.UntrustedData))
                .Build();

            _ = HubConnection.On<string, int, byte[]?>("MessageReceived", MessageReceived);

            HubConnection.StartAsync().Forget();
        }

        public async Task StartConnection()
        {
            if (HubConnection.State == HubConnectionState.Disconnected)
                await HubConnection.StartAsync();

            if (HubConnection.State != HubConnectionState.Connected)
                await TaskHelper.WaitToAsync(() => HubConnection.State == HubConnectionState.Connected, 3000, 100);
        }

        public async Task StopConnection()
        {
            await HubConnection.StopAsync();
            await HubConnection.DisposeAsync();
        }

        public virtual async Task Send(string user, int messageTag, object? message)
        {
            Logger.Info($"Send; {nameof(user)}: {user}; {nameof(messageTag)}: {messageTag}");

            await StartConnection();
            HubConnection.SendAsync("MessageReceived", "", messageTag, message).Forget();
        }

        public virtual Task MessageReceived(string user, int messageTag, byte[]? message)
        {
            Logger.Info($"MessageReceived; {nameof(user)}: {user}; {nameof(messageTag)}: {messageTag}");

            try
            {
                OnMessageReceived(messageTag, message);
            }
            catch(Exception ex)
            {
                Logger.Error($"MessageReceived error; {ex.Message}", ex);
                throw;
            }

            return Task.CompletedTask;
        }
    }
}