inabox/inabox.ipc.shared/PipeRequest.cs

using InABox.Clients;
using InABox.Core;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.NetworkInformation;
using System.Text;
using System.Threading.Tasks;

namespace InABox.IPC.Shared
{
    public enum RequestError
    {
        NONE,
        DISCONNECTED,
        UNKNOWN,
        TIMEOUT
    }

    public enum Method
    {
        None,
        Query,
        Save,
        MultiSave,
        Delete,
        MultiDelete,
        QueryMultiple,
        Validate,
        Check2FA,
        Ping,
        Info,
        Notification
    }

    [Serializable]
    public class PipeRequest
    {
        public Guid RequestID;
        public Method Method;
        public string? Type;
        private string? Data;
        private byte[]? BinaryData;

        [NonSerialized]
        public RequestError ErrorCode;

        private PipeRequest(Guid requestID, Method method, string? type, string data, RequestError error = RequestError.NONE)
        {
            RequestID = requestID;
            Method = method;
            Type = type;
            Data = data;
            BinaryData = null;
            ErrorCode = error;
        }
        private PipeRequest(Guid requestID, Method method, string? type, byte[] data, RequestError error = RequestError.NONE)
        {
            RequestID = requestID;
            Method = method;
            Type = type;
            BinaryData = data;
            Data = null;
            ErrorCode = error;
        }

        public PipeRequest Respond<TResponse>(TResponse response) where TResponse : Response
        {
            if(response is ISerializeBinary binary)
            {
                return new PipeRequest(RequestID, Method.None, Type, binary.WriteBinary(BinarySerializationSettings.Latest));
            }
            {
                return new PipeRequest(RequestID, Method.None, Type, Serialization.Serialize(response));
            }
        }
        private static PipeRequest CreateRequest(Guid requestID, Method method, string? type, object? data)
        {
            if (data is ISerializeBinary binary)
            {
                return new PipeRequest(requestID, method, type, binary.WriteBinary(BinarySerializationSettings.Latest));
            }
            {
                return new PipeRequest(requestID, method, type, Serialization.Serialize(data));
            }
        }

        public TRequest GetRequest<TRequest>()
        {
            if (BinaryData is not null)
            {
                return (TRequest)Serialization.ReadBinary(typeof(TRequest), BinaryData, BinarySerializationSettings.Latest);
            }
            else
            {
                return Serialization.Deserialize<TRequest>(Data);
            }
        }
        public object? GetRequest(Type TRequest)
        {
            if (BinaryData is not null)
            {
                return Serialization.ReadBinary(TRequest, BinaryData, BinarySerializationSettings.Latest);
            }
            else
            {
                return Serialization.Deserialize(TRequest, Data);
            }
        }

        public TResponse GetResponse<TResponse>() where TResponse : Response, new()
        {
            var start = DateTime.Now;
            var response = GetRequest<TResponse>();

            response ??= new TResponse();
            switch (ErrorCode)
            {
                case RequestError.NONE:
                    break;
                case RequestError.DISCONNECTED:
                    response.Status = StatusCode.Error;
                    response.Messages.Add("Server disconnected");
                    break;
                case RequestError.UNKNOWN:
                    response.Status = StatusCode.Error;
                    response.Messages.Add("Unknown Error");
                    break;
                case RequestError.TIMEOUT:
                    response.Status = StatusCode.Error;
                    response.Messages.Add("Timeout");
                    break;
            }
            return response;
        }

        public static PipeRequest Query<T>(QueryRequest<T> request) where T : Entity, new()
        {
            return CreateRequest(Guid.NewGuid(), Method.Query, typeof(T).Name, request);
        }

        public static PipeRequest Save<T>(SaveRequest<T> request) where T : Entity, new()
        {
            return CreateRequest(Guid.NewGuid(), Method.Save, typeof(T).Name, request);
        }

        public static PipeRequest MultiSave<T>(MultiSaveRequest<T> request) where T : Entity, new()
        {
            return CreateRequest(Guid.NewGuid(), Method.MultiSave, typeof(T).Name, request);
        }

        public static PipeRequest Delete<T>(DeleteRequest<T> request) where T : Entity, new()
        {
            return CreateRequest(Guid.NewGuid(), Method.Delete, typeof(T).Name, request);
        }

        public static PipeRequest MultiDelete<T>(MultiDeleteRequest<T> request) where T : Entity, new()
        {
            return CreateRequest(Guid.NewGuid(), Method.MultiDelete, typeof(T).Name, request);
        }

        public static PipeRequest QueryMultiple(MultiQueryRequest request)
        {
            return CreateRequest(Guid.NewGuid(), Method.QueryMultiple, null, request);
        }

        public static PipeRequest Validate(ValidateRequest request)
        {
            return CreateRequest(Guid.NewGuid(), Method.Validate, null, request);
        }

        public static PipeRequest Check2FA(Check2FARequest request)
        {
            return CreateRequest(Guid.NewGuid(), Method.Check2FA, null, request);
        }

        public static PipeRequest Error(RequestError error)
        {
            return new PipeRequest(Guid.NewGuid(), Method.None, null, "", error);
        }

        public static PipeRequest Ping(PingRequest request)
        {
            return CreateRequest(Guid.NewGuid(), Method.Ping, null, request);
        }
        
        public static PipeRequest Info(InfoRequest request)
        {
            return CreateRequest(Guid.NewGuid(), Method.Info, null, request);
        }

        public static PipeRequest Notification<TNotification>(TNotification notification) where TNotification : BaseObject
            => Notification(typeof(TNotification), notification);
        public static PipeRequest Notification(Type TNotification, BaseObject notification)
        {
            return CreateRequest(Guid.NewGuid(), Method.Notification, TNotification.EntityName(), notification);
        }
    }
}