using System.Globalization;
using System.Text.Json;
using View_by_Distance.Shared.Models;

namespace View_by_Distance.Map.Models.Stateless;

public class ByDeterministicHashCode
{

    private static void SetOther(string outputExtension, Dictionary<string, Person> personKeyValuePairs, string deterministicHashCodePeopleDirectory, List<double> skipCollection, List<(string, int?, string, PersonBirthday[])> peopleCollection)
    {
        string json;
        string personKey;
        string[] segments;
        int? approximateYears;
        string groupDirectoryName;
        string personKeyJsonFileName;
        string[] personKeyDirectories;
        string personKeyJsonDirectory;
        PersonBirthday? personBirthday;
        string[] personDisplayDirectories;
        string convertedPersonKeyDirectory;
        string? personDisplayDirectoryName;
        List<PersonBirthday> personBirthdays;
        string[] groupDirectories = Directory.GetDirectories(deterministicHashCodePeopleDirectory, "*", SearchOption.TopDirectoryOnly);
        foreach (string groupDirectory in groupDirectories)
        {
            groupDirectoryName = Path.GetFileName(groupDirectory);
            if (groupDirectoryName[0] == '!')
            {
                skipCollection.AddRange(from l in Directory.GetFiles(groupDirectory, $"*{outputExtension}", SearchOption.AllDirectories) select double.Parse(Path.GetFileNameWithoutExtension(l)));
                continue;
            }
            else if (groupDirectoryName[0] is not '_' and not '~' and not '^')
                continue;
            skipCollection.AddRange(from l in Directory.GetFiles(groupDirectory, $"*{outputExtension}", SearchOption.AllDirectories) select double.Parse(Path.GetFileNameWithoutExtension(l)));
            personDisplayDirectories = Directory.GetDirectories(groupDirectory, "*", SearchOption.TopDirectoryOnly);
            foreach (string personDisplayDirectory in personDisplayDirectories)
            {
                personBirthdays = new();
                personDisplayDirectoryName = Path.GetFileName(personDisplayDirectory);
                if (string.IsNullOrEmpty(personDisplayDirectoryName))
                    continue;
                if (groupDirectoryName[0] != '~')
                    approximateYears = null;
                else
                {
                    segments = personDisplayDirectoryName.Split('~');
                    if (segments.Length == 1 || !int.TryParse(segments[1].Split('-')[0], out int years))
                        approximateYears = null;
                    else
                        approximateYears = years;
                }
                personKeyDirectories = Directory.GetDirectories(personDisplayDirectory, "*", SearchOption.TopDirectoryOnly);
                foreach (string personKeyDirectory in personKeyDirectories)
                {
                    personKey = Path.GetFileName(personKeyDirectory);
                    if (!DateTime.TryParseExact(personKey, "MM.dd.yyyy", CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime birthday))
                        personBirthday = Shared.Models.Stateless.Methods.IPersonBirthday.GetPersonBirthday(personKey);
                    else
                    {
                        personBirthday = new PersonBirthday(birthday);
                        personKey = Shared.Models.Stateless.Methods.IPersonBirthday.GetFormatted(personBirthday);
                        convertedPersonKeyDirectory = Path.Combine(personDisplayDirectory, personKey);
                        if (!Directory.Exists(convertedPersonKeyDirectory))
                            Directory.Move(personKeyDirectory, convertedPersonKeyDirectory);
                    }
                    if (personBirthday is null)
                        continue;
                    personBirthdays.Add(personBirthday);
                }
                foreach (string personKeyDirectory in personKeyDirectories)
                {
                    personKey = Path.GetFileName(personKeyDirectory);
                    personBirthday = Shared.Models.Stateless.Methods.IPersonBirthday.GetPersonBirthday(personKey);
                    if (personBirthday is null)
                        continue;
                    if (personKeyValuePairs.ContainsKey(personKey))
                    {
                        personKeyJsonDirectory = Path.Combine(personDisplayDirectory, personKey);
                        if (!Directory.Exists(personKeyJsonDirectory))
                            Directory.Move(personKeyDirectory, personKeyJsonDirectory);
                        personKeyJsonFileName = Path.Combine(personKeyJsonDirectory, $"{personKey}.json");
                        json = JsonSerializer.Serialize(personKeyValuePairs[personKey], new JsonSerializerOptions() { WriteIndented = true });
                        _ = Shared.Models.Stateless.Methods.IPath.WriteAllText(personKeyJsonFileName, json, updateDateWhenMatches: false, compareBeforeWrite: true, updateToWhenMatches: null);
                    }
                    peopleCollection.Add(new(personDisplayDirectoryName, approximateYears, personKey, personBirthdays.OrderByDescending(l => l.Value).ToArray()));
                }
            }
        }
    }

