using System;
using System.Diagnostics;
using System.IO;
using System.Threading.Tasks;

namespace PCMonitor {

    /// <summary>
    /// Executor untuk Perintah Remote dari Server
    /// </summary>
    public class CommandExecutor : IDisposable {
        private readonly ApiClient apiClient;
        private readonly ILog logger = new FileLogger();

        public CommandExecutor(ApiClient client) {
            apiClient = client;
        }

        public async Task ExecutePendingCommandsAsync() {
            try {
                // Get pending commands from server
                var result = await apiClient.GetAsync("command/pending");
                
                var commands = result as Newtonsoft.Json.Linq.JArray;
                if (commands != null) {
                    foreach (var cmd in commands) {
                        await ExecuteCommandAsync(cmd.ToObject<dynamic>());
                    }
                }
            } catch (Exception ex) {
                logger.Error($"Error executing pending commands: {ex.Message}");
            }
        }

        private async Task ExecuteCommandAsync(dynamic command) {
            try {
                string commandType = command["command_type"];
                string commandId = command["id"];

                logger.Info($"Executing command: {commandType} (ID: {commandId})");

                bool success = false;
                string response = "";

                switch (commandType.ToLower()) {
                    case "shutdown":
                        success = ExecuteShutdown();
                        response = "System shutdown command executed";
                        break;

                    case "restart":
                        success = ExecuteRestart();
                        response = "System restart command executed";
                        break;

                    case "lock":
                        success = ExecuteLockWorkstation();
                        response = "Workstation locked";
                        break;

                    case "disconnect_internet":
                        var bwController = new BandwidthController(apiClient);
                        success = await bwController.DisconnectInternetAsync();
                        response = "Internet disconnected";
                        bwController.Dispose();
                        break;

                    case "connect_internet":
                        var bwController2 = new BandwidthController(apiClient);
                        success = await bwController2.ConnectInternetAsync();
                        response = "Internet connected";
                        bwController2.Dispose();
                        break;

                    case "screen_mirror":
                        success = await CaptureScreenAsync();
                        response = "Screenshot captured";
                        break;

                    case "take_screenshot":
                        success = await CaptureScreenAsync();
                        response = "Screenshot taken";
                        break;

                    case "refresh_data":
                        success = true;
                        response = "Data refresh command received";
                        break;

                    default:
                        response = $"Unknown command: {commandType}";
                        break;
                }

                // Report command status back to server
                await apiClient.SendAsync("command/status", "PUT", new {
                    command_id = commandId,
                    status = success ? "completed" : "failed",
                    response = response
                });
            } catch (Exception ex) {
                logger.Error($"Error executing command: {ex.Message}");
            }
        }

        private bool ExecuteShutdown() {
            try {
                Process.Start(new ProcessStartInfo {
                    FileName = "cmd.exe",
                    Arguments = "/C shutdown /s /t 30 /c \"Shutdown ordered by administrator\"",
                    UseShellExecute = false,
                    CreateNoWindow = true,
                    Verb = "runas"
                });
                logger.Info("Shutdown command sent");
                return true;
            } catch (Exception ex) {
                logger.Error($"Error during shutdown: {ex.Message}");
                return false;
            }
        }

        private bool ExecuteRestart() {
            try {
                Process.Start(new ProcessStartInfo {
                    FileName = "cmd.exe",
                    Arguments = "/C shutdown /r /t 30 /c \"Restart ordered by administrator\"",
                    UseShellExecute = false,
                    CreateNoWindow = true,
                    Verb = "runas"
                });
                logger.Info("Restart command sent");
                return true;
            } catch (Exception ex) {
                logger.Error($"Error during restart: {ex.Message}");
                return false;
            }
        }

        private bool ExecuteLockWorkstation() {
            try {
                Process.Start("rundll32.exe", "user32.dll,LockWorkStation");
                logger.Info("Lock workstation command sent");
                return true;
            } catch (Exception ex) {
                logger.Error($"Error locking workstation: {ex.Message}");
                return false;
            }
        }

        private async Task<bool> CaptureScreenAsync() {
            try {
                string screenshotPath = Path.Combine(
                    Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData),
                    "PCMonitor", "Screenshots"
                );
                Directory.CreateDirectory(screenshotPath);

                string filename = Path.Combine(screenshotPath, $"screenshot_{DateTime.Now:yyyy-MM-dd_HH-mm-ss}.png");

                // Capture screen using PrintWindow API
                ScreenCapture.CaptureScreen(filename);

                // Upload screenshot
                await apiClient.UploadFileAsync("screenshot", filename);
                logger.Info($"Screenshot saved and uploaded: {filename}");
                return true;
            } catch (Exception ex) {
                logger.Error($"Error capturing screenshot: {ex.Message}");
                return false;
            }
        }

        public void Dispose() { }
    }

    /// <summary>
    /// Screen Capture Utility
    /// </summary>
    public static class ScreenCapture {
        public static void CaptureScreen(string filename) {
            try {
                var screenSize = System.Windows.Forms.Screen.PrimaryScreen.Bounds;
                using (var bitmap = new System.Drawing.Bitmap(screenSize.Width, screenSize.Height)) {
                    using (var g = System.Drawing.Graphics.FromImage(bitmap)) {
                        g.CopyFromScreen(0, 0, 0, 0, screenSize.Size);
                    }
                    bitmap.Save(filename, System.Drawing.Imaging.ImageFormat.Png);
                }
            } catch (Exception ex) {
                throw new Exception($"Error capturing screen: {ex.Message}");
            }
        }
    }
}