using System.Reflection;
using H.Pipes.Args;
using InABox.API;
using InABox.Clients;
using InABox.Core;

namespace InABox.IPC
{
    public class RPCServer<TTransport> : IDisposable, IRPCServer where TTransport : IRPCServerTransport
    {
        private TTransport _transport;

        public event LogFunction? OnLog;

        IPCNotifyState NotifyState = new();

        public RPCServer(Func<TTransport> transport)
        {
            _transport = transport();

            _transport.OnOpen += Transport_OnOpen;
            _transport.OnClose += Transport_OnClose;
            _transport.OnException += Transport_OnException;

            _transport.BeforeMessage += Transport_BeforeMessage;
            _transport.AfterMessage += Transport_AfterMessage;

            _transport.AddHandler<IRPCServer, RPCInfoCommand, RPCInfoParameters, RPCInfoResponse>(new RPCInfoHandler(this));

            _transport.AddHandler<IRPCServer, RPCValidateCommand, RPCValidateParameters, RPCValidateResponse>(new RPCValidateHandler(this));
            _transport.AddHandler<IRPCServer, RPCCheck2FACommand, RPCCheck2FAParameters, RPCCheck2FAResponse>(new RPCCheck2FAHandler(this));

            _transport.AddHandler<IRPCServer, RPCQueryCommand, RPCQueryParameters, RPCQueryResponse>(new RPCQueryHandler(this));
            _transport.AddHandler<IRPCServer, RPCSaveCommand, RPCSaveParameters, RPCSaveResponse>(new RPCSaveHandler(this));
            _transport.AddHandler<IRPCServer, RPCDeleteCommand, RPCDeleteParameters, RPCDeleteResponse>(new RPCDeleteHandler(this));

        }

        private void Transport_OnOpen(IRPCTransport transport, RPCTransportOpenArgs e)
        {
            OnLog?.Invoke(LogType.Information, $"{e.Session?.ID}", "Client Connected");
        }

        private void Transport_OnClose(IRPCTransport transport, RPCTransportCloseArgs e)
        {
            OnLog?.Invoke(LogType.Information, $"{e.Session?.ID}", $"Client Disconnected({e.Type})");
        }

        private void Transport_BeforeMessage(IRPCTransport transport, RPCTransportMessageArgs e)
        {
            OnLog?.Invoke(LogType.Information, "", $"Request Received [{e.Session?.ID}]: {e.Message?.Command ?? "Unknown"}");
        }

        private void Transport_AfterMessage(IRPCTransport transport, RPCTransportMessageArgs e)
        {
            OnLog?.Invoke(LogType.Information, "", $"Sending Response [{e.Session?.ID}]: {e.Message?.Command ?? "Unknown"}");
        }

        private void Transport_OnException(IRPCTransport transport, RPCTransportExceptionArgs e)
        {
            OnLog?.Invoke(LogType.Error, $"", $"Exception Occurredn in {e.Session?.ID}: {e.Exception.Message}");
        }

        public void Start()
        {
            _transport.Start();
        }

        public void Stop()
        {
            _transport.Stop();
        }

        private static List<Type>? _persistentRemotable;

        private static Type? GetEntity(string entityName)
        {
            _persistentRemotable ??= CoreUtils.TypeList(
                e => e.IsSubclassOf(typeof(Entity)) &&
                     e.GetInterfaces().Contains(typeof(IRemotable)) &&
                     e.GetInterfaces().Contains(typeof(IPersistent))).ToList();
            return _persistentRemotable.FirstOrDefault(x => x.Name == entityName);
        }

        private static Type? GetResponseType(Method method, string? entityName)
        {
            if (entityName != null)
            {
                var entityType = GetEntity(entityName);
                if (entityType != null)
                {
                    var response = method switch
                    {
                        Method.Query => typeof(QueryResponse<>).MakeGenericType(entityType),
                        Method.Delete => typeof(DeleteResponse<>).MakeGenericType(entityType),
                        Method.MultiDelete => typeof(MultiDeleteResponse<>).MakeGenericType(entityType),
                        Method.Save => typeof(SaveResponse<>).MakeGenericType(entityType),
                        Method.MultiSave => typeof(MultiSaveResponse<>).MakeGenericType(entityType),
                        _ => null
                    };
                    if (response != null) return response;
                }
            }

            return method switch
            {
                Method.QueryMultiple => typeof(MultiQueryResponse),
                Method.Validate => typeof(ValidateResponse),
                Method.Check2FA => typeof(Check2FAResponse),
                _ => null
            };
        }

        private class RequestData
        {
            public ConnectionMessageEventArgs<IPCMessage?> e { get; }

            public RequestData(ConnectionMessageEventArgs<IPCMessage?> e)
            {
                this.e = e;
            }
        }

        private IPCMessage QueryMultiple(IPCMessage request, RequestData data)
        {
            var response = RestService.QueryMultiple(request.GetRequest<MultiQueryRequest>(), true);
            return request.Respond(response);
        }

        private IPCMessage Validate(IPCMessage request, RequestData data)
        {
            var response = RestService.Validate(request.GetRequest<ValidateRequest>());
            return request.Respond(response);
        }

        private IPCMessage Ping(IPCMessage request, RequestData data) => request.Respond(new PingResponse().Status(StatusCode.OK));

        private IPCMessage Info(IPCMessage request, RequestData data)
        {
            var response = RestService.Info(request.GetRequest<InfoRequest>());
            return request.Respond(response);
        }

