using Comal.Classes;
using Comal.Stores;
using GenHTTP.Api.Protocol;
using GenHTTP.Modules.IO;
using InABox.Clients;
using InABox.Configuration;
using InABox.Core;
using InABox.Rpc;
using InABox.Wpf.Reports;
using PRS.Shared;
using PRSServer;
using PRSServices;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using RequestMethod = GenHTTP.Api.Protocol.RequestMethod;

namespace PRSLicensing;

public class LicensingHandler : Handler<LicensingHandlerProperties>
{
    public override void Init(LicensingHandlerProperties properties)
    {
    }

    private IResponseBuilder HandleGET(IRequest request)
    {
        return request.Respond().Content("Hello, World!").Status(ResponseStatus.OK);
    }

    private IResponseBuilder HandlePOST(IRequest request)
    {
        return request.Respond().Status(ResponseStatus.NotFound);
    }

    public override ValueTask<IResponse?> HandleAsync(IRequest request)
    {
        try
        {
            switch (request.Method.KnownMethod)
            {
                case RequestMethod.GET:
                    return new ValueTask<IResponse?>(HandleGET(request).Build());
                case RequestMethod.POST:
                    return new ValueTask<IResponse?>(HandlePOST(request).Build());
                default:
                    Logger.Send(LogType.Error, ClientFactory.UserID, $"Request method {request.Method.RawMethod} unknown");
                    return new ValueTask<IResponse?>(request.Respond().Status(ResponseStatus.MethodNotAllowed).Build());
            }
        }
        catch (Exception eListen)
        {
            Logger.Send(LogType.Error, ClientFactory.UserID, eListen.Message);
            return new ValueTask<IResponse?>(request.Respond().Status(ResponseStatus.InternalServerError).Build());
        }
    }
}

public class LicensingHandlerProperties
{
}

public class LicensingEngine : Engine<LicensingEngineProperties>
{
    private Listener<LicensingHandler, LicensingHandlerProperties> listener;

    public override void Run()
    {
        Logger.Send(LogType.Information, "", "Starting..");

        if (string.IsNullOrWhiteSpace(Properties.Server))
        {
            Logger.Send(LogType.Error, "", "Server is blank!");
            return;
        }

        var transport = new RpcClientPipeTransport(DatabaseServerProperties.GetPipeName(Properties.Server, true));
        ClientFactory.SetClientType(typeof(RpcClient<>), Platform.WebEngine, Version, transport);
        CheckConnection();
        
        Logger.Send(LogType.Information, "", "Registering Classes");

        StoreUtils.RegisterClasses();
        CoreUtils.RegisterClasses();
        ComalUtils.RegisterClasses();
        PRSSharedUtils.RegisterClasses();
        ReportUtils.RegisterClasses();
        ConfigurationUtils.RegisterClasses();

        Logger.Send(LogType.Information, "", "Starting Listener on port " + Properties.ListenPort);

        try
        {
            listener = new Listener<LicensingHandler, LicensingHandlerProperties>(new LicensingHandlerProperties());
            listener.InitHTTPS((ushort)Properties.ListenPort, CertificateFileName());

            Logger.Send(LogType.Information, "", "Starting Web Listener on port " + Properties.ListenPort);
            listener.Start();
        }
        catch (Exception eListen)
        {
            Logger.Send(LogType.Error, ClientFactory.UserID, eListen.Message);
        }
    }

    private string CertificateFileName() => Properties.CertificateFile;

    private void CheckConnection()
    {
        // Wait for server connection
        while (!Client.Ping())
        {
            Logger.Send(LogType.Error, "", "Database server unavailable. Trying again in 30 seconds...");
            Task.Delay(30_000).Wait();
            Logger.Send(LogType.Information, "", "Retrying connection...");
        }

        ClientFactory.SetBypass();
    }

    public override void Stop()
    {
        Logger.Send(LogType.Information, "", "Stopping");
        listener?.Stop();
    }
}

public class LicensingEngineProperties : ServerProperties
{

    [ComboLookupEditor(typeof(LicensingDatabaseServerLookupGenerator))]
    [EditorSequence(1)]
    public string Server { get; set; }

    [IntegerEditor]
    [EditorSequence(2)]
    public int ListenPort { get; set; }

    [EditorSequence(3)]
    [FileNameEditor("Certificate Files (*.pfx)|*.pfx")]
    public string CertificateFile { get; set; }

    public override ServerType Type()
    {
        return ServerType.Other;
    }
}

public class LicensingDatabaseServerLookupGenerator : LookupGenerator<LicensingEngineProperties>
{
    public LicensingDatabaseServerLookupGenerator(LicensingEngineProperties[] items) : base(items)
    {
    }

    protected override void DoGenerateLookups()
    {
        var config = new LocalConfiguration<ServerSettings>(CoreUtils.GetCommonAppData("PRSServer"), "");
        var servers = config.LoadAll();
        foreach (var server in servers.Select(x => x.Value.CreateServer(x.Key)))
        {
            if (server.Type == ServerType.Database)
            {
                AddValue(server.Key, server.Name);
            }
        }
    }
}