using AmtScanner.Api.Data;
using AmtScanner.Api.Models;
using Intel.Management.Wsman;
using Microsoft.EntityFrameworkCore;
using System.Collections.Concurrent;
using System.Net;
using System.Net.Sockets;
using System.Net.Security;
using System.Security;
using System.Security.Cryptography.X509Certificates;

namespace AmtScanner.Api.Services;

public class AmtScannerService : IAmtScannerService
{
    private readonly IServiceScopeFactory _scopeFactory;
    private readonly ILogger<AmtScannerService> _logger;
    private readonly IConfiguration _configuration;
    private readonly ConcurrentDictionary<string, CancellationTokenSource> _cancellationTokens = new();
    
    public AmtScannerService(
        IServiceScopeFactory scopeFactory,
        ILogger<AmtScannerService> logger,
        IConfiguration configuration)
    {
        _scopeFactory = scopeFactory;
        _logger = logger;
        _configuration = configuration;
    }
    
    public async Task<List<AmtDevice>> ScanNetworkAsync(
        string taskId,
        string networkSegment,
        string subnetMask,
        IProgress<ScanProgress> progress,
        CancellationToken cancellationToken = default)
    {
        _logger.LogInformation("Starting network scan for task: {TaskId}", taskId);
        
        var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
        _cancellationTokens[taskId] = cts;
        
        try
        {
            var ipList = CalculateIpRange(networkSegment, subnetMask);
            _logger.LogInformation("Calculated {Count} IP addresses to scan", ipList.Count);
            
            var foundDevices = new ConcurrentBag<AmtDevice>();
            int scannedCount = 0;
            int foundCount = 0;
            
            var threadPoolSize = _configuration.GetValue<int>("Scanner:ThreadPoolSize", 100);
            var parallelOptions = new ParallelOptions
            {
                MaxDegreeOfParallelism = threadPoolSize,
                CancellationToken = cts.Token
            };
            
            await Parallel.ForEachAsync(ipList, parallelOptions, async (ip, ct) =>
            {
                try
                {
                    var device = await ScanSingleDeviceAsync(ip, ct);
                    
                    var scanned = Interlocked.Increment(ref scannedCount);
                    
                    if (device != null)
                    {
                        foundDevices.Add(device);
                        var found = Interlocked.Increment(ref foundCount);
                        
                        // Save to database
                        await SaveDeviceAsync(device);
                        
                        progress.Report(new ScanProgress
                        {
                            TaskId = taskId,
                            ScannedCount = scanned,
                            TotalCount = ipList.Count,
                            FoundDevices = found,
                            ProgressPercentage = (double)scanned / ipList.Count * 100,
                            CurrentIp = ip,
                            LatestDevice = device
                        });
                    }
                    else
                    {
                        progress.Report(new ScanProgress
                        {
                            TaskId = taskId,
                            ScannedCount = scanned,
                            TotalCount = ipList.Count,
                            FoundDevices = foundCount,
                            ProgressPercentage = (double)scanned / ipList.Count * 100,
                            CurrentIp = ip
                        });
                    }
                }
                catch (Exception ex)
                {
                    _logger.LogError(ex, "Error scanning {Ip}", ip);
                }
            });
            
            _logger.LogInformation("Scan completed for task: {TaskId}. Found {Count} devices", taskId, foundDevices.Count);
            return foundDevices.ToList();
        }
        finally
        {
            _cancellationTokens.TryRemove(taskId, out _);
            cts.Dispose();
        }
    }
    
    public void CancelScan(string taskId)
    {
        if (_cancellationTokens.TryGetValue(taskId, out var cts))
        {
            cts.Cancel();
            _logger.LogInformation("Scan task {TaskId} cancelled", taskId);
        }
    }
    
    private async Task<AmtDevice?> ScanSingleDeviceAsync(string ip, CancellationToken cancellationToken)
    {
        // Check if AMT ports are open
        var openPorts = await GetOpenAmtPortsAsync(ip, cancellationToken);
        
        if (openPorts.Count == 0)
        {
            return null;
        }
        
        _logger.LogInformation("Found AMT device at {Ip} with ports: {Ports}", ip, string.Join(", ", openPorts));
        
        // Get credential in a separate scope to avoid DbContext disposal issues
        AmtCredential? credential = null;
        string? decryptedPassword = null;
        
        using (var credScope = _scopeFactory.CreateScope())
        {
            var credentialService = credScope.ServiceProvider.GetRequiredService<ICredentialService>();
            credential = await credentialService.GetDefaultCredentialAsync();
            
            if (credential != null)
            {
                decryptedPassword = credentialService.DecryptPassword(credential.Password);
            }
        }
        
        // Try to get device info using Intel SDK
        if (credential != null && decryptedPassword != null)
        {
            try
            {
                var device = await GetAmtInfoUsingSDK(ip, credential.Username, decryptedPassword, openPorts);
                if (device != null)
                {
                    // Save to database using a new scope
                    await SaveDeviceAsync(device);
                    return device;
                }
            }
            catch (Exception ex)
            {
                _logger.LogWarning(ex, "Failed to get AMT info for {Ip} using SDK", ip);
            }
        }
        
        // Fallback: create device with basic info
        var fallbackDevice = new AmtDevice
        {
            IpAddress = ip,
            MajorVersion = 0,
            MinorVersion = 0,
            ProvisioningState = ProvisioningState.UNKNOWN,
            Description = openPorts.Contains(16993) && !openPorts.Contains(16992) 
                ? $"AMT device detected (HTTPS only). Open ports: {string.Join(", ", openPorts)}. Unable to query details via HTTPS."
                : $"Detected via port scan. Open ports: {string.Join(", ", openPorts)}",
            AmtOnline = true,
            OsOnline = false,
            DiscoveredAt = DateTime.UtcNow,
            LastSeenAt = DateTime.UtcNow
        };
        
        await SaveDeviceAsync(fallbackDevice);
        return fallbackDevice;
    }
    
