using File_Watcher.Models;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Text.Json;
using System.Text.Json.Serialization;

namespace File_Watcher.Helpers;

internal static partial class DiskInfoHelper
{

    public record DiskDrive(string? Caption,
                            string? DeviceID,
                            string? FirmwareRevision,
                            uint? Index,
                            string? Model,
                            string? Name,
                            uint? Partitions,
                            DiskPartition[]? PartitionCollection,
                            string? SerialNumber,
                            ulong? Size,
                            string? Status,
                            string? SystemName,
                            ulong? TotalCylinders,
                            ulong? TotalHeads)
    {

        internal static DiskDrive Get(DiskDrive diskDrive, DiskPartition[] diskPartitions, LogicalDrive[] logicalDrives)
        {
            DiskDrive result;
            DiskPartition[] collection = DiskPartition.Get((from l in diskPartitions where l.DiskIndex == diskDrive.Index select l).ToArray(), logicalDrives);
            result = new(Caption: diskDrive.Caption,
                         DeviceID: diskDrive.DeviceID,
                         FirmwareRevision: diskDrive.FirmwareRevision,
                         Index: diskDrive.Index,
                         Model: diskDrive.Model,
                         Name: diskDrive.Name,
                         Partitions: diskDrive.Partitions,
                         PartitionCollection: collection,
                         SerialNumber: diskDrive.SerialNumber,
                         Size: diskDrive.Size,
                         Status: diskDrive.Status,
                         SystemName: diskDrive.SystemName,
                         TotalCylinders: diskDrive.TotalCylinders,
                         TotalHeads: diskDrive.TotalHeads);
            return result;
        }

    }

    [JsonSourceGenerationOptions(WriteIndented = true)]
    [JsonSerializable(typeof(DiskDrive[]))]
    private partial class DiskDriveArraySourceGenerationContext : JsonSerializerContext
    {
    }

    [JsonSourceGenerationOptions(WriteIndented = true)]
    [JsonSerializable(typeof(Dictionary<string, object>))]
    private partial class DictionaryStringObjectSourceGenerationContext : JsonSerializerContext
    {
    }

    [JsonSourceGenerationOptions(WriteIndented = true)]
    [JsonSerializable(typeof(JsonElement))]
    private partial class JsonElementSourceGenerationContext : JsonSerializerContext
    {
    }

    public record DiskPartition(bool? BootPartition,
                                string? Caption,
                                string? Description,
                                string? DeviceID,
                                uint? DiskIndex,
                                uint? Index,
                                LogicalDrive[]? LogicalDrives,
                                ulong? Size,
                                ulong? StartingOffset,
                                string? SystemName,
                                string? Type)
    {

        internal static DiskPartition[] Get(DiskPartition[] diskPartitions, LogicalDrive[] logicalDrives)
        {
            List<DiskPartition> results = [];
            ulong lowerMatch;
            ulong upperMatch;
            LogicalDrive[] collection;
            DiskPartition diskPartition;
            foreach (DiskPartition p in diskPartitions)
            {
                if (p.Size is null)
                    continue;
                lowerMatch = p.Size.Value - 10240;
                upperMatch = p.Size.Value + 10240;
                collection = (from l in logicalDrives where l.DriveType != 4 && l.Size > lowerMatch && l.Size < upperMatch select l).ToArray();
                diskPartition = new(BootPartition: p.BootPartition,
                                    Caption: p.Caption,
                                    Description: p.Description,
                                    DeviceID: p.DeviceID,
                                    DiskIndex: p.DiskIndex,
                                    Index: p.Index,
                                    LogicalDrives: collection,
                                    Size: p.Size,
                                    StartingOffset: p.StartingOffset,
                                    SystemName: p.SystemName,
                                    Type: p.Type);
                results.Add(diskPartition);
            }
            return results.ToArray();
        }

    }

    [JsonSourceGenerationOptions(WriteIndented = true)]
    [JsonSerializable(typeof(DiskPartition[]))]
    private partial class DiskPartitionSourceGenerationContext : JsonSerializerContext
    {
    }

