using System.Reflection;

using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging.Console;

using Avalonia;
using Avalonia.OpenGL.Egl;

using GSS2.Core;
using GSS2.Core.Logging;
using GSS2.Core.Analysis.AmineContent.Database;

using ConsoleFormatter = GSS2.Core.Logging.ConsoleFormatter;

namespace GSS2.Test;

public class Program
{
    public static IHost ApplicationHost { get; } = BuildHostApp();
    public static event ConsoleCancelEventHandler? ShutdownRequested;

    [STAThread]
    public static int Main(string[] args)
    {
        var builder = BuildAvaloniaApp();

        if (args.Contains("--drm"))
        {
            if (!args.Contains("--console"))
                SilenceConsole();
            return builder.StartLinuxDrm(args, "/dev/dri/card1", 1.0);
        }
        if (args.Contains("--help"))
        {
            Console.WriteLine($"Usage of {Assembly.GetEntryAssembly()?.GetName().Name}:");
            Console.WriteLine($"\t--help    - show this help");
            Console.WriteLine($"\t--drm     - use DRM rendering mode");
            Console.WriteLine($"\t--console - in DRM rendering mode do not suppress console output");
            return 0;
        }

        Console.CancelKeyPress += new ConsoleCancelEventHandler(OnProgramShutdown);
        Console.WriteLine("Press Ctrl+C to shut down.");

        return builder.StartWithClassicDesktopLifetime(args);
    }

    private static void OnProgramShutdown(object? sender, ConsoleCancelEventArgs ea)
    {
        ShutdownRequested?.Invoke(sender, ea);
        ea.Cancel = true;
    }

    private static void SilenceConsole()
    {
        new Thread(() =>
        {
            Console.CursorVisible = false;
            while (true)
                Console.ReadKey(true);
        })
        { IsBackground = true }.Start();
    }

    private static IHost BuildHostApp()
    {
        var builder = Host.CreateApplicationBuilder();

        builder.Logging.ClearProviders();
        builder.Logging.AddConsole(options => options.FormatterName = nameof(ConsoleFormatter));
        builder.Logging.AddConsoleFormatter<ConsoleFormatter, ConsoleFormatterOptions>();
        builder.Logging.AddProvider(new FileLoggerProvider("full.log", true));
        builder.Logging.AddProvider(new FileLoggerProvider("last_run.log", false));
        builder.Services.AddSingleton<LibCameraLogSink>();

        builder.Services.AddAmineContentCalibrationContext(builder.Configuration);
        builder.Services.AddAmineContentResultsContext(builder.Configuration);

        builder.Services.AddLightsService("Hardware:Lights");
        builder.Services.AddTemperatureHumidityService("Hardware:TemperatureHumidity");
        builder.Services.AddIlluminatorService("Hardware:Illuminator");
        builder.Services.AddCameraService("Hardware:Camera", true);
        builder.Services.AddComputeResourcesService();

        builder.Services.AddViewsAndModels();

        var host = builder.Build();
        host.Services.GetRequiredService<LibCameraLogSink>();

        using (var scope = host.Services.CreateScope())
        {
            var context = scope.ServiceProvider.GetRequiredService<AmineContentCalibrationContext>();
            context.Database.Migrate();
        }
        using (var scope = host.Services.CreateScope())
        {
            var context = scope.ServiceProvider.GetRequiredService<AmineContentResultsContext>();
            context.Database.Migrate();
        }

        return host;
    }

    private static AppBuilder BuildAvaloniaApp()
        => AppBuilder.Configure<App>()
            .UsePlatformDetect()
            .UseSkia()
            .LogToTrace()
            .With(new X11PlatformOptions
            {
                RenderingMode = [X11RenderingMode.Egl]
            })
            .With(new EglDisplayOptions
            {
                SupportsContextSharing = true
            });
}