using Humanizer;
using ShellProgressBar;
using System.Text.Json;
using View_by_Distance.Shared.Models;
using View_by_Distance.Shared.Models.Stateless.Methods;
using WindowsShortcutFactory;

namespace View_by_Distance.Map.Models.Stateless;

internal abstract class MapLogic
{

    private static List<PersonContainer> GetNonSpecificPeopleCollection(Configuration configuration, long ticks, List<long> personKeys)
    {
        List<PersonContainer> results = new();
        Person person;
        long personKey;
        int? approximateYears = null;
        PersonBirthday personBirthday;
        PersonContainer personContainer;
        string[] personDisplayDirectoryAllFiles = Array.Empty<string>();
        DateTime incrementDate = new(configuration.PersonBirthdayFirstYear, 1, 1);
        for (int i = 0; i < int.MaxValue; i++)
        {
            personKey = incrementDate.Ticks;
            incrementDate = incrementDate.AddDays(1);
            if (incrementDate.Ticks > ticks)
                break;
            if (personKeys.Contains(personKey))
                continue;
            personBirthday = IPersonBirthday.GetPersonBirthday(personKey);
            person = IPerson.GetPerson(configuration.PersonCharacters.ToArray(), configuration.MappingDefaultName, personKey, personBirthday);
            personContainer = new(approximateYears, person, new PersonBirthday[] { personBirthday }, personDisplayDirectoryAllFiles, configuration.MappingDefaultName, personKey);
            results.Add(personContainer);
        }
        return results;
    }

    private static void SetPersonCollections(Configuration configuration, List<PersonContainer> personContainers, string? a2PeopleSingletonDirectory, List<long> personKeys, Dictionary<string, string> personKeyFormattedToNewestPersonKeyFormatted, List<string> personKeyFormattedCollection, Dictionary<int, List<int>> skipCollection, Dictionary<int, List<int>> skipNotSkipCollection)
    {
        int? id;
        long personKey;
        int? normalizedRectangle;
        string personKeyFormatted;
        string newestPersonKeyFormatted;
        bool skipNotSkipDirectoriesAny = configuration.SkipNotSkipDirectories.Any();
        string[] checkDirectories = (from l in configuration.SkipNotSkipDirectories select Path.GetFullPath(string.Concat(a2PeopleSingletonDirectory, l))).ToArray();
        foreach (PersonContainer personContainer in personContainers)
        {
            foreach (string personDisplayDirectoryAllFile in personContainer.DisplayDirectoryAllFiles)
            {
                if (!personDisplayDirectoryAllFile.EndsWith(configuration.FacesFileNameExtension))
                    continue;
                (id, normalizedRectangle) = IMapping.GetConverted(configuration.FacesFileNameExtension, personDisplayDirectoryAllFile);
                if (id is null || normalizedRectangle is null)
                    continue;
                if (!skipNotSkipDirectoriesAny || !checkDirectories.Any(l => personDisplayDirectoryAllFile.StartsWith(l)))
                {
                    if (!skipCollection.ContainsKey(id.Value))
                        skipCollection.Add(id.Value, new());
                    skipCollection[id.Value].Add(normalizedRectangle.Value);
                }
                else
                {
                    if (!skipNotSkipCollection.ContainsKey(id.Value))
                        skipNotSkipCollection.Add(id.Value, new());
                    skipNotSkipCollection[id.Value].Add(normalizedRectangle.Value);
                }
            }
            if (personContainer.Person is null || personContainer.Key is null || personContainer.Birthdays is null || !personContainer.Birthdays.Any())
                continue;
            foreach (PersonBirthday personBirthday in personContainer.Birthdays)
            {
                personKey = personBirthday.Value.Ticks;
                personKeys.Add(personKey);
            }
            foreach (PersonBirthday personBirthday in personContainer.Birthdays)
            {
                personKeyFormatted = IPersonBirthday.GetFormatted(configuration.PersonBirthdayFormat, personBirthday);
                personKeyFormattedCollection.Add(personKeyFormatted);
                if (personContainer.Birthdays.Length < 1)
                    continue;
                newestPersonKeyFormatted = IPersonBirthday.GetFormatted(configuration.PersonBirthdayFormat, personContainer.Key.Value);
                if (!personKeyFormattedToNewestPersonKeyFormatted.ContainsKey(personKeyFormatted))
                    personKeyFormattedToNewestPersonKeyFormatted.Add(personKeyFormatted, newestPersonKeyFormatted);
            }
        }
    }