        private IPCMessage Check2FA(IPCMessage request, RequestData data)
        {
            var response = RestService.Check2FA(request.GetRequest<Check2FARequest>());
            return request.Respond(response);
        }

        private IPCMessage Query<T>(IPCMessage request, RequestData data) where T : Entity, new()
        {
            var response = RestService<T>.List(request.GetRequest<QueryRequest<T>>());
            return request.Respond(response);
        }

        private IPCMessage Save<T>(IPCMessage request, RequestData data) where T : Entity, new()
        {
            var response = RestService<T>.Save(request.GetRequest<SaveRequest<T>>());
            return request.Respond(response);
        }

        private IPCMessage MultiSave<T>(IPCMessage request, RequestData data) where T : Entity, new()
        {
            var response = RestService<T>.MultiSave(request.GetRequest<MultiSaveRequest<T>>());
            return request.Respond(response);
        }

        private IPCMessage Delete<T>(IPCMessage request, RequestData data) where T : Entity, new()
        {
            var response = RestService<T>.Delete(request.GetRequest<DeleteRequest<T>>());
            return request.Respond(response);
        }

        private IPCMessage MultiDelete<T>(IPCMessage request, RequestData data) where T : Entity, new()
        {
            var response = RestService<T>.MultiDelete(request.GetRequest<MultiDeleteRequest<T>>());
            return request.Respond(response);
        }

        private static readonly MethodInfo QueryMethod = GetMethod(nameof(Query));
        private static readonly MethodInfo SaveMethod = GetMethod(nameof(Save));
        private static readonly MethodInfo MultiSaveMethod = GetMethod(nameof(MultiSave));
        private static readonly MethodInfo DeleteMethod = GetMethod(nameof(Delete));
        private static readonly MethodInfo MultiDeleteMethod = GetMethod(nameof(MultiDelete));
        private static readonly MethodInfo QueryMultipleMethod = GetMethod(nameof(QueryMultiple));
        private static readonly MethodInfo ValidateMethod = GetMethod(nameof(Validate));
        private static readonly MethodInfo Check2FAMethod = GetMethod(nameof(Check2FA));
        private static readonly MethodInfo PingMethod = GetMethod(nameof(Ping));
        private static readonly MethodInfo InfoMethod = GetMethod(nameof(Info));

        private static MethodInfo GetMethod(string name) =>
            typeof(IPCServer).GetMethod(name, BindingFlags.NonPublic | BindingFlags.Instance)
            ?? throw new Exception($"Invalid method '{name}'");

        private void Server_MessageReceived(object? sender, H.Pipes.Args.ConnectionMessageEventArgs<IPCMessage?> e)
        {
            Task.Run(() =>
            {
                var start = DateTime.Now;
                try
                {
                    if (e.Message == null) throw new Exception($"Invalid message");

                    var method = e.Message.Method switch
                    {
                        Method.Query => QueryMethod,
                        Method.QueryMultiple => QueryMultipleMethod,
                        Method.Delete => DeleteMethod,
                        Method.MultiDelete => MultiDeleteMethod,
                        Method.Save => SaveMethod,
                        Method.MultiSave => MultiSaveMethod,
                        Method.Check2FA => Check2FAMethod,
                        Method.Validate => ValidateMethod,
                        Method.Ping => PingMethod,
                        Method.Info => InfoMethod,
                        Method.None or _ => throw new Exception($"Invalid method '{e.Message.Method}'")
                    };

                    if (e.Message.Type != null)
                    {
                        var entityType = GetEntity(e.Message.Type) ?? throw new Exception($"No entity '{e.Message.Type}'");
                        method = method.MakeGenericMethod(entityType);
                    }

                    var response = method.Invoke(this, new object[] { e.Message, new RequestData(e) }) as IPCMessage;
                    e.Connection.WriteAsync(response).ContinueWith(task =>
                    {
                        if (task.Exception != null)
                        {
                            Logger.Send(LogType.Error, "", $"Error in response: {CoreUtils.FormatException(task.Exception)}");
                        }
                    });
                }
                catch (Exception err)
                {
                    Logger.Send(LogType.Error, "", err.Message);
                    if (e.Message != null)
                    {
                        var responseType = GetResponseType(e.Message.Method, e.Message.Type);
                        if (responseType != null)
                        {
                            var response = (Activator.CreateInstance(responseType) as Response)!;
                            response.Status = StatusCode.Error;
                            response.Messages.Add(err.Message);
                            e.Connection.WriteAsync(e.Message.Respond(response)).ContinueWith(task =>
                            {
                                if (task.Exception != null)
                                {
                                    Logger.Send(LogType.Error, "", $"Error in response: {CoreUtils.FormatException(task.Exception)}");
                                }
                            });
                        }
                    }
                }
            });
        }

        private void Server_ClientDisconnected(object? sender, H.Pipes.Args.ConnectionEventArgs<IPCMessage> e)
        {
            Logger.Send(LogType.Information, "", "Client Disconnected");

            var sessionID = NotifyState.SessionMap.Where(x => x.Value.Connection == e.Connection).FirstOrDefault().Key;
            NotifyState.SessionMap.TryRemove(sessionID, out var session);

            e.Connection.DisposeAsync();
        }

        private void Server_ClientConnected(object? sender, H.Pipes.Args.ConnectionEventArgs<IPCMessage> e)
        {
            Logger.Send(LogType.Information, "", "Client Connected");
        }

        public void Dispose()
        {
            _transport?.Stop();
        }

        ~RPCServer()
        {
            Dispose();
        }
    }
}