using System;
using System.Diagnostics;
using System.Linq;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using PCMonitorAgent.Services;

namespace PCMonitor {

    /// <summary>
    /// Core Agent Service
    /// Menangani komunikasi dengan server dan monitoring
    /// </summary>
    public class AgentService {
        private readonly ILog logger = new FileLogger();
        private readonly string agentId;
        private readonly string apiServerUrl;
        private readonly ApiClient apiClient;
        private bool isRunning = false;
        
        private ActivityMonitor activityMonitor;
        private ProcessMonitor processMonitor;
        private SystemInfoMonitor systemInfoMonitor;
        private BandwidthController bandwidthController;
        private CommandExecutor commandExecutor;

        public AgentService() {
            agentId = GenerateAgentId();
            apiServerUrl = ConfigReader.GetApiUrl();
            apiClient = new ApiClient(apiServerUrl, agentId);
            
            logger.Info($"Agent initialized - ID: {agentId}");
        }

        public void Start() {
            if (isRunning) return;
            
            isRunning = true;
            logger.Info("Agent service starting...");

            try {
                // Initialize monitors
                activityMonitor = new ActivityMonitor(apiClient);
                processMonitor = new ProcessMonitor(apiClient);
                systemInfoMonitor = new SystemInfoMonitor(apiClient);
                bandwidthController = new BandwidthController(apiClient);
                commandExecutor = new CommandExecutor(apiClient);

                // Register agent with server
                _ = RegisterAgentAsync();

                // Start background tasks
                Task.Run(() => RunMonitoringLoopAsync());

                logger.Info("Agent service started successfully");
            } catch (Exception ex) {
                logger.Error($"Error starting service: {ex.Message}");
                isRunning = false;
                throw;
            }
        }

        public void Stop() {
            isRunning = false;
            logger.Info("Agent service stopping...");

            try {
                // Cleanup
                activityMonitor?.Dispose();
                processMonitor?.Dispose();
                systemInfoMonitor?.Dispose();
                bandwidthController?.Dispose();
                commandExecutor?.Dispose();
                apiClient?.Dispose();

                logger.Info("Agent service stopped");
            } catch (Exception ex) {
                logger.Error($"Error stopping service: {ex.Message}");
            }
        }

        private async Task RegisterAgentAsync() {
            try {
                var agentInfo = new {
                    agent_id = agentId,
                    pc_name = Environment.MachineName,
                    pc_ip = GetLocalIPAddress(),
                    os_info = GetOsInfo()
                };

                await apiClient.SendAsync("agent", "POST", agentInfo);
                logger.Info("Agent registered with server");
            } catch (Exception ex) {
                logger.Warning($"Failed to register agent: {ex.Message}");
            }
        }

        private async Task RunMonitoringLoopAsync() {
            while (isRunning) {
                try {
                    // Monitor activity
                    await activityMonitor.CollectAsync();

                    // Monitor processes
                    await processMonitor.CollectAsync();

                    // Monitor system info
                    await systemInfoMonitor.CollectAsync();

                    // Check for pending commands
                    await commandExecutor.ExecutePendingCommandsAsync();

                    // Wait before next iteration
                    await Task.Delay(30000); // 30 seconds
                } catch (Exception ex) {
                    logger.Error($"Error in monitoring loop: {ex.Message}");
                    await Task.Delay(5000); // Wait before retry
                }
            }
        }

        private string GenerateAgentId() {
            string pcName = Environment.MachineName;
            string machineId = GetMachineId();
            return $"{pcName}_{machineId}".ToLower();
        }

        private string GetMachineId() {
            try {
                var process = Process.Start(new ProcessStartInfo {
                    FileName = "wmic",
                    Arguments = "os get serialnumber",
                    UseShellExecute = false,
                    RedirectStandardOutput = true,
                    CreateNoWindow = true
                });
                process.WaitForExit();
                string output = process.StandardOutput.ReadToEnd();
                var lines = output.Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
                if (lines.Length > 1) {
                    return lines[1].Trim().Substring(0, Math.Min(8, lines[1].Trim().Length)).GetHashCode().ToString();
                }
            } catch { }
            
            return Guid.NewGuid().ToString("N").Substring(0, 8);
        }

        private string GetLocalIPAddress() {
            try {
                var hostname = System.Net.Dns.GetHostName();
                var addresses = System.Net.Dns.GetHostAddresses(hostname);
                var ipv4 = addresses.FirstOrDefault(a => a.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork);
                return ipv4?.ToString() ?? "127.0.0.1";
            } catch {
                return "127.0.0.1";
            }
        }

        private string GetOsInfo() {
            try {
                return System.Runtime.InteropServices.RuntimeInformation.OSDescription;
            } catch {
                return "Windows";
            }
        }
    }
}