using System.Text.Json;
using System.Text.Json.Serialization;

using Microsoft.Extensions.Logging;

namespace File_Folder_Helper.ADO2025.PI6;

internal static partial class Helper20250701 {

    [JsonSourceGenerationOptions(WriteIndented = true, DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull)]
    [JsonSerializable(typeof(JsonElement))]
    internal partial class JsonElementSourceGenerationContext : JsonSerializerContext {
    }

    internal static void ProcessDataStandardFormatToJavaScriptObjectNotation(ILogger<Worker> logger, List<string> args) {
        logger.LogInformation(args[0]);
        logger.LogInformation(args[1]);
        logger.LogInformation(args[2]);
        string searchPattern = args[2];
        int sizeFilter = int.Parse(args[3]);
        string sourceDirectory = Path.GetFullPath(args[0].Split('~')[0]);
        string destinationDirectory = Path.GetFullPath(args[4].Split('~')[0]);
        string[] directories = Directory.GetDirectories(sourceDirectory, "*", SearchOption.TopDirectoryOnly);
        WriteJavaScriptObjectNotation(logger, directories, searchPattern, sizeFilter, destinationDirectory);
    }

    private static void WriteJavaScriptObjectNotation(ILogger<Worker> logger, string[] directories, string searchPattern, int sizeFilter, string destinationDirectory) {
        string? json;
        string[] files;
        string markdown;
        string checkFile;
        FileInfo fileInfo;
        string? pipeTable;
        string directoryName;
        string checkDirectory;
        string fileNameWithoutExtension;
        foreach (string directory in directories) {
            files = Directory.GetFiles(directory, searchPattern, SearchOption.AllDirectories);
            foreach (string file in files) {
                fileInfo = new(file);
                if (fileInfo.LastWriteTime > DateTime.Now.AddSeconds(-2)) {
                    continue;
                }
                directoryName = Path.GetFileName(fileInfo.DirectoryName);
                if (fileInfo.Length > sizeFilter && !directoryName.StartsWith('Z')) {
                    checkDirectory = Path.Combine(destinationDirectory, $"Z{directoryName}-Big");
                    if (!Directory.Exists(checkDirectory)) {
                        _ = Directory.CreateDirectory(checkDirectory);
                    }
                    checkFile = Path.Combine(checkDirectory, fileInfo.Name);
                    if (File.Exists(checkFile)) {
                        continue;
                    }
                    File.Move(file, checkFile);
                    continue;
                }
                fileNameWithoutExtension = Path.GetFileNameWithoutExtension(file);
                checkDirectory = Path.Combine(destinationDirectory, directoryName);
                if (!Directory.Exists(checkDirectory)) {
                    _ = Directory.CreateDirectory(checkDirectory);
                }
                checkFile = Path.Combine(checkDirectory, $"{fileNameWithoutExtension}.json");
                if (File.Exists(checkFile)) {
                    continue;
                }
                json = GetJavaScriptObjectNotation(logger, file);
                if (string.IsNullOrEmpty(json)) {
                    logger.LogWarning("json is null");
                    continue;
                }
                pipeTable = GetPipeTable(logger, json);
                if (string.IsNullOrEmpty(pipeTable)) {
                    logger.LogWarning("pipeTable is null");
                    continue;
                }
                markdown = $"# {fileNameWithoutExtension}{Environment.NewLine}{Environment.NewLine}{pipeTable}{Environment.NewLine}";
                File.WriteAllText(checkFile, json);
                File.WriteAllText($"{checkFile}.md", markdown);
                logger.LogInformation("<{checkFile}> was written", checkFile);
            }
        }
    }

    private static string? GetJavaScriptObjectNotation(ILogger<Worker> logger, string file) {
        string? result = null;
        string[] lines = File.ReadAllLines(file);
        int? columnTitlesLine = GetProcessDataStandardFormatColumnTitlesLine(lines);
        if (columnTitlesLine is null) {
            logger.LogWarning("<{columnTitlesLine}> is null", nameof(columnTitlesLine));
        } else {
            if (lines.Length < columnTitlesLine.Value + 1) {
                logger.LogWarning("<{lines}>(s)", lines.Length);
            } else {
                result = GetJavaScriptObjectNotation(columnTitlesLine.Value, [], lines);
            }
        }
        return result;
    }

    private static int? GetProcessDataStandardFormatColumnTitlesLine(string[] lines) {
        int? result = null;
        for (int i = 0; i < lines.Length; i++) {
            if (lines[i].StartsWith("END_OFFSET") && i + 3 < lines.Length) {
                result = i + 1;
                break;
            }
        }
        return result;
    }

    private static string GetJavaScriptObjectNotation(int columnTitlesLine, string[] columns, string[] lines) {
#pragma warning disable CA1845, IDE0057
        string result = "[\n";
        string line;
        string value;
        string[] segments;
        if (columns.Length == 0) {
            columns = lines[columnTitlesLine].Split('\t');
        }
        for (int i = columnTitlesLine + 1; i < lines.Length; i++) {
            if (lines[i].StartsWith("NUM_DATA_ROWS"))
                break;
            line = "{";
            segments = lines[i].Split('\t');
            if (segments.Length > columns.Length) {
                continue;
            }
            for (int c = 0; c < segments.Length; c++) {
                value = segments[c].Replace("\\", "\\\\").Replace("\"", "\\\"");
                line += '"' + columns[c].Trim('"') + '"' + ':' + '"' + value + '"' + ',';
            }
            line = line.Substring(0, line.Length - 1) + '}' + ',' + '\n';
            result += line;
        }
        result = result.Substring(0, result.Length - 2) + ']';
        return result;
#pragma warning restore CA1845, IDE0057
    }

    private static string? GetPipeTable(ILogger<Worker> logger, string json) {
        string? result = null;
        string? value;
        string[]? columns = null;
        List<string> values = [];
        List<string> results = [];
        Dictionary<string, string> keyValuePairs = [];
        JsonElement jsonElement = JsonSerializer.Deserialize(json, JsonElementSourceGenerationContext.Default.JsonElement);
        JsonElement[] jsonElements = jsonElement.EnumerateArray().ToArray();
        foreach (JsonElement j in jsonElements) {
            values.Clear();
            keyValuePairs.Clear();
            foreach (JsonProperty jsonProperty in j.EnumerateObject().ToArray()) {
                if (columns is null) {
                    JsonProperty[] jsonProperties = j.EnumerateObject().OrderBy(l => l.Name).ToArray();
                    columns = jsonProperties.Select(l => l.Name).ToArray();
                    results.Add($"|{string.Join('|', columns)}|");
                    results.Add($"|{string.Join('|', columns.Select(l => '-'))}|");
                }
                keyValuePairs.Add(jsonProperty.Name, jsonProperty.Value.ToString());
            }
            foreach (string column in columns) {
                if (!keyValuePairs.TryGetValue(column, out value)) {
                    values.Add(new string(' ', column.Length));
                } else {
                    values.Add(value.PadLeft(column.Length, ' '));
                }
            }
            results.Add($"|{string.Join('|', values)}|");
        }
        if (results.Count > 0)
            result = string.Join(Environment.NewLine, results);
        return result;
    }
}