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;

public class MapLogic
{

    protected readonly Dictionary<int, List<int>> _SkipCollection;
    protected readonly List<PersonContainer> _NotMappedPersonContainers;
    protected readonly Dictionary<long, PersonContainer> _PersonKeyToPersonContainer;
    protected readonly Dictionary<long, (long LCL, long Minimum, long Maximum, long UCL)> _PersonKeyToRanges;
    protected readonly Dictionary<int, Dictionary<int, PersonContainer[]>> _IdThenNormalizedPixelPercentageToPersonContainers;

    public Dictionary<int, int[]> KeyValuePairs => throw new NotImplementedException();
    public Dictionary<int, int[]> IndicesFromNew => throw new NotImplementedException();

    private readonly long _Ticks;
    private readonly Serilog.ILogger? _Log;
    private readonly int _MaxDegreeOfParallelism;
    private readonly Configuration? _Configuration;
    private readonly string _FacesFileNameExtension;
    private readonly string _FacePartsFileNameExtension;
    private readonly string _FacesHiddenFileNameExtension;
    private readonly string _EDistanceContentTicksDirectory;

    public MapLogic(int maxDegreeOfParallelism, Shared.Models.Properties.IPropertyConfiguration propertyConfiguration, Configuration? configuration, string facesFileNameExtension, string facesHiddenFileNameExtension, string facePartsFileNameExtension, long ticks, PersonContainer[] personContainers, string a2PeopleSingletonDirectory, string eDistanceContentDirectory, List<Face> distinctFilteredFaces, Shared.Models.Methods.IFaceDistance? faceDistance)
    {
        _Ticks = ticks;
        _Configuration = configuration;
        _Log = Serilog.Log.ForContext<MapLogic>();
        _FacesFileNameExtension = facesFileNameExtension;
        _MaxDegreeOfParallelism = maxDegreeOfParallelism;
        _FacePartsFileNameExtension = facePartsFileNameExtension;
        _FacesHiddenFileNameExtension = facesHiddenFileNameExtension;
        if (_Log is null)
        { }
        if (propertyConfiguration.VerifyToSeason is null || !propertyConfiguration.VerifyToSeason.Any())
            throw new Exception();
        if (_MaxDegreeOfParallelism == 0)
        { }
        string json;
        string fullPath;
        List<KeyValuePair<int, int[]>>? collection;
        Dictionary<int, List<int>> skipCollection = new();
        List<PersonContainer> notMappedPersonContainers = new();
        Dictionary<long, PersonContainer> personKeyToPersonContainer = new();
        string? rootDirectoryParent = Path.GetDirectoryName(propertyConfiguration.RootDirectory);
        Dictionary<long, (long LCL, long Minimum, long Maximum, long UCL)> personKeyToRanges = new();
        string eDistanceContentTicksDirectory = Path.Combine(eDistanceContentDirectory, $"({ticks})");
        Dictionary<int, Dictionary<int, PersonContainer[]>> idThenNormalizedPixelPercentageToPersonContainers = new();
        for (int i = 1; i < 5; i++)
            _ = IPath.DeleteEmptyDirectories(eDistanceContentDirectory);
        _ = IPath.DeleteEmptyDirectories(eDistanceContentDirectory);
        if (string.IsNullOrEmpty(rootDirectoryParent))
            throw new NullReferenceException(nameof(rootDirectoryParent));
        if (!Directory.Exists(eDistanceContentDirectory))
            _ = Directory.CreateDirectory(eDistanceContentDirectory);
        if (!Directory.Exists(eDistanceContentTicksDirectory))
            _ = Directory.CreateDirectory(eDistanceContentTicksDirectory);
        if (configuration is not null && faceDistance is not null)
        {
            List<PersonContainer> personContainerCollection = new(personContainers);
            Stateless.MapLogic.Set(propertyConfiguration,
                                   configuration,
                                   facesFileNameExtension,
                                   ticks,
                                   personContainerCollection,
                                   a2PeopleSingletonDirectory,
                                   eDistanceContentDirectory,
                                   distinctFilteredFaces,
                                   faceDistance,
                                   personKeyToPersonContainer,
                                   personKeyToRanges,
                                   notMappedPersonContainers,
                                   skipCollection,
                                   idThenNormalizedPixelPercentageToPersonContainers);
            if (personContainerCollection.Count == personContainers.Length)
                throw new NotSupportedException();
        }
        foreach (string propertyContentCollectionFile in propertyConfiguration.PropertyContentCollectionFiles)
        {
            fullPath = Path.GetFullPath(string.Concat(rootDirectoryParent, propertyContentCollectionFile));
            if (fullPath.Contains(propertyConfiguration.RootDirectory))
                continue;
            if (!File.Exists(fullPath))
                continue;
            json = File.ReadAllText(fullPath);
            collection = JsonSerializer.Deserialize<List<KeyValuePair<int, int[]>>>(json);
            if (collection is null)
                throw new NullReferenceException(nameof(collection));
        }
        _SkipCollection = skipCollection;
        _PersonKeyToRanges = personKeyToRanges;
        _NotMappedPersonContainers = notMappedPersonContainers;
        _PersonKeyToPersonContainer = personKeyToPersonContainer;
        _EDistanceContentTicksDirectory = eDistanceContentTicksDirectory;
        _IdThenNormalizedPixelPercentageToPersonContainers = idThenNormalizedPixelPercentageToPersonContainers;
    }

