using System.Collections.Concurrent;
using System.Reflection;
using AyCode.Core.Extensions;
using AyCode.Core.Loggers;
using AyCode.Services.SignalRs;
using Microsoft.AspNetCore.SignalR;
using TIAM.Database.DataLayers.Admins;
using MessagePack.Resolvers;
using AyCode.Services.Server.SignalRs;
using TIAM.Services;
using TIAMWebApp.Server.Controllers;
using TIAM.Entities.ServiceProviders;
using System.Runtime.CompilerServices;
using MessagePack;
using TIAM.Entities.Addresses;
using Microsoft.AspNetCore.Hosting;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq.Expressions;
using AutoMapper;
using AyCode.Core.Helpers;
using DevExpress.Pdf.Native.BouncyCastle.Security;
using TIAM.Entities.Emails;
using TIAM.Services.Server;
using Profile = TIAM.Entities.Profiles.Profile;
using Serialize.Linq.Serializers;

namespace TIAMWebApp.Server.Services;

public static class ExtensionMethods
{
    public static object? InvokeMethod(this MethodInfo methodInfo, object obj, params object[]? parameters)
    {
        if (methodInfo.GetCustomAttribute(typeof(AsyncStateMachineAttribute)) is AsyncStateMachineAttribute isAsyncTask)
        {
            dynamic awaitable = methodInfo.Invoke(obj, parameters)!;
            return awaitable.GetAwaiter().GetResult();
        }

        return methodInfo.Invoke(obj, parameters);
    }
}

public class MethodInfoModel<TAttribute> where TAttribute : TagAttribute
{
    public ParameterInfo[]? ParamInfos { get; init; } = null;
    public TAttribute Attribute { get; init; }
    public MethodInfo MethodInfo { get; init; }

    public MethodInfoModel(TAttribute attribute, MethodInfo methodInfo)
    {
        Attribute = attribute;
        MethodInfo = methodInfo;

        var parameters = methodInfo.GetParameters();

        //if (parameters.Length > 1)
        //    throw new Exception("MethodInfoModel; parameters.Length > 1");

        ParamInfos = parameters;
    }
}

public class DynamicMethodCallModel<TAttribute> where TAttribute : TagAttribute
{
    public object InstanceObject { get; init; }
    public ConcurrentDictionary<int, MethodInfoModel<TAttribute>> MethodsByMessageTag { get; init; } = new();


    public DynamicMethodCallModel(Type instanceObjectType) : this(instanceObjectType, null!)
    {
    }

    public DynamicMethodCallModel(Type instanceObjectType, params object[] constructorParams) : this(Activator.CreateInstance(instanceObjectType, constructorParams)!)
    {
    }

    public DynamicMethodCallModel(object instanceObject)
    {
        InstanceObject = instanceObject;

        foreach (var methodInfo in instanceObject.GetType().GetMethods())
        {
            if (methodInfo.GetCustomAttribute(typeof(TAttribute)) is not TAttribute attribute) continue;

            if (MethodsByMessageTag.ContainsKey(attribute.MessageTag))
                throw new Exception($"Multiple SignaRMessageTag! messageTag: {attribute.MessageTag}; methodName: {methodInfo.Name}");

            MethodsByMessageTag[attribute.MessageTag] = new MethodInfoModel<TAttribute>(attribute, methodInfo!);
        }
    }
}

public class DevAdminSignalRHub : Hub<ISignalRHubItemServer>, IAcSignalRHubServer
{
    private readonly List<DynamicMethodCallModel<SignalRAttribute>> _dynamicMethodCallModels = [];
    private readonly TIAM.Core.Loggers.Logger<DevAdminSignalRHub> _logger;

    private readonly AdminDal _adminDal;
    //private readonly ServiceProviderAPIController _serviceProviderApiController;
    //private readonly TransferDataAPIController _transferDataApiController;

    public DevAdminSignalRHub(AdminDal adminDal, UserAPIController userApiController, ServiceProviderAPIController serviceProviderApiController, TransferDataAPIController transferDataApiController, MessageAPIController messageApiController, ProfileAPIController profileApiController, LoggerApiController loggerApiController, IEnumerable<IAcLogWriterBase> logWriters)
    {
        _adminDal = adminDal;
        //_serviceProviderApiController = serviceProviderApiController;
        //_transferDataApiController = transferDataApiController;

        _logger = new(logWriters.ToArray());

        _dynamicMethodCallModels.Add(new DynamicMethodCallModel<SignalRAttribute>(userApiController));
        _dynamicMethodCallModels.Add(new DynamicMethodCallModel<SignalRAttribute>(serviceProviderApiController));
        _dynamicMethodCallModels.Add(new DynamicMethodCallModel<SignalRAttribute>(transferDataApiController));
        _dynamicMethodCallModels.Add(new DynamicMethodCallModel<SignalRAttribute>(messageApiController));
        _dynamicMethodCallModels.Add(new DynamicMethodCallModel<SignalRAttribute>(profileApiController));
        _dynamicMethodCallModels.Add(new DynamicMethodCallModel<SignalRAttribute>(loggerApiController));
        //_dynamicMethodCallModels.Add(new DynamicMethodCallModel<SignalRAttribute>(typeof(AdminDal)));

    }

