using Adaptation.FileHandlers.json.WorkItems;
using Adaptation.Shared;
using Adaptation.Shared.Duplicator;
using Adaptation.Shared.Methods;
using log4net;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using System.Text.Json;
using System.Text.Json.Serialization;

namespace Adaptation.FileHandlers.Kanban;

public class ProcessData : IProcessData
{

    private readonly List<object> _Details;

    List<object> Shared.Properties.IProcessData.Details => _Details;

    private readonly ILog _Log;

    public ProcessData(IFileRead fileRead, Logistics logistics, string targetFileLocation, string url, List<FileInfo> fileInfoCollection)
    {
        if (fileRead.IsEAFHosted)
        { }
        if (url is null)
            throw new ArgumentNullException(nameof(url));
        fileInfoCollection.Clear();
        _Details = new List<object>();
        _Log = LogManager.GetLogger(typeof(ProcessData));
        WriteFiles(fileRead, logistics, targetFileLocation, fileInfoCollection);
    }

    string IProcessData.GetCurrentReactor(IFileRead fileRead, Logistics logistics, Dictionary<string, string> reactors) =>
        throw new Exception(string.Concat("See ", nameof(WriteFiles)));

    Tuple<string, Test[], JsonElement[], List<FileInfo>> IProcessData.GetResults(IFileRead fileRead, Logistics logistics, List<FileInfo> fileInfoCollection) =>
        new(logistics.Logistics1[0], Array.Empty<Test>(), Array.Empty<JsonElement>(), fileInfoCollection);

#nullable enable

    internal static List<Description> GetDescriptions(JsonElement[] jsonElements)
    {
        List<Description> results = new();
        Description? description;
        JsonSerializerOptions jsonSerializerOptions = new() { NumberHandling = JsonNumberHandling.AllowReadingFromString | JsonNumberHandling.WriteAsString };
        foreach (JsonElement jsonElement in jsonElements)
        {
            if (jsonElement.ValueKind != JsonValueKind.Object)
                throw new Exception();
            description = JsonSerializer.Deserialize<Description>(jsonElement.ToString(), jsonSerializerOptions);
            if (description is null)
                continue;
            results.Add(description);
        }
        return results;
    }

    private void WriteFiles(IFileRead fileRead, Logistics logistics, string destinationDirectory, List<FileInfo> fileInfoCollection)
    {
        bool keepRelations = true;
        const string taskWorkItemType = "Task";
        string json = File.ReadAllText(logistics.ReportFullPath);
        WorkItem[]? workItems = JsonSerializer.Deserialize<WorkItem[]>(json);
        if (workItems is null)
            throw new Exception(nameof(workItems));
        _Details.Add(workItems);
        if (!Directory.Exists(destinationDirectory))
            _ = Directory.CreateDirectory(destinationDirectory);
        ReadOnlyDictionary<int, Record> keyValuePairs = GetWorkItems(workItems, keepRelations);
        ReadOnlyCollection<string> bugUserStoryTaskWorkItemTypes = new(new string[] { "Bug", "User Story", "Task" });
        ReadOnlyDictionary<int, string> collection = MoveCurrentAndGetExpectedDirectories(taskWorkItemType, destinationDirectory, bugUserStoryTaskWorkItemTypes, keyValuePairs);
        WriteFiles(fileRead, fileInfoCollection, taskWorkItemType, destinationDirectory, keyValuePairs, collection);
    }

    private static ReadOnlyDictionary<int, Record> GetWorkItems(WorkItem[] workItems, bool keepRelations)
    {
        ReadOnlyDictionary<int, Record> results;
        Dictionary<int, WorkItem> keyValuePairs = new();
        foreach (WorkItem workItem in workItems)
            keyValuePairs.Add(workItem.Id, workItem);
        results = GetKeyValuePairs(new(keyValuePairs), keepRelations);
        return results;
    }