    public record LogicalDrive(string? Caption,
                               string? DeviceID,
                               uint? DriveType,
                               string? FileSystem,
                               ulong? FreeSpace,
                               string? Name,
                               ulong? PercentageFree,
                               ulong? PercentageUsed,
                               string? ProviderName,
                               ulong? Size,
                               string? SystemName,
                               string? VolumeName,
                               string? VolumeSerialNumber);

    [JsonSourceGenerationOptions(WriteIndented = true)]
    [JsonSerializable(typeof(LogicalDrive[]))]
    private partial class LogicalDriveSourceGenerationContext : JsonSerializerContext
    {
    }

    public record Record(long AvailableFreeSpace,
                         string DriveFormat,
                         string DriveType,
                         bool IsReady,
                         char Name,
                         ulong PercentageFree,
                         ulong PercentageUsed,
                         long TotalFreeSpace,
                         long TotalSize,
                         string VolumeLabel)
    {

        public static Record Get(DriveInfo driveInfo) =>
            new(AvailableFreeSpace: driveInfo.AvailableFreeSpace,
                DriveFormat: driveInfo.DriveFormat,
                DriveType: driveInfo.DriveType.ToString(),
                IsReady: driveInfo.IsReady,
                Name: driveInfo.Name.ToUpper()[0],
                PercentageUsed: (ulong)(Math.Round(driveInfo.AvailableFreeSpace / (double)driveInfo.TotalSize, 2) * 100),
                PercentageFree: (ulong)(Math.Round((driveInfo.TotalSize - driveInfo.AvailableFreeSpace) / (double)driveInfo.TotalSize, 2) * 100),
                TotalFreeSpace: driveInfo.TotalFreeSpace,
                TotalSize: driveInfo.TotalSize,
                VolumeLabel: driveInfo.VolumeLabel);
    }

    [JsonSourceGenerationOptions(WriteIndented = true)]
    [JsonSerializable(typeof(Record[]))]
    private partial class RecordSourceGenerationContext : JsonSerializerContext
    {
    }

    private record Win32(string? DiskDrive,
                         string? Processor,
                         string? LogicalDisk,
                         string? DiskPartition,
                         string? NetworkAdapter);

    internal static bool WriteDiskInfo(AppSettings appSettings, ILogger<Worker> logger)
    {
        string? json = WriteRecord();
        ReadOnlyCollection<DiskDrive> devices = GetDrives(appSettings, logger);
        string yaml = GetYetAnotherMarkupLanguage(devices);
        ReadOnlyCollection<string> normalized = GetNormalized(appSettings, logger, devices);
        string text = string.Join(Environment.NewLine, normalized);
        string markdown = string.Concat("# ",
                                        Environment.MachineName.ToUpper(),
                                        Environment.NewLine,
                                        Environment.NewLine,
                                        "## Normalized",
                                        Environment.NewLine,
                                        Environment.NewLine,
                                        "```log",
                                        Environment.NewLine,
                                        text,
                                        Environment.NewLine,
                                        "```",
                                        Environment.NewLine,
                                        Environment.NewLine,
                                        "## json",
                                        Environment.NewLine,
                                        Environment.NewLine,
                                        "```json",
                                        Environment.NewLine,
                                        json,
                                        Environment.NewLine,
                                        "```",
                                        Environment.NewLine,
                                        Environment.NewLine,
                                        "## yaml",
                                        Environment.NewLine,
                                        Environment.NewLine,
                                        "```yaml",
                                        Environment.NewLine,
                                        yaml,
                                        Environment.NewLine,
                                        "```",
                                        Environment.NewLine);
        WriteAllText(Path.Combine(appSettings.DiskInfoConfiguration.Destination, $"{Environment.MachineName.ToUpper()}.md"), markdown);
        return true;
    }

    private static string WriteRecord()
    {
        string result;
        Record record;
        List<Record> records = [];
        DriveInfo[] drives = DriveInfo.GetDrives();
        foreach (DriveInfo driveInfo in drives)
        {
            record = Record.Get(driveInfo);
            records.Add(record);
        }
        result = JsonSerializer.Serialize(records.ToArray(), RecordSourceGenerationContext.Default.RecordArray);
        return result;
    }

