using Microsoft.AspNetCore.Mvc;
using ResourceMonitorService.Models;
using ResourceMonitorService.Services;
using System.Diagnostics;

namespace ResourceMonitorService.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    public class ResourceController : ControllerBase
    {
        private readonly IResourceMonitorService _resourceMonitorService;
        private readonly ISystemInfoService _systemInfoService;
        private readonly ILogger<ResourceController> _logger;

        public ResourceController(
            IResourceMonitorService resourceMonitorService,
            ISystemInfoService systemInfoService,
            ILogger<ResourceController> logger)
        {
            _resourceMonitorService = resourceMonitorService;
            _systemInfoService = systemInfoService;
            _logger = logger;
        }

        [HttpGet("usage")]
        public async Task<ActionResult<ResourceUsage>> GetResourceUsage()
        {
            try
            {
                var usage = await _resourceMonitorService.GetResourceUsageAsync();
                return Ok(usage);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error getting resource usage");
                return StatusCode(500, "Internal server error");
            }
        }

        [HttpGet("system-info")]
        public async Task<ActionResult<SystemInfo>> GetSystemInfo()
        {
            try
            {
                var systemInfo = await _systemInfoService.GetSystemInfoAsync();
                return Ok(systemInfo);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error getting system info");
                return StatusCode(500, "Internal server error");
            }
        }

        [HttpGet("cpu")]
        public async Task<ActionResult<CpuUsage>> GetCpuUsage()
        {
            try
            {
                var cpuUsage = await _resourceMonitorService.GetCpuUsageAsync();
                return Ok(cpuUsage);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error getting CPU usage");
                return StatusCode(500, "Internal server error");
            }
        }

        [HttpGet("memory")]
        public async Task<ActionResult<MemoryUsage>> GetMemoryUsage()
        {
            try
            {
                var memoryUsage = await _resourceMonitorService.GetMemoryUsageAsync();
                return Ok(memoryUsage);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error getting memory usage");
                return StatusCode(500, "Internal server error");
            }
        }

        [HttpGet("gpu")]
        public async Task<ActionResult<GpuUsage>> GetGpuUsage()
        {
            try
            {
                var gpuUsage = await _resourceMonitorService.GetGpuUsageAsync();
                return Ok(gpuUsage);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error getting GPU usage");
                return StatusCode(500, "Internal server error");
            }
        }

        [HttpGet("disks")]
        public async Task<ActionResult<List<DiskUsage>>> GetDiskUsage()
        {
            try
            {
                var diskUsage = await _resourceMonitorService.GetDiskUsageAsync();
                return Ok(diskUsage);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error getting disk usage");
                return StatusCode(500, "Internal server error");
            }
        }

        [HttpGet("processes")]
        public async Task<ActionResult<List<ProcessInfo>>> GetTopProcesses([FromQuery] int count = 10)
        {
            try
            {
                var processes = await _resourceMonitorService.GetTopProcessesAsync(count);
                return Ok(processes);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error getting top processes");
                return StatusCode(500, "Internal server error");
            }
        }

        [HttpPost("kill-process/{processId}")]
        public ActionResult KillProcess(int processId)
        {
            try
            {
                var process = Process.GetProcessById(processId);
                if (process == null)
                {
                    return NotFound($"Process with ID {processId} not found");
                }

                process.Kill();
                _logger.LogInformation($"Process {process.ProcessName} (ID: {processId}) was terminated");
                
                return Ok(new { message = $"Process {process.ProcessName} (ID: {processId}) was terminated successfully" });
            }
            catch (ArgumentException)
            {
                return NotFound($"Process with ID {processId} not found");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, $"Error killing process {processId}");
                return StatusCode(500, "Internal server error");
            }
        }

        [HttpPost("system-control")]
        public ActionResult SystemControl([FromBody] SystemControlRequest request)
        {
            try
            {
                if (request == null)
                {
                    return BadRequest("Invalid request");
                }

                // Validate action
                if (request.Action != "shutdown" && request.Action != "restart")
                {
                    return BadRequest("Invalid action. Use 'shutdown' or 'restart'");
                }

                // Validate timer
                if (request.Timer < 0 || request.Timer > 86400)
                {
                    return BadRequest("Timer must be between 0 and 86400 seconds (24 hours)");
                }

                // Build the shutdown command
                var arguments = request.Action == "shutdown" ? "/s" : "/r";
                
                if (request.Force)
                {
                    arguments += " /f";
                }
                
                if (request.Timer > 0)
                {
                    arguments += $" /t {request.Timer}";
                }

                // Execute the shutdown command
                var processInfo = new ProcessStartInfo
                {
                    FileName = "shutdown",
                    Arguments = arguments,
                    UseShellExecute = false,
                    CreateNoWindow = true
                };

                var process = Process.Start(processInfo);
                
                string message;
                if (request.Timer > 0)
                {
                    var minutes = request.Timer / 60;
                    var seconds = request.Timer % 60;
                    var timeString = minutes > 0 
                        ? $"{minutes} minute{(minutes != 1 ? "s" : "")}" + (seconds > 0 ? $" and {seconds} second{(seconds != 1 ? "s" : "")}" : "")
                        : $"{seconds} second{(seconds != 1 ? "s" : "")}";
                    
                    message = $"System {request.Action} scheduled in {timeString}";
                }
                else
                {
                    message = $"System {request.Action} initiated immediately";
                }

                _logger.LogWarning($"System {request.Action} command executed by user. Timer: {request.Timer}s, Force: {request.Force}");
                
                return Ok(new { message });
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, $"Error executing system {request?.Action} command");
                return StatusCode(500, "Internal server error");
            }
        }

        [HttpPost("cancel-shutdown")]
        public ActionResult CancelShutdown()
        {
            try
            {
                // Execute the shutdown abort command
                var processInfo = new ProcessStartInfo
                {
                    FileName = "shutdown",
                    Arguments = "/a",
                    UseShellExecute = false,
                    CreateNoWindow = true,
                    RedirectStandardOutput = true,
                    RedirectStandardError = true
                };

                var process = Process.Start(processInfo);
                process?.WaitForExit();

                var exitCode = process?.ExitCode ?? -1;
                
                string message;
                if (exitCode == 0)
                {
                    message = "Shutdown/restart canceled successfully";
                    _logger.LogInformation("Shutdown/restart canceled by user");
                }
                else
                {
                    message = "No shutdown/restart was scheduled to cancel, or cancellation failed";
                    _logger.LogInformation("Attempted to cancel shutdown but none was scheduled");
                }

                return Ok(new { message });
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error canceling shutdown command");
                return StatusCode(500, "Internal server error");
            }
        }
    }

    public class SystemControlRequest
    {
        public string Action { get; set; } = string.Empty;
        public int Timer { get; set; } = 0;
        public bool Force { get; set; } = true;
    }
}