    private static ReadOnlyDictionary<int, string> MoveCurrentAndGetExpectedDirectories(string taskWorkItemType, string destinationDirectory, ReadOnlyCollection<string> bugUserStoryTaskWorkItemTypes, ReadOnlyDictionary<int, Record> keyValuePairs)
    {
        ReadOnlyDictionary<int, string> results;
        string? directory;
        ReadOnlyDictionary<int, string> collection = GetCurrentDirectories(destinationDirectory, bugUserStoryTaskWorkItemTypes);
        results = GetExpectedDirectories(taskWorkItemType, destinationDirectory, bugUserStoryTaskWorkItemTypes, keyValuePairs);
        foreach (KeyValuePair<int, string> keyValuePair in collection)
        {
            if (!results.TryGetValue(keyValuePair.Key, out directory))
                MoveToUnknown(destinationDirectory, keyValuePair.Key, keyValuePair.Value);
            else
            {
                if (keyValuePair.Value == directory)
                    continue;
                else
                    MoveToNew(destinationDirectory, keyValuePair.Key, keyValuePair.Value, directory);
            }
        }
        return results;
    }

    private static FileInfo GetFileInfoAndMaybeWriteFile(string directory, WorkItem workItem)
    {
        FileInfo result;
        string json;
        json = JsonSerializer.Serialize(workItem, WorkItemSourceGenerationContext.Default.WorkItem);
        string singletonDirectory = Path.Combine(directory, $"{workItem.Id}");
        if (!Directory.Exists(singletonDirectory))
            _ = Directory.CreateDirectory(singletonDirectory);
        result = new(Path.Combine(singletonDirectory, ".json"));
        string old = result.Exists ? File.ReadAllText(result.FullName) : string.Empty;
        if (old != json)
            File.WriteAllText(result.FullName, json);
        return result;
    }

    private static void WriteFiles(IFileRead fileRead, List<FileInfo> fileInfoCollection, string taskWorkItemType, string destinationDirectory, ReadOnlyDictionary<int, Record> keyValuePairs, ReadOnlyDictionary<int, string> collection)
    {
        string? directory;
        FileInfo fileInfo;
        WorkItem workItem;
        Record? parent;
        foreach (KeyValuePair<int, Record> keyValuePair in keyValuePairs)
        {
            workItem = keyValuePair.Value.WorkItem;
            if (!collection.TryGetValue(keyValuePair.Key, out directory))
            {
                if (workItem.WorkItemType != taskWorkItemType || workItem.Parent is not null)
                    continue;
                directory = GetDirectory(destinationDirectory, workItem);
            }
            fileInfo = GetFileInfoAndMaybeWriteFile(directory, workItem);
            if (!fileRead.IsEAFHosted)
                fileInfoCollection.Add(fileInfo);
            if (workItem.WorkItemType != taskWorkItemType && workItem.Parent is not null && keyValuePairs.TryGetValue(workItem.Parent.Value, out parent))
                _ = GetFileInfoAndMaybeWriteFile(Path.Combine(directory, ".parent"), parent.WorkItem);
        }
    }

    private static ReadOnlyDictionary<int, Record> GetKeyValuePairs(ReadOnlyDictionary<int, WorkItem> keyValuePairs, bool keepRelations)
    {
        Dictionary<int, Record> results = new();
        Record record;
        List<bool> nests = new();
        WorkItem? parentWorkItem;
        ReadOnlyCollection<Record> childRecords;
        ReadOnlyCollection<Record> relatedRecords;
        ReadOnlyCollection<Record> successorRecords;
        foreach (KeyValuePair<int, WorkItem> keyValuePair in keyValuePairs)
        {
            nests.Clear();
            if (keyValuePair.Value.Parent is null)
                parentWorkItem = null;
            else
                _ = keyValuePairs.TryGetValue(keyValuePair.Value.Parent.Value, out parentWorkItem);
            try
            {
                childRecords = Record.GetKeyValuePairs(keyValuePairs, keyValuePair.Value, "Child", nests, keepRelations); // Forward
                // records = Record.GetKeyValuePairs(keyValuePairs, keyValuePair.Value, "Predecessor", nests, keepRelations); // Reverse
                relatedRecords = Record.GetKeyValuePairs(keyValuePairs, keyValuePair.Value, "Related", nests, keepRelations); // Related
                successorRecords = Record.GetKeyValuePairs(keyValuePairs, keyValuePair.Value, "Successor", nests, keepRelations); // Forward
                record = Record.Get(keyValuePair.Value, parentWorkItem, childRecords, relatedRecords, successorRecords, keepRelations);
            }
            catch (Exception)
            {
                record = new(keyValuePair.Value, parentWorkItem, Array.Empty<Record>(), Array.Empty<Record>(), Array.Empty<Record>());
            }
            results.Add(keyValuePair.Key, record);
        }
        return new(results);
    }