    private static ReadOnlyCollection<DiskDrive> GetDrives(AppSettings appSettings, ILogger<Worker> logger)
    {
#pragma warning disable CA1416
        List<DiskDrive> results = [];
        Win32 win32 = GetWin32(appSettings, logger);
        if (win32.DiskDrive is not null && win32.DiskPartition is not null && win32.LogicalDisk is not null)
        {
            DiskDrive diskDrive;
            string diskDriveJson = win32.DiskDrive[0] == '[' ? win32.DiskDrive : $"[{win32.DiskDrive}]";
            string logicalDiskJson = win32.LogicalDisk[0] == '[' ? win32.LogicalDisk : $"[{win32.LogicalDisk}]";
            string diskPartitionJson = win32.DiskPartition[0] == '[' ? win32.DiskPartition : $"[{win32.DiskPartition}]";
            DiskDrive[] diskDrives = JsonSerializer.Deserialize(diskDriveJson, DiskDriveArraySourceGenerationContext.Default.DiskDriveArray) ??
                throw new NullReferenceException(nameof(DiskDrive));
            LogicalDrive[] logicalDrives = JsonSerializer.Deserialize(logicalDiskJson, LogicalDriveSourceGenerationContext.Default.LogicalDriveArray) ??
                throw new NullReferenceException(nameof(LogicalDrive));
            DiskPartition[] diskPartitions = JsonSerializer.Deserialize(diskPartitionJson, DiskPartitionSourceGenerationContext.Default.DiskPartitionArray) ??
                throw new NullReferenceException(nameof(DiskPartition));
            foreach (DiskDrive d in diskDrives)
            {
                diskDrive = DiskDrive.Get(d, diskPartitions, logicalDrives);
                results.Add(diskDrive);
            }
        }
        return results.AsReadOnly();
#pragma warning restore
    }

    private static Win32 GetWin32(AppSettings appSettings, ILogger<Worker> logger)
    {
        Win32 win32;
        Process? process;
        string[] segments;
        string standardError;
        string standardOutput;
        string? diskDrive = null;
        string? processor = null;
        string? logicalDisk = null;
        string? diskPartition = null;
        string? networkAdapter = null;
        ProcessStartInfo processStartInfo;
        string fileName = "powershell.exe";
        string date = DateTime.Now.ToString("yyyy-MM-dd");
        foreach (string className in appSettings.DiskInfoConfiguration.Classes)
        {
            segments = className.Split(' ');
            if (segments[0].Length < 3)
                continue;
            processStartInfo = new(fileName, $"-NoProfile -ExecutionPolicy ByPass Get-WmiObject {className} | ConvertTo-JSON")
            {
                RedirectStandardError = true,
                RedirectStandardOutput = true,
                UseShellExecute = false
            };
            try
            {
                process = Process.Start(processStartInfo);
                if (process is not null)
                {
                    for (int j = 1; j < 45; j++)
                    {
                        _ = process.WaitForExit(1000);
                        if (process.HasExited)
                            break;
                    }
                    if (!process.HasExited)
                    {
                        logger.LogWarning($"// {segments[0]} Never exited!");
                        if (segments[0] is "Win32_DiskDrive" or "Win32_DiskPartition" or "Win32_LogicalDisk")
                            break;
                    }
                    else
                    {
                        standardError = process.StandardError.ReadToEnd();
                        standardOutput = process.StandardOutput.ReadToEnd();
                        logger.LogInformation("// {className}{line}{error}{line}{line}// {output}", segments[0], Environment.NewLine, standardError, Environment.NewLine, Environment.NewLine, standardOutput);
                        if (string.IsNullOrEmpty(standardError))
                        {
                            if (segments[0] == "Win32_DiskDrive")
                                diskDrive = standardOutput;
                            else if (segments[0] == "Win32_DiskPartition")
                                diskPartition = standardOutput;
                            else if (segments[0] == "Win32_LogicalDisk")
                                logicalDisk = standardOutput;
                            else if (segments[0] == "Win32_NetworkAdapter")
                                networkAdapter = standardOutput;
                            else if (segments[0] == "Win32_Processor")
                                processor = standardOutput;
                            WriteAllText(Path.Combine(appSettings.DiskInfoConfiguration.Destination, $"{Environment.MachineName.ToUpper()}-{segments[0]}-{date}.json"), standardOutput);
                        }
                    }
                }
                process?.Dispose();
            }
            catch (Exception ex)
            {
                logger.LogError(ex, "Error:");
            }
        }
        win32 = new(DiskDrive: diskDrive,
                    Processor: processor,
                    LogicalDisk: logicalDisk,
                    DiskPartition: diskPartition,
                    NetworkAdapter: networkAdapter);
        return win32;
    }

