aa/Metadata/Models/A_Metadata.cs

using MetadataExtractor;
using System.Collections.ObjectModel;
using System.Text.Json;
using View_by_Distance.Metadata.Models.Stateless;
using View_by_Distance.Metadata.Models.Stateless.Methods;
using View_by_Distance.Shared.Models;
using View_by_Distance.Shared.Models.Properties;
using View_by_Distance.Shared.Models.Stateless.Methods;

namespace View_by_Distance.Metadata.Models;

public class A_Metadata
{

    private readonly MetadataConfiguration _MetadataConfiguration;
    private readonly ReadOnlyDictionary<int, ReadOnlyDictionary<string, string[]>> _FileGroups;

    public A_Metadata(MetadataConfiguration metadataConfiguration)
    {
        _MetadataConfiguration = metadataConfiguration;
        string bResultsFullGroupDirectory = IResult.GetResultsFullGroupDirectory(metadataConfiguration.ResultConfiguration,
                                                                                 nameof(A_Metadata),
                                                                                 string.Empty,
                                                                                 includeResizeGroup: false,
                                                                                 includeModel: false,
                                                                                 includePredictorModel: false);
        _FileGroups = IPath.GetKeyValuePairs(metadataConfiguration.ResultConfiguration, bResultsFullGroupDirectory, [metadataConfiguration.ResultConfiguration.ResultSingleton]);
    }

    private (int, FileInfo) GetFileInfo(ResultConfiguration resultConfiguration, FilePath filePath)
    {
        FileInfo result;
        FileInfo fileInfo = new(filePath.FullName);
        (_, int directoryIndex) = IPath.GetDirectoryNameAndIndex(resultConfiguration, filePath);
        DateTime minimumDateTime = fileInfo.CreationTime < fileInfo.LastWriteTime ? fileInfo.CreationTime : fileInfo.LastWriteTime;
        int fileInfoMinimumYear = minimumDateTime.Year < resultConfiguration.EpicYear ? resultConfiguration.EpicYear : minimumDateTime.Year;
        result = new(Path.Combine(_FileGroups[fileInfoMinimumYear][_MetadataConfiguration.ResultConfiguration.ResultSingleton][directoryIndex], $"{filePath.NameWithoutExtension}{filePath.ExtensionLowered}.json"));
        return (fileInfoMinimumYear, result);
    }

    private (int, string) GetJsonFile(ResultConfiguration resultConfiguration, FilePath filePath, ExifDirectory exifDirectory)
    {
        string? result;
        DateTime? dateTime;
        dateTime = IDate.GetDateTimeOriginal(exifDirectory);
        dateTime ??= IDate.GetMinimum(exifDirectory);
        (_, int directoryIndex) = IPath.GetDirectoryNameAndIndex(resultConfiguration, filePath);
        int exifYear = dateTime.Value.Year < resultConfiguration.EpicYear ? resultConfiguration.EpicYear : dateTime.Value.Year;
        result = Path.Combine(_FileGroups[exifYear][_MetadataConfiguration.ResultConfiguration.ResultSingleton][directoryIndex], $"{filePath.NameWithoutExtension}{filePath.ExtensionLowered}.json");
        return (exifYear, result);
    }

    private static (string, ExifDirectory?) Get(string jsonFile)
    {
        ExifDirectory? result;
        string json = File.ReadAllText(jsonFile);
        try
        {
            result = JsonSerializer.Deserialize(json, ExifDirectorySourceGenerationContext.Default.ExifDirectory);
            if (result is null)
                throw new Exception();
        }
        catch (Exception)
        {
            result = null;
        }
        return (json, result);
    }