    private static ReadOnlyDictionary<int, string> GetCurrentDirectories(string destinationDirectory, ReadOnlyCollection<string> bugUserStoryTaskWorkItemTypes)
    {
        Dictionary<int, string> results = new();
        int id;
        string idCheck;
        string? fileName;
        string[] directories;
        string[] split = new string[] { "-" };
        foreach (string w in bugUserStoryTaskWorkItemTypes)
        {
            directories = Directory.GetDirectories(destinationDirectory, $"*-{w.Replace(" ", "-")}", SearchOption.AllDirectories);
            foreach (string directory in directories)
            {
                fileName = Path.GetFileName(directory);
                if (string.IsNullOrEmpty(fileName))
                    continue;
                idCheck = fileName.Split(split, StringSplitOptions.None)[0];
                if (!int.TryParse(idCheck, out id))
                    continue;
                if (!results.ContainsKey(id))
                    results.Add(id, directory);
                else
                    MoveToDuplicate(destinationDirectory, directory);
            }
        }
        return new(results);
    }

    private static ReadOnlyDictionary<int, string> GetExpectedDirectories(string taskWorkItemType, string destinationDirectory, ReadOnlyCollection<string> bugUserStoryTaskWorkItemTypes, ReadOnlyDictionary<int, Record> keyValuePairs)
    {
        Dictionary<int, string> results = new();
        string directory;
        WorkItem workItem;
        foreach (KeyValuePair<int, Record> keyValuePair in keyValuePairs)
        {
            workItem = keyValuePair.Value.WorkItem;
            if (!bugUserStoryTaskWorkItemTypes.Contains(workItem.WorkItemType))
                continue;
            if (workItem.WorkItemType == taskWorkItemType && workItem.Parent is not null)
                continue;
            directory = GetDirectory(destinationDirectory, workItem);
            results.Add(workItem.Id, directory);
        }
        return new(results);
    }

    private static void MoveToUnknown(string destinationDirectory, int id, string directory)
    {
        if (string.IsNullOrEmpty(destinationDirectory))
            throw new ArgumentException($"'{nameof(destinationDirectory)}' {id} cannot be null or empty.", nameof(destinationDirectory));
        if (string.IsNullOrEmpty(directory))
            throw new ArgumentException($"'{nameof(directory)}' cannot be null or empty.", nameof(directory));
    }

    private static void MoveToNew(string destinationDirectory, int id, string oldDirectory, string newDirectory)
    {
        if (Directory.Exists(newDirectory))
            MoveToDuplicate(destinationDirectory, id, oldDirectory);
        else
        {
            string directory = Path.GetDirectoryName(newDirectory) ?? throw new NotImplementedException();
            if (!Directory.Exists(directory))
                _ = Directory.CreateDirectory(directory);
            Directory.Move(oldDirectory, newDirectory);
        }
    }

    private static string GetDirectory(string destinationDirectory, WorkItem workItem)
    {
        string result;
        string workItemType = workItem.WorkItemType.Replace(" ", "-");
        string iterationPath = workItem.IterationPath.Replace(" ", "-");
        result = Path.Combine(destinationDirectory, iterationPath, $"{workItem.Id}-{workItemType}");
        return result;
    }

    private static void MoveToDuplicate(string destinationDirectory, string directory)
    {
        if (string.IsNullOrEmpty(destinationDirectory))
            throw new ArgumentException($"'{nameof(destinationDirectory)}' cannot be null or empty.", nameof(destinationDirectory));
        if (string.IsNullOrEmpty(directory))
            throw new ArgumentException($"'{nameof(directory)}' cannot be null or empty.", nameof(directory));
    }

    private static void MoveToDuplicate(string destinationDirectory, int id, string oldDirectory)
    {
        if (string.IsNullOrEmpty(destinationDirectory))
            throw new ArgumentException($"'{nameof(destinationDirectory)}' {id} cannot be null or empty.", nameof(destinationDirectory));
        if (string.IsNullOrEmpty(oldDirectory))
            throw new ArgumentException($"'{nameof(oldDirectory)}' cannot be null or empty.", nameof(oldDirectory));
    }

}