    public static Dictionary<string, object> DeserializeAndFlatten(string json, char? remove)
    {
        Dictionary<string, object> results = [];
        JsonElement jsonElement = JsonSerializer.Deserialize(json, JsonElementSourceGenerationContext.Default.JsonElement);
        FillDictionaryFromJToken(results, jsonElement, string.Empty, remove);
        return results;
    }

    private static void FillDictionaryFromJToken(Dictionary<string, object> results, JsonElement jsonElement, string prefix, char? remove)
    {
        switch (jsonElement.ValueKind)
        {
            case JsonValueKind.Object:
                foreach (JsonProperty jsonProperty in jsonElement.EnumerateObject())
                {
                    FillDictionaryFromJToken(results, jsonProperty.Value, Join(prefix, jsonProperty.Name), remove);
                }
                break;

            case JsonValueKind.Array:
                int index = 0;
                foreach (JsonElement value in jsonElement.EnumerateArray())
                {
                    FillDictionaryFromJToken(results, value, Join(prefix, index.ToString()), remove);
                    index++;
                }
                break;

            case JsonValueKind.String:
                if (remove is null)
                {
                    results.Add(prefix, jsonElement.ToString());
                }
                else
                {
                    results.Add(prefix, jsonElement.ToString().Replace(remove.Value, '_'));
                }
                break;

            case JsonValueKind.True:
            case JsonValueKind.False:
            case JsonValueKind.Number:
                results.Add(prefix, jsonElement.ToString());
                break;
        }
    }

    private static string Join(string prefix, string name) =>
        string.IsNullOrEmpty(prefix) ? name : prefix + "." + name;

    private static string GetYetAnotherMarkupLanguage(ReadOnlyCollection<DiskDrive> devices)
    {
        string result;
        List<string> results = [];
        string json = JsonSerializer.Serialize(devices.ToArray(), DiskDriveArraySourceGenerationContext.Default.DiskDriveArray);
        Dictionary<string, object> keyValuePairs = DeserializeAndFlatten(json, ':');
        string[] lines = JsonSerializer.Serialize(keyValuePairs, DictionaryStringObjectSourceGenerationContext.Default.DictionaryStringObject).Split(Environment.NewLine);
        for (int i = 1; i < lines.Length - 1; i++)
        {
            results.Add(lines[i].Trim()
                .Trim(',')
                .Trim('"')
                .Replace("\": \"", ": ")
                .Replace("\": ", ": "));
        }
        result = string.Join(Environment.NewLine, results);
        return result;
    }