    public MapLogic(int maxDegreeOfParallelism, Shared.Models.Properties.IPropertyConfiguration propertyConfiguration, Configuration? configuration, string outputExtension, long ticks, PersonContainer[] personContainers, string a2PeopleSingletonDirectory, string eDistanceContentDirectory) :
        this(maxDegreeOfParallelism, propertyConfiguration, configuration, outputExtension, outputExtension, outputExtension, ticks, personContainers, a2PeopleSingletonDirectory, eDistanceContentDirectory, new(), null)
    { }

    public override string ToString()
    {
        string result = JsonSerializer.Serialize(this, new JsonSerializerOptions() { WriteIndented = true });
        return result;
    }

    private List<(long, long, long, long)> GetPersonKeysRangesCollection(PersonContainer[] personContainers)
    {
        List<(long, long, long, long)> results = new();
        (long, long, long, long) singleton;
        foreach (PersonContainer personContainer in personContainers)
        {
            if (personContainer.Key is null)
                continue;
            if (!_PersonKeyToRanges.TryGetValue(personContainer.Key.Value, out singleton))
                continue;
            results.Add(singleton);
        }
        return results;
    }

    public bool Used(FaceDistance faceDistanceEncoding)
    {
        bool result = false;
        if (faceDistanceEncoding.NormalizedPixelPercentage is null)
            throw new NotSupportedException();
        List<int>? normalizedPixelPercentages;
        Dictionary<int, PersonContainer[]>? normalizedPixelPercentageToPersonContainers;
        if (_SkipCollection.TryGetValue(faceDistanceEncoding.Id, out normalizedPixelPercentages))
        {
            if (normalizedPixelPercentages.Contains(faceDistanceEncoding.NormalizedPixelPercentage.Value))
                result = true;
        }
        if (!result && _IdThenNormalizedPixelPercentageToPersonContainers.TryGetValue(faceDistanceEncoding.Id, out normalizedPixelPercentageToPersonContainers))
        {
            if (normalizedPixelPercentageToPersonContainers.ContainsKey(faceDistanceEncoding.NormalizedPixelPercentage.Value))
                result = true;
        }
        return result;
    }

    public List<Sorting> GetSortingCollection(int i, FaceDistance faceDistanceEncoding, List<FaceDistance> faceDistanceLengths)
    {
        if (_Configuration is null)
            throw new NullReferenceException(nameof(_Configuration));
        List<Sorting> results = new();
        Sorting sorting;
        FaceDistance faceDistanceLength;
        List<int>? normalizedPixelPercentages;
        Dictionary<int, PersonContainer[]>? normalizedPixelPercentageToPersonContainers;
        List<(long lcl, long minimum, long maximum, long ucl)> personKeysRangesCollection;
        for (int j = 0; j < faceDistanceLengths.Count; j++)
        {
            if (faceDistanceEncoding.NormalizedPixelPercentage is null)
                throw new NotSupportedException();
            if (j == i)
                continue;
            if (_SkipCollection.TryGetValue(faceDistanceEncoding.Id, out normalizedPixelPercentages))
            {
                if (normalizedPixelPercentages.Contains(faceDistanceEncoding.NormalizedPixelPercentage.Value))
                    continue;
            }
            if (_IdThenNormalizedPixelPercentageToPersonContainers.TryGetValue(faceDistanceEncoding.Id, out normalizedPixelPercentageToPersonContainers))
            {
                if (normalizedPixelPercentageToPersonContainers.ContainsKey(faceDistanceEncoding.NormalizedPixelPercentage.Value))
                    continue;
            }
            faceDistanceLength = faceDistanceLengths[j];
            if (faceDistanceLength.NormalizedPixelPercentage is null || faceDistanceLength.Length is null)
                throw new NotSupportedException();
            if (faceDistanceLength.Length == 0)
                continue;
            if (!_IdThenNormalizedPixelPercentageToPersonContainers.TryGetValue(faceDistanceLength.Id, out normalizedPixelPercentageToPersonContainers))
                continue;
            if (!normalizedPixelPercentageToPersonContainers.ContainsKey(faceDistanceLength.NormalizedPixelPercentage.Value))
                continue;
            personKeysRangesCollection = GetPersonKeysRangesCollection(normalizedPixelPercentageToPersonContainers[faceDistanceLength.NormalizedPixelPercentage.Value]);
            sorting = ISorting.Get(_Configuration.FaceDistancePermyriad, _Configuration.FaceDistanceTolerance, faceDistanceEncoding, faceDistanceLength, personKeysRangesCollection);
            if (sorting.DistancePermyriad == 0)
                continue;
            if (sorting.Id == faceDistanceEncoding.Id)
            {
                if (sorting.NormalizedPixelPercentage == faceDistanceEncoding.NormalizedPixelPercentage.Value)
                    throw new NotSupportedException();
                continue;
            }
            results.Add(sorting);
        }
        return results;
    }