    internal static void SetKeyValuePairs(string deterministicHashCodeContentDirectory, List<(string, double)> deterministicHashCodeCollection, List<(string, double)> incorrectDeterministicHashCodeCollection, Dictionary<int, List<Face>> keyValuePairs)
    {
        string[] files;
        string personKey;
        string[] yearDirectories;
        string ticksDirectoryName;
        string? personFirstInitial;
        string[] personKeyDirectories;
        string[] personNameDirectories;
        string[] personNameLinkDirectories;
        string? personFirstInitialDirectory;
        double? reversedDeterministicHashCodeKey;
        bool keyValuePairsAny = keyValuePairs.Any();
        string[] ticksDirectories = Directory.GetDirectories(deterministicHashCodeContentDirectory, "*", SearchOption.TopDirectoryOnly);
        foreach (string ticksDirectory in ticksDirectories)
        {
            ticksDirectoryName = Path.GetFileName(ticksDirectory);
            if (ticksDirectoryName.Length < 3 || ticksDirectoryName[0] != '(' || ticksDirectoryName[^1] != ')')
                continue;
            personKeyDirectories = Directory.GetDirectories(ticksDirectory, "*", SearchOption.TopDirectoryOnly);
            foreach (string personKeyDirectory in personKeyDirectories)
            {
                personKey = Path.GetFileName(personKeyDirectory);
                if (personKey == nameof(Closest))
                    throw new Exception($"Move personKey directories up one from {nameof(Closest)} and delete {nameof(Closest)} directory!");
                yearDirectories = Directory.GetDirectories(personKeyDirectory, "*", SearchOption.TopDirectoryOnly);
                foreach (string yearDirectory in yearDirectories)
                {
                    files = Directory.GetFiles(yearDirectory, "*", SearchOption.TopDirectoryOnly);
                    personNameDirectories = Directory.GetDirectories(yearDirectory, "*", SearchOption.TopDirectoryOnly);
                    foreach (string file in files)
                        File.Delete(file);
                    foreach (string personNameDirectory in personNameDirectories)
                    {
                        personFirstInitial = Path.GetFileName(personNameDirectory)[..1];
                        if (personFirstInitial is null)
                            continue;
                        personFirstInitialDirectory = Path.Combine(yearDirectory, personFirstInitial);
                        files = Directory.GetFiles(personNameDirectory, "*", SearchOption.TopDirectoryOnly);
                        foreach (string file in files)
                        {
                            if (file.EndsWith(".lnk") || file.EndsWith(".json"))
                                continue;
                            reversedDeterministicHashCodeKey = Shared.Models.Stateless.Methods.IMapping.GetReversedDeterministicHashCodeKey(keyValuePairsAny, keyValuePairs, file);
                            if (reversedDeterministicHashCodeKey is null)
                                continue;
                            deterministicHashCodeCollection.Add(new(personKey, reversedDeterministicHashCodeKey.Value));
                        }
                        if (personNameDirectory == personFirstInitialDirectory)
                            continue;
                        personNameLinkDirectories = Directory.GetDirectories(personNameDirectory, "*", SearchOption.TopDirectoryOnly);
                        foreach (string personNameLinkDirectory in personNameLinkDirectories)
                        {
                            files = Directory.GetFiles(personNameLinkDirectory, "*", SearchOption.TopDirectoryOnly);
                            foreach (string file in files)
                            {
                                if (!file.EndsWith(".lnk"))
                                    continue;
                                File.Delete(file);
                            }
                            _ = Shared.Models.Stateless.Methods.IPath.DeleteEmptyDirectories(personNameLinkDirectory);
                        }
                        Directory.Move(personNameDirectory, personFirstInitialDirectory);
                        _ = Shared.Models.Stateless.Methods.IPath.DeleteEmptyDirectories(personNameDirectory);
                    }
                    _ = Shared.Models.Stateless.Methods.IPath.DeleteEmptyDirectories(yearDirectory);
                }
                _ = Shared.Models.Stateless.Methods.IPath.DeleteEmptyDirectories(personKeyDirectory);
            }
            _ = Shared.Models.Stateless.Methods.IPath.DeleteEmptyDirectories(ticksDirectory);
        }
    }

