using System;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Security.Principal;
using System.Text.Json;
using System.Threading.Tasks;
using Inventory.Core;
using Microsoft.Extensions.Logging;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using DotNetEnv;

namespace Inventory.AdminTool
{
    class Program
    {
        static async Task Main(string[] args)
        {
            if (OperatingSystem.IsWindows() && !IsAdministrator())
            {
                Console.WriteLine("This tool requires administrator privileges to collect all system information.");
                Console.WriteLine("Attempting to restart with elevated permissions...");

                try
                {
                    var exeName = Process.GetCurrentProcess().MainModule.FileName;
                    var startInfo = new ProcessStartInfo(exeName)
                    {
                        Verb = "runas",
                        Arguments = string.Join(" ", args),
                        UseShellExecute = true
                    };
                    Process.Start(startInfo);
                    return; // Exit the non-elevated instance
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"Failed to restart with admin privileges. Please run your terminal as an administrator and try again. Error: {ex.Message}");
                    return;
                }
            }

            var host = CreateHostBuilder(args).Build();

            await host.RunAsync();
        }

        private static IHostBuilder CreateHostBuilder(string[] args)
        {
            Env.TraversePath().Load();
            string? dbCon = Env.GetString("DB_CONNECTION_STRING");

            if (string.IsNullOrWhiteSpace(dbCon))
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine("FATAL ERROR: DB_CONNECTION_STRING is not set in the .env file.");
                Console.WriteLine("Please ensure a .env file exists in the project directory and contains the connection string.");
                Console.ResetColor();
                Environment.Exit(1); // Exit with an error code
            }