    // https://docs.microsoft.com/en-us/aspnet/core/signalr/hubs?view=aspnetcore-3.1#strongly-typed-hubs
    public override async Task OnConnectedAsync()
    {
        _logger.Debug($"Server OnConnectedAsync; ConnectionId: {Context.ConnectionId}; UserIdentifier: {Context.UserIdentifier}");

        //await Groups.AddToGroupAsync(Context.ConnectionId, "SignalR Users");
        await base.OnConnectedAsync();

        //Clients.Caller.ConnectionId = Context.ConnectionId;
        //Clients.Caller.UserIdentifier = Context.UserIdentifier;
    }

    public override async Task OnDisconnectedAsync(Exception? exception)
    {
        _logger.ErrorConditional($"Server OnDisconnectedAsync; ConnectionId: {Context.ConnectionId}; UserIdentifier: {Context.UserIdentifier}", exception);

        //await Groups.RemoveFromGroupAsync(Context.ConnectionId, "SignalR Users");
        await base.OnDisconnectedAsync(exception);
    }

    public async Task OnReceiveMessage(int messageTag, byte[]? message, int? requestId)
    {
        var tagName = ConstHelper.NameByValue<SignalRTags>(messageTag);
        var logText = $"Server OnReceiveMessage; {nameof(requestId)}: {requestId}; ConnectionId: {Context.ConnectionId}; {tagName}";

        if (message is { Length: 0 }) _logger.Warning($"message.Length == 0! {logText}");
        else _logger.Info(logText);

        try
        {
            foreach (var methodsByDeclaringObject in _dynamicMethodCallModels)
            {
                if (!methodsByDeclaringObject.MethodsByMessageTag.TryGetValue(messageTag, out var methodInfoModel)) continue;

                object[]? paramValues = null;

                logText = $"Found dynamic method for the tag! method: {methodsByDeclaringObject.InstanceObject.GetType().Name}.{methodInfoModel.MethodInfo.Name}";

                if (methodInfoModel.ParamInfos is { Length: > 0 })
                {
                    _logger.Debug($"{logText}({string.Join(", ", methodInfoModel.ParamInfos.Select(x => x.Name))}); {tagName}");

                    paramValues = new object[methodInfoModel.ParamInfos.Length];

                    var firstParamType = methodInfoModel.ParamInfos[0].ParameterType;
                    if (methodInfoModel.ParamInfos.Length > 1 || firstParamType == typeof(string) || firstParamType.IsEnum || firstParamType.IsValueType || firstParamType == typeof(DateTime))
                    {
                        var msg = message!.MessagePackTo<SignalPostJsonDataMessage<IdMessage>>();

                        for (var i = 0; i < msg.PostData.Ids.Count; i++)
                        {
                            //var obj = (string)msg.PostData.Ids[i];
                            //if (msg.PostData.Ids[i] is Guid id)
                            //{
                            //    if (id.IsNullOrEmpty()) throw new NullReferenceException($"PostData.Id.IsNullOrEmpty(); Ids: {msg.PostData.Ids}");
                            //    paramValues[i] = id;
                            //}
                            //else if (Guid.TryParse(obj, out id))
                            //{
                            //    if (id.IsNullOrEmpty()) throw new NullReferenceException($"PostData.Id.IsNullOrEmpty(); Ids: {msg.PostData.Ids}");
                            //    paramValues[i] = id;
                            //}
                            //else if (Enum.TryParse(methodInfoModel.ParameterType, obj, out var enumObj))
                            //{
                            //    paramValues[i] = enumObj;
                            //}
                            //else paramValues[i] = Convert.ChangeType(obj, methodInfoModel.ParameterType);

                            var obj = msg.PostData.Ids[i];
                            //var config = new MapperConfiguration(cfg =>
                            //{
                            //    cfg.CreateMap(obj.GetType(), methodInfoModel.ParameterType);
                            //});

                            //var mapper = new Mapper(config);
                            //paramValues[i] = mapper.Map(obj, methodInfoModel.ParameterType);

                            //paramValues[i] = obj;

                            var a = Array.CreateInstance(methodInfoModel.ParamInfos[i].ParameterType, 1);

                            if (methodInfoModel.ParamInfos[i].ParameterType == typeof(Expression))
                            {
                                var serializer = new ExpressionSerializer(new JsonSerializer());
                                paramValues[i] = serializer.DeserializeText((string)(obj.JsonTo(a.GetType()) as Array)?.GetValue(0)!);
                            }
                            else paramValues[i] = (obj.JsonTo(a.GetType()) as Array)?.GetValue(0)!;

                        }
                    }
                    else paramValues[0] = message!.MessagePackTo<SignalPostJsonDataMessage<object>>(MessagePackSerializerOptions.Standard).PostDataJson.JsonTo(firstParamType)!;
                }
                else _logger.Debug($"{logText}(); {tagName}");

                await ResponseToCaller(messageTag, new SignalResponseJsonMessage(SignalResponseStatus.Success, methodInfoModel.MethodInfo.InvokeMethod(methodsByDeclaringObject.InstanceObject, paramValues)), requestId);
                    
                return;
            }

            _logger.Debug($"Not found dynamic method for the tag! {tagName}");

            switch (messageTag)
            {
                case SignalRTags.GetAddress:
                    //var id = Guid.Parse((string)message!.MessagePackTo<SignalPostJsonDataMessage<IdMessage>>().PostData.Ids[0]);
                    var id = message!.MessagePackTo<SignalPostJsonDataMessage<IdMessage>>().PostData.Ids[0].JsonTo<Guid[]>()![0];

                    var address = await _adminDal.GetAddressByIdAsync(id);
                    await ResponseToCaller(messageTag, new SignalResponseJsonMessage(SignalResponseStatus.Success, address), requestId);

                    return;

                case SignalRTags.GetAddressesByContextId:
                    //id = Guid.Parse((string)message!.MessagePackTo<SignalPostJsonDataMessage<IdMessage>>().PostData.Ids[0]);
                    id = message!.MessagePackTo<SignalPostJsonDataMessage<IdMessage>>().PostData.Ids[0].JsonTo<Guid[]>()![0];

                    address = await _adminDal.GetAddressByIdAsync(id);
                    await ResponseToCaller(messageTag, new SignalResponseJsonMessage(SignalResponseStatus.Success, new List<Address> { address! }), requestId);

                    return;

                case SignalRTags.UpdateAddress:
                    address = message!.MessagePackTo<SignalPostJsonDataMessage<Address>>().PostData;

                    await _adminDal.UpdateAddressAsync(address);
                    await ResponseToCaller(messageTag, new SignalResponseJsonMessage(SignalResponseStatus.Success, address), requestId);

                    return;

                case SignalRTags.UpdateProfile:
                    var profile = message!.MessagePackTo<SignalPostJsonDataMessage<Profile>>().PostData;

                    await _adminDal.UpdateProfileAsync(profile);
                    await ResponseToCaller(messageTag, new SignalResponseJsonMessage(SignalResponseStatus.Success, profile), requestId);

                    return;

                //case SignalRTags.GetTransfersAsync:
                //    await ResponseToCaller(messageTag, new SignalResponseJsonMessage(SignalResponseStatus.Success, await _transferDataApiController.GetTransfers()), requestId);

                //    return;

                //case SignalRTags.GetPropertiesByOwnerIdAsync:
                //    var ownerId = message!.MessagePackTo<SignalRequestByIdMessage>().Id;

                //    await ResponseToCaller(messageTag, new SignalResponseJsonMessage(SignalResponseStatus.Success, await _serviceProviderApiController.GetServiceProvidersByOwnerId(ownerId)), requestId);

                //    return;

                //case SignalRTags.UpdateTransferAsync:
                //    var transfer = message!.MessagePackTo<SignalPostJsonDataMessage<Transfer>>().PostData;

                //    await _transferDataApiController.UpdateTransfer(transfer);
                //    await ResponseToCaller(messageTag, new SignalResponseJsonMessage(SignalResponseStatus.Success, transfer), requestId);

                //    return;

                //case SignalRTags.GetCompaniesAsync:
                //    await ResponseToCaller(messageTag, new SignalResponseJsonMessage(SignalResponseStatus.Success, await _serviceProviderApiController.GetServiceProviders()), requestId);

                //    return;
                //case SignalRTags.UpdateCompanyAsync:

                //    var updateCompany = message!.MessagePackTo<SignalPostJsonDataMessage<Company>>().PostData;

                //    await _serviceProviderApiController.UpdateServiceProvider(updateCompany);
                //    await ResponseToCaller(messageTag, new SignalResponseJsonMessage(SignalResponseStatus.Success, updateCompany), requestId);

                //    return; 

                default:
                    _logger.Error($"Server OnReceiveMessage; messageTag not found! {tagName}");
                    break;
            }
        }
        catch (Exception ex)
        {
            _logger.Error($"Server OnReceiveMessage; {ex.Message}; {tagName}", ex);
        }

        await ResponseToCaller(messageTag, new SignalResponseJsonMessage(SignalResponseStatus.Error), requestId);
    }

    protected async Task ResponseToCaller(int messageTag, ISignalRMessage message, int? requestId)
        => await SendMessageToClient(Clients.Caller, messageTag, message, requestId);

    protected async Task SendMessageToClient(ISignalRHubItemServer sendTo, int messageTag, ISignalRMessage message, int? requestId = null)
    {
        _logger.Info($"Server SendMessageToClient; {nameof(requestId)}: {requestId}; ConnectionId: {Context.ConnectionId}; {ConstHelper.NameByValue<SignalRTags>(messageTag)}");

        await sendTo.OnReceiveMessage(messageTag, message.ToMessagePack(ContractlessStandardResolver.Options), requestId);
    }

    public async Task SendMessageToGroup(string groupId, int messageTag, string message)
    {
        //await Clients.Group(groupId).Post("", messageTag, message);
    }
}