    public void SaveShortcuts(string[] juliePhares, List<Face> distinctFilteredFaces)
    {
        if (_Configuration is null)
            throw new NullReferenceException(nameof(_Configuration));
        List<(Face, List<(string?, string, string?, string?, string)>)> facesToCollection = GetCollection(distinctFilteredFaces);
        foreach ((Face face, List<(string? PersonKeyFormatted, string, string?, string?, string)> collection) in facesToCollection)
        {
            if (collection.Any(l => l.PersonKeyFormatted is not null and "1501-04-10_00"))
                continue;
            foreach ((string? personKeyFormatted, string directory, string? copyDirectory, string? copyFileName, string _) in collection)
            {
                if (face.Mapping is null)
                    throw new NotSupportedException();
                if (personKeyFormatted is null)
                    continue;
                if (!Directory.Exists(directory))
                    _ = Directory.CreateDirectory(directory);
                if (string.IsNullOrEmpty(copyDirectory) || string.IsNullOrEmpty(copyFileName))
                    continue;
                if (!juliePhares.Contains(personKeyFormatted))
                    continue;
                if (!Directory.Exists(copyDirectory))
                    _ = Directory.CreateDirectory(copyDirectory);
                if (!File.Exists(copyFileName))
                    File.Copy(face.Mapping.MappingFromItem.ResizedFileHolder.FullName, copyFileName);
                break;
            }
        }
    }

    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;
    }

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

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

    public int AddToMapping(List<Face> distinctFilteredFaces)
    {
        if (_Configuration is null)
            throw new NullReferenceException(nameof(_Configuration));
        int result = 0;
        const int zero = 0;
        string mappingSegmentB;
        PersonBirthday personBirthday;
        PersonContainer[]? collection;
        int by = Stateless.IMapLogic.Mapping;
        List<PersonContainer> personContainers = new();
        Dictionary<int, PersonContainer[]>? keyValuePairs;
        foreach (Face face in distinctFilteredFaces)
        {
            personContainers.Clear();
            if (face.Mapping is null)
                throw new NotSupportedException();
            if (!_IdThenNormalizedPixelPercentageToPersonContainers.TryGetValue(face.Mapping.MappingFromItem.Id, out keyValuePairs))
                result += 1;
            else
            {
                if (!keyValuePairs.TryGetValue(face.Mapping.MappingFromLocation.NormalizedPixelPercentage, out collection))
                    result += 1;
                else
                    personContainers.AddRange(collection);
            }
            foreach (PersonContainer personContainer in personContainers)
            {
                if (personContainer.Key is null || personContainer.Birthdays is null || !personContainer.Birthdays.Any())
                    continue;
                personBirthday = personContainer.Birthdays[zero];
                mappingSegmentB = GetMappingSegmentB(_Ticks, personBirthday, personContainer.ApproximateYears, face.Mapping.MappingFromItem);
                face.Mapping.UpdateMappingFromPerson(personContainer.ApproximateYears, by, personContainer.DisplayDirectoryName, personBirthday, mappingSegmentB);
            }
        }
        return result;
    }

    private void SaveContainers(int totalNotMapped, int updated, List<SaveContainer> saveContainers)
    {
        string checkFile;
        string sourceFile;
        WindowsShortcut windowsShortcut;
        string[] directories = (from l in saveContainers select l.Directory).Distinct().ToArray();
        int totalSeconds = (int)Math.Floor(new TimeSpan(DateTime.Now.Ticks - _Ticks).TotalSeconds);
        string message = $") {saveContainers.Count:000} save(s) - {totalNotMapped} Total not Mapped - {updated} Updated - {totalSeconds} total second(s)";
        ProgressBarOptions options = new() { ProgressCharacter = '─', ProgressBarOnBottom = true, DisableBottomPercentage = true };
        foreach (string directory in directories)
        {
            if (string.IsNullOrEmpty(directory))
                continue;
            if (!Directory.Exists(directory))
                _ = Directory.CreateDirectory(directory);
        }
        using ProgressBar progressBar = new(saveContainers.Count, message, options);
        foreach (SaveContainer saveContainer in saveContainers)
        {
            progressBar.Tick();
            if (string.IsNullOrEmpty(saveContainer.Directory) || string.IsNullOrEmpty(saveContainer.CheckFile) || saveContainer.ResizedFileHolder is null || saveContainer.FaceFileHolder is null || !string.IsNullOrEmpty(saveContainer.Json))
                continue;
            if (!saveContainer.FaceFileHolder.Exists && saveContainer.ResizedFileHolder.Exists)
            {
                checkFile = saveContainer.CheckFile;
                sourceFile = saveContainer.ResizedFileHolder.FullName;
            }
            else if (saveContainer.FaceFileHolder.Exists)
            {
                sourceFile = saveContainer.FaceFileHolder.FullName;
                checkFile = $"{saveContainer.CheckFile}{_FacesFileNameExtension}";
            }
            else
                continue;
            if (File.Exists(checkFile))
                continue;
            File.Copy(sourceFile, checkFile);
            if (saveContainer.HiddenFaceFileHolder is not null && saveContainer.HiddenFaceFileHolder.Exists)
            {
                sourceFile = saveContainer.HiddenFaceFileHolder.FullName;
                checkFile = $"{saveContainer.CheckFile}{_FacesHiddenFileNameExtension}";
            }
            else if (saveContainer.FacePartsFileHolder is not null && saveContainer.FacePartsFileHolder.Exists)
            {
                sourceFile = saveContainer.FacePartsFileHolder.FullName;
                checkFile = $"{saveContainer.CheckFile}{_FacePartsFileNameExtension}";
            }
            if (File.Exists(checkFile))
                continue;
            File.Copy(sourceFile, checkFile);
        }
        foreach (SaveContainer saveContainer in saveContainers)
        {
            if (string.IsNullOrEmpty(saveContainer.Directory) || string.IsNullOrEmpty(saveContainer.CheckFile) || saveContainer.ResizedFileHolder is not null || saveContainer.FaceFileHolder is not null || string.IsNullOrEmpty(saveContainer.Json))
                continue;
            if (File.Exists(saveContainer.CheckFile))
                continue;
            _ = IPath.WriteAllText(saveContainer.CheckFile, saveContainer.Json, updateDateWhenMatches: false, compareBeforeWrite: true, updateToWhenMatches: null);
        }
        foreach (SaveContainer saveContainer in saveContainers)
        {
            if (string.IsNullOrEmpty(saveContainer.Directory) || string.IsNullOrEmpty(saveContainer.CheckFile) || saveContainer.ResizedFileHolder is null)
                continue;
            if (string.IsNullOrEmpty(saveContainer.ShortcutFile) || !saveContainer.ResizedFileHolder.Exists)
                continue;
            try
            {
                windowsShortcut = new() { Path = saveContainer.ResizedFileHolder.FullName };
                windowsShortcut.Save(saveContainer.ShortcutFile);
                windowsShortcut.Dispose();
            }
            catch (Exception)
            { }
        }
    }

    public void SaveNotMappedTicks()
    {
        if (_Configuration is null)
            throw new NullReferenceException(nameof(_Configuration));
        int updated = 0;
        string directory;
        const int zero = 0;
        int totalNotMapped = 0;
        string personKeyFormatted;
        SaveContainer saveContainer;
        PersonBirthday personBirthday;
        List<SaveContainer> saveContainers = new();
        const string facePopulatedKey = nameof(Stateless.IMapLogic.Sorting);
        foreach (PersonContainer personContainer in _NotMappedPersonContainers)
        {
            if (personContainer.Key is null || personContainer.Birthdays is null || !personContainer.Birthdays.Any())
                continue;
            personBirthday = personContainer.Birthdays[zero];
            personKeyFormatted = IPersonBirthday.GetFormatted(_Configuration.PersonBirthdayFormat, personBirthday);
            directory = Path.Combine(_EDistanceContentTicksDirectory, $"{facePopulatedKey}NotMapped", personKeyFormatted, _Configuration.MappingDefaultName);
            saveContainer = new(directory);
            saveContainers.Add(saveContainer);
        }
        SaveContainers(totalNotMapped, updated, saveContainers);
    }

    private List<(Face, List<(string?, string, string?, string?, string)>)> GetCollection(List<Face> distinctFilteredFaces)
    {
        if (_Configuration is null)
            throw new NullReferenceException(nameof(_Configuration));
        List<(Face, List<(string?, string, string?, string?, string)>)> results = new();
        int years;
        string directory;
        TimeSpan? timeSpan;
        string? copyFileName;
        string? relativePath;
        string? copyDirectory;
        string isWrongYearFlag;
        string shortcutFileName;
        string subDirectoryName;
        string personKeyFormatted;
        DateTime dateTime = DateTime.Now;
        PersonContainer[] personContainers;
        Dictionary<int, PersonContainer[]>? idToPersonContainers;
        List<(string?, string, string?, string?, string)> collection;
        foreach (Face face in distinctFilteredFaces)
        {
            if (face.Mapping is null)
                throw new NotSupportedException();
            collection = new();
            copyFileName = null;
            copyDirectory = null;
            relativePath = Path.GetDirectoryName($"C:{face.RelativePath}");
            if (string.IsNullOrEmpty(relativePath) || relativePath.Length < 3)
                continue;
            if (!_IdThenNormalizedPixelPercentageToPersonContainers.TryGetValue(face.Mapping.MappingFromItem.Id, out idToPersonContainers))
            {
                directory = Path.Combine(_EDistanceContentTicksDirectory, $"Unnamed{relativePath[2..]}");
                shortcutFileName = Path.Combine(directory, $"{face.Mapping.MappingFromItem.Id}.lnk");
                collection.Add(new(null, directory, copyDirectory, copyFileName, shortcutFileName));
            }
            else
            {
                if (!idToPersonContainers.ContainsKey(face.Mapping.MappingFromLocation.NormalizedPixelPercentage))
                    continue;
                isWrongYearFlag = IItem.GetWrongYearFlag(face.Mapping.MappingFromItem.IsWrongYear);
                subDirectoryName = $"{isWrongYearFlag}{face.Mapping.MappingFromItem.MinimumDateTime:yyyy}";
                personContainers = idToPersonContainers[face.Mapping.MappingFromLocation.NormalizedPixelPercentage];
                foreach (PersonContainer personContainer in personContainers)
                {
                    if (personContainers.Length != 1)
                        break;
                    if (personContainer.Key is null || personContainer.Birthdays is null || !personContainer.Birthdays.Any())
                        continue;
                    foreach (PersonBirthday personBirthday in personContainer.Birthdays)
                    {
                        timeSpan = IPersonBirthday.GetTimeSpan(face.Mapping.MappingFromItem.MinimumDateTime, face.Mapping.MappingFromItem.IsWrongYear, personBirthday);
                        if (timeSpan.HasValue)
                        {
                            if (timeSpan.Value.Ticks < 0)
                                subDirectoryName = "!---";
                            else
                            {
                                (years, _) = IPersonBirthday.GetAge(dateTime, personBirthday);
                                subDirectoryName = $"^{years:000}";
                            }
                        }
                        personKeyFormatted = IPersonBirthday.GetFormatted(_Configuration.PersonBirthdayFormat, personBirthday);
                        directory = Path.Combine(_EDistanceContentTicksDirectory, "Shortcuts", personKeyFormatted, subDirectoryName);
                        if (face.FaceEncoding is not null)
                            copyDirectory = Path.Combine(_EDistanceContentTicksDirectory, "Images", personKeyFormatted, subDirectoryName);
                        else
                            copyDirectory = Path.Combine(_EDistanceContentTicksDirectory, "ImagesBut", personKeyFormatted, subDirectoryName);
                        copyFileName = Path.Combine(copyDirectory, $"{face.Mapping.MappingFromItem.Id}{face.Mapping.MappingFromItem.ResizedFileHolder.ExtensionLowered}");
                        shortcutFileName = Path.Combine(directory, $"{face.Mapping.MappingFromItem.Id}.lnk");
                        collection.Add(new(personKeyFormatted, directory, copyDirectory, copyFileName, shortcutFileName));
                    }
                }
                if (!collection.Any())
                {
                    copyFileName = null;
                    copyDirectory = null;
                    directory = Path.Combine(_EDistanceContentTicksDirectory, $"Not Supported{relativePath[2..]}", subDirectoryName);
                    shortcutFileName = Path.Combine(directory, $"{face.Mapping.MappingFromItem.Id}.lnk");
                    collection.Add(new(null, directory, copyDirectory, copyFileName, shortcutFileName));
                }
            }
            results.Add(new(face, collection));
        }
        return results;
    }

    private int UpdateFromSortingContainers(SortingContainer[] sortingContainers)
    {
        if (_Configuration is null)
            throw new NullReferenceException(nameof(_Configuration));
        int result = 0;
        string key;
        const int zero = 0;
        string mappingSegmentB;
        string personKeyFormatted;
        List<Mapping> checkCollection;
        PersonBirthday personBirthday;
        PersonContainer[] personContainers;
        const int by = Stateless.IMapLogic.Sorting;
        List<int> normalizedPixelPercentageCollection;
        Dictionary<string, List<Mapping>> checkKeyValuePairs = new();
        Dictionary<int, List<int>> idToNormalizedPixelPercentageCollection = new();
        Dictionary<int, PersonContainer[]>? normalizedPixelPercentageToPersonContainers;
        int totalSeconds = (int)Math.Floor(new TimeSpan(DateTime.Now.Ticks - _Ticks).TotalSeconds);
        string message = $") {sortingContainers.Length:000} Update From Sorting Container(s) - {totalSeconds} total second(s)";
        ProgressBarOptions options = new() { ProgressCharacter = '─', ProgressBarOnBottom = true, DisableBottomPercentage = true };
        using ProgressBar progressBar = new(sortingContainers.Length, message, options);
        foreach (SortingContainer sortingContainer in sortingContainers)
        {
            progressBar.Tick();
            if (sortingContainer.Face.Mapping is null)
                throw new NotSupportedException();
            if (!_IdThenNormalizedPixelPercentageToPersonContainers.TryGetValue(sortingContainer.Sorting.Id, out normalizedPixelPercentageToPersonContainers))
                throw new NotSupportedException();
            if (!normalizedPixelPercentageToPersonContainers.ContainsKey(sortingContainer.Sorting.NormalizedPixelPercentage))
                throw new NotSupportedException();
            if (!idToNormalizedPixelPercentageCollection.ContainsKey(sortingContainer.Face.Mapping.MappingFromItem.Id))
                idToNormalizedPixelPercentageCollection.Add(sortingContainer.Face.Mapping.MappingFromItem.Id, new());
            normalizedPixelPercentageCollection = idToNormalizedPixelPercentageCollection[sortingContainer.Face.Mapping.MappingFromItem.Id];
            if (normalizedPixelPercentageCollection.Contains(sortingContainer.Face.Mapping.MappingFromLocation.NormalizedPixelPercentage))
                continue;
            personContainers = normalizedPixelPercentageToPersonContainers[sortingContainer.Sorting.NormalizedPixelPercentage];
            foreach (PersonContainer personContainer in personContainers)
            {
                if (personContainer.Key is null || personContainer.Birthdays is null || !personContainer.Birthdays.Any())
                    continue;
                personBirthday = personContainer.Birthdays[zero];
                personKeyFormatted = IPersonBirthday.GetFormatted(_Configuration.PersonBirthdayFormat, personBirthday);
                mappingSegmentB = GetMappingSegmentB(_Ticks, personBirthday, personContainer.ApproximateYears, sortingContainer.Face.Mapping.MappingFromItem);
                key = string.Concat(personKeyFormatted, '\t', mappingSegmentB);
                if (!checkKeyValuePairs.ContainsKey(key))
                    checkKeyValuePairs.Add(key, new());
                checkCollection = checkKeyValuePairs[key];
                if (checkCollection.Count > _Configuration.SortingMaximumPerKey)
                    continue;
                normalizedPixelPercentageCollection.Add(sortingContainer.Face.Mapping.MappingFromLocation.NormalizedPixelPercentage);
                sortingContainer.Face.Mapping.UpdateMappingFromPerson(personContainer.ApproximateYears, by, personContainer.DisplayDirectoryName, personBirthday, mappingSegmentB);
                checkCollection.Add(sortingContainer.Face.Mapping);
                result += 1;
                break;
            }
        }
        return result;
    }

    internal void ForceSingleImage(IEnumerable<Face> distinctFilteredFaces)
    {
        if (_Configuration is null)
            throw new NullReferenceException(nameof(_Configuration));
        const int zero = 0;
        string mappingSegmentB;
        PersonBirthday personBirthday;
        List<int>? normalizedPixelPercentages;
        int by = Stateless.IMapLogic.ForceSingleImage;
        string displayDirectoryName = _Configuration.MappingDefaultName;
        Face[] orderedDistinctFilteredFaces = (from l in distinctFilteredFaces orderby l.Mapping is not null, l.Mapping?.MappingFromLocation.Confidence descending select l).ToArray();
        foreach (Face face in orderedDistinctFilteredFaces)
        {
            if (face.Mapping is null)
                throw new NotSupportedException();
            if (face.Mapping.MappingFromPerson.PersonBirthday is not null)
                continue;
            if (_SkipCollection.TryGetValue(face.Mapping.MappingFromItem.Id, out normalizedPixelPercentages))
            {
                if (normalizedPixelPercentages.Contains(face.Mapping.MappingFromLocation.NormalizedPixelPercentage))
                    continue;
            }
            foreach (PersonContainer personContainer in _NotMappedPersonContainers)
            {
                if (personContainer.Key is null || personContainer.Birthdays is null || !personContainer.Birthdays.Any())
                    continue;
                personBirthday = personContainer.Birthdays[zero];
                mappingSegmentB = GetMappingSegmentB(_Ticks, personBirthday, personContainer.ApproximateYears, face.Mapping.MappingFromItem);
                face.Mapping.UpdateMappingFromPerson(personContainer.ApproximateYears, by, personContainer.DisplayDirectoryName, personBirthday, mappingSegmentB);
                break;
            }
            break;
        }
    }

    private List<SaveContainer> GetMappingSaveContainers(string dFacesContentDirectory, string d2FacePartsContentDirectory, List<Face> filteredFaces, int? useFiltersCounter)
    {
        if (_Configuration is null)
            throw new NullReferenceException(nameof(_Configuration));
        List<SaveContainer> results = new();
        string by;
        string checkFile;
        string directory;
        string shortcutFile;
        string facesDirectory;
        string? directoryName;
        string personDirectory;
        FileHolder faceFileHolder;
        string facePartsDirectory;
        string personKeyFormatted;
        SaveContainer saveContainer;
        FileHolder facePartsFileHolder;
        FileHolder hiddenFaceFileHolder;
        Dictionary<string, int> keyValuePairs = new();
        string forceSingleImageHumanized = nameof(Stateless.IMapLogic.ForceSingleImage).Humanize(LetterCasing.Title);
        foreach (Face face in filteredFaces)
        {
            if (face.Mapping is null)
                throw new NotSupportedException();
            directoryName = Path.GetDirectoryName(face.RelativePath);
            if (directoryName is null)
                throw new NotSupportedException();
            if (face.Mapping.MappingFromPerson.PersonBirthday is null)
                continue;
            if (string.IsNullOrEmpty(face.Mapping.MappingFromPerson.SegmentB))
                throw new NotSupportedException();
            personKeyFormatted = IPersonBirthday.GetFormatted(_Configuration.PersonBirthdayFormat, face.Mapping.MappingFromPerson.PersonBirthday);
            if (face.Mapping.MappingFromPerson.By is null)
                by = $"{nameof(Stateless.IMapLogic.Mapping)}Null";
            else if (useFiltersCounter.HasValue && face.Mapping.MappingFromPerson.By.Value == Stateless.IMapLogic.Sorting)
                by = $"{nameof(Stateless.IMapLogic.Sorting)} Modified Filters - {useFiltersCounter.Value}";
            else
            {
                if (face.Mapping.MappingFromPerson.By == Stateless.IMapLogic.Mapping && !_Configuration.MappingSaveMapped)
                    continue;
                by = face.Mapping.MappingFromPerson.By.Value switch
                {
                    Stateless.IMapLogic.Mapping => nameof(Stateless.IMapLogic.Mapping),
                    Stateless.IMapLogic.Sorting => nameof(Stateless.IMapLogic.Sorting),
                    Stateless.IMapLogic.ForceSingleImage => forceSingleImageHumanized,
                    _ => throw new NotImplementedException()
                };
            }
            directory = Path.Combine(_EDistanceContentTicksDirectory, by, personKeyFormatted, face.Mapping.MappingFromPerson.SegmentB);
            if (!keyValuePairs.ContainsKey(directory))
                keyValuePairs.Add(directory, 0);
            keyValuePairs[directory]++;
            if (face.Mapping.MappingFromPerson.By is not null)
                personDirectory = Path.Combine(directory, face.Mapping.MappingFromPerson.DisplayDirectoryName, "lnk");
            else
                personDirectory = Path.Combine(directory, face.Mapping.MappingFromPerson.DisplayDirectoryName[..1], "lnk");
            saveContainer = new(personDirectory);
            results.Add(saveContainer);
            facesDirectory = Path.Combine($"{dFacesContentDirectory}{directoryName}", face.Mapping.MappingFromItem.ImageFileHolder.NameWithoutExtension);
            facePartsDirectory = Path.Combine($"{d2FacePartsContentDirectory}{directoryName}", face.Mapping.MappingFromItem.ImageFileHolder.NameWithoutExtension);
            checkFile = Path.Combine(directory, $"{face.Mapping.MappingFromLocation.DeterministicHashCodeKey}{face.Mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}");
            faceFileHolder = new(Path.Combine(facesDirectory, $"{face.Mapping.MappingFromLocation.DeterministicHashCodeKey}{face.Mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}{_FacesFileNameExtension}"));
            hiddenFaceFileHolder = new(Path.Combine(facesDirectory, $"{face.Mapping.MappingFromLocation.DeterministicHashCodeKey}{face.Mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}{_FacesHiddenFileNameExtension}"));
            facePartsFileHolder = new(Path.Combine(facePartsDirectory, $"{face.Mapping.MappingFromLocation.DeterministicHashCodeKey}{face.Mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}{_FacePartsFileNameExtension}"));
            if (string.IsNullOrEmpty(personDirectory) || face.Mapping.MappingFromPerson.By == Stateless.IMapLogic.Mapping)
                shortcutFile = string.Empty;
            else
                shortcutFile = Path.Combine(personDirectory, $"{face.Mapping.MappingFromLocation.DeterministicHashCodeKey}{face.Mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}.lnk");
            saveContainer = new(checkFile, directory, faceFileHolder, hiddenFaceFileHolder, string.Empty, facePartsFileHolder, face.Mapping.MappingFromItem.ResizedFileHolder, shortcutFile);
            results.Add(saveContainer);
        }
        return results;
    }

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

    private 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)
            { }
        }
    }

    public void ForceSingleImageThenSaveMapping(string dFacesContentDirectory, string d2FacePartsContentDirectory, List<Face> distinctFilteredFaces, SortingContainer[] sortingContainers, int? useFiltersCounter, int totalNotMapped)
    {
        if (_Configuration is null)
            throw new NullReferenceException(nameof(_Configuration));
        int updated;
        List<SaveContainer> saveContainers;
        if (!sortingContainers.Any())
        {
            updated = 0;
            ForceSingleImage(distinctFilteredFaces);
            saveContainers = GetMappingSaveContainers(dFacesContentDirectory, d2FacePartsContentDirectory, distinctFilteredFaces, useFiltersCounter);
        }
        else
        {
            updated = UpdateFromSortingContainers(sortingContainers);
            if (useFiltersCounter is null && totalNotMapped - updated > 0)
                ForceSingleImage(distinctFilteredFaces);
            saveContainers = GetMappingSaveContainers(dFacesContentDirectory, d2FacePartsContentDirectory, distinctFilteredFaces, useFiltersCounter);
        }
        SaveContainers(totalNotMapped, updated, saveContainers);
        if (_Configuration.MappingSaveMapped)
        {
            string mappingDirectory = Path.Combine(_EDistanceContentTicksDirectory, nameof(Stateless.IMapLogic.Mapping));
            if (Directory.Exists(mappingDirectory))
                SaveMappingShortcuts(mappingDirectory);
        }
    }

    private static Dictionary<int, Dictionary<int, Face>> GetKeyValuePairs(List<Face> distinctFilteredFaces)
    {
        Dictionary<int, Dictionary<int, Face>> results = new();
        Dictionary<int, Face> keyValuePairs;
        foreach (Face face in distinctFilteredFaces)
        {
            if (face.Mapping is null)
                throw new NotSupportedException();
            if (!results.ContainsKey(face.Mapping.MappingFromItem.Id))
                results.Add(face.Mapping.MappingFromItem.Id, new());
            keyValuePairs = results[face.Mapping.MappingFromItem.Id];
            if (keyValuePairs.ContainsKey(face.Mapping.MappingFromLocation.NormalizedPixelPercentage))
                throw new NotSupportedException();
            keyValuePairs.Add(face.Mapping.MappingFromLocation.NormalizedPixelPercentage, face);
        }
        return results;
    }

    public void CopyManualFiles(string dFacesContentDirectory, List<Face> distinctFilteredFaces)
    {
        if (_Configuration is null)
            throw new NullReferenceException(nameof(_Configuration));
        int? id;
        Face face;
        string faceFile;
        string checkFile;
        string directory;
        FileInfo fileInfo;
        const int zero = 0;
        string faceFileName;
        string shortcutFile;
        string? directoryName;
        string facesDirectory;
        string mappingSegmentB;
        string personDirectory;
        string personKeyFormatted;
        string personDisplayFileName;
        PersonBirthday personBirthday;
        string? personDisplayDirectory;
        int? normalizedPixelPercentage;
        WindowsShortcut windowsShortcut;
        Dictionary<int, PersonContainer[]>? keyValuePairs;
        string by = nameof(Stateless.IMapLogic.ManualCopy);
        Dictionary<int, Face>? normalizedPixelPercentageToFace;
        string successfull = $"_ {nameof(Stateless.IMapLogic.ManualCopy).Humanize(LetterCasing.Title)} Successfull";
        Dictionary<int, Dictionary<int, Face>> idToNormalizedPixelPercentageToFace = GetKeyValuePairs(distinctFilteredFaces);
        foreach (KeyValuePair<long, PersonContainer> keyValuePair in _PersonKeyToPersonContainer)
        {
            if (keyValuePair.Value.Key is null || keyValuePair.Value.Birthdays is null || !keyValuePair.Value.Birthdays.Any())
                continue;
            personBirthday = keyValuePair.Value.Birthdays[zero];
            foreach (string personDisplayDirectoryAllFile in keyValuePair.Value.DisplayDirectoryAllFiles)
            {
                if (!personDisplayDirectoryAllFile.EndsWith(_FacesFileNameExtension))
                    continue;
                (id, normalizedPixelPercentage, _) = IMapping.GetReversedDeterministicHashCodeKey(_FacesFileNameExtension, personDisplayDirectoryAllFile);
                if (id is null || normalizedPixelPercentage is null)
                    continue;
                if (_IdThenNormalizedPixelPercentageToPersonContainers.TryGetValue(id.Value, out keyValuePairs))
                {
                    if (keyValuePairs.ContainsKey(normalizedPixelPercentage.Value))
                        continue;
                }
                fileInfo = new(personDisplayDirectoryAllFile);
                if (!fileInfo.Exists)
                    continue;
                personDisplayFileName = Path.GetFileName(personDisplayDirectoryAllFile);
                personDisplayDirectory = Path.GetDirectoryName(personDisplayDirectoryAllFile);
                personKeyFormatted = IPersonBirthday.GetFormatted(_Configuration.PersonBirthdayFormat, personBirthday);
                mappingSegmentB = GetMappingSegmentB(_Ticks, personBirthday, keyValuePair.Value.ApproximateYears, fileInfo.CreationTime, isWrongYear: null);
                directory = Path.Combine(_EDistanceContentTicksDirectory, by, personKeyFormatted, mappingSegmentB);
                personDirectory = Path.Combine(directory, keyValuePair.Value.DisplayDirectoryName, "lnk");
                if (!idToNormalizedPixelPercentageToFace.TryGetValue(id.Value, out normalizedPixelPercentageToFace))
                    continue;
                if (!normalizedPixelPercentageToFace.ContainsKey(normalizedPixelPercentage.Value))
                    continue;
                face = idToNormalizedPixelPercentageToFace[id.Value][normalizedPixelPercentage.Value];
                if (face.Mapping is null)
                    throw new NotSupportedException();
                if (string.IsNullOrEmpty(personDisplayDirectory))
                    throw new NotSupportedException();
                directoryName = Path.GetDirectoryName(face.RelativePath);
                if (string.IsNullOrEmpty(directoryName))
                    throw new NotSupportedException();
                shortcutFile = Path.Combine(personDisplayDirectory, $"{personDisplayFileName}.lnk");
                facesDirectory = Path.Combine($"{dFacesContentDirectory}{directoryName}", face.Mapping.MappingFromItem.ImageFileHolder.NameWithoutExtension);
                faceFileName = $"{face.Mapping.MappingFromLocation.DeterministicHashCodeKey}{face.Mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}{_FacesFileNameExtension}";
                checkFile = Path.Combine(directory, fileInfo.Name);
                if (!Directory.Exists(personDirectory))
                    _ = Directory.CreateDirectory(personDirectory);
                if (!File.Exists(checkFile))
                    File.Copy(personDisplayDirectoryAllFile, checkFile);
                if (personDisplayDirectoryAllFile.Contains(successfull))
                    continue;
                directoryName = Path.Combine(personDisplayDirectory, successfull);
                if (!Directory.Exists(directoryName))
                    _ = Directory.CreateDirectory(directoryName);
                checkFile = Path.Combine(directoryName, personDisplayFileName);
                File.Move(personDisplayDirectoryAllFile, checkFile);
                faceFile = Path.Combine(facesDirectory, faceFileName);
                if (!File.Exists(faceFile))
                    continue;
                if (File.Exists(shortcutFile))
                    continue;
                windowsShortcut = new() { Path = faceFile };
                windowsShortcut.Save(shortcutFile);
                windowsShortcut.Dispose();
                if (!File.Exists(shortcutFile))
                    continue;
                File.SetLastWriteTime(shortcutFile, face.Mapping.MappingFromItem.MinimumDateTime);
            }
        }
    }

}