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 : Shared.Models.Methods.IMapLogic
{

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

    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 _EDistanceContentTicksDirectory;
    private readonly Shared.Models.Methods.IMapLogicSupport? _MapLogicSupport;
    private readonly Shared.Models.Properties.IPropertyConfiguration _PropertyConfiguration;

    public MapLogic(int maxDegreeOfParallelism, Shared.Models.Properties.IPropertyConfiguration propertyConfiguration, Configuration? configuration, long ticks, PersonContainer[] personContainers, string a2PeopleSingletonDirectory, string eDistanceContentDirectory, Shared.Models.Methods.IMapLogicSupport? mapLogicSupport)
    {
        _Ticks = ticks;
        _Configuration = configuration;
        _MapLogicSupport = mapLogicSupport;
        _Log = Serilog.Log.ForContext<MapLogic>();
        _PropertyConfiguration = propertyConfiguration;
        _MaxDegreeOfParallelism = maxDegreeOfParallelism;
        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);
        string eDistanceContentTicksDirectory = Path.Combine(eDistanceContentDirectory, $"({ticks})");
        Dictionary<int, Dictionary<int, PersonContainer[]>> idThenNormalizedRectangleToPersonContainers = 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 && mapLogicSupport is not null)
        {
            List<PersonContainer> personContainerCollection = new(personContainers);
            Stateless.MapLogic.Set(propertyConfiguration,
                                   configuration,
                                   ticks,
                                   personContainerCollection,
                                   a2PeopleSingletonDirectory,
                                   eDistanceContentDirectory,
                                   mapLogicSupport,
                                   personKeyToPersonContainer,
                                   notMappedPersonContainers,
                                   skipCollection,
                                   idThenNormalizedRectangleToPersonContainers);
            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;
        _PersonKeyToPersonContainer = personKeyToPersonContainer;
        _EDistanceContentTicksDirectory = eDistanceContentTicksDirectory;
        _IdThenNormalizedRectangleToPersonContainers = idThenNormalizedRectangleToPersonContainers;
        _NotMappedPersonContainers = notMappedPersonContainers.OrderByDescending(l => l.Key).ToList();
    }

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

    (bool, Dictionary<int, PersonContainer[]>?) Shared.Models.Methods.IMapLogic.GetNormalizedRectangleToPersonContainers(int id)
    {
        bool result = _IdThenNormalizedRectangleToPersonContainers.TryGetValue(id, out Dictionary<int, PersonContainer[]>? normalizedRectangleToPersonContainers);
        return new(result, normalizedRectangleToPersonContainers);
    }

    public (Dictionary<long, int>, int) AddToMapping(Mapping[] mappingCollection)
    {
        if (_Configuration is null)
            throw new NullReferenceException(nameof(_Configuration));
        int result = 0;
        long personKey;
        const int zero = 0;
        string mappingSegmentB;
        PersonBirthday personBirthday;
        PersonContainer[]? collection;
        List<PersonContainer> personContainers = new();
        Dictionary<long, int> personKeyToCount = new();
        Dictionary<int, PersonContainer[]>? normalizedRectangleToPersonContainers;
        foreach (Mapping mapping in mappingCollection)
        {
            personContainers.Clear();
            if (!_IdThenNormalizedRectangleToPersonContainers.TryGetValue(mapping.MappingFromItem.Id, out normalizedRectangleToPersonContainers))
                result += 1;
            else
            {
                if (!normalizedRectangleToPersonContainers.TryGetValue(mapping.MappingFromLocation.NormalizedRectangle, 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];
                personKey = personBirthday.Value.Ticks;
                if (!personKeyToCount.ContainsKey(personKey))
                    personKeyToCount.Add(personKey, 0);
                personKeyToCount[personKey] += 1;
                mappingSegmentB = Stateless.MapLogic.GetMappingSegmentB(_Ticks, personBirthday, personContainer.ApproximateYears, mapping.MappingFromItem);
                mapping.UpdateMappingFromPerson(personContainer.ApproximateYears, personContainer.DisplayDirectoryName, personBirthday, mappingSegmentB);
            }
        }
        return new(personKeyToCount, result);
    }

    public void SaveContainers(int totalNotMapped, int? updated, List<SaveContainer> saveContainers)
    {
        if (_Configuration is null)
            throw new NullReferenceException(nameof(_Configuration));
        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;
        if (updated is null)
            message = $") {saveContainers.Count:000} save(s) - {totalNotMapped} Total not Mapped - {totalSeconds} total second(s)";
        else
            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)
        {
            if (string.IsNullOrEmpty(saveContainer.Directory) || string.IsNullOrEmpty(saveContainer.CheckFile) || saveContainer.FaceFileHolder is null)
                continue;
            progressBar.Tick();
            if (!saveContainer.FaceFileHolder.Exists && saveContainer.ResizedFileHolder is not null && saveContainer.ResizedFileHolder.Exists)
            {
                checkFile = saveContainer.CheckFile;
                sourceFile = saveContainer.ResizedFileHolder.FullName;
            }
            else if (saveContainer.FaceFileHolder.Exists)
            {
                sourceFile = saveContainer.FaceFileHolder.FullName;
                checkFile = $"{saveContainer.CheckFile}{_Configuration.FacesFileNameExtension}";
            }
            else
                continue;
            if (File.Exists(checkFile))
                continue;
            File.Copy(sourceFile, checkFile);
            if (saveContainer.MakeAllHidden)
                File.SetAttributes(checkFile, FileAttributes.Hidden);
            if (saveContainer.HiddenFaceFileHolder is not null && saveContainer.HiddenFaceFileHolder.Exists)
            {
                sourceFile = saveContainer.HiddenFaceFileHolder.FullName;
                checkFile = $"{saveContainer.CheckFile}{_Configuration.FacesHiddenFileNameExtension}";
            }
            else if (saveContainer.FacePartsFileHolder is not null && saveContainer.FacePartsFileHolder.Exists)
            {
                sourceFile = saveContainer.FacePartsFileHolder.FullName;
                checkFile = $"{saveContainer.CheckFile}{_Configuration.FacePartsFileNameExtension}";
            }
            if (File.Exists(checkFile))
                continue;
            File.Copy(sourceFile, checkFile);
            if (saveContainer.MakeAllHidden)
                File.SetAttributes(checkFile, FileAttributes.Hidden);
        }
        if (updated is null)
        {
            foreach (SaveContainer saveContainer in saveContainers)
            {
                if (string.IsNullOrEmpty(saveContainer.Directory) || string.IsNullOrEmpty(saveContainer.CheckFile) || saveContainer.ResizedFileHolder is null || !saveContainer.ResizedFileHolder.Exists)
                    continue;
                checkFile = saveContainer.CheckFile;
                sourceFile = saveContainer.ResizedFileHolder.FullName;
                if (File.Exists(checkFile))
                    continue;
                File.Copy(sourceFile, checkFile);
                if (saveContainer.MakeAllHidden)
                    File.SetAttributes(checkFile, FileAttributes.Hidden);
            }
        }
        foreach (SaveContainer saveContainer in saveContainers)
        {
            if (string.IsNullOrEmpty(saveContainer.ShortcutFile) || saveContainer.ResizedFileHolder is null || !saveContainer.ResizedFileHolder.Exists)
                continue;
            try
            {
                string description = saveContainer.FaceFileHolder is not null ? saveContainer.FaceFileHolder.Name : string.Empty;
                windowsShortcut = new() { Path = saveContainer.ResizedFileHolder.FullName, Description = description };
                windowsShortcut.Save(saveContainer.ShortcutFile);
                windowsShortcut.Dispose();
                if (saveContainer.MakeAllHidden)
                    File.SetAttributes(saveContainer.ShortcutFile, FileAttributes.Hidden);
            }
            catch (Exception)
            { }
        }
    }

    private static string? GetFacesDirectory(string dFacesContentDirectory, MappingFromItem mappingFromItem)
    {
        string? result;
        string? directoryName = Path.GetDirectoryName(mappingFromItem.RelativePath);
        if (directoryName is null)
            result = null;
        else
            result = Path.Combine($"{dFacesContentDirectory}{directoryName}", mappingFromItem.ImageFileHolder.NameWithoutExtension);
        return result;
    }

    private static string? GetFacePartsDirectory(string d2FacePartsContentDirectory, MappingFromItem mappingFromItem)
    {
        string? result;
        string? directoryName = Path.GetDirectoryName(mappingFromItem.RelativePath);
        if (directoryName is null)
            result = null;
        else
            result = Path.Combine($"{d2FacePartsContentDirectory}{directoryName}", mappingFromItem.ImageFileHolder.NameWithoutExtension);
        return result;
    }

    private SaveContainer? GetMatchSaveContainer(string dFacesContentDirectory, string d2FacePartsContentDirectory, string directory, Mapping mapping)
    {
        if (_Configuration is null)
            throw new NullReferenceException(nameof(_Configuration));
        SaveContainer? result;
        string shortcutFile = string.Empty;
        string? facesDirectory = GetFacesDirectory(dFacesContentDirectory, mapping.MappingFromItem);
        if (facesDirectory is null)
            result = null;
        else
        {
            FileHolder faceFileHolder = new(Path.Combine(facesDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}{_Configuration.FacesFileNameExtension}"));
            if (!faceFileHolder.Exists)
                result = null;
            else
            {
                string? facePartsDirectory = GetFacePartsDirectory(d2FacePartsContentDirectory, mapping.MappingFromItem);
                if (facePartsDirectory is null)
                    result = null;
                else
                {
                    string checkFile = Path.Combine(directory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}");
                    FileHolder hiddenFaceFileHolder = new(Path.Combine(facesDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}{_Configuration.FacesHiddenFileNameExtension}"));
                    FileHolder facePartsFileHolder = new(Path.Combine(facePartsDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}{_Configuration.FacePartsFileNameExtension}"));
                    result = new(checkFile, directory, faceFileHolder, hiddenFaceFileHolder, facePartsFileHolder, mapping.MappingFromItem.ResizedFileHolder, shortcutFile);
                }
            }
        }
        return result;
    }

    private static (string, bool, bool) Get(int? useFiltersCounter, string forceSingleImageHumanized, Mapping mapping)
    {
        string by;
        bool isByMapping;
        bool isBySorting;
        if (mapping.By is null)
        {
            isByMapping = false;
            isBySorting = false;
            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 = $"{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 => nameof(Shared.Models.Stateless.IMapLogic.Sorting),
                    Shared.Models.Stateless.IMapLogic.ForceSingleImage => forceSingleImageHumanized,
                    _ => throw new NotImplementedException()
                };
            }
        }
        return new(by, isByMapping, isBySorting);
    }

    private string GetDirectory(string by, MappingFromItem mappingFromItem, SortingContainer sortingContainer)
    {
        if (_Configuration is null)
            throw new NullReferenceException(nameof(_Configuration));
        string result;
        const int zero = 0;
        string mappingSegmentB;
        string personKeyFormatted;
        PersonBirthday personBirthday;
        PersonContainer personContainer;
        result = Path.Combine(_EDistanceContentTicksDirectory, by, sortingContainer.Sorting.Id.ToString(), sortingContainer.Sorting.NormalizedRectangle.ToString());
        for (int i = _NotMappedPersonContainers.Count - 1; i > 0; i--)
        {
            personContainer = _NotMappedPersonContainers[i];
            if (personContainer.Key is null || personContainer.Birthdays is null || !personContainer.Birthdays.Any())
                continue;
            personBirthday = personContainer.Birthdays[zero];
            mappingSegmentB = Stateless.MapLogic.GetMappingSegmentB(_Ticks, personBirthday, personContainer.ApproximateYears, mappingFromItem);
            personKeyFormatted = IPersonBirthday.GetFormatted(_Configuration.PersonBirthdayFormat, personBirthday);
            result = Path.Combine(_EDistanceContentTicksDirectory, by, personKeyFormatted, mappingSegmentB);
            _NotMappedPersonContainers.RemoveAt(i);
            break;
        }
        return result;
    }

    private List<SaveContainer> GetSaveContainers(string dFacesContentDirectory, string d2FacePartsContentDirectory, Mapping[] mappingCollection, Dictionary<int, Dictionary<int, Mapping>> idToNormalizedRectangleToMapping, Dictionary<long, int> personKeyToCount, int? useFiltersCounter, bool saveNullPerson, bool saveMapped)
    {
        if (_Configuration is null)
            throw new NullReferenceException(nameof(_Configuration));
        List<SaveContainer> results = new();
        string by;
        long personKey;
        bool isByMapping;
        bool isBySorting;
        string checkFile;
        string directory;
        string shortcutFile;
        string? directoryName;
        string personDirectory;
        string? facesDirectory;
        FileHolder faceFileHolder;
        string personKeyFormatted;
        List<int> distinct = new();
        string? facePartsDirectory;
        SaveContainer? saveContainer;
        FileHolder facePartsFileHolder;
        FileHolder hiddenFaceFileHolder;
        Dictionary<int, Mapping>? normalizedRectangleToMapping;
        string forceSingleImageHumanized = nameof(Shared.Models.Stateless.IMapLogic.ForceSingleImage).Humanize(LetterCasing.Title);
        foreach (Mapping mapping in mappingCollection)
        {
            directoryName = Path.GetDirectoryName(mapping.MappingFromItem.RelativePath);
            if (directoryName is null)
                throw new NotSupportedException();
            (by, isByMapping, isBySorting) = Get(useFiltersCounter, forceSingleImageHumanized, mapping);
            if (isByMapping && !saveMapped)
                continue;
            if (mapping.MappingFromPerson is null)
            {
                if (!saveNullPerson)
                    continue;
                if (mapping.SortingContainer is null)
                    continue;
                if (distinct.Contains(mapping.MappingFromItem.Id))
                    continue;
                if (distinct.Contains(mapping.SortingContainer.Sorting.Id))
                    continue;
                directory = GetDirectory(by, mapping.MappingFromItem, mapping.SortingContainer);
                personDirectory = Path.Combine(directory, $"Z]{DateTime.Now.Ticks}");
                distinct.Add(mapping.MappingFromItem.Id);
                distinct.Add(mapping.SortingContainer.Sorting.Id);
            }
            else
            {
                if (string.IsNullOrEmpty(mapping.MappingFromPerson.SegmentB))
                    throw new NotSupportedException();
                if (string.IsNullOrEmpty(mapping.MappingFromPerson.DisplayDirectoryName))
                    throw new NotSupportedException();
                personKey = mapping.MappingFromPerson.PersonBirthday.Value.Ticks;
                personKeyFormatted = IPersonBirthday.GetFormatted(_Configuration.PersonBirthdayFormat, mapping.MappingFromPerson.PersonBirthday);
                if (string.IsNullOrEmpty(mapping.SegmentC))
                    directory = Path.Combine(_EDistanceContentTicksDirectory, by, personKeyFormatted, mapping.MappingFromPerson.SegmentB);
                else
                    directory = Path.Combine(_EDistanceContentTicksDirectory, by, personKeyFormatted, mapping.MappingFromPerson.SegmentB, mapping.SegmentC);
                if (isByMapping)
                    personDirectory = Path.Combine(directory, mapping.MappingFromPerson.DisplayDirectoryName);
                else if (mapping.By is not null)
                    personDirectory = Path.Combine(directory, mapping.MappingFromPerson.DisplayDirectoryName, "lnk");
                else
                    personDirectory = Path.Combine(directory, mapping.MappingFromPerson.DisplayDirectoryName[..1], "lnk");
                if (isByMapping && personKeyToCount.TryGetValue(personKey, out int count))
                {
                    saveContainer = new(Path.Combine(directory, mapping.MappingFromPerson.DisplayDirectoryName, $"{count} Face(s)"));
                    results.Add(saveContainer);
                }
            }
            saveContainer = new(personDirectory);
            results.Add(saveContainer);
            facesDirectory = GetFacesDirectory(dFacesContentDirectory, mapping.MappingFromItem);
            if (facesDirectory is null)
                continue;
            faceFileHolder = new(Path.Combine(facesDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}{_Configuration.FacesFileNameExtension}"));
            if (!faceFileHolder.Exists)
                continue;
            if (isByMapping)
            {
                checkFile = Path.Combine(personDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}");
                saveContainer = new(checkFile, directory, faceFileHolder);
            }
            else
            {
                facePartsDirectory = GetFacePartsDirectory(d2FacePartsContentDirectory, mapping.MappingFromItem);
                if (facePartsDirectory is null)
                    continue;
                // if (!isBySorting || mapping.MappingFromPerson is not null)
                checkFile = Path.Combine(directory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}");
                // else
                //     checkFile = Path.Combine(directory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}-Source{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}");
                shortcutFile = Path.Combine(personDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}.lnk");
                hiddenFaceFileHolder = new(Path.Combine(facesDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}{_Configuration.FacesHiddenFileNameExtension}"));
                facePartsFileHolder = new(Path.Combine(facePartsDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}{_Configuration.FacePartsFileNameExtension}"));
                saveContainer = new(checkFile, directory, faceFileHolder, hiddenFaceFileHolder, facePartsFileHolder, mapping.MappingFromItem.ResizedFileHolder, shortcutFile);
            }
            results.Add(saveContainer);
            if (!isBySorting || mapping.SortingContainer is null)
                continue;
            if (!idToNormalizedRectangleToMapping.TryGetValue(mapping.SortingContainer.Sorting.Id, out normalizedRectangleToMapping))
                continue;
            if (!normalizedRectangleToMapping.ContainsKey(mapping.SortingContainer.Sorting.NormalizedRectangle))
                continue;
            if (isBySorting && mapping.MappingFromPerson is null)
            {
                saveContainer = GetMatchSaveContainer(dFacesContentDirectory, d2FacePartsContentDirectory, directory, normalizedRectangleToMapping[mapping.SortingContainer.Sorting.NormalizedRectangle]);
                if (saveContainer is not null)
                    results.Add(saveContainer);
            }
            saveContainer = Stateless.MapLogic.GetDebugSaveContainer(directory, mapping.SortingContainer, normalizedRectangleToMapping[mapping.SortingContainer.Sorting.NormalizedRectangle]);
            results.Add(saveContainer);
        }
        return results;
    }

    public List<SaveContainer> GetSaveContainers(string dFacesContentDirectory, string d2FacePartsContentDirectory, Mapping[] mappingCollection, Dictionary<int, Dictionary<int, Mapping>> idToNormalizedRectangleToMapping, int? useFiltersCounter, bool saveNullPerson)
    {
        if (_Configuration is null)
            throw new NullReferenceException(nameof(_Configuration));
        List<SaveContainer> results;
        bool saveMapped = false;
        Dictionary<long, int> personKeyToCount = new();
        results = GetSaveContainers(dFacesContentDirectory, d2FacePartsContentDirectory, mappingCollection, idToNormalizedRectangleToMapping, personKeyToCount, useFiltersCounter, saveNullPerson, saveMapped);
        return results;
    }

    public void SaveMapped(string dFacesContentDirectory, string d2FacePartsContentDirectory, Mapping[] mappingCollection, Dictionary<int, Dictionary<int, Mapping>> idToNormalizedRectangleToMapping, Dictionary<long, int> personKeyToCount, int totalNotMapped)
    {
        if (_Configuration is null)
            throw new NullReferenceException(nameof(_Configuration));
        int? updated = null;
        bool saveMapped = true;
        bool saveNullPerson = false;
        int? useFiltersCounter = null;
        string mappingDirectory = Path.Combine(_EDistanceContentTicksDirectory, nameof(Shared.Models.Stateless.IMapLogic.Mapping));
        List<SaveContainer> saveContainers = GetSaveContainers(dFacesContentDirectory, d2FacePartsContentDirectory, mappingCollection, idToNormalizedRectangleToMapping, personKeyToCount, useFiltersCounter, saveNullPerson, saveMapped);
        SaveContainers(totalNotMapped, updated, saveContainers);
        if (!string.IsNullOrEmpty(_EDistanceContentTicksDirectory) && Directory.Exists(mappingDirectory))
            Stateless.MapLogic.SaveMappingShortcuts(mappingDirectory);
    }

    private List<(long, long, long, long)> GetPersonKeysRangesCollection(PersonContainer[] personContainers)
    {
        if (_PersonKeyToRanges is null)
            throw new NullReferenceException(nameof(_PersonKeyToRanges));
        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.NormalizedRectangle is null)
            throw new NotSupportedException();
        List<int>? normalizedRectangles;
        Dictionary<int, PersonContainer[]>? normalizedRectangleToPersonContainers;
        if (_SkipCollection.TryGetValue(faceDistanceEncoding.Id, out normalizedRectangles))
        {
            if (normalizedRectangles.Contains(faceDistanceEncoding.NormalizedRectangle.Value))
                result = true;
        }
        if (!result && _IdThenNormalizedRectangleToPersonContainers.TryGetValue(faceDistanceEncoding.Id, out normalizedRectangleToPersonContainers))
        {
            if (normalizedRectangleToPersonContainers.ContainsKey(faceDistanceEncoding.NormalizedRectangle.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>? normalizedRectangles;
        Dictionary<int, PersonContainer[]>? normalizedRectangleToPersonContainers;
        List<(long lcl, long minimum, long maximum, long ucl)> personKeysRangesCollection;
        for (int j = 0; j < faceDistanceLengths.Count; j++)
        {
            if (faceDistanceEncoding.NormalizedRectangle is null)
                throw new NotSupportedException();
            if (j == i)
                continue;
            if (_SkipCollection.TryGetValue(faceDistanceEncoding.Id, out normalizedRectangles))
            {
                if (normalizedRectangles.Contains(faceDistanceEncoding.NormalizedRectangle.Value))
                    continue;
            }
            if (_IdThenNormalizedRectangleToPersonContainers.TryGetValue(faceDistanceEncoding.Id, out normalizedRectangleToPersonContainers))
            {
                if (normalizedRectangleToPersonContainers.ContainsKey(faceDistanceEncoding.NormalizedRectangle.Value))
                    continue;
            }
            faceDistanceLength = faceDistanceLengths[j];
            if (faceDistanceLength.NormalizedRectangle is null || faceDistanceLength.Length is null)
                throw new NotSupportedException();
            if (faceDistanceLength.Length == 0)
                continue;
            if (!_IdThenNormalizedRectangleToPersonContainers.TryGetValue(faceDistanceLength.Id, out normalizedRectangleToPersonContainers))
                personKeysRangesCollection = new();
            else
            {
                if (!normalizedRectangleToPersonContainers.ContainsKey(faceDistanceLength.NormalizedRectangle.Value))
                    personKeysRangesCollection = new();
                else
                    personKeysRangesCollection = GetPersonKeysRangesCollection(normalizedRectangleToPersonContainers[faceDistanceLength.NormalizedRectangle.Value]);
            }
            sorting = ISorting.Get(_Configuration.FaceDistancePermyriad, _Configuration.RangeDistanceTolerance, faceDistanceEncoding, faceDistanceLength, personKeysRangesCollection);
            if (sorting.DistancePermyriad == 0)
                continue;
            if (sorting.Id == faceDistanceEncoding.Id)
            {
                if (sorting.NormalizedRectangle == faceDistanceEncoding.NormalizedRectangle.Value)
                    continue;
                continue;
            }
            results.Add(sorting);
        }
        return results;
    }

    public int UpdateFromSortingContainers(SortingContainer[] sortingContainers, bool saveNullPerson)
    {
        if (_Configuration is null)
            throw new NullReferenceException(nameof(_Configuration));
        if (_MapLogicSupport is not null)
        {
            string counts = _MapLogicSupport.GetCounts();
            _ = Directory.CreateDirectory(Path.Combine(_EDistanceContentTicksDirectory, counts));
        }
        int result = 0;
        string key;
        const int zero = 0;
        string mappingSegmentB;
        string personKeyFormatted;
        PersonBirthday personBirthday;
        PersonContainer[]? personContainers;
        Dictionary<string, int> keyToCount = new();
        List<int> normalizedRectangleCollectionForA;
        List<int> normalizedRectangleCollectionForB;
        Dictionary<string, string> keyToSegmentC = new();
        Dictionary<int, List<int>> idToNormalizedRectangleCollectionForA = new();
        Dictionary<int, List<int>> idToNormalizedRectangleCollectionForB = new();
        Dictionary<int, PersonContainer[]>? normalizedRectangleToPersonContainers;
        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.Mapping is null)
                throw new NotSupportedException();
            if (!idToNormalizedRectangleCollectionForA.ContainsKey(sortingContainer.Mapping.MappingFromItem.Id))
                idToNormalizedRectangleCollectionForA.Add(sortingContainer.Mapping.MappingFromItem.Id, new());
            normalizedRectangleCollectionForA = idToNormalizedRectangleCollectionForA[sortingContainer.Mapping.MappingFromItem.Id];
            if (!idToNormalizedRectangleCollectionForB.ContainsKey(sortingContainer.Mapping.MappingFromItem.Id))
                idToNormalizedRectangleCollectionForB.Add(sortingContainer.Mapping.MappingFromItem.Id, new());
            normalizedRectangleCollectionForB = idToNormalizedRectangleCollectionForB[sortingContainer.Mapping.MappingFromItem.Id];
            if (!_IdThenNormalizedRectangleToPersonContainers.TryGetValue(sortingContainer.Sorting.Id, out normalizedRectangleToPersonContainers) || !normalizedRectangleToPersonContainers.TryGetValue(sortingContainer.Sorting.NormalizedRectangle, out personContainers))
            {
                if (!saveNullPerson)
                    continue;
                if (normalizedRectangleCollectionForA.Contains(sortingContainer.Mapping.MappingFromLocation.NormalizedRectangle))
                    continue;
                sortingContainer.Mapping.UpdateMappingFromUnknownPerson(sortingContainer);
                normalizedRectangleCollectionForA.Add(sortingContainer.Mapping.MappingFromLocation.NormalizedRectangle);
                result += 1;
            }
            else
            {
                if (normalizedRectangleCollectionForB.Contains(sortingContainer.Mapping.MappingFromLocation.NormalizedRectangle))
                    continue;
                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 = Stateless.MapLogic.GetMappingSegmentB(_Ticks, personBirthday, personContainer.ApproximateYears, sortingContainer.Mapping.MappingFromItem);
                    key = string.Concat(personKeyFormatted, '\t', mappingSegmentB);
                    if (!keyToCount.ContainsKey(key))
                        keyToCount.Add(key, new());
                    if (!keyToCount.ContainsKey(key))
                        keyToCount.Add(key, 0);
                    if (!keyToSegmentC.ContainsKey(key))
                        keyToSegmentC.Add(key, string.Empty);
                    keyToCount[key]++;
                    if (keyToCount[key] > _Configuration.SortingMaximumPerKey)
                    {
                        keyToCount[key] = 0;
                        keyToSegmentC[key] = sortingContainer.Sorting.DistancePermyriad.ToString();
                    }
                    sortingContainer.Mapping.UpdateMappingFromPerson(personContainer.ApproximateYears, personContainer.DisplayDirectoryName, personBirthday, mappingSegmentB, keyToSegmentC[key], sortingContainer);
                    normalizedRectangleCollectionForB.Add(sortingContainer.Mapping.MappingFromLocation.NormalizedRectangle);
                    result += 1;
                    break;
                }
            }
        }
        return result;
    }

    public void CopyManualFiles(string dFacesContentDirectory, Dictionary<int, Dictionary<int, Mapping>> idToNormalizedRectangleToMapping)
    {
        if (_Configuration is null)
            throw new NullReferenceException(nameof(_Configuration));
        int? id;
        Mapping mapping;
        string faceFile;
        string checkFile;
        string directory;
        FileInfo fileInfo;
        const int zero = 0;
        string faceFileName;
        string shortcutFile;
        string? directoryName;
        string mappingSegmentB;
        string personDirectory;
        string? facesDirectory;
        string personKeyFormatted;
        string personDisplayFileName;
        PersonBirthday personBirthday;
        string? personDisplayDirectory;
        int? normalizedRectangle;
        WindowsShortcut windowsShortcut;
        Dictionary<int, Mapping>? normalizedRectangleToMapping;
        string by = nameof(Shared.Models.Stateless.IMapLogic.ManualCopy);
        Dictionary<int, PersonContainer[]>? normalizedRectangleToPeronContainerCollection;
        string successfull = $"_ {nameof(Shared.Models.Stateless.IMapLogic.ManualCopy).Humanize(LetterCasing.Title)} Successfull";
        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.Contains("-2318605"))
                    continue;
                if (!personDisplayDirectoryAllFile.EndsWith(_Configuration.FacesFileNameExtension))
                    continue;
                (id, normalizedRectangle) = IMapping.GetConverted(_Configuration.FacesFileNameExtension, personDisplayDirectoryAllFile);
                if (id is null || normalizedRectangle is null)
                    continue;
                fileInfo = new(personDisplayDirectoryAllFile);
                if (!fileInfo.Exists)
                    continue;
                personDisplayFileName = Path.GetFileName(personDisplayDirectoryAllFile);
                personDisplayDirectory = Path.GetDirectoryName(personDisplayDirectoryAllFile);
                personKeyFormatted = IPersonBirthday.GetFormatted(_Configuration.PersonBirthdayFormat, personBirthday);
                mappingSegmentB = Stateless.MapLogic.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 (!idToNormalizedRectangleToMapping.TryGetValue(id.Value, out normalizedRectangleToMapping))
                    continue;
                if (!normalizedRectangleToMapping.ContainsKey(normalizedRectangle.Value))
                    continue;
                mapping = normalizedRectangleToMapping[normalizedRectangle.Value];
                if (string.IsNullOrEmpty(personDisplayDirectory))
                    throw new NotSupportedException();
                directoryName = Path.GetDirectoryName(mapping.MappingFromItem.RelativePath);
                if (string.IsNullOrEmpty(directoryName))
                    throw new NotSupportedException();
                shortcutFile = Path.Combine(personDisplayDirectory, $"{personDisplayFileName}.lnk");
                facesDirectory = GetFacesDirectory(dFacesContentDirectory, mapping.MappingFromItem); // Path.Combine($"{dFacesContentDirectory}{directoryName}", mapping.MappingFromItem.ImageFileHolder.NameWithoutExtension);
                if (facesDirectory is null)
                    continue;
                faceFileName = $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}{_Configuration.FacesFileNameExtension}";
                checkFile = Path.Combine(directory, fileInfo.Name);
                if (!_IdThenNormalizedRectangleToPersonContainers.TryGetValue(id.Value, out normalizedRectangleToPeronContainerCollection) || !normalizedRectangleToPeronContainerCollection.ContainsKey(normalizedRectangle.Value))
                {
                    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);
                if (File.Exists(checkFile))
                    File.Delete(personDisplayDirectoryAllFile);
                else
                    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, mapping.MappingFromItem.MinimumDateTime);
            }
        }
    }

    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(Shared.Models.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 (string, PersonBirthday?) GetPersonBirthday(string[] directoryNames)
    {
        if (_Configuration is null)
            throw new NullReferenceException(nameof(_Configuration));
        PersonBirthday? personBirthday = null;
        string personKeyFormatted = string.Empty;
        foreach (string directoryName in directoryNames)
        {
            personBirthday = IPersonBirthday.GetPersonBirthday(_Configuration.PersonBirthdayFormat, directoryName);
            if (personBirthday is not null)
            {
                personKeyFormatted = directoryName;
                break;
            }
        }
        return new(personKeyFormatted, personBirthday);
    }

    private (string, PersonBirthday?) GetPersonBirthday(string windowsShortcutPath)
    {
        if (_Configuration is null)
            throw new NullReferenceException(nameof(_Configuration));
        string[] directoryNames = IPath.GetDirectoryNames(windowsShortcutPath);
        (string personKeyFormatted, PersonBirthday? personBirthday) = GetPersonBirthday(directoryNames);
        if (personBirthday is null)
        {
            string[] directories = Directory.GetDirectories(windowsShortcutPath, "*", SearchOption.TopDirectoryOnly);
            foreach (string directory in directories)
            {
                directoryNames = IPath.GetDirectoryNames(directory);
                (personKeyFormatted, personBirthday) = GetPersonBirthday(directoryNames);
                if (personBirthday is not null)
                    break;
            }
        }
        return new(personKeyFormatted, personBirthday);
    }

    private List<string> GetPersonKeyFormattedCollection(string[] jLinks, string a2PeopleSingletonDirectory, PersonContainer[] personContainers, Dictionary<long, int> personKeyToCount)
    {
        if (_Configuration is null)
            throw new NullReferenceException(nameof(_Configuration));
        if (_MapLogicSupport is null)
            throw new NullReferenceException(nameof(_MapLogicSupport));
        List<string> results = new();
        string[] files;
        string checkDirectory;
        string[] checkDirectories;
        string personKeyFormatted;
        PersonContainer[] matches;
        PersonBirthday? personBirthday;
        string fileNameWithoutExtension;
        WindowsShortcut windowsShortcut;
        List<(long, string)> collection = new();
        foreach (string directoryName in jLinks)
        {
            checkDirectory = Path.Combine(a2PeopleSingletonDirectory, directoryName);
            if (!Directory.Exists(checkDirectory))
                continue;
            checkDirectories = Directory.GetDirectories(checkDirectory, "*", SearchOption.TopDirectoryOnly);
            files = Directory.GetFiles(checkDirectory, "*.lnk", SearchOption.TopDirectoryOnly);
            foreach (string file in files)
            {
                collection.Clear();
                windowsShortcut = WindowsShortcut.Load(file);
                fileNameWithoutExtension = Path.GetFileNameWithoutExtension(file);
                if (windowsShortcut.Path is null)
                    continue;
                if (!Directory.Exists(windowsShortcut.Path))
                {
                    if (files.Length != checkDirectories.Length)
                        throw new NotSupportedException(fileNameWithoutExtension);
                    continue;
                }
                (personKeyFormatted, personBirthday) = GetPersonBirthday(windowsShortcut.Path);
                if (personBirthday is null)
                    throw new NotSupportedException(fileNameWithoutExtension);
                if (!personKeyToCount.ContainsKey(personBirthday.Value.Ticks))
                    collection.Add(new(personBirthday.Value.Ticks, Path.Combine(checkDirectory, personKeyFormatted, fileNameWithoutExtension)));
                else
                    collection.Add(new(personBirthday.Value.Ticks, Path.Combine(checkDirectory, personKeyFormatted, fileNameWithoutExtension, $"{personKeyToCount[personBirthday.Value.Ticks]} Face(s)")));
                foreach ((long personKey, string displayDirectoryName) in collection)
                {
                    matches = (from l in personContainers where l.Key == personKey && l.ApproximateYears.HasValue select l).ToArray();
                    if (!matches.Any())
                        continue;
                    personKeyFormatted = IPersonBirthday.GetFormatted(_Configuration.PersonBirthdayFormat, personKey);
                    if (!displayDirectoryName.Contains(personKeyFormatted))
                        continue;
                    if (!Directory.Exists(displayDirectoryName))
                        _ = Directory.CreateDirectory(displayDirectoryName);
                    results.Add(personKeyFormatted);
                }
            }
        }
        return results;
    }

    private (int, FileHolder, int, string, string, string, string)[] GetCollectionForSaveFilteredOriginalImagesFromJLinks(string[] jLinks, string a2PeopleSingletonDirectory, PersonContainer[] personContainers, Mapping[] mappingCollection, Dictionary<long, int> personKeyToCount)
    {
        if (_Configuration is null)
            throw new NullReferenceException(nameof(_Configuration));
        (int, FileHolder, int, string, string, string, string)[] results;
        string checkFile;
        string directory;
        string? directoryName;
        string personDirectory;
        string personKeyFormatted;
        bool usePersonKeyAndDeterministicHashCodeKey = false;
        List<string> personKeyFormattedCollection = GetPersonKeyFormattedCollection(jLinks, a2PeopleSingletonDirectory, personContainers, personKeyToCount);
        List<(int Id, FileHolder ImageFileHolder, int ApproximateYears, string PersonKeyFormatted, string CheckFile, string Directory, string PersonDirectory)> collection = new();
        foreach (Mapping mapping in mappingCollection)
        {
            directoryName = Path.GetDirectoryName(mapping.MappingFromItem.RelativePath);
            if (directoryName is null)
                throw new NotSupportedException();
            if (mapping.By is null or Shared.Models.Stateless.IMapLogic.Sorting)
                continue;
            if (mapping.MappingFromPerson?.ApproximateYears is null)
                continue;
            if (string.IsNullOrEmpty(mapping.MappingFromPerson.SegmentB))
                throw new NotSupportedException();
            if (string.IsNullOrEmpty(mapping.MappingFromPerson.DisplayDirectoryName))
                throw new NotSupportedException();
            personKeyFormatted = IPersonBirthday.GetFormatted(_Configuration.PersonBirthdayFormat, mapping.MappingFromPerson.PersonBirthday);
            if (personKeyFormatted == "1501-04-10_00")
                continue;
            if (!personKeyFormattedCollection.Contains(personKeyFormatted))
                continue;
            if (!usePersonKeyAndDeterministicHashCodeKey)
            {
                directory = Path.Combine(_EDistanceContentTicksDirectory, "Images");
                personDirectory = Path.Combine(directory, mapping.MappingFromPerson.DisplayDirectoryName);
                checkFile = Path.Combine(directory, $"{mapping.MappingFromItem.Id}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}");
            }
            else
            {
                directory = Path.Combine(_EDistanceContentTicksDirectory, "Images", personKeyFormatted);
                personDirectory = Path.Combine(directory, mapping.MappingFromPerson.DisplayDirectoryName);
                checkFile = Path.Combine(directory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}");
            }
            collection.Add(new(mapping.MappingFromItem.Id, mapping.MappingFromItem.ImageFileHolder, mapping.MappingFromPerson.ApproximateYears.Value, personKeyFormatted, directory, personDirectory, checkFile));
        }
        results = (from l in collection orderby l.ApproximateYears descending, l.PersonKeyFormatted descending select l).ToArray();
        return results;
    }

    public void SaveFilteredOriginalImagesFromJLinks(string[] jLinks, PersonContainer[] personContainers, string a2PeopleSingletonDirectory, Mapping[] mappingCollection, Dictionary<long, int> personKeyToCount, int totalNotMapped)
    {
        if (_Configuration is null)
            throw new NullReferenceException(nameof(_Configuration));
        SaveContainer? saveContainer;
        List<int> distinctCollection = new();
        List<SaveContainer> saveContainers = new();
        (int, FileHolder, int, string, string, string, string)[] collection = GetCollectionForSaveFilteredOriginalImagesFromJLinks(jLinks, a2PeopleSingletonDirectory, personContainers, mappingCollection, personKeyToCount);
        foreach ((int id, FileHolder imageFileHolder, int approximateYears, string personKeyFormatted, string directory, string personDirectory, string checkFile) in collection)
        {
            if (distinctCollection.Contains(id))
                continue;
            distinctCollection.Add(id);
            saveContainer = new(personDirectory);
            saveContainers.Add(saveContainer);
            saveContainer = new(imageFileHolder, checkFile, directory);
            saveContainers.Add(saveContainer);
        }
        SaveContainers(totalNotMapped, null, saveContainers);
    }

    private (List<(string, DateTime[])>, List<(string, string, string, string)>) GetCollectionForSaveShortcutsForOutputResolutions(List<Item> filteredItems, Mapping[] mappingCollection, Dictionary<long, int> personKeyToCount)
    {
        if (_Configuration is null)
            throw new NullReferenceException(nameof(_Configuration));
        long personKey;
        string fileName;
        string directory;
        string? directoryName;
        string personDirectory;
        string personKeyFormatted;
        List<string> distinct = new();
        List<(string, string, string, string)> collection = new();
        List<(string, DateTime[])> directoriesAndDateTimes = new();
        foreach (Item item in filteredItems)
        {
            if (item.ResizedFileHolder is null)
                continue;
            foreach (Face face in item.Faces)
            {
                if (face.FaceEncoding is null || face.Location is null || face.OutputResolution is null || face.Mapping is null)
                    continue;
                directoryName = Path.GetDirectoryName(face.Mapping.MappingFromItem.RelativePath);
                if (directoryName is null)
                    throw new NotSupportedException();
                if (item.ResizedFileHolder?.DirectoryName is null || !item.ResizedFileHolder.Exists)
                    continue;
                directory = Path.Combine(item.ResizedFileHolder.DirectoryName, $"{_PropertyConfiguration.ResultAllInOne}Shortcuts", _PropertyConfiguration.ResultAllInOne);
                personDirectory = Path.Combine(directory, "No Faces");
                fileName = Path.Combine(personDirectory, $"{item.ResizedFileHolder.Name}.lnk");
                collection.Add(new(item.ResizedFileHolder.FullName, personDirectory, fileName, face.Mapping.MappingFromItem.Id.ToString()));
                if (face.Mapping.MappingFromItem.ContainerDateTimes.Any() && !distinct.Contains(item.ResizedFileHolder.DirectoryName))
                {
                    distinct.Add(item.ResizedFileHolder.DirectoryName);
                    directoriesAndDateTimes.Add(new(item.ResizedFileHolder.DirectoryName, face.Mapping.MappingFromItem.ContainerDateTimes));
                }
            }
        }
        foreach (Mapping mapping in mappingCollection)
        {
            if (mapping.MappingFromItem.ResizedFileHolder.DirectoryName is null || !mapping.MappingFromItem.ResizedFileHolder.Exists)
                continue;
            if (mapping.By is null or Shared.Models.Stateless.IMapLogic.Sorting || mapping.MappingFromPerson?.ApproximateYears is null)
                continue;
            if (string.IsNullOrEmpty(mapping.MappingFromPerson.SegmentB))
                throw new NotSupportedException();
            if (string.IsNullOrEmpty(mapping.MappingFromPerson.DisplayDirectoryName))
                throw new NotSupportedException();
            personKeyFormatted = IPersonBirthday.GetFormatted(_Configuration.PersonBirthdayFormat, mapping.MappingFromPerson.PersonBirthday);
        }
        foreach (Mapping mapping in mappingCollection)
        {
            directoryName = Path.GetDirectoryName(mapping.MappingFromItem.RelativePath);
            if (directoryName is null)
                throw new NotSupportedException();
            if (mapping.MappingFromItem.ResizedFileHolder.DirectoryName is null || !mapping.MappingFromItem.ResizedFileHolder.Exists)
                continue;
            if (mapping.By is null or Shared.Models.Stateless.IMapLogic.Sorting || mapping.MappingFromPerson?.ApproximateYears is null)
            {
                if (mapping.MappingFromItem.ContainerDateTimes.Any() && !distinct.Contains(mapping.MappingFromItem.ResizedFileHolder.DirectoryName))
                {
                    distinct.Add(mapping.MappingFromItem.ResizedFileHolder.DirectoryName);
                    directoriesAndDateTimes.Add(new(mapping.MappingFromItem.ResizedFileHolder.DirectoryName, mapping.MappingFromItem.ContainerDateTimes));
                }
                directory = Path.Combine(mapping.MappingFromItem.ResizedFileHolder.DirectoryName, $"{_PropertyConfiguration.ResultAllInOne}Shortcuts", _PropertyConfiguration.ResultAllInOne);
                personDirectory = Path.Combine(directory, "Unknown");
                fileName = Path.Combine(personDirectory, $"{mapping.MappingFromItem.ResizedFileHolder.Name}.lnk");
                collection.Add(new(mapping.MappingFromItem.ResizedFileHolder.FullName, personDirectory, fileName, mapping.MappingFromLocation.DeterministicHashCodeKey));
            }
            else
            {
                if (string.IsNullOrEmpty(mapping.MappingFromPerson.SegmentB))
                    throw new NotSupportedException();
                if (string.IsNullOrEmpty(mapping.MappingFromPerson.DisplayDirectoryName))
                    throw new NotSupportedException();
                personKeyFormatted = IPersonBirthday.GetFormatted(_Configuration.PersonBirthdayFormat, mapping.MappingFromPerson.PersonBirthday);
                personKey = mapping.MappingFromPerson.PersonBirthday.Value.Ticks;
                if (mapping.MappingFromItem.ContainerDateTimes.Any() && !distinct.Contains(mapping.MappingFromItem.ResizedFileHolder.DirectoryName))
                {
                    distinct.Add(mapping.MappingFromItem.ResizedFileHolder.DirectoryName);
                    directoriesAndDateTimes.Add(new(mapping.MappingFromItem.ResizedFileHolder.DirectoryName, mapping.MappingFromItem.ContainerDateTimes));
                }
                directory = Path.Combine(mapping.MappingFromItem.ResizedFileHolder.DirectoryName, $"{_PropertyConfiguration.ResultAllInOne}Shortcuts", personKeyFormatted);
                if (!personKeyToCount.ContainsKey(personKey))
                    personDirectory = Path.Combine(directory, mapping.MappingFromPerson.DisplayDirectoryName);
                else
                    personDirectory = Path.Combine(directory, mapping.MappingFromPerson.DisplayDirectoryName, $"{personKeyToCount[personKey]} Face(s)");
                fileName = Path.Combine(directory, $"{mapping.MappingFromItem.ResizedFileHolder.Name}.lnk");
                collection.Add(new(mapping.MappingFromItem.ResizedFileHolder.FullName, personDirectory, fileName, mapping.MappingFromLocation.DeterministicHashCodeKey));
            }
        }
        return new(directoriesAndDateTimes, collection);
    }

    public void SaveShortcutsForOutputResolutions(List<Item> filteredItems, Mapping[] mappingCollection, Dictionary<long, int> personKeyToCount)
    {
        if (_Configuration is null)
            throw new NullReferenceException(nameof(_Configuration));
        WindowsShortcut windowsShortcut;
        List<(string, DateTime[])> directoriesAndDateTimes;
        List<(string, string Directory, string, string)> collection;
        (directoriesAndDateTimes, collection) = GetCollectionForSaveShortcutsForOutputResolutions(filteredItems, mappingCollection, personKeyToCount);
        string[] directories = (from l in collection select l.Directory).Distinct().ToArray();
        foreach (string directory in directories)
        {
            if (string.IsNullOrEmpty(directory))
                continue;
            if (!Directory.Exists(directory))
                _ = Directory.CreateDirectory(directory);
        }
        foreach ((string fullName, string directory, string fileName, string description) in collection)
        {
            if (File.Exists(fileName))
                continue;
            try
            {
                windowsShortcut = new() { Path = fullName, Description = description };
                windowsShortcut.Save(fileName);
                windowsShortcut.Dispose();
            }
            catch (Exception)
            { }
        }
        foreach ((string directory, DateTime[] dateTimes) in directoriesAndDateTimes)
        {
            if (!dateTimes.Any())
                continue;
            Directory.SetCreationTime(directory, dateTimes[0]);
            Directory.SetLastWriteTime(directory, dateTimes[1]);
        }
    }

    private List<(string, FileHolder, string)> GetCollection(string dFacesContentDirectory, Dictionary<int, Dictionary<int, Mapping>> idToNormalizedRectangleToMapping)
    {
        if (_Configuration is null)
            throw new NullReferenceException(nameof(_Configuration));
        List<(string, FileHolder, string)> results = new();
        Mapping mapping;
        string checkFile;
        string directory;
        string? directoryName;
        string? facesDirectory;
        FileHolder faceFileHolder;
        List<int>? normalizedRectangles;
        string by = nameof(Shared.Models.Stateless.IMapLogic.CopyNotMappedFaces);
        Dictionary<int, PersonContainer[]>? normalizedRectangleToPersonContainers;
        foreach (KeyValuePair<int, Dictionary<int, Mapping>> keyValuePair in idToNormalizedRectangleToMapping)
        {
            _ = _IdThenNormalizedRectangleToPersonContainers.TryGetValue(keyValuePair.Key, out normalizedRectangleToPersonContainers);
            foreach (KeyValuePair<int, Mapping> normalizedRectangleAndMapping in keyValuePair.Value)
            {
                mapping = normalizedRectangleAndMapping.Value;
                if (normalizedRectangleToPersonContainers is not null && normalizedRectangleToPersonContainers.ContainsKey(mapping.MappingFromLocation.NormalizedRectangle))
                    continue;
                _ = _SkipCollection.TryGetValue(keyValuePair.Key, out normalizedRectangles);
                if (normalizedRectangles is not null && normalizedRectangles.Contains(mapping.MappingFromLocation.NormalizedRectangle))
                    continue;
                directoryName = Path.GetDirectoryName(mapping.MappingFromItem.RelativePath);
                facesDirectory = GetFacesDirectory(dFacesContentDirectory, mapping.MappingFromItem); // Path.Combine($"{dFacesContentDirectory}{directoryName}", mapping.MappingFromItem.ImageFileHolder.NameWithoutExtension);
                if (facesDirectory is null)
                    continue;
                faceFileHolder = new(Path.Combine(facesDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}{_Configuration.FacesFileNameExtension}"));
                if (directoryName is null || !faceFileHolder.Exists)
                    continue;
                directory = Path.Combine(_EDistanceContentTicksDirectory, by, $"{mapping.MappingFromLocation.AreaPermille:0000}A{mapping.MappingFromItem.MinimumDateTime.ToString("yyyy")[..3]}#");
                checkFile = Path.Combine(directory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}{_Configuration.FacesFileNameExtension}");
                results.Add(new(directory, faceFileHolder, checkFile));
            }
        }
        return results;
    }

    public void CopyNotMappedFaces(int[] rangeFaceAreaPermilleTolerance, string dFacesContentDirectory, Dictionary<int, Dictionary<int, Mapping>> idToNormalizedRectangleToMapping)
    {
        if (_Configuration is null)
            throw new NullReferenceException(nameof(_Configuration));
        List<(string Directory, FileHolder FaceFileHolder, string CheckFile)> collection = GetCollection(dFacesContentDirectory, idToNormalizedRectangleToMapping);
        string[] directories = (from l in collection select l.Directory).Distinct().ToArray();
        foreach (string directory in directories)
        {
            if (string.IsNullOrEmpty(directory))
                continue;
            if (!Directory.Exists(directory))
                _ = Directory.CreateDirectory(directory);
        }
        foreach ((string directory, FileHolder faceFileHolder, string checkFile) in collection)
        {
            if (File.Exists(checkFile))
                continue;
            File.Copy(faceFileHolder.FullName, checkFile);
        }
    }

    public Dictionary<int, Dictionary<int, PersonContainer[]>> GetMissing(Dictionary<int, Dictionary<int, Mapping>> idToNormalizedRectangleToMapping)
    {
        Dictionary<int, Dictionary<int, PersonContainer[]>> results = new();
        foreach (KeyValuePair<int, Dictionary<int, PersonContainer[]>> normalizedRectangleToPersonContainers in _IdThenNormalizedRectangleToPersonContainers)
        {
            if (idToNormalizedRectangleToMapping.ContainsKey(normalizedRectangleToPersonContainers.Key))
                continue;
            results.Add(normalizedRectangleToPersonContainers.Key, normalizedRectangleToPersonContainers.Value);
        }
        return results;
    }

    public void UpdatedPersonKeyToRanges(Configuration configuration, long ticks, Mapping[] mappingCollection)
    {
        Dictionary<long, (long LCL, long Minimum, long Maximum, long UCL)> personKeyToRanges = new();
        Stateless.MapLogic.SetPersonTicks(configuration, ticks, mappingCollection, personKeyToRanges, _IdThenNormalizedRectangleToPersonContainers);
        _PersonKeyToRanges = personKeyToRanges;
    }

}