using System.Diagnostics;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Newtonsoft.Json;
using Microsoft.AspNetCore.Http;
using System.Runtime.InteropServices;
using System.Management;

namespace ResourceMonitorService
{
    public class Worker : BackgroundService
    {
        private readonly IHostApplicationLifetime _lifetime;

        public Worker(IHostApplicationLifetime lifetime)
        {
            _lifetime = lifetime;
        }

        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            var builder = WebApplication.CreateBuilder();
            builder.Services.AddControllers().AddNewtonsoftJson();
            var app = builder.Build();

            app.MapGet("/api/resource-usage", async context =>
            {
                var computerInfo = GetComputerInfo();
                var cpuUsage = GetCpuUsage();
                var ramUsage = GetRamUsage();
                var gpuUsage = GetGpuUsage();

                var resourceUsage = new
                {
                    ComputerInfo = computerInfo,
                    CPU = cpuUsage,
                    RAM = ramUsage,
                    GPU = gpuUsage
                };

                var json = JsonConvert.SerializeObject(resourceUsage);
                context.Response.ContentType = "application/json";
                await context.Response.WriteAsync(json);
            });

            app.RunAsync(stoppingToken);

            await Task.Delay(Timeout.Infinite, stoppingToken);
        }

        private object GetComputerInfo()
        {
            return new
            {
                MachineName = Environment.MachineName,
                OSVersion = RuntimeInformation.OSDescription,
                OSArchitecture = RuntimeInformation.OSArchitecture.ToString(),
                ProcessorCount = Environment.ProcessorCount
            };
        }

        private float GetCpuUsage()
        {
            var cpuCounter = new PerformanceCounter("Processor", "% Processor Time", "_Total");
            cpuCounter.NextValue();
            Thread.Sleep(1000); // Wait a second to get a valid reading
            return cpuCounter.NextValue();
        }

        private float GetRamUsage()
        {
            var ramCounter = new PerformanceCounter("Memory", "Available MBytes");
            var totalMemory = GetTotalPhysicalMemory();
            var availableMemory = ramCounter.NextValue() * 1024 * 1024;
            return (float)(totalMemory - availableMemory) / totalMemory * 100;
        }

        private ulong GetTotalPhysicalMemory()
        {
            ulong totalMemory = 0;
            var searcher = new ManagementObjectSearcher("SELECT TotalPhysicalMemory FROM Win32_ComputerSystem");
            foreach (var obj in searcher.Get())
            {
                totalMemory = (ulong)obj["TotalPhysicalMemory"];
            }
            return totalMemory;
        }

        private object GetGpuUsage()
        {
            NvmlWrapper.NvmlInit();
            IntPtr device;
            NvmlWrapper.NvmlDeviceGetHandleByIndex(0, out device);
            NvmlWrapper.NvmlUtilization utilization;
            NvmlWrapper.NvmlDeviceGetUtilizationRates(device, out utilization);

            uint temperature;
            NvmlWrapper.NvmlDeviceGetTemperature(device, 0, out temperature);

            uint fanSpeed;
            NvmlWrapper.NvmlDeviceGetFanSpeed(device, out fanSpeed);

            NvmlWrapper.NvmlShutdown();

            return new
            {
                Usage = utilization.Gpu,
                Temperature = temperature,
                FanSpeed = fanSpeed
            };
        }
    }
}