using ShellProgressBar;
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 resizeFilenameExtension, Person[] people, string deterministicHashCodePeopleDirectory, List<double> skipCollection, Dictionary<long, long> personKeyAliases, List<(string, int?, PersonBirthday[], long)> peopleCollection)
    {
        long pK;
        string json;
        long personKey;
        PersonBirthday pB;
        string[] segments;
        const int zero = 0;
        int? approximateYears;
        string groupDirectoryName;
        string personKeyFormatted;
        PersonBirthday[] collection;
        string personKeyJsonFileName;
        List<long> personKeys = new();
        string[] personKeyDirectories;
        string personKeyJsonDirectory;
        PersonBirthday? personBirthday;
        string[] personDisplayDirectories;
        string convertedPersonKeyDirectory;
        string? personDisplayDirectoryName;
        List<PersonBirthday> personBirthdays;
        Dictionary<string, Person> personKeyValuePairs = new();
        foreach (Person person in people)
        {
            personKeyFormatted = Shared.Models.Stateless.Methods.IPersonBirthday.GetFormatted(person.Birthday);
            if (personKeyValuePairs.ContainsKey(personKeyFormatted))
                break;
            personKeyValuePairs.Add(personKeyFormatted, person);
        }
        string[] groupDirectories = Directory.GetDirectories(deterministicHashCodePeopleDirectory, "*", SearchOption.TopDirectoryOnly);
        foreach (string groupDirectory in groupDirectories)
        {
            groupDirectoryName = Path.GetFileName(groupDirectory);
            if (groupDirectoryName[zero] == '!')
            {
                skipCollection.AddRange(from l in Directory.GetFiles(groupDirectory, $"*{resizeFilenameExtension}", SearchOption.AllDirectories) select double.Parse(Path.GetFileNameWithoutExtension(l)));
                continue;
            }
            else if (groupDirectoryName[zero] is not '_' and not '~' and not '^')
                continue;
            skipCollection.AddRange(from l in Directory.GetFiles(groupDirectory, $"*{resizeFilenameExtension}", 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[zero] != '~')
                    approximateYears = null;
                else
                {
                    segments = personDisplayDirectoryName.Split('~');
                    if (segments.Length == 1 || !int.TryParse(segments[1].Split('-')[zero], out int years))
                        approximateYears = null;
                    else
                        approximateYears = years;
                }
                personKeyDirectories = Directory.GetDirectories(personDisplayDirectory, "*", SearchOption.TopDirectoryOnly);
                foreach (string personKeyDirectory in personKeyDirectories)
                {
                    personKeyFormatted = Path.GetFileName(personKeyDirectory);
                    if (!DateTime.TryParseExact(personKeyFormatted, "MM.dd.yyyy", CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime birthday))
                        personBirthday = Shared.Models.Stateless.Methods.IPersonBirthday.GetPersonBirthday(personKeyFormatted);
                    else
                    {
                        personBirthday = new PersonBirthday(birthday);
                        personKeyFormatted = Shared.Models.Stateless.Methods.IPersonBirthday.GetFormatted(personBirthday);
                        convertedPersonKeyDirectory = Path.Combine(personDisplayDirectory, personKeyFormatted);
                        if (!Directory.Exists(convertedPersonKeyDirectory))
                            Directory.Move(personKeyDirectory, convertedPersonKeyDirectory);
                    }
                    if (personBirthday is null)
                        continue;
                    personBirthdays.Add(personBirthday);
                }
                if (!personBirthdays.Any())
                    continue;
                foreach (string personKeyDirectory in personKeyDirectories)
                {
                    personKeyFormatted = Path.GetFileName(personKeyDirectory);
                    personBirthday = Shared.Models.Stateless.Methods.IPersonBirthday.GetPersonBirthday(personKeyFormatted);
                    if (personBirthday is null)
                        continue;
                    if (personKeyValuePairs.ContainsKey(personKeyFormatted))
                    {
                        personKeyJsonDirectory = Path.Combine(personDisplayDirectory, personKeyFormatted);
                        if (!Directory.Exists(personKeyJsonDirectory))
                            Directory.Move(personKeyDirectory, personKeyJsonDirectory);
                        personKeyJsonFileName = Path.Combine(personKeyJsonDirectory, $"{personKeyFormatted}.json");
                        json = JsonSerializer.Serialize(personKeyValuePairs[personKeyFormatted], new JsonSerializerOptions() { WriteIndented = true });
                        _ = Shared.Models.Stateless.Methods.IPath.WriteAllText(personKeyJsonFileName, json, updateDateWhenMatches: false, compareBeforeWrite: true, updateToWhenMatches: null);
                    }
                    collection = personBirthdays.OrderByDescending(l => l.Value).ToArray();
                    personKey = collection[zero].Value.Ticks;
                    if (personBirthdays.Count > 1)
                    {
                        for (int i = 1; i < collection.Length; i++)
                        {
                            pB = collection[i];
                            pK = pB.Value.Ticks;
                            if (!personKeyAliases.ContainsKey(pK))
                                personKeyAliases.Add(pK, personKey);
                        }
                    }
                    peopleCollection.Add(new(personDisplayDirectoryName, approximateYears, collection, personKey));
                    for (int i = 0; i < collection.Length; i++)
                    {
                        personKey = collection[i].Value.Ticks;
                        personKeys.Add(personKey);
                    }
                }
            }
        }
        approximateYears = null;
        const string displayDirectoryName = Property.Models.Stateless.IResult.AllInOne;
        DateTime incrementDate = new(Shared.Models.Stateless.IPersonBirthday.FirstYear, 1, 1);
        for (int i = 0; i < 500; i++)
        {
            personKey = incrementDate.Ticks;
            personBirthday = new(incrementDate);
            incrementDate = incrementDate.AddDays(1);
            personKeyFormatted = Shared.Models.Stateless.Methods.IPersonBirthday.GetFormatted(personBirthday);
            if (personKeys.Contains(personKey))
                continue;
            personKeys.Add(personKey);
            peopleCollection.Add(new(displayDirectoryName, approximateYears, new PersonBirthday[] { personBirthday }, personKey));
        }
    }
    internal static void SetCollections(int maxDegreeOfParallelism, long ticks, string zPropertyHolderContentDirectory, Dictionary<long, long> personKeyAliases, List<(PersonBirthday, int, int)> idThenNormalizedPixelPercentageCollection, List<(PersonBirthday, double)> incorrectDeterministicHashCodeCollection, Dictionary<int, List<Face>> keyValuePairs)
    {
        int? id;
        string[] files;
        long personKey;
        const int zero = 0;
        string[] yearDirectories;
        string personKeyFormatted;
        string ticksDirectoryName;
        string? personFirstInitial;
        string[] personKeyDirectories;
        int? normalizedPixelPercentage;
        string[] personNameDirectories;
        PersonBirthday? personBirthday;
        string[] personNameLinkDirectories;
        string? personFirstInitialDirectory;
        bool keyValuePairsAny = keyValuePairs.Any();
        ParallelOptions parallelOptions = new() { MaxDegreeOfParallelism = maxDegreeOfParallelism };
        int totalSeconds = (int)Math.Floor(new TimeSpan(DateTime.Now.Ticks - ticks).TotalSeconds);
        string[] ticksDirectories = Directory.GetDirectories(zPropertyHolderContentDirectory, "*", SearchOption.TopDirectoryOnly);
        string message = $") {ticksDirectories.Length:000} ticks Director(ies) - {totalSeconds} total second(s)";
        ProgressBarOptions options = new() { ProgressCharacter = '─', ProgressBarOnBottom = true, DisableBottomPercentage = true };
        using ProgressBar progressBar = new(ticksDirectories.Length, message, options);
        foreach (string ticksDirectory in ticksDirectories)
        {
            progressBar.Tick();
            ticksDirectoryName = Path.GetFileName(ticksDirectory);
            if (ticksDirectoryName.Length < 3 || ticksDirectoryName[zero] != '(' || ticksDirectoryName[^1] != ')')
                continue;
            personKeyDirectories = Directory.GetDirectories(ticksDirectory, "*", SearchOption.TopDirectoryOnly);
            foreach (string personKeyDirectory in personKeyDirectories)
            {
                personKeyFormatted = Path.GetFileName(personKeyDirectory);
                if (personKeyFormatted.Length != Shared.Models.Stateless.IPersonBirthday.Format.Length)
                    personBirthday = null;
                else
                {
                    personBirthday = Shared.Models.Stateless.Methods.IPersonBirthday.GetPersonBirthday(personKeyFormatted);
                    if (personBirthday is null)
                        continue;
                    personKey = personBirthday.Value.Ticks;
                    if (personKeyAliases.ContainsKey(personKey))
                    {
                        personKey = personKeyAliases[personKey];
                        personBirthday = Shared.Models.Stateless.Methods.IPersonBirthday.GetPersonBirthday(personKey);
                    }
                }
                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);
                        if (personKeyFormatted == nameof(Models.MapLogic.ForceSingleImage) && files.Any())
                            throw new Exception($"Move personKey directories up one from {nameof(Models.MapLogic.ForceSingleImage)} and delete {nameof(Models.MapLogic.ForceSingleImage)} directory!");
                        if (personKeyFormatted == nameof(Sorting) && files.Any())
                            throw new Exception($"Move personKey directories up one from {nameof(Sorting)} and delete {nameof(Sorting)} directory!");
                        if (personBirthday is null)
                            continue;
                        foreach (string file in files)
                        {
                            if (file.EndsWith(".lnk") || file.EndsWith(".json"))
                                continue;
                            (id, normalizedPixelPercentage) = Shared.Models.Stateless.Methods.IMapping.GetReversedDeterministicHashCodeKey(keyValuePairsAny, keyValuePairs, file);
                            if (id is null || normalizedPixelPercentage is null)
                                continue;
                            idThenNormalizedPixelPercentageCollection.Add(new(personBirthday, id.Value, normalizedPixelPercentage.Value));
                        }
                        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);
                        }
                        if (personNameDirectory == personFirstInitialDirectory)
                            continue;
                        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);
            _ = Shared.Models.Stateless.Methods.IPath.DeleteEmptyDirectories(ticksDirectory);
        }
    }

    private static List<long> GetPersonKeys(Dictionary<int, PersonBirthday[]> deterministicHashCodeUnknownFaceKeyValuePairs)
    {
        List<long> results = new();
        long personKey;
        foreach (KeyValuePair<int, PersonBirthday[]> keyValuePair in deterministicHashCodeUnknownFaceKeyValuePairs)
        {
            foreach (PersonBirthday personBirthday in keyValuePair.Value)
            {
                personKey = personBirthday.Value.Ticks;
                results.Add(personKey);
            }
        }
        results = results.Distinct().ToList();
        return results;
    }

    private static void SetKeyValuePairs(List<(PersonBirthday, int, int)> idThenNormalizedPixelPercentageCollection, List<(PersonBirthday PersonBirthday, double IdAndNormalizedPixelPercentage)> incorrectDeterministicHashCodeCollection, Dictionary<double, PersonBirthday[]> incorrectDeterministicHashCodeKeyValuePairs, Dictionary<int, Dictionary<int, PersonBirthday[]>> idThenNormalizedPixelPercentageKeyValuePairs)
    {
        Dictionary<double, List<PersonBirthday>> incorrectDeterministicHashCodeScope = new();
        Dictionary<int, Dictionary<int, List<PersonBirthday>>> idThenNormalizedPixelPercentageScope = new();
        foreach ((PersonBirthday personBirthday, double idAndNormalizedPixelPercentage) in incorrectDeterministicHashCodeCollection)
        {
            if (!incorrectDeterministicHashCodeScope.ContainsKey(idAndNormalizedPixelPercentage))
                incorrectDeterministicHashCodeScope.Add(idAndNormalizedPixelPercentage, new());
            incorrectDeterministicHashCodeScope[idAndNormalizedPixelPercentage].Add(personBirthday);
        }
        foreach (KeyValuePair<double, List<PersonBirthday>> keyValuePair in incorrectDeterministicHashCodeScope)
            incorrectDeterministicHashCodeKeyValuePairs.Add(keyValuePair.Key, keyValuePair.Value.Distinct().ToArray());
        string check;
        int normalizedPixelPercentageInDecimalForm;
        foreach ((PersonBirthday personBirthday, int id, int normalizedPixelPercentage) in idThenNormalizedPixelPercentageCollection)
        {
            if (!idThenNormalizedPixelPercentageScope.ContainsKey(id))
                idThenNormalizedPixelPercentageScope.Add(id, new());
            check = normalizedPixelPercentage.ToString();
            if (check.Length == Shared.Models.Stateless.ILocation.Digits)
            {
                if (!idThenNormalizedPixelPercentageScope[id].ContainsKey(normalizedPixelPercentage))
                    idThenNormalizedPixelPercentageScope[id].Add(normalizedPixelPercentage, new());
                idThenNormalizedPixelPercentageScope[id][normalizedPixelPercentage].Add(personBirthday);
            }
            else
            {
                normalizedPixelPercentageInDecimalForm = int.Parse(check.PadRight(Shared.Models.Stateless.ILocation.Digits, '0'));
                if (!idThenNormalizedPixelPercentageScope[id].ContainsKey(normalizedPixelPercentageInDecimalForm))
                    idThenNormalizedPixelPercentageScope[id].Add(normalizedPixelPercentageInDecimalForm, new());
                idThenNormalizedPixelPercentageScope[id][normalizedPixelPercentageInDecimalForm].Add(personBirthday);
            }
        }
        foreach (KeyValuePair<int, Dictionary<int, List<PersonBirthday>>> keyValuePair in idThenNormalizedPixelPercentageScope)
        {
            idThenNormalizedPixelPercentageKeyValuePairs.Add(keyValuePair.Key, new());
            foreach (KeyValuePair<int, List<PersonBirthday>> innerKeyValuePair in keyValuePair.Value)
                idThenNormalizedPixelPercentageKeyValuePairs[keyValuePair.Key].Add(innerKeyValuePair.Key, innerKeyValuePair.Value.Distinct().ToArray());
        }
    }

    internal static void SetByRef(int maxDegreeOfParallelism, long ticks, string resizeFilenameExtension, Person[] people, List<double> skipCollection, Dictionary<long, (string DisplayDirectoryName, int? ApproximateYears, PersonBirthday[] PersonBirthdays, long PersonKey)> peopleKeyValuePairs, List<long> notMappedPersonKeys, Dictionary<int, PersonBirthday[]> deterministicHashCodeUnknownFaceKeyValuePairs, Dictionary<int, Dictionary<int, PersonBirthday[]>> idThenNormalizedPixelPercentageKeyValuePairs, Dictionary<double, PersonBirthday[]> incorrectDeterministicHashCodeKeyValuePairs, string zPropertyHolderContentDirectory, string zPropertyHolderPeopleContentDirectory)
    {
        Dictionary<long, long> personKeyAliases = new();
        Dictionary<int, List<Face>> keyValuePairs = new();
        List<long> idThenNormalizedPixelPercentagePersonKeys = new();
        List<(string, int?, PersonBirthday[], long)> peopleCollection = new();
        List<(PersonBirthday, int, int)> idThenNormalizedPixelPercentageCollection = new();
        List<long> deterministicHashCodeUnknownFacePersonKeys = GetPersonKeys(deterministicHashCodeUnknownFaceKeyValuePairs);
        List<(PersonBirthday PersonBirthday, double IdAndNormalizedPixelPercentage)> incorrectDeterministicHashCodeCollection = new();
        SetOther(resizeFilenameExtension, people, zPropertyHolderPeopleContentDirectory, skipCollection, personKeyAliases, peopleCollection);
        SetCollections(maxDegreeOfParallelism, ticks, zPropertyHolderContentDirectory, personKeyAliases, idThenNormalizedPixelPercentageCollection, incorrectDeterministicHashCodeCollection, keyValuePairs);
        SetKeyValuePairs(idThenNormalizedPixelPercentageCollection, incorrectDeterministicHashCodeCollection, incorrectDeterministicHashCodeKeyValuePairs, idThenNormalizedPixelPercentageKeyValuePairs);
        incorrectDeterministicHashCodeCollection = (from l in incorrectDeterministicHashCodeCollection orderby l.IdAndNormalizedPixelPercentage select l).ToList();
        foreach (KeyValuePair<int, Dictionary<int, PersonBirthday[]>> keyValuePair in idThenNormalizedPixelPercentageKeyValuePairs)
        {
            foreach (KeyValuePair<int, PersonBirthday[]> keyValue in keyValuePair.Value)
                idThenNormalizedPixelPercentagePersonKeys.AddRange(from l in keyValue.Value select l.Value.Ticks);
        }
        idThenNormalizedPixelPercentagePersonKeys = idThenNormalizedPixelPercentagePersonKeys.Distinct().ToList();
        foreach (KeyValuePair<int, PersonBirthday[]> keyValuePair in deterministicHashCodeUnknownFaceKeyValuePairs)
            deterministicHashCodeUnknownFacePersonKeys.AddRange(from l in keyValuePair.Value select l.Value.Ticks);
        deterministicHashCodeUnknownFacePersonKeys = deterministicHashCodeUnknownFacePersonKeys.Distinct().ToList();
        if (peopleCollection.Any())
        {
            foreach ((string displayDirectoryName, int? approximateYears, PersonBirthday[] personBirthdays, long personKey) in peopleCollection)
            {
                if (peopleKeyValuePairs.ContainsKey(personKey))
                {
                    if (peopleKeyValuePairs[personKey].DisplayDirectoryName == displayDirectoryName)
                        continue;
                    throw new NotImplementedException();
                }
                if (!deterministicHashCodeUnknownFacePersonKeys.Contains(personKey) && !idThenNormalizedPixelPercentagePersonKeys.Contains(personKey))
                    notMappedPersonKeys.Add(personKey);
                else
                    peopleKeyValuePairs.Add(personKey, new(displayDirectoryName, approximateYears, personBirthdays, personKey));
            }
        }
        if (deterministicHashCodeUnknownFacePersonKeys.Any() || idThenNormalizedPixelPercentagePersonKeys.Any())
        {
            int? approximateYears = null;
            PersonBirthday? personBirthday;
            const string displayDirectoryName = Property.Models.Stateless.IResult.AllInOne;
            foreach (long personKey in deterministicHashCodeUnknownFacePersonKeys)
            {
                if (!peopleKeyValuePairs.ContainsKey(personKey))
                {
                    personBirthday = Shared.Models.Stateless.Methods.IPersonBirthday.GetPersonBirthday(personKey);
                    peopleKeyValuePairs.Add(personKey, new(displayDirectoryName, approximateYears, new PersonBirthday[] { personBirthday }, personKey));
                }
            }
            foreach (long personKey in idThenNormalizedPixelPercentagePersonKeys)
            {
                if (!peopleKeyValuePairs.ContainsKey(personKey))
                {
                    personBirthday = Shared.Models.Stateless.Methods.IPersonBirthday.GetPersonBirthday(personKey);
                    peopleKeyValuePairs.Add(personKey, new(displayDirectoryName, approximateYears, new PersonBirthday[] { personBirthday }, personKey));
                }
            }
        }
    }

}