    public (FileInfo, ExifDirectory) GetMetadataCollection(MetadataConfiguration metadataConfiguration, FilePath filePath, DeterministicHashCode deterministicHashCode)
    {
        ExifDirectory? result;
        (int fileInfoMinimumYear, FileInfo fileInfo) = GetFileInfo(metadataConfiguration.ResultConfiguration, filePath);
        if (_MetadataConfiguration.ForceMetadataLastWriteTimeToCreationTime && !fileInfo.Exists && File.Exists(Path.ChangeExtension(fileInfo.FullName, ".delete")))
        {
            File.Move(Path.ChangeExtension(fileInfo.FullName, ".delete"), fileInfo.FullName);
            fileInfo.Refresh();
        }
        if (_MetadataConfiguration.ForceMetadataLastWriteTimeToCreationTime && fileInfo.Exists && fileInfo.LastWriteTime != fileInfo.CreationTime)
        {
            File.SetLastWriteTime(fileInfo.FullName, fileInfo.CreationTime);
            fileInfo.Refresh();
        }
        if (_MetadataConfiguration.PropertiesChangedForMetadata)
            result = null;
        else if (!fileInfo.Exists)
            result = null;
        else if (!fileInfo.FullName.EndsWith(".json") && !fileInfo.FullName.EndsWith(".old"))
            throw new ArgumentException("must be a *.json file");
        else
        {
            string json = File.ReadAllText(fileInfo.FullName);
            try
            {
                result = JsonSerializer.Deserialize(json, ExifDirectorySourceGenerationContext.Default.ExifDirectory);
                if (result is null)
                    throw new Exception();
            }
            catch (Exception)
            {
                result = null;
            }
        }
        if (result is null)
        {
            string json;
            System.Drawing.Size? size = Dimensions.GetDimensions(filePath.FullName);
            IReadOnlyList<MetadataExtractor.Directory> directories = ImageMetadataReader.ReadMetadata(filePath.FullName);
            result = Exif.Covert(filePath, deterministicHashCode, size, directories);
            (int exifYear, string jsonFile) = GetJsonFile(metadataConfiguration.ResultConfiguration, filePath, result);
            if (exifYear == fileInfoMinimumYear)
                json = JsonSerializer.Serialize(result, ExifDirectorySourceGenerationContext.Default.ExifDirectory);
            else
            {
                fileInfo = new(jsonFile);
                if (!File.Exists(jsonFile))
                    json = JsonSerializer.Serialize(result, ExifDirectorySourceGenerationContext.Default.ExifDirectory);
                else
                {
                    (string checkJson, ExifDirectory? exifDirectory) = Get(jsonFile);
                    if (exifDirectory is null)
                        json = JsonSerializer.Serialize(result, ExifDirectorySourceGenerationContext.Default.ExifDirectory);
                    else
                    {
                        json = checkJson;
                        result = exifDirectory;
                    }
                }
            }
            if (IPath.WriteAllText(fileInfo.FullName, json, updateDateWhenMatches: false, compareBeforeWrite: true, updateToWhenMatches: null) && _MetadataConfiguration.ForceMetadataLastWriteTimeToCreationTime)
            {
                File.SetLastWriteTime(fileInfo.FullName, fileInfo.CreationTime);
                fileInfo.Refresh();
            }
        }
        return (fileInfo, result);
    }

    public static Action<string> SetExifDirectoryCollection(IRename rename, IRenameConfiguration renameConfiguration, A_Metadata metadata, List<(string, FileInfo, ExifDirectory)> exifDirectories)
    {
        return file =>
        {
            rename.Tick();
            FileInfo fileInfo;
            FilePath? ffmpegFilePath;
            ExifDirectory exifDirectory;
            ReadOnlyCollection<string> ffmpegFiles;
            DeterministicHashCode deterministicHashCode;
            FilePath filePath = IId.GetFilePath(renameConfiguration.MetadataConfiguration, file);
            if (!renameConfiguration.SkipIdFiles || filePath.Id is null || !filePath.IsIdFormat && !filePath.IsPaddedIdFormat)
            {
                (ffmpegFiles, ffmpegFilePath) = rename.ConvertAndGetFfmpegFiles(renameConfiguration, filePath);
                if (ffmpegFilePath is not null)
                    filePath = ffmpegFilePath;
                deterministicHashCode = filePath.Id is not null ? deterministicHashCode = new(null, filePath.Id, null) : deterministicHashCode = rename.GetDeterministicHashCode(filePath);
                (fileInfo, exifDirectory) = metadata.GetMetadataCollection(renameConfiguration.MetadataConfiguration, filePath, deterministicHashCode);
                lock (exifDirectories)
                    exifDirectories.Add(new(file, fileInfo, exifDirectory));
                foreach (string ffmpegFile in ffmpegFiles)
                    File.Delete(ffmpegFile);
            }

        };
    }

}