    private static string GetSizeWithSuffix(ulong value)
    {
        string result;
        int i = 0;
        double displayValue = value * 1f;
        string[] SizeSuffixes = ["bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
        while (Math.Round(displayValue / 1024f) >= 1)
        {
            displayValue /= 1024;
            i++;
        }
        result = string.Format("{0:n1} {1}", displayValue, SizeSuffixes[i]);
        return result;
    }

    private static void WriteAllText(string path, string text)
    {
        string check = !File.Exists(path) ? string.Empty : File.ReadAllText(path);
        if (check != text)
            File.WriteAllText(path, text);
    }

    private static ReadOnlyCollection<string> GetNormalized(AppSettings appSettings, ILogger<Worker> logger, ReadOnlyCollection<DiskDrive> drives)
    {
        List<string> results = [];
        decimal free;
        decimal used;
        string display;
        int deviceCount;
        int offsetCount;
        string deviceSize;
        int partitionCount;
        results.Add("Max");
        string offsetDisplay;
        string partitionSize;
        decimal devicePercent;
        string logicalDriveUsed;
        string logicalDriveSize;
        decimal partitionPercent;
        int logicalDriveFreeCount;
        int logicalDriveUsedCount;
        decimal partitionDecimalSize;
        string logicalDriveFreeSpace;
        decimal logicalDriveDecimalFreeSpace;
        DiskInfoConfiguration diskInfoConfiguration = appSettings.DiskInfoConfiguration;
        results.Add($"{new string('-', diskInfoConfiguration.Bars)} Value of Max Argument");
        foreach (DiskDrive drive in drives.OrderBy(l => l.Index))
        {
            if (drive.Size is null || drive.PartitionCollection is null)
                continue;
            devicePercent = drive.Size.Value / diskInfoConfiguration.Max;
            deviceSize = GetSizeWithSuffix(drive.Size.Value);
            results.Add($"{drive.DeviceID} - Cylinders: {drive.TotalCylinders} - {drive.Model}");
            deviceCount = (int)Math.Round(devicePercent * diskInfoConfiguration.Bars);
            results.Add($"{new string('-', deviceCount)} {Math.Round(devicePercent, 2) * 100:000}% of Max Argument {deviceSize}");
            foreach (DiskPartition partition in drive.PartitionCollection.OrderBy(l => l.Index))
            {
                if (partition.Size is null || partition.StartingOffset is null || partition.LogicalDrives is null)
                    continue;
                partitionPercent = partition.Size.Value / diskInfoConfiguration.Max;
                partitionSize = GetSizeWithSuffix(partition.Size.Value);
                partitionCount = (int)Math.Round(partitionPercent * diskInfoConfiguration.Bars);
                offsetCount = (int)Math.Round(partition.StartingOffset.Value / diskInfoConfiguration.Max * diskInfoConfiguration.Bars);
                offsetDisplay = new string('_', offsetCount);
                results.Add($"{partition.DeviceID} - {string.Join(", ", partition.LogicalDrives.Select(l => l.DeviceID))}");
                results.Add($"{offsetDisplay}{new string('-', partitionCount)}{new string('_', diskInfoConfiguration.Bars - offsetCount - partitionCount)} {Math.Round(partitionPercent, 2) * 100:000}% of Disk {partitionSize}");
                foreach (LogicalDrive logicalDrive in partition.LogicalDrives)
                {
                    if (logicalDrive.Size is null || logicalDrive.FreeSpace is null)
                        continue;
                    if ((int)Math.Round(logicalDrive.Size.Value / diskInfoConfiguration.Max * diskInfoConfiguration.Bars) != (int)Math.Round(partition.Size.Value / diskInfoConfiguration.Max * diskInfoConfiguration.Bars))
                    {
                        logger.LogWarning("logicalDrive.Size !~ partition.Size");
                        break;
                    }
                    partitionDecimalSize = partition.Size.Value;
                    logicalDriveDecimalFreeSpace = logicalDrive.FreeSpace.Value;
                    logicalDriveSize = GetSizeWithSuffix(logicalDrive.Size.Value);
                    logicalDriveFreeSpace = GetSizeWithSuffix(logicalDrive.FreeSpace.Value);
                    logicalDriveUsed = GetSizeWithSuffix(logicalDrive.Size.Value - logicalDrive.FreeSpace.Value);
                    logicalDriveFreeCount = (int)Math.Round(logicalDriveDecimalFreeSpace / diskInfoConfiguration.Max * diskInfoConfiguration.Bars);
                    display = string.IsNullOrEmpty(logicalDrive.DeviceID) ? "Partition" : logicalDrive.DeviceID;
                    logicalDriveUsedCount = (int)Math.Round((partitionDecimalSize - logicalDriveDecimalFreeSpace) / diskInfoConfiguration.Max * diskInfoConfiguration.Bars);
                    free = (int)(Math.Round(logicalDriveDecimalFreeSpace / partitionDecimalSize, 2) * 100);
                    used = (int)(Math.Round((partitionDecimalSize - logicalDriveDecimalFreeSpace) / partitionDecimalSize, 2) * 100);
                    results.Add($"{offsetDisplay}{new string('-', logicalDriveUsedCount)}{new string('*', logicalDriveFreeCount)}{new string('_', diskInfoConfiguration.Bars - offsetCount - logicalDriveUsedCount - logicalDriveFreeCount)} {used:000}% of [{display}] {logicalDriveUsed} ({free:000}% {logicalDriveFreeSpace} free)");
                }
            }
        }
        return results.AsReadOnly();
    }

}