            return Host.CreateDefaultBuilder(args)
                  .ConfigureLogging(logging =>
                  {
                      // Suppress informational logs from Entity Framework Core
                      logging.AddFilter("Microsoft.EntityFrameworkCore", LogLevel.Warning);
                  })
                  .ConfigureServices((hostContext, services) =>
                  {
                      services.AddDbContext<InventoryContext>(options =>
                          options.UseSqlServer(dbCon));

                      services.AddHostedService<AppHostService>();
                      services.AddHttpClient();
                      services.AddSingleton<SystemInfoCollector>();
                      services.AddScoped<DatabaseUpdater>();
                      services.AddScoped<HealthMonitor>();
                      services.AddScoped<SlurpitClient>();
                      services.AddScoped<UpdateWorkflow>();
                  });
        }

        private static bool IsAdministrator()
        {
            if (!OperatingSystem.IsWindows())
            {
                // On non-Windows systems, we can assume root access is handled differently (e.g., via sudo).
                return true;
            }
            var identity = WindowsIdentity.GetCurrent();
            var principal = new WindowsPrincipal(identity);
            return principal.IsInRole(WindowsBuiltInRole.Administrator);
        }
    }

    public class AppHostService : IHostedService
    {
        private readonly IServiceProvider _serviceProvider;

        public AppHostService(IServiceProvider serviceProvider)
        {
            _serviceProvider = serviceProvider;
        }

        public async Task StartAsync(CancellationToken cancellationToken)
        {
            bool errorOccurred = false;
            try
            {
                using var scope = _serviceProvider.CreateScope();
                var services = scope.ServiceProvider;

                // Apply migrations on startup
                var dbContext = services.GetRequiredService<InventoryContext>();
                await dbContext.Database.MigrateAsync(cancellationToken);

                var collector = services.GetRequiredService<SystemInfoCollector>();
                var healthMonitor = services.GetRequiredService<HealthMonitor>();
                DisplaySystemInfo(collector, healthMonitor);

                await HandleLocationUpdate(services);

                Console.Write("\nDo you want to force an upsert now? (y/n): ");
                var response = Console.ReadLine();

                if (response?.Equals("y", StringComparison.OrdinalIgnoreCase) == true)
                {
                    var updateWorkflow = services.GetRequiredService<UpdateWorkflow>();
                    await updateWorkflow.Run();
                    Console.WriteLine("Upsert completed successfully.");
                }
            }
            catch (Exception ex)
            {
                errorOccurred = true;
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine("\n\nAn unexpected error occurred:");
                Console.WriteLine(ex.ToString());
                Console.ResetColor();
            }
            finally
            {
                Console.WriteLine(errorOccurred
                    ? "\nAn error occurred. The application will remain open. Press any key to exit."
                    : "\nExecution finished. Press any key to exit.");
                Console.ReadKey();
            }

            var lifetime = _serviceProvider.GetRequiredService<IHostApplicationLifetime>();
            lifetime.StopApplication();
        }

        public Task StopAsync(CancellationToken cancellationToken)
        {
            return Task.CompletedTask;
        }

        private static string FormatBytes(ulong bytes)
        {
            if (bytes == 0) return "0 B";
            const int scale = 1024;
            string[] orders = { "B", "KB", "MB", "GB", "TB", "PB" };
            var orderIndex = (int)Math.Floor(Math.Log(bytes, scale));
            if (orderIndex >= orders.Length) orderIndex = orders.Length - 1;
            double num = Math.Round(bytes / Math.Pow(scale, orderIndex), 2);
            return $"{num} {orders[orderIndex]}";
        }


        private void DisplaySystemInfo(SystemInfoCollector collector, HealthMonitor healthMonitor)
        {
            Console.WriteLine("--- System Information ---");
            Console.WriteLine($"Computer Name: {collector.GetComputerName()}");
            Console.WriteLine($"Device Type: {collector.GetDeviceType()}");
            Console.WriteLine($"Serial Number: {collector.GetSystemSerialNumber()}");
            Console.WriteLine($"Motherboard Serial Number: {collector.GetMotherboardSerialNumber()}");
            Console.WriteLine($"System UUID: {collector.GetSystemUUID()}");
            Console.WriteLine($"Processor: {collector.GetProcessor()}");
            Console.WriteLine($"RAM: {collector.GetTotalRAM()}");
            Console.WriteLine($"OS Version: {collector.GetOSVersion()}");
            Console.WriteLine($"OS Install Date: {collector.GetOSInstallDate()}");
            Console.WriteLine($"OS License Key: {collector.GetOSLicenseKey()}");
            var (ips, mac) = collector.GetNetworkInfo();
            Console.WriteLine("IP Addresses:");
            if (ips.Any())
            {
                foreach (var ip in ips)
                {
                    Console.WriteLine($"  - {ip}");
                }
            }
            Console.WriteLine($"MAC Address: {mac}");
            Console.WriteLine($"Optical Drive: {collector.HasOpticalDrive()}");

            Console.WriteLine("\n--- GPUs ---");
            var gpus = collector.GetGPUs();
            if (gpus.Any())
            {
                gpus.ForEach(gpu => Console.WriteLine($"  - {gpu}"));
            }
            else
            {
                Console.WriteLine("  No GPUs found.");
            }

            Console.WriteLine("\n--- Storage Devices ---");
            var storage = collector.GetStorage();
            if (storage.Any())
            {
                foreach (var drive in storage)
                {
                    Console.WriteLine($"  - Model: {drive.Model ?? "N/A"}");
                    Console.WriteLine($"    Serial: {drive.SerialNumber ?? "N/A"}");
                    Console.WriteLine($"    Type: {drive.MediaType} ({drive.InterfaceType})");
                    Console.WriteLine($"    Size: {FormatBytes(drive.Size)}");
                }
            }
            else
            {
                Console.WriteLine("  No storage devices found.");
            }

            Console.WriteLine("\n--- Monitors ---");
            var monitors = collector.GetMonitors();
            if (monitors.Any())
            {
                foreach (var monitor in monitors)
                {
                    Console.WriteLine($"  - Model: {monitor.Model ?? "N/A"}");
                    Console.WriteLine($"    Serial: {monitor.SerialNumber ?? "N/A"}");
                    Console.WriteLine($"    PnPDeviceID: {monitor.PnPDeviceID ?? "N/A"}");
                }
            }
            else
            {
                Console.WriteLine("  No monitors found.");
            }

            Console.WriteLine("\n--- Printers ---");
            var printers = collector.GetPrinters();
            if (printers.Any())
            {
                foreach (var printer in printers)
                {
                    string type = printer.IsNetwork ? "Network" : "Local";
                    Console.WriteLine($"  - Name: {printer.Name ?? "N/A"} ({type})");
                    Console.WriteLine($"    Driver: {printer.DriverName ?? "N/A"}");
                    Console.WriteLine($"    Port: {printer.PortName ?? "N/A"}");
                    Console.WriteLine($"    Host: {printer.HostName ?? "N/A"}");
                }
            }
            else
            {
                Console.WriteLine("  No physical printers found.");
            }

            Console.WriteLine("\n--- Local Admins ---");
            var admins = collector.GetLocalAdmins();
            if (admins.Any())
            {
                foreach (var admin in admins.OrderBy(a => a.Source).ThenBy(a => a.Name))
                {
                    string status = admin.IsEnabled == false ? " (Disabled)" : (admin.IsLockedOut == true ? " (Locked)" : "");
                    Console.WriteLine($"  - {admin.Name} [{admin.AccountType} / {admin.Source}]{status}");
                }
            }
            else
            {
                Console.WriteLine("  Could not retrieve local administrators.");
            }

            Console.WriteLine("\n--- Health Metrics (Requires Admin) ---");
            try
            {
                var report = healthMonitor.CollectHealthMetrics();
                Console.WriteLine($"CPU Temp: {(report.CpuTemp.HasValue ? $"{report.CpuTemp.Value}°C" : "N/A")}");
                Console.WriteLine($"CPU Load: {(report.CpuLoad.HasValue ? $"{Math.Round(report.CpuLoad.Value, 2)}%" : "N/A")}");
                Console.WriteLine($"CPU Power: {(report.CpuPower.HasValue ? $"{Math.Round(report.CpuPower.Value, 2)}W" : "N/A")}");

                Console.WriteLine($"GPU Temp: {(report.GpuTemp.HasValue ? $"{report.GpuTemp.Value}°C" : "N/A")}");
                Console.WriteLine($"GPU Load: {(report.GpuLoad.HasValue ? $"{Math.Round(report.GpuLoad.Value, 2)}%" : "N/A")}");
                Console.WriteLine($"GPU Power: {(report.GpuPower.HasValue ? $"{Math.Round(report.GpuPower.Value, 2)}W" : "N/A")}");
                Console.WriteLine($"GPU Clock: {(report.GpuClock.HasValue ? $"{Math.Round(report.GpuClock.Value, 0)}MHz" : "N/A")}");

                Console.WriteLine($"RAM Load: {(report.RamLoad.HasValue ? $"{Math.Round(report.RamLoad.Value, 2)}%" : "N/A")}");

                Console.WriteLine($"Battery Health: {(report.BatteryHealth.HasValue ? $"{report.BatteryHealth.Value}%" : "N/A")}");

                Console.WriteLine("Fan Speeds:");
                if (report.FanSpeeds.Any())
                {
                    foreach (var fan in report.FanSpeeds)
                    {
                        Console.WriteLine($"  - {fan.Name}: {(fan.Rpm.HasValue ? $"{Math.Round(fan.Rpm.Value, 0)} RPM" : "N/A")}");
                    }
                }

                Console.WriteLine("Drive Health:");
                if (report.DriveHealth.Any())
                {
                    foreach (var driveHealth in report.DriveHealth)
                    {
                        string failing = driveHealth.IsFailing == true ? " - PREDICTING FAILURE!" : "";
                        string health = driveHealth.HealthPercentage.HasValue ? $"Health: {driveHealth.HealthPercentage}% | " : "";
                        Console.WriteLine($"  - {driveHealth.Model}: {health}Temp: {(driveHealth.Temperature.HasValue ? $"{driveHealth.Temperature.Value}°C" : "N/A")}{failing}");
                    }
                }
                else
                {
                    Console.WriteLine("  No drive health sensors found.");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Could not retrieve health metrics. Ensure the tool is run as Administrator. Error: {ex.Message}");
            }

            Console.WriteLine("--------------------------");
        }

        private async Task HandleLocationUpdate(IServiceProvider services)
        {
            using var scope = services.CreateScope();
            var dbContext = scope.ServiceProvider.GetRequiredService<InventoryContext>();
            var collector = scope.ServiceProvider.GetRequiredService<SystemInfoCollector>();

            string? localIdentifier = GetLocalIdentifier(collector);
            if (string.IsNullOrWhiteSpace(localIdentifier))
            {
                Console.WriteLine("\nCould not determine a unique identifier for this machine. Cannot update location.");
                return;
            }

            var device = await dbContext.Devices.FirstOrDefaultAsync(d => d.HardwareIdentifier == localIdentifier);

            Console.WriteLine("\n--- Location Information ---");
            Console.WriteLine($"Current Location: {device?.Location ?? "Not set"}");
            Console.Write("Enter new location (leave blank to keep current): ");
            string? newLocation = Console.ReadLine();

            if (!string.IsNullOrWhiteSpace(newLocation))
            {
                if (device == null)
                {
                    // This case is unlikely if the update workflow runs first, but good to have.
                    device = new Device { HardwareIdentifier = localIdentifier };
                    dbContext.Devices.Add(device);
                }
                device.Location = newLocation;
                await dbContext.SaveChangesAsync();
                Console.WriteLine($"Location updated to '{newLocation}'.");
            }
        }

        private string? GetLocalIdentifier(SystemInfoCollector collector)
        {
            // This logic is duplicated from DatabaseUpdater to be used here.
            var identifiers = new[]
            {
                collector.GetMotherboardSerialNumber(),
                collector.GetSystemUUID(),
                collector.GetNetworkInfo().MACAddress
            };

            return identifiers.FirstOrDefault(id => 
                !string.IsNullOrWhiteSpace(id) && 
                !id.Equals("To be filled by O.E.M.", StringComparison.OrdinalIgnoreCase));
        }
    }
}