    internal static string SetByRef(string outputExtension, Dictionary<string, Person> personKeyValuePairs, List<double> skipCollection, Dictionary<string, (string, int?, string, PersonBirthday[])> peopleKeyValuePairs, Dictionary<int, string[]> deterministicHashCodeUnknownFaceKeyValuePairs, Dictionary<double, string[]> deterministicHashCodeKeyValuePairs, Dictionary<double, string[]> incorrectDeterministicHashCodeKeyValuePairs, string deterministicHashCodeRootDirectory)
    {
        string result;
        List<string> deterministicHashCodePersonKeys = new();
        List<string> deterministicHashCodeUnknownFacePersonKeys = new();
        foreach (KeyValuePair<int, string[]> keyValuePair in deterministicHashCodeUnknownFaceKeyValuePairs)
            deterministicHashCodeUnknownFacePersonKeys.AddRange(keyValuePair.Value);
        deterministicHashCodeUnknownFacePersonKeys = deterministicHashCodeUnknownFacePersonKeys.Distinct().ToList();
        List<(string, int?, string, PersonBirthday[])> peopleCollection = new();
        string deterministicHashCodePeopleDirectory = Path.Combine(deterministicHashCodeRootDirectory, "People");
        if (Directory.Exists(deterministicHashCodePeopleDirectory))
            SetOther(outputExtension, personKeyValuePairs, deterministicHashCodePeopleDirectory, skipCollection, peopleCollection);
        result = Path.Combine(deterministicHashCodeRootDirectory, "()");
        if (!Directory.Exists(result))
            result = string.Empty;
        else
        {
            Dictionary<int, List<Face>> keyValuePairs = new();
            Dictionary<double, List<string>> deterministicHashCodeScope = new();
            Dictionary<double, List<string>> incorrectDeterministicHashCodeScope = new();
            List<(string PersonKey, double IdAndNormalizedPixelPercentage)> deterministicHashCodeCollection = new();
            List<(string PersonKey, double IdAndNormalizedPixelPercentage)> incorrectDeterministicHashCodeCollection = new();
            SetKeyValuePairs(result, deterministicHashCodeCollection, incorrectDeterministicHashCodeCollection, keyValuePairs);
            deterministicHashCodeCollection = (from l in deterministicHashCodeCollection orderby l.IdAndNormalizedPixelPercentage select l).ToList();
            incorrectDeterministicHashCodeCollection = (from l in incorrectDeterministicHashCodeCollection orderby l.IdAndNormalizedPixelPercentage select l).ToList();
            foreach ((string personKey, double idAndNormalizedPixelPercentage) in deterministicHashCodeCollection)
            {
                if (!deterministicHashCodeScope.ContainsKey(idAndNormalizedPixelPercentage))
                    deterministicHashCodeScope.Add(idAndNormalizedPixelPercentage, new());
                deterministicHashCodeScope[idAndNormalizedPixelPercentage].Add(personKey);
                deterministicHashCodePersonKeys.Add(personKey);
            }
            deterministicHashCodePersonKeys = deterministicHashCodePersonKeys.Distinct().ToList();
            foreach ((string personKey, double idAndNormalizedPixelPercentage) in incorrectDeterministicHashCodeCollection)
            {
                if (!incorrectDeterministicHashCodeScope.ContainsKey(idAndNormalizedPixelPercentage))
                    incorrectDeterministicHashCodeScope.Add(idAndNormalizedPixelPercentage, new());
                incorrectDeterministicHashCodeScope[idAndNormalizedPixelPercentage].Add(personKey);
            }
            foreach (KeyValuePair<double, List<string>> keyValuePair in deterministicHashCodeScope)
                deterministicHashCodeKeyValuePairs.Add(keyValuePair.Key, keyValuePair.Value.Distinct().ToArray());
            foreach (KeyValuePair<double, List<string>> keyValuePair in incorrectDeterministicHashCodeScope)
                incorrectDeterministicHashCodeKeyValuePairs.Add(keyValuePair.Key, keyValuePair.Value.Distinct().ToArray());
        }
        foreach ((string personDisplayDirectoryName, int? approximateYears, string personKey, PersonBirthday[] personBirthdays) in peopleCollection)
        {
            if (peopleKeyValuePairs.ContainsKey(personKey) && peopleKeyValuePairs[personKey].Item1 != personDisplayDirectoryName)
                throw new NotImplementedException();
            if (deterministicHashCodeUnknownFacePersonKeys.Contains(personKey) || deterministicHashCodePersonKeys.Contains(personKey))
                peopleKeyValuePairs.Add(personKey, new(personDisplayDirectoryName, approximateYears, personKey, personBirthdays));
        }
        return result;
    }

}