using Humanizer;
using ShellProgressBar;
using System.Text;
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 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;
    }

    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, string a2PeopleSingletonDirectory, PersonContainer[] personContainers, 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);
        }
    }

    private DatabaseFileRoot GetDatabaseFileRoot()
    {
        if (_Configuration is null)
            throw new NullReferenceException(nameof(_Configuration));
        string file = Path.Combine(_Configuration.PhotoPrismDirectory, "files.json");
        string json = File.ReadAllText(file);
        DatabaseFileRoot? databaseFileRoot = JsonSerializer.Deserialize<DatabaseFileRoot>(json);
        if (databaseFileRoot is null)
            throw new NullReferenceException(nameof(databaseFileRoot));
        return databaseFileRoot;
    }

    private Marker[] GetMarkers()
    {
        if (_Configuration is null)
            throw new NullReferenceException(nameof(_Configuration));
        string file = Path.Combine(_Configuration.PhotoPrismDirectory, "markers.json");
        string json = File.ReadAllText(file);
        Marker[]? markerRoot = JsonSerializer.Deserialize<Marker[]>(json);
        if (markerRoot is null)
            throw new NullReferenceException(nameof(markerRoot));
        return markerRoot;
    }

    private static Dictionary<string, DatabaseFile> Get(DatabaseFileRoot databaseFileRoot)
    {
        Dictionary<string, DatabaseFile> fileUidToFile = new();
        for (int i = 0; i < databaseFileRoot.Files.Count; i++)
            fileUidToFile.Add(databaseFileRoot.Files[i].FileUid, databaseFileRoot.Files[i]);
        return fileUidToFile;
    }

    private static MarkerWith GetMarkerWith(int? dlib, DatabaseFile databaseFile, Marker marker, int? count, double? percent, int? normalizedRectangle, long? personKey, string personKeyFormatted)
    {
        return new(marker.MarkerUid,
                   marker.FileUid,
                   marker.MarkerType,
                   marker.MarkerSrc,
                   marker.MarkerName,
                   marker.MarkerReview,
                   marker.MarkerInvalid,
                   marker.SubjUid,
                   marker.SubjSrc,
                   marker.FaceId,
                   marker.FaceDist,
                   marker.EmbeddingsJson,
                   marker.LandmarksJson,
                   marker.X,
                   marker.Y,
                   marker.W,
                   marker.H,
                   marker.Q,
                   marker.Size,
                   marker.Score,
                   marker.Thumb,
                   marker.MatchedAt,
                   marker.CreatedAt,
                   marker.UpdatedAt,
                   databaseFile.Id,
                   databaseFile.FileName,
                   dlib,
                   count,
                   percent,
                   normalizedRectangle,
                   personKey,
                   personKeyFormatted);
    }

    private static Dictionary<string, List<Face>> GetFacesByFileName(List<Item> filteredItems)
    {
        Dictionary<string, List<Face>> results = new();
        string key;
        foreach (Item item in filteredItems)
        {
            foreach (Face face in item.Faces)
            {
                if (face.FaceEncoding is null || face.Location is null || face.OutputResolution is null || face.Mapping is null)
                    continue;
                key = Path.GetFileNameWithoutExtension(face.Mapping.MappingFromItem.RelativePath);
                if (!results.ContainsKey(key))
                    results.Add(key, new());
                results[key].Add(face);
            }
        }
        return results;
    }

    public void FindMatch(List<Item> filteredItems)
    {
        if (_Configuration is null)
            throw new NullReferenceException(nameof(_Configuration));
        int? dlib;
        double? percent;
        long? personKey;
        const int zero = 0;
        List<Face>? matches;
        MarkerWith markerWith;
        int? normalizedRectangle;
        string personKeyFormatted;
        DatabaseFile? databaseFile;
        PersonBirthday personBirthday;
        Marker[] markers = GetMarkers();
        string fileNameWithoutExtension;
        PersonContainer[]? personContainers;
        System.Drawing.Rectangle dlibRectangle;
        System.Drawing.Rectangle prismRectangle;
        System.Drawing.Rectangle intersectRectangle;
        (Face Face, double Percent)[] sortedCollection;
        List<(Face Face, double Percent)> collection = new();
        DatabaseFileRoot databaseFileRoot = GetDatabaseFileRoot();
        Dictionary<string, DatabaseFile> fileUidToFile = Get(databaseFileRoot);
        Dictionary<int, PersonContainer[]>? normalizedRectangleToPersonContainers;
        Dictionary<string, List<Face>> keyValuePairs = GetFacesByFileName(filteredItems);
        foreach (Marker marker in markers)
        {
            dlib = null;
            personKey = null;
            collection.Clear();
            normalizedRectangle = null;
            personKeyFormatted = string.Empty;
            normalizedRectangleToPersonContainers = null;
            if (!fileUidToFile.TryGetValue(marker.FileUid, out databaseFile))
                continue;
            fileNameWithoutExtension = Path.GetFileNameWithoutExtension(Path.Combine("C:", databaseFile.FileName));
            prismRectangle = new((int)(marker.X * databaseFile.FileWidth), (int)(marker.Y * databaseFile.FileHeight), (int)(marker.W * databaseFile.FileWidth), (int)(marker.H * databaseFile.FileHeight));
            if (!keyValuePairs.TryGetValue(fileNameWithoutExtension, out matches) || !int.TryParse(fileNameWithoutExtension, out int id))
                percent = null;
            else
            {
                dlib = id;
                _ = _IdThenNormalizedRectangleToPersonContainers.TryGetValue(dlib.Value, out normalizedRectangleToPersonContainers);
                foreach (Face face in matches)
                {
                    if (face.Location is null || face.OutputResolution is null)
                        continue;
                    dlibRectangle = new(face.Location.Left, face.Location.Top, face.Location.Right - face.Location.Left, face.Location.Bottom - face.Location.Top);
                    intersectRectangle = System.Drawing.Rectangle.Intersect(prismRectangle, dlibRectangle);
                    if (intersectRectangle.Width == 0 || intersectRectangle.Height == 0)
                        continue;
                    percent = (double)intersectRectangle.Width * intersectRectangle.Height / (dlibRectangle.Width * dlibRectangle.Height);
                    if (percent < 0.000001)
                        continue;
                    collection.Add(new(face, percent.Value));
                }
            }
            if (!collection.Any())
                percent = null;
            else
            {
                sortedCollection = collection.OrderByDescending(l => l.Percent).ToArray();
                percent = sortedCollection[zero].Percent;
                normalizedRectangle = sortedCollection[zero].Face.Mapping?.MappingFromLocation.NormalizedRectangle;
                if (normalizedRectangleToPersonContainers is null || normalizedRectangle is null || !normalizedRectangleToPersonContainers.TryGetValue(normalizedRectangle.Value, out personContainers))
                    personContainers = null;
                else
                {
                    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;
                        personKeyFormatted = IPersonBirthday.GetFormatted(_Configuration.PersonBirthdayFormat, personBirthday);
                        break;
                    }
                }
            }
            markerWith = GetMarkerWith(dlib, databaseFile, marker, collection.Count, percent, normalizedRectangle, personKey, personKeyFormatted);
            string json = JsonSerializer.Serialize(markerWith, new JsonSerializerOptions() { WriteIndented = true });
            if (IPath.WriteAllText(Path.Combine(_Configuration.PhotoPrismDirectory, "With", $"{marker.MarkerUid}.json"), json, updateDateWhenMatches: false, compareBeforeWrite: true))
                continue;
        }
    }

    public void SaveMarkers()
    {
        if (_Configuration is null)
            throw new NullReferenceException(nameof(_Configuration));
        double[]? encoding;
        string file = Path.Combine(_Configuration.PhotoPrismDirectory, "markers.json");
        string json = File.ReadAllText(file);
        Marker[]? markers = JsonSerializer.Deserialize<Marker[]>(json);
        if (markers is null)
            throw new NullReferenceException(nameof(markers));
        foreach (Marker marker in markers)
        {
            encoding = JsonSerializer.Deserialize<double[]>(marker.EmbeddingsJson[1..^1]);
            File.WriteAllText(Path.Combine(_Configuration.PhotoPrismDirectory, "EmbeddingsJson", $"{marker.MarkerUid}.json"), marker.EmbeddingsJson);
            if (encoding is null)
                continue;
        }
    }

    public void LoadMatches()
    {
        if (_Configuration is null)
            throw new NullReferenceException(nameof(_Configuration));
        string json;
        MarkerWith? markerWith;
        List<MarkerWith> collection = new();
        StringBuilder stringBuilder = new();
        List<(int Count, MarkerWith MarkerWith)> countCollection = new();
        List<(double Percent, MarkerWith MarkerWith)> percentCollection = new();
        string[] files = Directory.GetFiles(Path.Combine(_Configuration.PhotoPrismDirectory, "With"), "*.json", SearchOption.TopDirectoryOnly);
        foreach (string file in files)
        {
            json = File.ReadAllText(file);
            markerWith = JsonSerializer.Deserialize<MarkerWith>(json);
            if (markerWith is null || markerWith.DlibId is null)
                continue;
            collection.Add(markerWith);
            if (markerWith.Count is null || markerWith.Count.Value == 0)
                continue;
            countCollection.Add(new(markerWith.Count.Value, markerWith));
            if (markerWith.Percent is null)
                continue;
            percentCollection.Add(new(markerWith.Percent.Value, markerWith));
            if (string.IsNullOrEmpty(markerWith.PersonKeyFormatted))
                continue;
            _ = stringBuilder.
                Append("update `markers` set subj_src = 'manual' marker_name = '").
                Append(markerWith.PersonKeyFormatted).
                Append("' where marker_uid = '").
                Append(markerWith.MarkerUid).
                AppendLine("';");
        }
        (int, MarkerWith)[] countSorted = countCollection.OrderByDescending(l => l.Count).ToArray();
        (double, MarkerWith)[] percentSorted = percentCollection.OrderBy(l => l.Percent).ToArray();
        if (collection.Any())
        { }
        File.WriteAllText(Path.Combine(_Configuration.PhotoPrismDirectory, "marker_name_update.sql"), stringBuilder.ToString());
    }

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

}