    private async Task<AmtDevice?> GetAmtInfoUsingSDK(string ip, string username, string password, List<int> openPorts)
    {
        try
        {
            // Determine which protocol and port to use
            string protocol;
            int port;
            
            if (openPorts.Contains(16992))
            {
                // Prefer HTTP if available (faster, no cert issues)
                protocol = "http";
                port = 16992;
            }
            else if (openPorts.Contains(16993))
            {
                // Use HTTPS if only that is available
                protocol = "https";
                port = 16993;
            }
            else
            {
                _logger.LogWarning("No suitable AMT port found for {Ip}. Open ports: {Ports}", ip, string.Join(", ", openPorts));
                return null;
            }
            
            _logger.LogInformation("Connecting to AMT device at {Ip} using {Protocol}://{Ip}:{Port} with username: {Username}", 
                ip, protocol, ip, port, username);
            
            // Convert password to SecureString
            var securePassword = new SecureString();
            foreach (char c in password)
            {
                securePassword.AppendChar(c);
            }
            securePassword.MakeReadOnly();
            
            // Create WS-Management connection using Intel SDK
            var connection = new WsmanConnection();
            connection.Address = $"{protocol}://{ip}:{port}/wsman";
            connection.SetCredentials(username, securePassword);
            
            // Accept self-signed certificates for HTTPS connections
            if (protocol == "https")
            {
                connection.Options.ServerCertificateValidationCallback = (certificate, sslPolicyErrors) =>
                {
                    // If certificate is self-signed, ignore all errors
                    if (certificate.Subject.Equals(certificate.Issuer))
                    {
                        return true;
                    }
                    if (sslPolicyErrors == System.Net.Security.SslPolicyErrors.None)
                    {
                        return true;
                    }
                    return false;
                };
            }
            
            // Get AMT version from CIM_SoftwareIdentity
            string? version = null;
            string? hostname = null;
            int provisioningState = 0;
            
            await Task.Run(() =>
            {
                try
                {
                    // Query AMT version
                    var versionQuery = connection.ExecQuery("SELECT * FROM CIM_SoftwareIdentity WHERE InstanceID='AMT'");
                    foreach (Intel.Management.Wsman.IWsmanItem item in versionQuery)
                    {
                        var versionProp = item.Object.GetProperty("VersionString");
                        if (!versionProp.IsNull)
                        {
                            version = versionProp.ToString();
                            break;
                        }
                    }
                    
                    // Query AMT general settings for hostname and provisioning state
                    var settingsQuery = connection.ExecQuery("SELECT * FROM AMT_GeneralSettings");
                    foreach (Intel.Management.Wsman.IWsmanItem item in settingsQuery)
                    {
                        var hostnameProp = item.Object.GetProperty("HostName");
                        if (!hostnameProp.IsNull)
                        {
                            hostname = hostnameProp.ToString();
                        }
                        break;
                    }
                    
                    // Query provisioning state from AMT_SetupAndConfigurationService
                    var setupQuery = connection.ExecQuery("SELECT * FROM AMT_SetupAndConfigurationService");
                    foreach (Intel.Management.Wsman.IWsmanItem item in setupQuery)
                    {
                        var stateProp = item.Object.GetProperty("ProvisioningState");
                        if (!stateProp.IsNull)
                        {
                            provisioningState = int.Parse(stateProp.ToString());
                        }
                        break;
                    }
                }
                catch (Exception ex)
                {
                    _logger.LogWarning(ex, "Error querying AMT info for {Ip}", ip);
                }
            });
            
            if (version != null)
            {
                _logger.LogInformation("Successfully got AMT info for {Ip}: version={Version}, state={State}", 
                    ip, version, provisioningState);
                
                return new AmtDevice
                {
                    IpAddress = ip,
                    Hostname = hostname ?? ip,
                    MajorVersion = ParseMajorVersion(version),
                    MinorVersion = ParseMinorVersion(version),
                    ProvisioningState = MapProvisioningStateFromInt(provisioningState),
                    Description = $"Detected via WS-Management ({protocol.ToUpper()}). Version: {version}",
                    AmtOnline = true,
                    OsOnline = false,
                    DiscoveredAt = DateTime.UtcNow,
                    LastSeenAt = DateTime.UtcNow
                };
            }
            
            return null;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error getting AMT info for {Ip}", ip);
            return null;
        }
    }
    
