using Humanizer;
using ShellProgressBar;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Drawing;
using System.Globalization;
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 record Record(string PersonKeyFormatted,
                          string[] PersonDisplayDirectoryNames,
                          bool IsDefault,
                          string MappedFaceFile);

    private record TicksDirectory(string Directory,
                                  string DirectoryName,
                                  long DirectoryTicks,
                                  float? TotalDays);

    private record PersonKeyFormattedIdThenWholePercentages(string PersonKeyFormatted,
                                                            string[] PersonDisplayDirectoryNames,
                                                            bool IsDefault,
                                                            string MappedFaceFile,
                                                            int Id,
                                                            int WholePercentages);

    private static void SetPersonCollections(Configuration configuration, ReadOnlyCollection<PersonContainer> personContainers, string? a2PeopleSingletonDirectory, Dictionary<string, string> personKeyFormattedToNewestPersonKeyFormatted, List<string> personKeyFormattedCollection, Dictionary<int, List<int>> skipCollection, Dictionary<int, List<int>> skipNotSkipCollection)
    {
        int? id;
        int? wholePercentages;
        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, wholePercentages) = IMapping.GetConverted(configuration.FacesFileNameExtension, personDisplayDirectoryAllFile);
                if (id is null || wholePercentages 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(wholePercentages.Value);
                }
                else
                {
                    if (!skipNotSkipCollection.ContainsKey(id.Value))
                        skipNotSkipCollection.Add(id.Value, new());
                    skipNotSkipCollection[id.Value].Add(wholePercentages.Value);
                }
            }
            if (personContainer.Key is null || personContainer.Birthdays is null || personContainer.Birthdays.Length == 0)
                continue;
            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);
            }
        }
    }

    private static void MoveTo(string actionDirectory, TicksDirectory ticksDirectory, string directory, string personKeyFormatted, string yearDirectoryName, string alphaDirectoryName, string[] files, string[] facesFileNames)
    {
        string checkFile;
        string actionDirectoryName = Path.GetFileName(actionDirectory);
        string checkDirectory = actionDirectoryName.StartsWith("y", StringComparison.CurrentCultureIgnoreCase) ? Path.Combine(ticksDirectory.Directory, personKeyFormatted, yearDirectoryName, alphaDirectoryName) : Path.Combine(directory, actionDirectoryName);
        if (!Directory.Exists(checkDirectory))
            _ = Directory.CreateDirectory(checkDirectory);
        foreach (string file in files)
        {
            if (facesFileNames.Contains(file))
            {
                checkFile = Path.Combine(checkDirectory, Path.GetFileName(file));
                if (File.Exists(checkFile))
                    continue;
                File.Move(file, checkFile);
                continue;
            }
            File.Delete(file);
        }
    }

    private static void Individually(Configuration configuration, TicksDirectory ticksDirectory, string directory)
    {
        bool isDefault;
        string[] files;
        FileInfo[] collection;
        string[] facesFileNames;
        string yearDirectoryName;
        string[] yearDirectories;
        string alphaDirectoryName;
        string matchDirectoryName;
        string personKeyFormatted;
        string[] alphaDirectories;
        string[] matchDirectories;
        string[] actionDirectories;
        string personDisplayDirectory;
        string[] personKeyDirectories;
        string[] segmentCDirectories = Directory.GetDirectories(directory, "*", SearchOption.TopDirectoryOnly);
        foreach (string segmentCDirectory in segmentCDirectories)
        {
            personKeyDirectories = Directory.GetDirectories(segmentCDirectory, "*", SearchOption.TopDirectoryOnly);
            foreach (string personKeyDirectory in personKeyDirectories)
            {
                personKeyFormatted = Path.GetFileName(personKeyDirectory);
                yearDirectories = Directory.GetDirectories(personKeyDirectory, "*", SearchOption.TopDirectoryOnly);
                foreach (string yearDirectory in yearDirectories)
                {
                    yearDirectoryName = Path.GetFileName(yearDirectory);
                    if (yearDirectoryName.StartsWith('='))
                        Directory.Move(yearDirectory, yearDirectory.Replace('=', '~'));
                }
                yearDirectories = Directory.GetDirectories(personKeyDirectory, "*", SearchOption.TopDirectoryOnly);
                foreach (string yearDirectory in yearDirectories)
                {
                    yearDirectoryName = Path.GetFileName(yearDirectory);
                    matchDirectories = Directory.GetDirectories(yearDirectory, "*", SearchOption.TopDirectoryOnly);
                    alphaDirectories = matchDirectories.Where(l => !long.TryParse(Path.GetFileName(l), out long a)).ToArray();
                    if (!alphaDirectories.Any())
                        continue;
                    alphaDirectoryName = Path.GetFileName(alphaDirectories[0]);
                    foreach (string matchDirectory in matchDirectories)
                    {
                        matchDirectoryName = Path.GetFileName(matchDirectory);
                        files = Directory.GetFiles(matchDirectory, "*", SearchOption.TopDirectoryOnly);
                        if (files.Length != 4)
                            continue;
                        collection = files.Select(l => new FileInfo(l)).ToArray();
                        isDefault = alphaDirectoryName.First() == 'X' && IPersonBirthday.IsCounterPersonYear(personKeyFormatted[..4]);
                        if (isDefault)
                            facesFileNames = (from l in collection where l.Extension == configuration.FacesFileNameExtension select l.FullName).ToArray();
                        else
                            facesFileNames = (from l in collection where l.Extension == configuration.FacesFileNameExtension && l.Name.Contains(matchDirectoryName) select l.FullName).ToArray();
                        if (!facesFileNames.Any())
                            continue;
                        personDisplayDirectory = Path.Combine(matchDirectory, alphaDirectoryName);
                        if (!Directory.Exists(personDisplayDirectory) || !Directory.Exists(matchDirectory))
                            continue;
                        _ = Process.Start("explorer", matchDirectory);
                        for (int i = 0; i < int.MaxValue; i++)
                        {
                            Thread.Sleep(500);
                            actionDirectories = Directory.GetDirectories(matchDirectory, "*", SearchOption.TopDirectoryOnly).Where(l => l != personDisplayDirectory && !l.EndsWith("Maybe")).ToArray();
                            if (actionDirectories.Any())
                            {
                                MoveTo(actionDirectories[0], ticksDirectory, directory, personKeyFormatted, yearDirectoryName, alphaDirectoryName, files, facesFileNames);
                                break;
                            }
                        }
                    }
                }
            }
        }
    }

    private static void MoveFiles(string personKeyFormatted, string personKeyDirectory, string newestPersonKeyFormatted, string newestPersonKeyDirectory)
    {
        string[] files;
        string checkFile;
        string? checkDirectory;
        string[] directories = Directory.GetDirectories(personKeyDirectory, "*", SearchOption.TopDirectoryOnly);
        foreach (string directory in directories)
        {
            checkDirectory = Path.Combine(newestPersonKeyDirectory, Path.GetFileName(directory));
            if (!Directory.Exists(checkDirectory))
                Directory.Move(directory, checkDirectory);
            else
            {
                files = Directory.GetFiles(directory, "*", SearchOption.AllDirectories);
                foreach (string file in files)
                {
                    if (file.Split(personKeyFormatted).Length != 2 || file.Contains(newestPersonKeyFormatted))
                        continue;
                    checkFile = file.Replace(personKeyFormatted, newestPersonKeyFormatted);
                    checkDirectory = Path.GetDirectoryName(checkFile);
                    if (checkDirectory is null)
                        continue;
                    if (File.Exists(checkFile))
                        continue;
                    if (!Directory.Exists(checkDirectory))
                        _ = Directory.CreateDirectory(checkDirectory);
                    File.Move(file, checkFile);
                }
            }
        }
    }

    private static void MovedToNewestPersonKeyFormatted(string personKeyFormatted, string newestPersonKeyFormatted, TicksDirectory ticksDirectory, string personKeyDirectory)
    {
        string newestPersonKeyDirectory = Path.Combine(ticksDirectory.Directory, newestPersonKeyFormatted);
        if (Directory.Exists(newestPersonKeyDirectory))
            MoveFiles(personKeyFormatted, personKeyDirectory, newestPersonKeyFormatted, newestPersonKeyDirectory);
        else
            Directory.Move(personKeyDirectory, newestPersonKeyDirectory);
    }

    private static void RenameUnknown(string[] files)
    {
        foreach (string file in files)
        {
            if (file.EndsWith(".unk"))
                continue;
            File.Move(file, $"{file}.unk");
        }
    }

    private static List<Record> DeleteEmptyDirectoriesAndGetCollection(Configuration configuration, Dictionary<string, string> personKeyFormattedToNewestPersonKeyFormatted, List<string> personKeyFormattedCollection, List<TicksDirectory> ticksDirectories, string message)
    {
        List<Record> results = new();
        int? id;
        bool isDefault;
        string[] files;
        string fileName;
        DateTime dateTime;
        TimeSpan timeSpan;
        bool check = false;
        int? wholePercentages;
        string checkDirectory;
        string[] yearDirectories;
        string personKeyFormatted;
        string? personFirstInitial;
        bool isReservedDirectoryName;
        List<string> distinct = new();
        string[] personKeyDirectories;
        string[] personNameDirectories;
        string? newestPersonKeyFormatted;
        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.Count, message, options);
        foreach (TicksDirectory ticksDirectory in ticksDirectories)
        {
            progressBar.Tick();
            personKeyDirectories = Directory.GetDirectories(ticksDirectory.Directory, "*", 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));
                if (!isReservedDirectoryName && personKeyFormatted.StartsWith(nameof(Shared.Models.Stateless.IMapLogic.Individually)))
                {
                    Individually(configuration, ticksDirectory, personKeyDirectory);
                    throw new Exception($"B) Move personKey directories up one from {nameof(Shared.Models.Stateless.IMapLogic.Sorting)} and delete {nameof(Shared.Models.Stateless.IMapLogic.Sorting)} directory!");
                }
                _ = personKeyFormattedToNewestPersonKeyFormatted.TryGetValue(personKeyFormatted, out newestPersonKeyFormatted);
                if (personKeyFormattedToNewestPersonKeyFormatted.Count > 0 && newestPersonKeyFormatted is null)
                {
                    timeSpan = new TimeSpan(DateTime.Now.Ticks - ticksDirectory.DirectoryTicks);
                    if (timeSpan.TotalDays > 7)
                        throw new Exception($"{configuration.MappingDefaultName} are only allowed within x days!");
                }
                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;
                        isDefault = personDisplayDirectoryNames[^1].First() == 'X' && IPersonBirthday.IsCounterPersonYear(personKeyFormatted[..4]);
                        if (isDefault && personDisplayDirectoryNames[^1].Length == 1)
                        {
                            if (personKeyFormatted.Length != configuration.PersonBirthdayFormat.Length || !DateTime.TryParseExact(personKeyFormatted, configuration.PersonBirthdayFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out dateTime))
                                continue;
                            checkDirectory = Path.Combine(yearDirectory, $"X]{dateTime.Ticks}");
                            if (Directory.Exists(checkDirectory))
                            {
                                Directory.Delete(yearDirectory, recursive: true);
                                continue;
                            }
                            Directory.Move(personNameDirectory, checkDirectory);
                            if (!check)
                                check = true;
                            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 (!isDefault)
                        {
                            if (personKeyFormattedToNewestPersonKeyFormatted.Count > 0 && newestPersonKeyFormatted is null)
                                RenameUnknown(files);
                            else if (newestPersonKeyFormatted is not null && personKeyFormatted != newestPersonKeyFormatted)
                            {
                                if (!check)
                                    check = true;
                                MovedToNewestPersonKeyFormatted(personKeyFormatted, newestPersonKeyFormatted, ticksDirectory, personKeyDirectory);
                                continue;
                            }
                        }
                        if (personKeyFormatted.Length != configuration.PersonBirthdayFormat.Length)
                            continue;
                        if (personDisplayDirectoryNames[^1].Length == 1 || isDefault || !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());
                            if (Directory.Exists(personFirstInitialDirectory))
                                throw new Exception("Forgot to ...");
                            Directory.Move(personNameDirectory, personFirstInitialDirectory);
                            files = Directory.GetFiles(personFirstInitialDirectory, "*", SearchOption.TopDirectoryOnly);
                        }
                        foreach (string mappedFaceFile in files)
                        {
                            if (mappedFaceFile.EndsWith(".lnk"))
                                continue;
                            (id, wholePercentages) = IMapping.GetConverted(configuration.FacesFileNameExtension, mappedFaceFile);
                            if (id is null || wholePercentages is null)
                                continue;
                            fileName = Path.GetFileName(mappedFaceFile);
                            if (distinct.Contains(fileName))
                            {
                                if (!File.Exists($"{mappedFaceFile}.dup"))
                                    File.Move(mappedFaceFile, $"{mappedFaceFile}.dup");
                                continue;
                            }
                            distinct.Add(fileName);
                            results.Add(new(personKeyFormatted, personDisplayDirectoryNames, isDefault, mappedFaceFile));
                        }
                        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.Directory);
            _ = IPath.DeleteEmptyDirectories(ticksDirectory.Directory);
        }
        if (check)
            throw new Exception("PersonKey director(ies) where renamed. Please restart!");
        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 SetKeyValuePairsAndAddToCollections(Configuration configuration, ReadOnlyCollection<PersonContainer> personContainers, Dictionary<long, List<PersonContainer>> personKeyToPersonContainerCollection, Dictionary<string, PersonContainer> personKeyFormattedToPersonContainer, List<PersonKeyFormattedIdThenWholePercentages> personKeyFormattedIdThenWholePercentagesCollection, Dictionary<long, PersonContainer> personKeyToPersonContainer, Dictionary<int, Dictionary<int, PersonContainer[]>> idThenWholePercentagesToPersonContainers, List<(PersonKeyFormattedIdThenWholePercentages, PersonContainer)> possiblyNewPersonDisplayDirectoryNamesAndPersonContainer)
    {
        PersonBirthday? personBirthday;
        PersonContainer[] distinctPersonContainers;
        (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>>> idThenWholePercentagesToPersonContainerCollection = new();
        if (personKeyFormattedIdThenWholePercentagesCollection.Any())
        {
            string group;
            char[] matches;
            char status, sex, first;
            PersonContainer personContainer;
            PersonDirectory personDirectory;
            string personDisplayDirectoryName;
            foreach (PersonKeyFormattedIdThenWholePercentages personKeyFormattedIdThenWholePercentages in personKeyFormattedIdThenWholePercentagesCollection)
            {
                personBirthday = IPersonBirthday.GetPersonBirthday(configuration.PersonBirthdayFormat, personKeyFormattedIdThenWholePercentages.PersonKeyFormatted);
                if (personBirthday is null)
                    continue;
                if (!personKeyFormattedToPersonContainer.ContainsKey(personKeyFormattedIdThenWholePercentages.PersonKeyFormatted))
                {
                    personDisplayDirectoryName = personKeyFormattedIdThenWholePercentages.PersonDisplayDirectoryNames[^1];
                    matches = configuration.PersonCharacters.Where(l => personDisplayDirectoryName.Contains(l)).ToArray();
                    if (matches.Length == 0)
                        throw new NotSupportedException();
                    group = IPerson.GetHourGroup(personDisplayDirectoryName, personBirthday.Value.Hour);
                    (status, sex, first) = IPerson.GetPersonHour(personDisplayDirectoryName, personBirthday.Value.Hour);
                    personDirectory = new(matches.First(), group, status, sex, first);
                    personContainer = new(configuration.PersonCharacters.ToArray(), personBirthday, personDisplayDirectoryName, personDirectory);
                    personKeyFormattedToPersonContainer.Add(personKeyFormattedIdThenWholePercentages.PersonKeyFormatted, personContainer);
                }
                if (!idThenWholePercentagesToPersonContainerCollection.ContainsKey(personKeyFormattedIdThenWholePercentages.Id))
                    idThenWholePercentagesToPersonContainerCollection.Add(personKeyFormattedIdThenWholePercentages.Id, new());
                if (!idThenWholePercentagesToPersonContainerCollection[personKeyFormattedIdThenWholePercentages.Id].ContainsKey(personKeyFormattedIdThenWholePercentages.WholePercentages))
                    idThenWholePercentagesToPersonContainerCollection[personKeyFormattedIdThenWholePercentages.Id].Add(personKeyFormattedIdThenWholePercentages.WholePercentages, new());
                idThenWholePercentagesToPersonContainerCollection[personKeyFormattedIdThenWholePercentages.Id][personKeyFormattedIdThenWholePercentages.WholePercentages].Add(personKeyFormattedToPersonContainer[personKeyFormattedIdThenWholePercentages.PersonKeyFormatted]);
                possiblyNewPersonDisplayDirectoryNamesAndPersonContainer.Add(new(personKeyFormattedIdThenWholePercentages, personKeyFormattedToPersonContainer[personKeyFormattedIdThenWholePercentages.PersonKeyFormatted]));
            }
        }
        foreach (KeyValuePair<int, Dictionary<int, List<PersonContainer>>> keyValuePair in idThenWholePercentagesToPersonContainerCollection)
        {
            idThenWholePercentagesToPersonContainers.Add(keyValuePair.Key, new());
            foreach (KeyValuePair<int, List<PersonContainer>> innerKeyValuePair in keyValuePair.Value)
            {
                distinctPersonContainers = GetDistinctPersonContainers(innerKeyValuePair.Value);
                idThenWholePercentagesToPersonContainers[keyValuePair.Key].Add(innerKeyValuePair.Key, distinctPersonContainers);
            }
        };
    }

    private static (long, PersonContainer)[] GetDistinctCollection(Configuration configuration, IEnumerable<PersonContainer> personContainers, Dictionary<long, List<PersonContainer>> personKeyToPersonContainerCollection, Dictionary<string, PersonContainer> personKeyFormattedToPersonContainer)
    {
        (long, PersonContainer)[] results;
        const int zero = 0;
        List<string> errors = new();
        string newestPersonKeyFormatted;
        List<(long PersonKey, PersonContainer PersonContainer)> collection = new();
        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)
                errors.Add(keyValuePair.Value[zero].DisplayDirectoryName);
            collection.Add(new(keyValuePair.Key, keyValuePair.Value[zero]));
        }
        if (errors.Any())
            throw new Exception(string.Join(Environment.NewLine, errors));
        results = (from l in collection orderby l.PersonKey descending select (l.PersonKey, l.PersonContainer)).ToArray();
        return results;
    }

    private static int SetCollectionsAndGetUnableToConvertCount(Configuration configuration, long ticks, List<PersonKeyFormattedIdThenWholePercentages> personKeyFormattedIdThenWholePercentagesCollection, List<Record> collection)
    {
        int result = 0;
        int? id;
        int? wholePercentages;
        string personDisplayDirectoryName;
        List<int> wholePercentagesCollection;
        Dictionary<int, List<int>> idToWholePercentagesCollection = 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 (Record record in collection)
        {
            progressBar.Tick();
            (id, wholePercentages) = IMapping.GetConverted(configuration.FacesFileNameExtension, record.MappedFaceFile);
            if (id is null || wholePercentages is null)
            {
                result++;
                continue;
            }
            if (!idToWholePercentagesCollection.ContainsKey(id.Value))
                idToWholePercentagesCollection.Add(id.Value, new());
            wholePercentagesCollection = idToWholePercentagesCollection[id.Value];
            wholePercentagesCollection.Add(wholePercentages.Value);
            idToWholePercentagesCollection[id.Value].Add(wholePercentages.Value);
            personDisplayDirectoryName = record.PersonDisplayDirectoryNames[^1];
            if (string.IsNullOrEmpty(personDisplayDirectoryName))
                continue;
            personKeyFormattedIdThenWholePercentagesCollection.Add(new(record.PersonKeyFormatted, record.PersonDisplayDirectoryNames, record.IsDefault, record.MappedFaceFile, id.Value, wholePercentages.Value));
        }
        return result;
    }

    private static List<PersonContainer> GetNonSpecificPeopleCollection(Configuration configuration, long ticks, List<long> personKeys)
    {
        List<PersonContainer> results = new();
        bool check;
        long personKey;
        int? approximateYears = null;
        PersonBirthday personBirthday;
        PersonContainer personContainer;
        string[] personDisplayDirectoryAllFiles = Array.Empty<string>();
        DateTime incrementDate = new(configuration.PersonBirthdayFirstYear, 1, 1);
        long oneHour = new DateTime(1, 1, 1, 1, 0, 0).Ticks - new DateTime(1, 1, 1).Ticks;
        for (int i = 0; i < int.MaxValue; i++)
        {
            check = false;
            personKey = incrementDate.Ticks;
            incrementDate = incrementDate.AddDays(1);
            if (incrementDate.Ticks > ticks)
                break;
            if (personKeys.Contains(personKey))
                continue;
            for (int j = 1; j < 24; j++)
            {
                if (personKeys.Contains(personKey + (oneHour * j)))
                {
                    check = true;
                    break;
                }
            }
            if (check)
                continue;
            personBirthday = IPersonBirthday.GetPersonBirthday(personKey + (oneHour * 2));
            personContainer = new(approximateYears, new PersonBirthday[] { personBirthday }, personDisplayDirectoryAllFiles, configuration.MappingDefaultName, personKey);
            results.Add(personContainer);
            if (results.Count > 99)
                break;
        }
        return results;
    }

    private static List<PersonContainer> GetNotMappedPersonContainers(Configuration configuration, long ticks, ReadOnlyCollection<PersonContainer> personContainers, long[] personKeyCollection)
    {
        List<PersonContainer> results = new();
        List<PersonContainer> notMappedAndNotNamedPersonKeys = new();
        List<PersonContainer> notMappedAndWithNamedPersonKeys = new();
        List<long> personKeys = IPersonContainer.GetPersonKeys(personContainers);
        foreach (PersonContainer personContainer in personContainers)
        {
            if (personContainer.Key is null || personContainer.Birthdays is null || personContainer.Birthdays.Length == 0)
                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);
        if (results.Count == 0)
            results.AddRange(GetNonSpecificPeopleCollection(configuration, ticks, personKeys));
        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, ReadOnlyCollection<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].PersonDirectory, displayDirectoryName, personKey);
                personKeyToPersonContainer.Add(personKey, personContainer);
            }
        }
    }

    static void PossiblyRebuildPersonContainers(Configuration configuration, string? a2PeopleSingletonDirectory, Dictionary<string, string> personKeyFormattedToNewestPersonKeyFormatted, List<(PersonKeyFormattedIdThenWholePercentages, PersonContainer)> possiblyNewPersonDisplayDirectoryNamesAndPersonContainer)
    {
        bool[] matches;
        string fileName;
        string checkFile;
        const int zero = 0;
        string personKeyFormatted;
        string[] deleteCollection;
        List<string> distinct = new();
        PersonBirthday personBirthday;
        string personDisplayDirectory;
        string personKeyFormattedDirectory;
        foreach ((PersonKeyFormattedIdThenWholePercentages personKeyFormattedIdThenWholePercentages, PersonContainer personContainer) in possiblyNewPersonDisplayDirectoryNamesAndPersonContainer)
        {
            if (distinct.Contains(personKeyFormattedIdThenWholePercentages.PersonKeyFormatted))
                continue;
            if (a2PeopleSingletonDirectory is null || personContainer.Key is null || personContainer.Birthdays is null || personContainer.PersonDirectory is null || personContainer.Birthdays.Length == 0)
                continue;
            fileName = $"{Path.GetFileName(personKeyFormattedIdThenWholePercentages.MappedFaceFile)}{configuration.FacesHiddenFileNameExtension}";
            matches = (from l in personContainer.DisplayDirectoryAllFiles where l.EndsWith(fileName) select true).ToArray();
            if (matches.Length > 0)
                continue;
            matches = (from l in personContainer.DisplayDirectoryAllFiles where l.EndsWith(configuration.FacesHiddenFileNameExtension) select true).ToArray();
            if (matches.Length > 0)
                continue;
            personBirthday = personContainer.Birthdays[zero];
            personKeyFormatted = IPersonBirthday.GetFormatted(configuration.PersonBirthdayFormat, personBirthday);
            personDisplayDirectory = Path.Combine(a2PeopleSingletonDirectory, personContainer.PersonDirectory.Char.ToString(), personContainer.PersonDirectory.Group, personContainer.DisplayDirectoryName);
            personKeyFormattedDirectory = Path.GetFullPath(Path.Combine(personDisplayDirectory, personKeyFormatted));
            deleteCollection = (from l in personContainer.DisplayDirectoryAllFiles where l.StartsWith(personKeyFormattedDirectory) select l).ToArray();
            if (personKeyFormattedToNewestPersonKeyFormatted.Count > 0 && personContainer.DisplayDirectoryAllFiles.Length != 0 && deleteCollection.Length == 0)
                throw new NotSupportedException();
            if (!Directory.Exists(personKeyFormattedDirectory))
                _ = Directory.CreateDirectory(personKeyFormattedDirectory);
            if (!File.Exists(personKeyFormattedIdThenWholePercentages.MappedFaceFile))
                continue;
            checkFile = Path.Combine(personKeyFormattedDirectory, $"{Path.GetFileName(personKeyFormattedIdThenWholePercentages.MappedFaceFile)}{configuration.FacesHiddenFileNameExtension}");
            if (File.Exists(checkFile))
                continue;
            File.Copy(personKeyFormattedIdThenWholePercentages.MappedFaceFile, checkFile);
            foreach (string delete in deleteCollection)
            {
                if (delete.EndsWith(".lnk"))
                    continue;
                if (!File.Exists(delete))
                    continue;
                File.Delete(delete);
            }
            Directory.SetLastWriteTime(personDisplayDirectory, DateTime.Now);
            distinct.Add(personKeyFormattedIdThenWholePercentages.PersonKeyFormatted);
        }
    }

    private static List<TicksDirectory> UpdateDateVerifyAndGetTicksDirectories(string eDistanceContentDirectory)
    {
        List<TicksDirectory> results = new();
        float? totalDays;
        string ticksDirectoryName;
        DirectoryInfo directoryInfo;
        long? lastDirectoryTicks = null;
        DateTime dateTime = DateTime.Now;
        for (int i = 1; i < 5; i++)
            _ = IPath.DeleteEmptyDirectories(eDistanceContentDirectory);
        string[] ticksDirectories = Directory.GetDirectories(eDistanceContentDirectory, "*", SearchOption.TopDirectoryOnly);
        foreach (string ticksDirectory in ticksDirectories)
        {
            ticksDirectoryName = Path.GetFileName(ticksDirectory);
            if (ticksDirectoryName.Length < 3 || ticksDirectoryName.First() != '(' || ticksDirectoryName[^1] != ')')
                continue;
            if (!long.TryParse(ticksDirectoryName[1..^1], out long directoryTicks))
            {
                if (!long.TryParse(ticksDirectoryName[1..^4], out directoryTicks))
                    throw new NotSupportedException();
            }
            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));
            totalDays = lastDirectoryTicks is null || new TimeSpan(dateTime.Ticks - directoryTicks).TotalDays < 1 ? null : (float)new TimeSpan(directoryTicks - lastDirectoryTicks.Value).TotalDays;
            results.Add(new(ticksDirectory, ticksDirectoryName, directoryTicks, totalDays));
            lastDirectoryTicks = directoryTicks;
        }
        string[] compare = (from l in results where l.TotalDays is not null and < 3.95f select l.Directory).ToArray();
        if (compare.Any())
            throw new Exception($"Please Consolidate <{string.Join(Environment.NewLine, compare)}>");
        return results;
    }

    private static List<(long, string)> GetDisplayDirectoryAllFiles(string fileNameExtension, ReadOnlyCollection<PersonContainer> personContainers)
    {
        List<(long, string)> results = new();
        string fileName;
        List<string> distinct = new();
        foreach (PersonContainer personContainer in personContainers)
        {
            if (personContainer.Key is null)
                continue;
            foreach (string displayDirectoryAllFile in personContainer.DisplayDirectoryAllFiles)
            {
                fileName = Path.GetFileName(displayDirectoryAllFile);
                if (!fileName.EndsWith(fileNameExtension))
                    continue;
                if (distinct.Contains(fileName))
                    continue;
                distinct.Add(fileName);
                results.Add(new(personContainer.Key.Value, displayDirectoryAllFile));
            }
        }
        return results;
    }

    private static List<(long PersonKey, string File)> GetCollection(Configuration configuration, ReadOnlyCollection<PersonContainer> personContainers, List<Record> records)
    {
        List<(long PersonKey, string File)> results = new();
        string file;
        long personKey;
        string fileName;
        List<string> distinct = new();
        PersonBirthday? personBirthday;
        results.AddRange(GetDisplayDirectoryAllFiles(configuration.FacesFileNameExtension, personContainers));
        foreach (Record record in records)
        {
            personBirthday = IPersonBirthday.GetPersonBirthday(configuration.PersonBirthdayFormat, record.PersonKeyFormatted);
            if (personBirthday is null)
                continue;
            fileName = Path.GetFileName(record.MappedFaceFile);
            if (distinct.Contains(fileName))
                continue;
            distinct.Add(fileName);
            personKey = personBirthday.Value.Ticks;
            results.Add(new(personKey, record.MappedFaceFile));
        }
        for (int i = results.Count - 1; i > -1; i--)
        {
            file = results[i].File;
            if (file.EndsWith(".old"))
            {
                results.RemoveAt(i);
                continue;
            }
            if (!file.EndsWith(".dup") && !file.EndsWith(".unk") && !file.EndsWith(".abd"))
                continue;
            if (!File.Exists(file))
                continue;
            File.Move(file, file[..^4]);
            results[i] = new(results[i].PersonKey, file[..^4]);
        }
        return results;
    }

    private static void ParallelFor(Configuration configuration, string eDistanceContentDirectory, List<LocationContainer<MetadataExtractor.Directory>> locationContainers, long personKey, string file)
    {
        const string lnk = ".lnk";
        int? id, wholePercentages;
        IReadOnlyList<MetadataExtractor.Directory> directories;
        bool fromDistanceContent = !file.EndsWith(lnk) && file.Contains(eDistanceContentDirectory);
        if (!file.EndsWith(lnk))
            (id, wholePercentages) = IMapping.GetConverted(configuration.FacesFileNameExtension, file);
        else
            (id, wholePercentages) = IMapping.GetConverted(configuration.FacesFileNameExtension, file[..^4]);
        if (id is null || wholePercentages is null)
            return;
        if (file.EndsWith(lnk) || (!configuration.DistanceMoveUnableToMatch && !configuration.DistanceRenameToMatch) || !File.Exists(file))
            directories = new List<MetadataExtractor.Directory>();
        else
            directories = MetadataExtractor.ImageMetadataReader.ReadMetadata(file);
        RectangleF? rectangle = ILocation.GetPercentagesRectangle(configuration.LocationDigits, wholePercentages.Value);
        lock (locationContainers)
            locationContainers.Add(new(fromDistanceContent, file, personKey, id.Value, wholePercentages.Value, directories, rectangle, null));
    }

    private static void OpenPossibleDuplicates(Configuration configuration, List<(long, int, string, float?)> duplicates)
    {
        string personKeyFormatted;
        foreach ((long personKey, int id, string file, float? percent) in duplicates)
        {
            if (percent is null)
                continue;
            _ = Process.Start("explorer.exe", string.Concat("\"", Path.GetDirectoryName(file), "\""));
            personKeyFormatted = IPersonBirthday.GetFormatted(configuration.PersonBirthdayFormat, personKey);
        }
        foreach ((long personKey, int id, string file, float? percent) in duplicates)
        {
            if (percent is not null && percent.Value == 0)
                continue;
            _ = Process.Start("explorer.exe", string.Concat("\"", Path.GetDirectoryName(file), "\""));
            personKeyFormatted = IPersonBirthday.GetFormatted(configuration.PersonBirthdayFormat, personKey);
        }
        foreach ((long personKey, int id, string file, float? percent) in duplicates)
        {
            if (percent is not null && percent.Value > 0)
                continue;
            _ = Process.Start("explorer.exe", string.Concat("\"", Path.GetDirectoryName(file), "\""));
            personKeyFormatted = IPersonBirthday.GetFormatted(configuration.PersonBirthdayFormat, personKey);
        }
    }

    private static void LookForPossibleDuplicates(Configuration configuration, List<LocationContainer<MetadataExtractor.Directory>> locationContainers)
    {
        string key;
        float? percent;
        float itemPercentagesArea;
        List<string> delete = new();
        RectangleF? itemPercentagesRectangle;
        (string File, int WholePercentages) item;
        Dictionary<string, (string, int)> distinct = new();
        List<(long, int, string, float?)> duplicates = new();
        foreach (LocationContainer<MetadataExtractor.Directory> locationContainer in locationContainers)
        {
            key = string.Concat(locationContainer.PersonKey, locationContainer.Id);
            if (distinct.TryGetValue(key, out item))
            {
                if (item.WholePercentages == locationContainer.WholePercentages)
                    continue;
                itemPercentagesRectangle = ILocation.GetPercentagesRectangle(configuration.LocationDigits, item.WholePercentages);
                if (itemPercentagesRectangle is null || locationContainer.Rectangle is null)
                    percent = null;
                else
                {
                    itemPercentagesArea = itemPercentagesRectangle.Value.Width * itemPercentagesRectangle.Value.Height;
                    percent = ILocation.GetIntersectPercent(itemPercentagesRectangle.Value, itemPercentagesArea, locationContainer.Rectangle.Value);
                }
                delete.Add(item.File);
                delete.Add(locationContainer.File);
                duplicates.Add(new(locationContainer.PersonKey, locationContainer.Id, locationContainer.File, percent));
                continue;
            }
            distinct.Add(key, new(locationContainer.File, locationContainer.WholePercentages));
        }
        if (!configuration.DeletePossibleDuplicates && duplicates.Any())
            OpenPossibleDuplicates(configuration, duplicates);
        else
        {
            if (delete.Count > 5)
                throw new Exception("Something maybe wrong!");
            foreach (string file in delete)
            {
                if (File.Exists(file))
                    File.Delete(file);
            }
        }
    }

    private static List<LocationContainer<MetadataExtractor.Directory>> GetLocationContainers(int maxDegreeOfParallelism, Configuration configuration, long ticks, ReadOnlyCollection<PersonContainer> personContainers, string eDistanceContentDirectory, List<Record> records)
    {
        List<LocationContainer<MetadataExtractor.Directory>> results = new();
        List<(long PersonKey, string File)> collection = GetCollection(configuration, personContainers, records);
        if (collection.Any() && (configuration.DistanceMoveUnableToMatch || configuration.DistanceRenameToMatch))
        {
            int totalSeconds = (int)Math.Floor(new TimeSpan(DateTime.Now.Ticks - ticks).TotalSeconds);
            string message = $") Building Mapped Face Files Collection - {totalSeconds} total second(s)";
            ParallelOptions parallelOptions = new() { MaxDegreeOfParallelism = maxDegreeOfParallelism };
            ProgressBarOptions options = new() { ProgressCharacter = '─', ProgressBarOnBottom = true, DisableBottomPercentage = true };
            using ProgressBar progressBar = new(collection.Count, message, options);
            _ = Parallel.For(0, collection.Count, parallelOptions, (i, state) =>
            {
                progressBar.Tick();
                ParallelFor(configuration, eDistanceContentDirectory, results, collection[i].PersonKey, collection[i].File);
            });
        }
        LookForPossibleDuplicates(configuration, results);
        return results;
    }

    internal static void Set(int maxDegreeOfParallelism, Configuration configuration, long ticks, ReadOnlyCollection<PersonContainer> personContainers, string? a2PeopleSingletonDirectory, string eDistanceContentDirectory, Dictionary<long, PersonContainer> personKeyToPersonContainer, List<PersonContainer> notMappedPersonContainers, Dictionary<int, List<int>> skipCollection, Dictionary<int, List<int>> skipNotSkipCollection, List<LocationContainer<MetadataExtractor.Directory>> locationContainers, Dictionary<int, Dictionary<int, PersonContainer[]>> idThenWholePercentagesToPersonContainers)
    {
        string message;
        int totalSeconds;
        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<TicksDirectory> ticksDirectories = UpdateDateVerifyAndGetTicksDirectories(eDistanceContentDirectory);
        List<PersonKeyFormattedIdThenWholePercentages> personKeyFormattedIdThenWholePercentagesCollection = new();
        List<(PersonKeyFormattedIdThenWholePercentages, PersonContainer)> possiblyNewPersonDisplayDirectoryNamesAndPersonContainer = new();
        SetPersonCollections(configuration, personContainers, a2PeopleSingletonDirectory, personKeyFormattedToNewestPersonKeyFormatted, personKeyFormattedCollection, skipCollection, skipNotSkipCollection);
        totalSeconds = (int)Math.Floor(new TimeSpan(DateTime.Now.Ticks - ticks).TotalSeconds);
        message = $") {ticksDirectories.Count:000} compile from and clean ticks Director(ies) - B - {totalSeconds} total second(s)";
        List<Record> records = DeleteEmptyDirectoriesAndGetCollection(configuration, personKeyFormattedToNewestPersonKeyFormatted, personKeyFormattedCollection, ticksDirectories, message);
        locationContainers.AddRange(GetLocationContainers(maxDegreeOfParallelism, configuration, ticks, personContainers, eDistanceContentDirectory, records));
        int unableToMatchCount = SetCollectionsAndGetUnableToConvertCount(configuration, ticks, personKeyFormattedIdThenWholePercentagesCollection, records);
        SetKeyValuePairsAndAddToCollections(configuration, personContainers, personKeyToPersonContainerCollection, personKeyFormattedToPersonContainer, personKeyFormattedIdThenWholePercentagesCollection, personKeyToPersonContainer, idThenWholePercentagesToPersonContainers, possiblyNewPersonDisplayDirectoryNamesAndPersonContainer);
        totalSeconds = (int)Math.Floor(new TimeSpan(DateTime.Now.Ticks - ticks).TotalSeconds);
        message = $") {records.Count:000} message from ticks Director(ies) - D - {unableToMatchCount} Unable To Match Count / {records.Count} Collection - {totalSeconds} total second(s)";
        ProgressBarOptions options = new() { ProgressCharacter = '─', ProgressBarOnBottom = true, DisableBottomPercentage = true };
        using (ProgressBar progressBar = new(records.Count, message, options))
        {
            foreach (KeyValuePair<int, Dictionary<int, PersonContainer[]>> keyValuePair in idThenWholePercentagesToPersonContainers)
            {
                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();
        PossiblyRebuildPersonContainers(configuration, a2PeopleSingletonDirectory, personKeyFormattedToNewestPersonKeyFormatted, possiblyNewPersonDisplayDirectoryNamesAndPersonContainer);
        SetPersonKeyToPersonContainer(configuration, personContainers, personKeyCollection, personKeyToPersonContainer, personKeyToPersonContainerCollection);
        notMappedPersonContainers.AddRange(GetNotMappedPersonContainers(configuration, ticks, personContainers, personKeyCollection));
    }

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

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

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

    internal static string? GetFacePartsContentCollectionFile(string extension, string d2FacePartsContentCollectionDirectory, MappingFromItem mappingFromItem)
    {
        string? result;
        string? directoryName = Path.GetDirectoryName(mappingFromItem.RelativePath);
        if (directoryName is null)
            result = null;
        else
            result = Path.Combine($"{d2FacePartsContentCollectionDirectory}{directoryName}", $"{mappingFromItem.ImageFileHolder.Name}{extension}");
        return result;
    }

    internal static string GetFacesDirectory(Shared.Models.Properties.IPropertyConfiguration propertyConfiguration, string dFacesContentDirectory, MappingFromItem mappingFromItem)
    {
        string result;
        (string directoryName, _) = IPath.GetDirectoryNameAndIndex(propertyConfiguration.ResultAllInOneSubdirectoryLength, mappingFromItem.ImageFileHolder.NameWithoutExtension);
        result = Path.Combine(dFacesContentDirectory, propertyConfiguration.ResultAllInOne, directoryName, mappingFromItem.ImageFileHolder.NameWithoutExtension);
        return result;
    }

    internal static string GetFacePartsDirectory(Shared.Models.Properties.IPropertyConfiguration propertyConfiguration, string d2FacePartsContentDirectory, MappingFromItem mappingFromItem)
    {
        string result;
        (string directoryName, _) = IPath.GetDirectoryNameAndIndex(propertyConfiguration.ResultAllInOneSubdirectoryLength, mappingFromItem.ImageFileHolder.NameWithoutExtension);
        result = Path.Combine(d2FacePartsContentDirectory, propertyConfiguration.ResultAllInOne, directoryName, mappingFromItem.ImageFileHolder.NameWithoutExtension);
        return result;
    }

    internal static SaveContainer GetDebugSaveContainer(string directory, MappingFromPerson? mappingFromPerson, 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.WholePercentages}");
        string shortcutFile;
        if (mappingFromPerson is null)
            shortcutFile = Path.Combine(directory, $"{sortingContainer.Mapping.MappingFromLocation.DeterministicHashCodeKey}{sortingContainer.Mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}.{sortingContainer.Sorting.DistancePermyriad}.lnk");
        else
            shortcutFile = Path.Combine(directory, $"{sortingContainer.Mapping.MappingFromLocation.DeterministicHashCodeKey}{sortingContainer.Mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}.{sortingContainer.Sorting.DistancePermyriad}.lnk");
        result = new(directory, faceFileHolder, mapping.MappingFromItem.ResizedFileHolder, shortcutFile);
        return result;
    }

    internal static (SaveContainer?, SaveContainer?) GetContainers(string facesFileNameExtension, string facePartsFileNameExtension, Shared.Models.Properties.IPropertyConfiguration propertyConfiguration, string dFacesContentDirectory, string d2FacePartsContentCollectionDirectory, string directory, SortingContainer sortingContainer, Mapping mapping)
    {
        SaveContainer? result;
        SaveContainer? saveContainer;
        if (sortingContainer.Mapping.MappingFromLocation is null)
            throw new NullReferenceException(nameof(sortingContainer.Mapping.MappingFromLocation));
        if (mapping.MappingFromLocation is null)
            (result, saveContainer) = (null, null);
        else
        {
            string? facePartsContentCollectionFile = GetFacePartsContentCollectionFile(facePartsFileNameExtension, d2FacePartsContentCollectionDirectory, mapping.MappingFromItem);
            if (facePartsContentCollectionFile is null || !File.Exists(facePartsContentCollectionFile))
                result = null;
            else
            {
                string checkFile = Path.Combine(directory, $"{mapping.MappingFromItem.ImageFileHolder.Name}{facePartsFileNameExtension}");
                result = new(checkFile, directory, new(facePartsContentCollectionFile));
            }
            string facesDirectory = GetFacesDirectory(propertyConfiguration, dFacesContentDirectory, mapping.MappingFromItem);
            FileHolder faceFileHolder = new(Path.Combine(facesDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}{facesFileNameExtension}"));
            if (!faceFileHolder.Exists)
                saveContainer = null;
            else
            {
                string checkFile = Path.Combine(directory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}{facesFileNameExtension}");
                saveContainer = new(checkFile, directory, faceFileHolder);
            }
        }
        return (result, saveContainer);
    }

    internal static (SaveContainer, SaveContainer?) GetContainers(string facesFileNameExtension, string facePartsFileNameExtension, string directory, FileHolder faceFileHolder, FileHolder facePartsFileHolder, Mapping mapping)
    {
        string checkFile;
        SaveContainer? saveContainer;
        if (mapping.MappingFromLocation is null)
            throw new NullReferenceException(nameof(mapping.MappingFromLocation));
        checkFile = Path.Combine(directory, $"{mapping.MappingFromItem.ImageFileHolder.Name}{facePartsFileNameExtension}");
        saveContainer = !facePartsFileHolder.Exists ? null : new(checkFile, directory, facePartsFileHolder);
        checkFile = Path.Combine(directory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}{facesFileNameExtension}");
        return (new(checkFile, directory, faceFileHolder), saveContainer);
    }

    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 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> faces)
    {
        Mapping[] results;
        IEnumerable<Mapping> collection = from l in faces 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 List<Face> GetFaces(List<Item> items)
    {
        List<Face> results = new();
        foreach (Item item in items)
        {
            if (item.Property?.Id is null || item.ResizedFileHolder is null)
                continue;
            foreach (Face face in item.Faces)
            {
                if (face.FaceEncoding is null || face.Location is null || face.OutputResolution is null)
                    continue;
                results.Add(face);
            }
        }
        return results;
    }

    internal static Mapping[] GetSelectedMappingCollection(List<Item> items)
    {
        Mapping[] results;
        List<Face> faces = GetFaces(items);
        results = GetSelectedMappingCollection(faces);
        return results;
    }

    internal static Dictionary<int, Dictionary<int, Mapping>> GetIdToWholePercentagesToFace(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.WholePercentages))
                continue;
            keyValuePairs.Add(mapping.MappingFromLocation.WholePercentages, mapping);
        }
        return results;
    }

    private static string? TryToFind(char[] personCharacters, string a2PeopleSingletonDirectory, List<(string Directory, string DirectoryName, string DirectoryNameSplitFirst)> a2PeopleSingletonDirectories, string file, string path)
    {
        string? result;
        string? pathName = Path.GetFileName(path);
        string? group = Path.GetDirectoryName(path);
        string? groupName = Path.GetFileName(group);
        if (pathName is null || group is null || groupName is null)
            result = null;
        else
        {
            string[] matches;
            matches = (from l in a2PeopleSingletonDirectories where l.DirectoryName == pathName select l.Directory).ToArray();
            if (matches.Length == 1)
                result = matches.First();
            else
            {
                string pathNameSplitFirst = pathName.Split(personCharacters).First();
                matches = (from l in a2PeopleSingletonDirectories where l.DirectoryNameSplitFirst == pathNameSplitFirst select l.Directory).ToArray();
                if (matches.Length == 1)
                    result = matches.First();
                else
                {
                    string checkDirectory = Path.Combine(a2PeopleSingletonDirectory, groupName, pathName);
                    if (!Directory.Exists(checkDirectory))
                        result = null;
                    else
                        result = checkDirectory;
                }
            }
            if (!string.IsNullOrEmpty(result))
            {
                try
                {
                    WindowsShortcut windowsShortcut;
                    windowsShortcut = new() { Path = result };
                    windowsShortcut.Save(file);
                    windowsShortcut.Dispose();
                }
                catch (Exception)
                { }
            }
        }
        return result;
    }

    private static List<(string, long)> GetJLinkResolvedDirectories(string personBirthdayFormat, List<string> resolvedDirectories)
    {
        List<(string, long)> results = new();
        DateTime dateTime;
        string directoryName;
        string[] directories;
        foreach (string resolvedDirectory in resolvedDirectories)
        {
            directories = Directory.GetDirectories(resolvedDirectory, "*", SearchOption.TopDirectoryOnly);
            foreach (string directory in directories)
            {
                directoryName = Path.GetFileName(directory);
                if (directoryName.Length != personBirthdayFormat.Length || !DateTime.TryParseExact(directoryName, personBirthdayFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out dateTime))
                    continue;
                results.Add((resolvedDirectory, dateTime.Ticks));
            }
        }
        if (results.Count != resolvedDirectories.Count)
            results.Clear();
        return results;
    }

    private static List<(string, long)> GetGenealogicalDataCommunicationDirectories(string genealogicalDataCommunicationFile, string[] jLinks, string personBirthdayFormat)
    {
        List<(string, long)> results = new();
        string directory;
        DateTime dateTime;
        string[] personKeyDirectories;
        string[] personDisplayDirectoryNames;
        string personKeyFormattedDirectoryName;
        string? genealogicalDataCommunicationDirectory = Path.GetDirectoryName(genealogicalDataCommunicationFile);
        foreach (string jLink in jLinks)
        {
            if (genealogicalDataCommunicationDirectory is null)
                continue;
            directory = Path.Combine(genealogicalDataCommunicationDirectory, jLink);
            if (!Directory.Exists(directory))
                continue;
            personDisplayDirectoryNames = Directory.GetDirectories(directory, "*", SearchOption.TopDirectoryOnly);
            foreach (string personDisplayDirectoryName in personDisplayDirectoryNames)
            {
                personKeyDirectories = Directory.GetDirectories(personDisplayDirectoryName, "*", SearchOption.TopDirectoryOnly);
                foreach (string personKeyFormattedDirectory in personKeyDirectories)
                {
                    personKeyFormattedDirectoryName = Path.GetFileName(personKeyFormattedDirectory);
                    if (personKeyFormattedDirectoryName.Length != personBirthdayFormat.Length || !DateTime.TryParseExact(personKeyFormattedDirectoryName, personBirthdayFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out dateTime))
                        continue;
                    results.Add((directory, dateTime.Ticks));
                }
            }
        }
        return results;
    }

    internal static List<(string, long)> GetJLinkDirectories(string genealogicalDataCommunicationFile, string[] jLinks, string personBirthdayFormat, char[] personCharacters, string a2PeopleSingletonDirectory, string a2PeopleContentDirectory)
    {
        List<(string, long)> results;
        string[] files;
        string? foundPath;
        int totalFiles = 0;
        string checkDirectory;
        WindowsShortcut windowsShortcut;
        List<string> resolvedDirectories = new();
        results = GetGenealogicalDataCommunicationDirectories(genealogicalDataCommunicationFile, jLinks, personBirthdayFormat);
        if (results.Count == 0 || results.Count < jLinks.Length)
        {
            List<(string, string, string)> a2PeopleSingletonDirectories = new();
            foreach (string directory in Directory.GetDirectories(a2PeopleSingletonDirectory, "*", SearchOption.AllDirectories))
                a2PeopleSingletonDirectories.Add((directory, Path.GetFileName(directory), Path.GetFileName(directory).Split(personCharacters).First()));
            foreach (string directoryName in jLinks)
            {
                checkDirectory = Path.Combine(a2PeopleContentDirectory, directoryName);
                if (!Directory.Exists(checkDirectory))
                    continue;
                files = Directory.GetFiles(checkDirectory, "*.lnk", SearchOption.TopDirectoryOnly);
                totalFiles += files.Length;
                foreach (string file in files)
                {
                    windowsShortcut = WindowsShortcut.Load(file);
                    if (windowsShortcut.Path is null)
                        continue;
                    if (Directory.Exists(windowsShortcut.Path))
                        resolvedDirectories.Add(windowsShortcut.Path);
                    else
                    {
                        foundPath = TryToFind(personCharacters, a2PeopleSingletonDirectory, a2PeopleSingletonDirectories, file, windowsShortcut.Path);
                        if (string.IsNullOrEmpty(foundPath))
                            continue;
                        resolvedDirectories.Add(foundPath);
                    }
                }
            }
            if (totalFiles == resolvedDirectories.Count)
                results = GetJLinkResolvedDirectories(personBirthdayFormat, resolvedDirectories);
            else
            {
                resolvedDirectories.Clear();
                results = new();
            }
        }
        return results;
    }

    internal static (string, bool, bool) Get(int? useFiltersCounter, bool saveIndividually, bool sortingContainersAny, string forceSingleImageHumanized, Mapping mapping)
    {
        string by;
        bool isByMapping;
        bool isBySorting;
        if (mapping.By is null)
        {
            isByMapping = false;
            isBySorting = !sortingContainersAny;
            by = $"{nameof(Shared.Models.Stateless.IMapLogic.Mapping)}Null";
        }
        else
        {
            isByMapping = mapping.By == Shared.Models.Stateless.IMapLogic.Mapping;
            isBySorting = mapping.By == Shared.Models.Stateless.IMapLogic.Sorting;
            if (isBySorting && mapping.MappingFromPerson is null)
                by = saveIndividually ? nameof(Shared.Models.Stateless.IMapLogic.Individually) : $"{nameof(Shared.Models.Stateless.IMapLogic.Sorting)} Without Person";
            else if (isBySorting && useFiltersCounter.HasValue)
                by = $"{nameof(Shared.Models.Stateless.IMapLogic.Sorting)} Modified Filters - {useFiltersCounter.Value}";
            else
            {
                by = mapping.By.Value switch
                {
                    Shared.Models.Stateless.IMapLogic.Mapping => nameof(Shared.Models.Stateless.IMapLogic.Mapping),
                    Shared.Models.Stateless.IMapLogic.Sorting => saveIndividually ? nameof(Shared.Models.Stateless.IMapLogic.Individually) : nameof(Shared.Models.Stateless.IMapLogic.Sorting),
                    Shared.Models.Stateless.IMapLogic.ForceSingleImage => forceSingleImageHumanized,
                    _ => throw new NotImplementedException()
                };
            }
        }
        return new(by, isByMapping, isBySorting);
    }

}