    internal static List<(string, string[], string)> DeleteEmptyDirectoriesAndGetCollection(Configuration configuration, List<string> personKeyFormattedCollection, string[] ticksDirectories, string message)
    {
        List<(string, string[], string)> results = new();
        int? id;
        string[] files;
        const int zero = 0;
        string[] yearDirectories;
        int? normalizedRectangle;
        string personKeyFormatted;
        string ticksDirectoryName;
        string? personFirstInitial;
        DirectoryInfo directoryInfo;
        bool isReservedDirectoryName;
        string[] personKeyDirectories;
        string[] personNameDirectories;
        string[] personNameLinkDirectories;
        string? personFirstInitialDirectory;
        string[] personDisplayDirectoryNames;
        string manualCopyHumanized = nameof(Shared.Models.Stateless.IMapLogic.ManualCopy).Humanize(LetterCasing.Title);
        string forceSingleImageHumanized = nameof(Shared.Models.Stateless.IMapLogic.ForceSingleImage).Humanize(LetterCasing.Title);
        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;
            if (!long.TryParse(ticksDirectoryName[1..^1], out long directoryTicks))
            {
                if (!long.TryParse(ticksDirectoryName[1..^4], out directoryTicks))
                    continue;
            }
            directoryInfo = new(ticksDirectory);
            if (directoryInfo.CreationTime.Ticks != directoryTicks)
                Directory.SetCreationTime(ticksDirectory, new DateTime(directoryTicks));
            if (directoryInfo.LastWriteTime.Ticks != directoryTicks)
                Directory.SetLastWriteTime(ticksDirectory, new DateTime(directoryTicks));
            personKeyDirectories = Directory.GetDirectories(ticksDirectory, "*", SearchOption.TopDirectoryOnly);
            foreach (string personKeyDirectory in personKeyDirectories)
            {
                personKeyFormatted = Path.GetFileName(personKeyDirectory);
                isReservedDirectoryName = personKeyFormatted.StartsWith(nameof(Shared.Models.Stateless.IMapLogic.Sorting)) || personKeyFormatted.StartsWith(nameof(Shared.Models.Stateless.IMapLogic.Mapping)) || personKeyFormatted.StartsWith(nameof(Shared.Models.Stateless.IMapLogic.ManualCopy));
                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)
                    {
                        personDisplayDirectoryNames = IPath.GetDirectoryNames(personNameDirectory);
                        if (!personDisplayDirectoryNames.Any())
                            continue;
                        files = Directory.GetFiles(personNameDirectory, "*", SearchOption.TopDirectoryOnly);
                        if (isReservedDirectoryName && files.Any())
                            throw new Exception($"Move personKey directories up one from {nameof(Shared.Models.Stateless.IMapLogic.Sorting)} and delete {nameof(Shared.Models.Stateless.IMapLogic.Sorting)} directory!");
                        if (personKeyFormatted == manualCopyHumanized && files.Any())
                            throw new Exception($"Move personKey directories up one from {manualCopyHumanized} and delete {manualCopyHumanized} directory!");
                        if (personKeyFormatted == forceSingleImageHumanized && files.Any())
                            throw new Exception($"Move personKey directories up one from {forceSingleImageHumanized} and delete {forceSingleImageHumanized} directory!");
                        if (personKeyFormatted.Length != configuration.PersonBirthdayFormat.Length)
                            continue;
                        if (personDisplayDirectoryNames[^1].Length == 1 || personDisplayDirectoryNames[^1] == configuration.MappingDefaultName || !personKeyFormattedCollection.Contains(personKeyFormatted))
                            personFirstInitialDirectory = personNameDirectory;
                        else
                        {
                            personFirstInitial = personDisplayDirectoryNames[^1][..1];
                            if (personFirstInitial.All(l => char.IsDigit(l)))
                            {
                                foreach (string file in files)
                                    File.Delete(file);
                                files = Directory.GetFiles(personNameDirectory, "*", SearchOption.AllDirectories);
                                foreach (string file in files)
                                    File.Delete(file);
                                _ = IPath.DeleteEmptyDirectories(personNameDirectory);
                                continue;
                            }
                            personFirstInitialDirectory = Path.Combine(yearDirectory, personFirstInitial.ToString());
                            Directory.Move(personNameDirectory, personFirstInitialDirectory);
                            files = Directory.GetFiles(personFirstInitialDirectory, "*", SearchOption.TopDirectoryOnly);
                        }
                        foreach (string file in files)
                        {
                            if (file.EndsWith(".lnk") || file.EndsWith(".json"))
                                continue;
                            (id, normalizedRectangle) = IMapping.GetConverted(configuration.FacesFileNameExtension, file);
                            if (id is null || normalizedRectangle is null)
                                continue;
                            results.Add(new(personKeyFormatted, personDisplayDirectoryNames, file));
                        }
                        personNameLinkDirectories = Directory.GetDirectories(personFirstInitialDirectory, "*", 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);
                            }
                            _ = IPath.DeleteEmptyDirectories(personNameLinkDirectory);
                        }
                        _ = IPath.DeleteEmptyDirectories(personFirstInitialDirectory);
                    }
                    _ = IPath.DeleteEmptyDirectories(yearDirectory);
                }
                _ = IPath.DeleteEmptyDirectories(personKeyDirectory);
            }
            _ = IPath.DeleteEmptyDirectories(ticksDirectory);
            _ = IPath.DeleteEmptyDirectories(ticksDirectory);
        }
        return results;
    }

    private static List<string> GetPersonKeyFormattedCollection(Configuration configuration, PersonContainer[] personContainers, List<(long? PersonKey, string Line)> lines)
    {
        List<string> results = new();
        string personKeyFormatted;
        foreach (PersonContainer personContainer in personContainers)
        {
            lines.AddRange(IPersonContainer.GetDisplay(configuration.PersonBirthdayFormat, personContainer));
            if (personContainer.Person is null || personContainer.Key is null || personContainer.Birthdays is null || !personContainer.Birthdays.Any())
                continue;
            foreach (PersonBirthday personBirthday in personContainer.Birthdays)
            {
                personKeyFormatted = IPersonBirthday.GetFormatted(configuration.PersonBirthdayFormat, personBirthday);
                results.Add(personKeyFormatted);
            }
        }
        return results;
    }

    internal static List<(long, string)> DeleteEmptyDirectoriesAndGetMappedFaceFiles(Configuration configuration, PersonContainer[] personContainers, long ticks, string? a2PeopleContentDirectory, string eDistanceContentDirectory)
    {
        List<(long, string)> results = new();
        List<(long? PersonKey, string Line)> lines = new();
        _ = GetDistinctCollection(configuration, personContainers, new(), new());
        int totalSeconds = (int)Math.Floor(new TimeSpan(DateTime.Now.Ticks - ticks).TotalSeconds);
        string[] ticksDirectories;
        if (string.IsNullOrEmpty(eDistanceContentDirectory))
            ticksDirectories = Array.Empty<string>();
        else
        {
            if (!Directory.Exists(eDistanceContentDirectory))
                _ = Directory.CreateDirectory(eDistanceContentDirectory);
            else
            {
                _ = IPath.DeleteEmptyDirectories(eDistanceContentDirectory);
                if (!Directory.Exists(eDistanceContentDirectory))
                    _ = Directory.CreateDirectory(eDistanceContentDirectory);
            }
            ticksDirectories = Directory.GetDirectories(eDistanceContentDirectory, "*", SearchOption.TopDirectoryOnly);
        }
        long personKey;
        List<string> distinct = new();
        PersonBirthday? personBirthday;
        string message = $") {ticksDirectories.Length:000} collect from and clean ticks Director(ies) - A - {totalSeconds} total second(s)";
        List<string> personKeyFormattedCollection = GetPersonKeyFormattedCollection(configuration, personContainers, lines);
        if (!string.IsNullOrEmpty(a2PeopleContentDirectory))
            File.WriteAllLines(Path.Combine(a2PeopleContentDirectory, "People - C.tsv"), from l in lines select l.Line);
        List<(string, string[], string)> collection = DeleteEmptyDirectoriesAndGetCollection(configuration, personKeyFormattedCollection, ticksDirectories, message);
        foreach ((string personKeyFormatted, _, string mappedFaceFile) in collection)
        {
            personBirthday = IPersonBirthday.GetPersonBirthday(configuration.PersonBirthdayFormat, personKeyFormatted);
            if (personBirthday is null)
                continue;
            if (distinct.Contains(mappedFaceFile))
                continue;
            distinct.Add(mappedFaceFile);
            personKey = personBirthday.Value.Ticks;
            results.Add(new(personKey, mappedFaceFile));
        }
        return results;
    }

    private static PersonContainer[] GetDistinctPersonContainers(List<PersonContainer> personContainers)
    {
        List<PersonContainer> results = new();
        List<long> distinctCheck = new();
        foreach (PersonContainer personContainer in personContainers)
        {
            if (personContainer.Key is null || distinctCheck.Contains(personContainer.Key.Value))
                continue;
            results.Add(personContainer);
        }
        return results.ToArray();
    }

    private static void SetKeyValuePairs(Configuration configuration, List<PersonContainer> personContainers, Dictionary<long, List<PersonContainer>> personKeyToPersonContainerCollection, Dictionary<string, PersonContainer> personKeyFormattedToPersonContainer, List<(string, string[], int, int)> personKeyFormattedIdThenNormalizedRectangleCollection, Dictionary<long, PersonContainer> personKeyToPersonContainer, Dictionary<int, Dictionary<int, PersonContainer[]>> idThenNormalizedRectangleToPersonContainers, List<(string[], PersonContainer)> possiblyNewPersonDisplayDirectoryNamesAndPersonContainer)
    {
        PersonBirthday? personBirthday;
        PersonContainer[] distinctPersonContainers;
        List<(long, PersonContainer)> collection = GetDistinctCollection(configuration, personContainers, personKeyToPersonContainerCollection, personKeyFormattedToPersonContainer);
        foreach ((long personKey, PersonContainer personContainer) in collection)
            personKeyToPersonContainer.Add(personKey, personContainer);
        Dictionary<int, Dictionary<int, List<PersonContainer>>> idThenNormalizedRectangleToPersonContainerCollection = new();
        if (personKeyFormattedIdThenNormalizedRectangleCollection.Any())
        {
            string personDisplayDirectory;
            PersonContainer personContainer;
            string personDisplayDirectoryName;
            Dictionary<string, (string[], PersonContainer)> personDisplayDirectoryTo = new();
            foreach ((string personKeyFormatted, string[] personDisplayDirectoryNames, int id, int normalizedRectangle) in personKeyFormattedIdThenNormalizedRectangleCollection)
            {
                personBirthday = IPersonBirthday.GetPersonBirthday(configuration.PersonBirthdayFormat, personKeyFormatted);
                if (personBirthday is null)
                    continue;
                personDisplayDirectoryName = personDisplayDirectoryNames[^1];
                personDisplayDirectory = Path.Combine(personDisplayDirectoryNames);
                if (!personKeyFormattedToPersonContainer.ContainsKey(personKeyFormatted))
                {
                    personContainer = new(configuration.PersonCharacters.ToArray(), personBirthday, personDisplayDirectoryName);
                    personKeyFormattedToPersonContainer.Add(personKeyFormatted, personContainer);
                }
                if (personDisplayDirectoryName.Length != 1 && personDisplayDirectoryName != configuration.MappingDefaultName && !personDisplayDirectoryTo.ContainsKey(personDisplayDirectory))
                    personDisplayDirectoryTo.Add(personDisplayDirectory, new(personDisplayDirectoryNames, personKeyFormattedToPersonContainer[personKeyFormatted]));
                if (!idThenNormalizedRectangleToPersonContainerCollection.ContainsKey(id))
                    idThenNormalizedRectangleToPersonContainerCollection.Add(id, new());
                if (!idThenNormalizedRectangleToPersonContainerCollection[id].ContainsKey(normalizedRectangle))
                    idThenNormalizedRectangleToPersonContainerCollection[id].Add(normalizedRectangle, new());
                idThenNormalizedRectangleToPersonContainerCollection[id][normalizedRectangle].Add(personKeyFormattedToPersonContainer[personKeyFormatted]);
            }
            foreach (KeyValuePair<string, (string[], PersonContainer)> keyValuePair in personDisplayDirectoryTo)
                possiblyNewPersonDisplayDirectoryNamesAndPersonContainer.Add(keyValuePair.Value);
        }
        foreach (KeyValuePair<int, Dictionary<int, List<PersonContainer>>> keyValuePair in idThenNormalizedRectangleToPersonContainerCollection)
        {
            idThenNormalizedRectangleToPersonContainers.Add(keyValuePair.Key, new());
            foreach (KeyValuePair<int, List<PersonContainer>> innerKeyValuePair in keyValuePair.Value)
            {
                distinctPersonContainers = GetDistinctPersonContainers(innerKeyValuePair.Value);
                idThenNormalizedRectangleToPersonContainers[keyValuePair.Key].Add(innerKeyValuePair.Key, distinctPersonContainers);
            }
        };
    }

    private static List<(long, PersonContainer)> GetDistinctCollection(Configuration configuration, IEnumerable<PersonContainer> personContainers, Dictionary<long, List<PersonContainer>> personKeyToPersonContainerCollection, Dictionary<string, PersonContainer> personKeyFormattedToPersonContainer)
    {
        List<(long, PersonContainer)> results = new();
        const int zero = 0;
        string newestPersonKeyFormatted;
        foreach (PersonContainer personContainer in personContainers)
        {
            if (personContainer.Key is null)
                continue;
            if (!personKeyToPersonContainerCollection.ContainsKey(personContainer.Key.Value))
                personKeyToPersonContainerCollection.Add(personContainer.Key.Value, new());
            personKeyToPersonContainerCollection[personContainer.Key.Value].Add(personContainer);
            newestPersonKeyFormatted = IPersonBirthday.GetFormatted(configuration.PersonBirthdayFormat, personContainer.Key.Value);
            if (!personKeyFormattedToPersonContainer.ContainsKey(newestPersonKeyFormatted))
                personKeyFormattedToPersonContainer.Add(newestPersonKeyFormatted, personContainer);
        }
        foreach (KeyValuePair<long, List<PersonContainer>> keyValuePair in personKeyToPersonContainerCollection)
        {
            if (keyValuePair.Value.Count != 1 && (from l in keyValuePair.Value select l.DisplayDirectoryName).Distinct().Count() != 1)
                throw new NotSupportedException(keyValuePair.Value[zero].DisplayDirectoryName);
            results.Add(new(keyValuePair.Key, keyValuePair.Value[zero]));
        }
        return results;
    }

    private static (int, int) SetCollectionsAndGetUnableToConvertCount(Configuration configuration, long ticks, Dictionary<string, string> personKeyFormattedToNewestPersonKeyFormatted, List<(string, string[], int, int)> personKeyFormattedIdThenNormalizedRectangleCollection, List<(string, string[], string)> collection)
    {
        int result = 0;
        int? id;
        int? normalizedRectangle;
        List<int> normalizedRectangles;
        string newestPersonKeyFormatted;
        string personDisplayDirectoryName;
        List<string> duplicateMappedFaceFiles = new();
        Dictionary<int, List<int>> idToNormalizedRectangles = new();
        int totalSeconds = (int)Math.Floor(new TimeSpan(DateTime.Now.Ticks - ticks).TotalSeconds);
        string message = $") {collection.Count:000} join from ticks Director(ies) - C - {totalSeconds} total second(s)";
        ProgressBarOptions options = new() { ProgressCharacter = '─', ProgressBarOnBottom = true, DisableBottomPercentage = true };
        using ProgressBar progressBar = new(collection.Count, message, options);
        foreach ((string personKeyFormatted, string[] personDisplayDirectoryNames, string mappedFaceFile) in collection)
        {
            progressBar.Tick();
            (id, normalizedRectangle) = IMapping.GetConverted(configuration.FacesFileNameExtension, mappedFaceFile);
            if (id is null || normalizedRectangle is null)
            {
                result++;
                continue;
            }
            if (!idToNormalizedRectangles.ContainsKey(id.Value))
                idToNormalizedRectangles.Add(id.Value, new());
            normalizedRectangles = idToNormalizedRectangles[id.Value];
            normalizedRectangles.Add(normalizedRectangle.Value);
            idToNormalizedRectangles[id.Value].Add(normalizedRectangle.Value);
            if (!personKeyFormattedToNewestPersonKeyFormatted.ContainsKey(personKeyFormatted))
                newestPersonKeyFormatted = personKeyFormatted;
            else
                newestPersonKeyFormatted = personKeyFormattedToNewestPersonKeyFormatted[personKeyFormatted];
            personDisplayDirectoryName = personDisplayDirectoryNames[^1];
            if (string.IsNullOrEmpty(personDisplayDirectoryName))
                continue;
            personKeyFormattedIdThenNormalizedRectangleCollection.Add(new(newestPersonKeyFormatted, personDisplayDirectoryNames, id.Value, normalizedRectangle.Value));
        }
        if (duplicateMappedFaceFiles.Any())
        {
            duplicateMappedFaceFiles.Sort();
            if (duplicateMappedFaceFiles.Any())
            { }
        }
        return new(result, duplicateMappedFaceFiles.Count);
    }

    private static double GetStandardDeviation(IEnumerable<long> values, double average)
    {
        double result = 0;
        if (!values.Any())
            throw new Exception("Collection must have at least one value!");
        double sum = values.Sum(l => (l - average) * (l - average));
        result = Math.Sqrt(sum / values.Count());
        return result;
    }

    private static List<double> GetSumCollection(long[] collection)
    {
        List<double> results = new();
        long result = 0;
        foreach (long item in collection)
        {
            result += item;
            if (result > long.MaxValue)
            {
                results.Add(result);
                result = 0;
            }
        }
        return results;
    }

    private static List<PersonContainer> GetNotMappedPersonContainers(Configuration configuration, List<PersonContainer> personContainers, List<long> personKeys, long[] personKeyCollection)
    {
        List<PersonContainer> results = new();
        List<PersonContainer> notMappedAndNotNamedPersonKeys = new();
        List<PersonContainer> notMappedAndWithNamedPersonKeys = new();
        foreach (PersonContainer personContainer in personContainers)
        {
            if (personContainer.Person is null || personContainer.Key is null || personContainer.Birthdays is null || !personContainer.Birthdays.Any())
                continue;
            if (personKeys.Contains(personContainer.Key.Value))
                continue;
            if (personKeyCollection.Contains(personContainer.Key.Value))
                continue;
            if (string.IsNullOrEmpty(personContainer.DisplayDirectoryName) || personContainer.DisplayDirectoryName == configuration.MappingDefaultName)
                notMappedAndNotNamedPersonKeys.Add(personContainer);
            else
                notMappedAndWithNamedPersonKeys.Add(personContainer);
        }
        results.AddRange(notMappedAndNotNamedPersonKeys);
        return results;
    }

    private static string? GetDisplayDirectoryName(Dictionary<long, PersonContainer> personKeyToPersonContainer, long key)
    {
        string? result = null;
        if (personKeyToPersonContainer.TryGetValue(key, out PersonContainer? personContainer))
        {
            result = personContainer.DisplayDirectoryName;
            if (string.IsNullOrEmpty(result))
                throw new NotSupportedException();
        }
        return result;
    }

    private static void SetPersonKeyToPersonContainer(Configuration configuration, List<PersonContainer> personContainers, long[] personKeyCollection, Dictionary<long, PersonContainer> personKeyToPersonContainer, Dictionary<long, List<PersonContainer>> personKeyToPersonContainerCollection)
    {
        string? displayDirectoryName;
        foreach (PersonContainer personContainer in personContainers)
        {
            if (personContainer.Key is null || !personKeyCollection.Contains(personContainer.Key.Value))
                continue;
            displayDirectoryName = GetDisplayDirectoryName(personKeyToPersonContainer, personContainer.Key.Value);
            if (displayDirectoryName is not null && (displayDirectoryName == personContainer.DisplayDirectoryName || (displayDirectoryName[0] == personContainer.DisplayDirectoryName[0] && (displayDirectoryName.Length == 1 || personContainer.DisplayDirectoryName.Length == 1))))
                continue;
            personKeyToPersonContainer.Add(personContainer.Key.Value, personContainer);
        }
        if (personKeyCollection.Any())
        {
            const int zero = 0;
            int? approximateYears = null;
            PersonBirthday? personBirthday;
            PersonContainer personContainer;
            displayDirectoryName = configuration.MappingDefaultName;
            foreach (long personKey in personKeyCollection)
            {
                if (personKeyToPersonContainer.ContainsKey(personKey))
                    continue;
                personBirthday = IPersonBirthday.GetPersonBirthday(personKey);
                if (!personKeyToPersonContainerCollection.ContainsKey(personKey))
                    personContainer = new(approximateYears, personBirthday, displayDirectoryName, personKey);
                else
                    personContainer = new(approximateYears, personBirthday, personKeyToPersonContainerCollection[personKey][zero].Char, displayDirectoryName, personKey);
                personKeyToPersonContainer.Add(personKey, personContainer);
            }
        }
    }

    static void SavePossiblyNewPersonContainers(string personBirthdayFormat, char[] personCharacters, string facesFileNameExtension, string? a2PeopleSingletonDirectory, List<(string[], PersonContainer)> possiblyNewPersonDisplayDirectoryNamesAndPersonContainer)
    {
        string json;
        string[] files;
        string checkFile;
        string[] segments;
        const int zero = 0;
        char personCharacter;
        string personKeyFormatted;
        string personDisplayDirectory;
        PersonBirthday personBirthday;
        string personDisplayDirectoryName;
        string checkPersonDisplayDirectory;
        string checkPersonKeyFormattedDirectory;
        JsonSerializerOptions jsonSerializerOptions = new() { WriteIndented = true };
        foreach ((string[] personDisplayDirectoryNames, PersonContainer personContainer) in possiblyNewPersonDisplayDirectoryNamesAndPersonContainer)
        {
            if (a2PeopleSingletonDirectory is null || personContainer.Key is null || personContainer.Birthdays is null || !personContainer.Birthdays.Any())
                continue;
            personBirthday = personContainer.Birthdays[zero];
            personDisplayDirectoryName = personDisplayDirectoryNames[^1];
            personDisplayDirectory = Path.Combine(personDisplayDirectoryNames);
            personKeyFormatted = IPersonBirthday.GetFormatted(personBirthdayFormat, personBirthday);
            segments = personDisplayDirectoryName.Split(personCharacters);
            if (segments.Length != 2)
                personCharacter = '_';
            else
                personCharacter = personDisplayDirectoryName[segments[zero].Length];
            checkPersonDisplayDirectory = Path.Combine(a2PeopleSingletonDirectory, personCharacter.ToString(), personDisplayDirectoryName);
            checkPersonKeyFormattedDirectory = Path.Combine(checkPersonDisplayDirectory, personKeyFormatted);
            if (Directory.Exists(checkPersonKeyFormattedDirectory))
                continue;
            _ = Directory.CreateDirectory(checkPersonKeyFormattedDirectory);
            checkFile = Path.Combine(checkPersonKeyFormattedDirectory, $"{personKeyFormatted}.json");
            json = JsonSerializer.Serialize(personContainer.Person, jsonSerializerOptions);
            _ = IPath.WriteAllText(checkFile, json, updateDateWhenMatches: false, compareBeforeWrite: true);
            if (!Directory.Exists(personDisplayDirectory))
                continue;
            files = Directory.GetFiles(personDisplayDirectory, $"*{facesFileNameExtension}", SearchOption.TopDirectoryOnly);
            foreach (string file in files)
            {
                checkFile = Path.Combine(checkPersonDisplayDirectory, Path.GetFileName(file));
                if (File.Exists(checkFile))
                    continue;
                File.Copy(files[0], checkFile);
                break;
            }
        }
    }

    internal static void Set(Configuration? configuration, long ticks, List<PersonContainer> personContainers, string? a2PeopleSingletonDirectory, string eDistanceContentDirectory, Dictionary<long, PersonContainer> personKeyToPersonContainer, List<PersonContainer> notMappedPersonContainers, Dictionary<int, List<int>> skipCollection, Dictionary<int, List<int>> skipNotSkipCollection, Dictionary<int, Dictionary<int, PersonContainer[]>> idThenNormalizedRectangleToPersonContainers)
    {
        if (configuration is null)
            throw new NullReferenceException(nameof(configuration));
        string message;
        int totalSeconds;
        List<long> personKeys = new();
        List<long?> nullablePersonKeyCollection = new();
        List<string> personKeyFormattedCollection = new();
        Dictionary<string, string> personKeyFormattedToNewestPersonKeyFormatted = new();
        Dictionary<string, PersonContainer> personKeyFormattedToPersonContainer = new();
        Dictionary<long, List<PersonContainer>> personKeyToPersonContainerCollection = new();
        List<(string, string[], int, int)> personKeyFormattedIdThenNormalizedRectangleCollection = new();
        List<(string[], PersonContainer)> possiblyNewPersonDisplayDirectoryNamesAndPersonContainer = new();
        SetPersonCollections(configuration, personContainers, a2PeopleSingletonDirectory, personKeys, personKeyFormattedToNewestPersonKeyFormatted, personKeyFormattedCollection, skipCollection, skipNotSkipCollection);
        personContainers.AddRange(GetNonSpecificPeopleCollection(configuration, ticks, personKeys));
        totalSeconds = (int)Math.Floor(new TimeSpan(DateTime.Now.Ticks - ticks).TotalSeconds);
        string[] ticksDirectories = Directory.GetDirectories(eDistanceContentDirectory, "*", SearchOption.TopDirectoryOnly);
        message = $") {ticksDirectories.Length:000} compile from and clean ticks Director(ies) - B - {totalSeconds} total second(s)";
        List<(string, string[], string)> collection = DeleteEmptyDirectoriesAndGetCollection(configuration, personKeyFormattedCollection, ticksDirectories, message);
        (int unableToMatchCount, int duplicateCount) = SetCollectionsAndGetUnableToConvertCount(configuration, ticks, personKeyFormattedToNewestPersonKeyFormatted, personKeyFormattedIdThenNormalizedRectangleCollection, collection);
        SetKeyValuePairs(configuration, personContainers, personKeyToPersonContainerCollection, personKeyFormattedToPersonContainer, personKeyFormattedIdThenNormalizedRectangleCollection, personKeyToPersonContainer, idThenNormalizedRectangleToPersonContainers, possiblyNewPersonDisplayDirectoryNamesAndPersonContainer);
        totalSeconds = (int)Math.Floor(new TimeSpan(DateTime.Now.Ticks - ticks).TotalSeconds);
        message = $") {collection.Count:000} message from ticks Director(ies) - D - {duplicateCount} Duplicate Count {unableToMatchCount} Unable To Match Count / {collection.Count} Collection - {totalSeconds} total second(s)";
        ProgressBarOptions options = new() { ProgressCharacter = '─', ProgressBarOnBottom = true, DisableBottomPercentage = true };
        using (ProgressBar progressBar = new(collection.Count, message, options))
        {
            foreach (KeyValuePair<int, Dictionary<int, PersonContainer[]>> keyValuePair in idThenNormalizedRectangleToPersonContainers)
            {
                progressBar.Tick();
                foreach (KeyValuePair<int, PersonContainer[]> keyValue in keyValuePair.Value)
                    nullablePersonKeyCollection.AddRange(from l in keyValue.Value select l.Key);
            }
        }
        long[] personKeyCollection = (from l in nullablePersonKeyCollection where l is not null select l.Value).Distinct().ToArray();
        SetPersonKeyToPersonContainer(configuration, personContainers, personKeyCollection, personKeyToPersonContainer, personKeyToPersonContainerCollection);
        notMappedPersonContainers.AddRange(GetNotMappedPersonContainers(configuration, personContainers, personKeys, personKeyCollection));
        if (possiblyNewPersonDisplayDirectoryNamesAndPersonContainer.Any())
            SavePossiblyNewPersonContainers(configuration.PersonBirthdayFormat, configuration.PersonCharacters.ToArray(), configuration.FacesFileNameExtension, a2PeopleSingletonDirectory, possiblyNewPersonDisplayDirectoryNamesAndPersonContainer);
    }

    private static string GetMappingSegmentB(long ticks, PersonBirthday personBirthday, int? approximateYears, long minimumDateTimeTicks, bool? isWrongYear)
    {
        int years;
        string result;
        TimeSpan? timeSpan = IPersonBirthday.GetTimeSpan(minimumDateTimeTicks, isWrongYear, personBirthday);
        if (timeSpan.HasValue && timeSpan.Value.Ticks < 0)
            result = "!---";
        else if (timeSpan.HasValue)
        {
            (years, _) = IPersonBirthday.GetAge(minimumDateTimeTicks, personBirthday);
            result = $"^{years:000}";
        }
        else if (approximateYears.HasValue)
        {
            DateTime dateTime = new(ticks);
            (years, _) = IAge.GetAge(minimumDateTimeTicks, dateTime.AddYears(-approximateYears.Value));
            result = $"~{years:000}";
        }
        else
        {
            string isWrongYearFlag = IItem.GetWrongYearFlag(isWrongYear);
            result = $"{isWrongYearFlag}{new DateTime(minimumDateTimeTicks):yyyy}";
        }
        return result;
    }

    internal static string GetMappingSegmentB(long ticks, PersonBirthday personBirthday, int? approximateYears, DateTime minimumDateTime, bool? isWrongYear)
    {
        string result = GetMappingSegmentB(ticks, personBirthday, approximateYears, minimumDateTime.Ticks, isWrongYear);
        return result;
    }

    internal static string GetMappingSegmentB(long ticks, PersonBirthday personBirthday, int? approximateYears, MappingFromItem mappingFromItem)
    {
        string result = GetMappingSegmentB(ticks, personBirthday, approximateYears, mappingFromItem.MinimumDateTime, mappingFromItem.IsWrongYear);
        return result;
    }

    internal static SaveContainer GetDebugSaveContainer(string directory, SortingContainer sortingContainer, Mapping mapping)
    {
        SaveContainer result;
        if (sortingContainer.Mapping.MappingFromLocation is null)
            throw new NullReferenceException(nameof(sortingContainer.Mapping.MappingFromLocation));
        FileHolder faceFileHolder = new($"C:/{sortingContainer.Sorting.Id}.{sortingContainer.Sorting.NormalizedRectangle}");
        string shortcutFile = Path.Combine(directory, $"{sortingContainer.Mapping.MappingFromLocation.DeterministicHashCodeKey}{sortingContainer.Mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}.debug.lnk");
        result = new(directory, faceFileHolder, mapping.MappingFromItem.ResizedFileHolder, shortcutFile);
        return result;
    }

    private static IEnumerable<(string, string)> GetCollection(string[] yearDirectories)
    {
        foreach (string l in yearDirectories)
            yield return new(l, Path.GetFileName(l));
    }

    internal static void SaveMappingShortcuts(string mappingDirectory)
    {
        string? shortcutFileName;
        string[] yearDirectories;
        string personKeyFormatted;
        string[] personNameDirectories;
        WindowsShortcut windowsShortcut;
        string personDisplayDirectoryName;
        (string, string)[] yearDirectoryNameCheck;
        List<(string, string)> yearDirectoryNames = new();
        string[] personKeyDirectories = Directory.GetDirectories(mappingDirectory, "*", SearchOption.TopDirectoryOnly);
        foreach (string personKeyDirectory in personKeyDirectories)
        {
            windowsShortcut = new();
            shortcutFileName = null;
            yearDirectoryNames.Clear();
            personKeyFormatted = Path.GetFileName(personKeyDirectory);
            yearDirectories = Directory.GetDirectories(personKeyDirectory, "*", SearchOption.TopDirectoryOnly);
            yearDirectoryNames.AddRange(GetCollection(yearDirectories));
            yearDirectoryNameCheck = (from l in yearDirectoryNames where l.Item2.Contains('^') select l).OrderByDescending(l => l.Item2).ToArray();
            if (!yearDirectoryNameCheck.Any())
                yearDirectoryNameCheck = (from l in yearDirectoryNames where l.Item2.Contains('~') select l).OrderByDescending(l => l.Item2).ToArray();
            if (!yearDirectoryNameCheck.Any())
                yearDirectoryNameCheck = (from l in yearDirectoryNames where l.Item2.Contains('=') select l).OrderByDescending(l => l.Item2).ToArray();
            if (!yearDirectoryNameCheck.Any())
                yearDirectoryNameCheck = (from l in yearDirectoryNames select l).OrderByDescending(l => l).ToArray();
            if (!yearDirectoryNameCheck.Any())
                continue;
            foreach ((string yearDirectory, string yearDirectoryName) in yearDirectoryNameCheck)
            {
                personNameDirectories = Directory.GetDirectories(yearDirectory, "*", SearchOption.TopDirectoryOnly);
                foreach (string personNameDirectory in personNameDirectories)
                {
                    personDisplayDirectoryName = Path.GetFileName(personNameDirectory).Split('-')[0];
                    if (personDisplayDirectoryName is null)
                        continue;
                    windowsShortcut.Path = yearDirectory;
                    windowsShortcut.Description = yearDirectoryName;
                    shortcutFileName = Path.Combine(mappingDirectory, $"{personDisplayDirectoryName} [{windowsShortcut.Description}].lnk");
                    break;
                }
                if (shortcutFileName is not null)
                {
                    if (!File.Exists(shortcutFileName))
                        break;
                }
            }
            if (shortcutFileName is null || windowsShortcut.Path is null || windowsShortcut.Description is null)
                continue;
            try
            {
                windowsShortcut.Save(shortcutFileName);
                windowsShortcut.Dispose();
            }
            catch (Exception)
            { }
        }
    }

    internal static List<(long, string)> GetDisplayDirectoryAllFiles(PersonContainer[] personContainers)
    {
        List<(long, string)> results = new();
        List<string> distinct = new();
        foreach (PersonContainer personContainer in personContainers)
        {
            if (personContainer.Key is null)
                continue;
            foreach (string displayDirectoryAllFile in personContainer.DisplayDirectoryAllFiles)
            {
                if (displayDirectoryAllFile.EndsWith(".json"))
                    continue;
                if (distinct.Contains(displayDirectoryAllFile))
                    continue;
                distinct.Add(displayDirectoryAllFile);
                results.Add(new(personContainer.Key.Value, displayDirectoryAllFile));
            }
        }
        return results;
    }

    internal static Dictionary<int, List<long>> GetIdToPersonKeys(Dictionary<long, List<int>> personKeyToIds)
    {
        Dictionary<int, List<long>> results = new();
        List<long>? collection;
        foreach (KeyValuePair<long, List<int>> keyValuePair in personKeyToIds)
        {
            foreach (int id in keyValuePair.Value)
            {
                if (!results.TryGetValue(id, out collection))
                {
                    results.Add(id, new());
                    if (!results.TryGetValue(id, out collection))
                        throw new Exception();
                }
                if (collection.Contains(keyValuePair.Key))
                    continue;
                collection.Add(keyValuePair.Key);
            }
        }
        return results;
    }

    internal static Mapping[] GetSelectedMappingCollection(List<Face> distinctFilteredFaces)
    {
        Mapping[] results;
        IEnumerable<Mapping> collection = from l in distinctFilteredFaces orderby l.Mapping?.MappingFromItem.Id select l.Mapping;
        results = (from l in collection where l is not null select l).ToArray();
        return results;
    }

    internal static Dictionary<int, Dictionary<int, Mapping>> GetIdToNormalizedRectangleToFace(Mapping[] mappingCollection)
    {
        Dictionary<int, Dictionary<int, Mapping>> results = new();
        Dictionary<int, Mapping>? keyValuePairs;
        foreach (Mapping mapping in mappingCollection)
        {
            if (mapping.MappingFromLocation is null)
                continue;
            if (!results.TryGetValue(mapping.MappingFromItem.Id, out keyValuePairs))
            {
                results.Add(mapping.MappingFromItem.Id, new());
                if (!results.TryGetValue(mapping.MappingFromItem.Id, out keyValuePairs))
                    throw new Exception();
            }
            if (keyValuePairs.ContainsKey(mapping.MappingFromLocation.NormalizedRectangle))
                continue;
            keyValuePairs.Add(mapping.MappingFromLocation.NormalizedRectangle, mapping);
        }
        return results;
    }

}