    private async Task<List<int>> GetOpenAmtPortsAsync(string ip, CancellationToken cancellationToken)
    {
        var ports = new[] { 16992, 16993, 623 };
        var openPorts = new List<int>();
        var timeout = _configuration.GetValue<int>("Scanner:TimeoutSeconds", 3) * 1000;
        
        foreach (var port in ports)
        {
            if (await IsPortOpenAsync(ip, port, timeout, cancellationToken))
            {
                openPorts.Add(port);
            }
        }
        
        return openPorts;
    }
    
    private async Task<bool> IsPortOpenAsync(string ip, int port, int timeoutMs, CancellationToken cancellationToken)
    {
        try
        {
            using var client = new TcpClient();
            using var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
            cts.CancelAfter(timeoutMs);
            
            await client.ConnectAsync(ip, port, cts.Token);
            return true;
        }
        catch
        {
            return false;
        }
    }
    
    private List<string> CalculateIpRange(string networkSegment, string subnetMask)
    {
        var ipList = new List<string>();
        
        try
        {
            var networkLong = IpToLong(networkSegment);
            var cidr = SubnetMaskToCidr(subnetMask);
            var hostBits = 32 - cidr;
            var totalHosts = (int)Math.Pow(2, hostBits);
            
            for (int i = 1; i < totalHosts - 1; i++)
            {
                var ipLong = networkLong + i;
                ipList.Add(LongToIp(ipLong));
            }
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error calculating IP range");
        }
        
        return ipList;
    }
    
    private long IpToLong(string ipAddress)
    {
        var parts = ipAddress.Split('.');
        long result = 0;
        for (int i = 0; i < 4; i++)
        {
            result = result << 8 | long.Parse(parts[i]);
        }
        return result;
    }
    
    private string LongToIp(long ip)
    {
        return $"{(ip >> 24) & 0xFF}.{(ip >> 16) & 0xFF}.{(ip >> 8) & 0xFF}.{ip & 0xFF}";
    }
    
    private int SubnetMaskToCidr(string subnetMask)
    {
        if (subnetMask.StartsWith("/"))
        {
            return int.Parse(subnetMask.Substring(1));
        }
        
        var parts = subnetMask.Split('.');
        int cidr = 0;
        foreach (var part in parts)
        {
            cidr += Convert.ToString(int.Parse(part), 2).Count(c => c == '1');
        }
        return cidr;
    }
    
    private async Task SaveDeviceAsync(AmtDevice device)
    {
        // Create a new scope for database operation
        using var scope = _scopeFactory.CreateScope();
        var context = scope.ServiceProvider.GetRequiredService<AppDbContext>();
        
        var existing = await context.AmtDevices
            .FirstOrDefaultAsync(d => d.IpAddress == device.IpAddress);
        
        if (existing != null)
        {
            existing.Hostname = device.Hostname;
            existing.MajorVersion = device.MajorVersion;
            existing.MinorVersion = device.MinorVersion;
            existing.ProvisioningState = device.ProvisioningState;
            existing.Description = device.Description;
            existing.AmtOnline = device.AmtOnline;
            existing.LastSeenAt = DateTime.UtcNow;
            
            context.AmtDevices.Update(existing);
        }
        else
        {
            context.AmtDevices.Add(device);
        }
        
        await context.SaveChangesAsync();
    }
    
    private int ParseMajorVersion(string version)
    {
        var parts = version.Split('.');
        return parts.Length > 0 && int.TryParse(parts[0], out var major) ? major : 0;
    }
    
    private int ParseMinorVersion(string version)
    {
        var parts = version.Split('.');
        return parts.Length > 1 && int.TryParse(parts[1], out var minor) ? minor : 0;
    }
    
    private ProvisioningState MapProvisioningState(string state)
    {
        return state?.ToUpper() switch
        {
            "PRE" => ProvisioningState.PRE,
            "IN" => ProvisioningState.IN,
            "POST" => ProvisioningState.POST,
            _ => ProvisioningState.UNKNOWN
        };
    }
    
    private ProvisioningState MapProvisioningStateFromInt(int state)
    {
        return state switch
        {
            0 => ProvisioningState.PRE,
            1 => ProvisioningState.IN,
            2 => ProvisioningState.POST,
            _ => ProvisioningState.UNKNOWN
        };
    }
}