aa/Rename/Rename.cs

using CliWrap;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging;
using ShellProgressBar;
using System.Drawing;
using System.Drawing.Imaging;
using System.Runtime.InteropServices;
using View_by_Distance.Metadata.Models;
using View_by_Distance.Rename.Models;
using View_by_Distance.Shared.Models;
using View_by_Distance.Shared.Models.Stateless.Methods;

namespace View_by_Distance.Rename;

public class Rename : IRename
{

    private readonly AppSettings _AppSettings;
    private readonly Configuration _Configuration;
    private readonly IConfigurationRoot _ConfigurationRoot;
    private readonly MetadataConfiguration _MetadataConfiguration;

    public Rename(List<string> args, ILogger<Program>? logger, IConfigurationRoot configurationRoot, AppSettings appSettings, bool isSilent, IConsole console)
    {
        if (isSilent)
        { }
        if (args is null)
            throw new NullReferenceException(nameof(args));
        if (console is null)
            throw new NullReferenceException(nameof(console));
        _AppSettings = appSettings;
        long ticks = DateTime.Now.Ticks;
        _ConfigurationRoot = configurationRoot;
        MetadataConfiguration metadataConfiguration = Metadata.Models.Binder.Configuration.Get(configurationRoot);
        Configuration configuration = Models.Binder.Configuration.Get(configurationRoot, metadataConfiguration);
        _MetadataConfiguration = metadataConfiguration;
        _Configuration = configuration;
        DirectoryInfo directoryInfo = new(Path.GetFullPath(metadataConfiguration.RootDirectory));
        logger?.LogInformation("{RootDirectory}", directoryInfo.FullName);
        MetadataConfiguration.Verify(metadataConfiguration, requireExist: false);
        Verify();
        List<string> linesB = RenameFilesInDirectories(logger, ticks, directoryInfo);
        if (linesB.Count != 0)
        {
            File.WriteAllLines($"D:/Tmp/Phares/{DateTime.Now.Ticks}.tsv", linesB);
            _ = IPath.DeleteEmptyDirectories(directoryInfo.FullName);
        }
    }

    private void Verify()
    {
        if (_AppSettings is null)
            throw new NullReferenceException(nameof(_AppSettings));
        if (_Configuration is null)
            throw new NullReferenceException(nameof(_Configuration));
        if (_ConfigurationRoot is null)
            throw new NullReferenceException(nameof(_ConfigurationRoot));
        if (_MetadataConfiguration is null)
            throw new NullReferenceException(nameof(_MetadataConfiguration));
    }

    private bool GetRunToDoCollectionFirst(long ticks, DirectoryInfo directoryInfo)
    {
        bool result = false;
        string[] directories;
        string seasonDirectory;
        DateTime dateTime = new(ticks);
        (int season, string seasonName) = IDate.GetSeason(dateTime.DayOfYear);
        string eDistanceContentDirectory = IResult.GetResultsDateGroupDirectory(_MetadataConfiguration, nameof(A_Metadata), _MetadataConfiguration.ResultContent);
        FileSystemInfo fileSystemInfo = new DirectoryInfo(eDistanceContentDirectory);
        string[] checkDirectories =
        [
            Path.Combine(directoryInfo.FullName, "Ancestry"),
            Path.Combine(directoryInfo.FullName, "Facebook"),
            Path.Combine(directoryInfo.FullName, "LinkedIn"),
            directoryInfo.FullName,
        ];
        foreach (string checkDirectory in checkDirectories)
        {
            if (checkDirectory == directoryInfo.FullName)
                seasonDirectory = Path.Combine(checkDirectory, $"{dateTime.Year}.{season} {seasonName}");
            else
                seasonDirectory = Path.Combine(checkDirectory, $"{dateTime.Year}.{season} {seasonName} {Path.GetFileName(checkDirectory)}");
            if (!Directory.Exists(seasonDirectory))
                _ = Directory.CreateDirectory(seasonDirectory);
            if (result)
                continue;
            directories = Directory.GetDirectories(checkDirectory, "*", SearchOption.TopDirectoryOnly);
            foreach (string directory in directories)
            {
                if (new DirectoryInfo(directory).LastWriteTime > fileSystemInfo.LastWriteTime)
                {
                    result = true;
                    break;
                }
            }
        }
        return result;
    }

    string[]? IRename.ConvertAndGetFfmpegFiles(FilePath filePath)
    {
        string[]? results;
        bool isIgnoreExtension;
        bool isValidImageFormatExtension = _MetadataConfiguration.ValidImageFormatExtensions.Contains(filePath.ExtensionLowered);
        isIgnoreExtension = isValidImageFormatExtension && _MetadataConfiguration.IgnoreExtensions.Contains(filePath.ExtensionLowered);
        if (!isIgnoreExtension && isValidImageFormatExtension)
            results = null;
        else
        {
            CommandTask<CommandResult> commandTask = Cli.Wrap("ffmpeg.exe")
                // .WithArguments(new[] { "-ss", "00:00:00", "-t", "00:00:00", "-i", files[i], "-qscale:v", "2", "-r", "0.01", $"{fileHolder.Name}-%4d.jpg" })
                .WithArguments(new[] { "-i", filePath.FullName, "-vframes", "1", $"{filePath.Name}-%4d.jpg" })
                .WithWorkingDirectory(filePath.DirectoryName)
                .ExecuteAsync();
            commandTask.Task.Wait();
            results = Directory.GetFiles(filePath.DirectoryName, $"{filePath.Name}-*.jpg", SearchOption.TopDirectoryOnly);
            if (results.Length == 0)
                throw new Exception();
            if (!filePath.Name.EndsWith("-0001.jpg"))
                throw new Exception();
            isValidImageFormatExtension = _MetadataConfiguration.ValidImageFormatExtensions.Contains(filePath.ExtensionLowered);
            isIgnoreExtension = isValidImageFormatExtension && _MetadataConfiguration.IgnoreExtensions.Contains(filePath.ExtensionLowered);
            if (isIgnoreExtension || !isValidImageFormatExtension)
                throw new Exception();
            if (filePath.DirectoryName is null)
                throw new NullReferenceException(nameof(filePath.DirectoryName));
        }
        return results;
    }

#pragma warning disable CA1416

    DeterministicHashCode IRename.GetDeterministicHashCode(FilePath filePath)
    {
        DeterministicHashCode result;
        int? id;
        int? width;
        int? height;
        try
        {
            using Image image = Image.FromFile(filePath.FullName);
            width = image.Width;
            height = image.Height;
            using Bitmap bitmap = new(image);
            Rectangle rectangle = new(0, 0, image.Width, image.Height);
            BitmapData bitmapData = bitmap.LockBits(rectangle, ImageLockMode.ReadOnly, bitmap.PixelFormat);
            IntPtr intPtr = bitmapData.Scan0;
            int length = bitmapData.Stride * bitmap.Height;
            byte[] bytes = new byte[length];
            Marshal.Copy(intPtr, bytes, 0, length);
            bitmap.UnlockBits(bitmapData);
            id = IId.GetDeterministicHashCode(bytes);
        }
        catch (Exception)
        {
            id = null;
            width = null;
            height = null;
        }
        result = new(height, id, width);
        return result;
    }

#pragma warning restore CA1416

    private void GetResultCollection(IRename rename, List<ExifDirectory> exifDirectories, IEnumerable<string> files, A_Metadata metadata)
    {
        string[]? ffmpegFiles;
        DeterministicHashCode deterministicHashCode;
        foreach (string file in files)
        {
            FilePath filePath = IId.GetFilePath(_MetadataConfiguration, file);
            if (filePath.ExtensionLowered is ".paddedId" or ".lsv")
                continue;
            if (files.Contains($"{filePath.FullName}.paddedId"))
                continue;
            if (filePath.Id is not null && (filePath.IsIdFormat || filePath.IsPaddedIdFormat))
                continue;
            ffmpegFiles = rename.ConvertAndGetFfmpegFiles(filePath);
            filePath = ffmpegFiles is null || ffmpegFiles.Length < 0 ? filePath : IId.GetFilePath(filePath, ffmpegFiles[0]);
            if (filePath.Id is not null)
                deterministicHashCode = new(null, filePath.Id, null);
            else
                deterministicHashCode = rename.GetDeterministicHashCode(filePath);
            if (ffmpegFiles is not null)
            {
                foreach (string ffmpegFile in ffmpegFiles)
                    File.Delete(ffmpegFile);
            }
            exifDirectories.Add(metadata.GetMetadataCollection(_MetadataConfiguration, filePath, deterministicHashCode));
        }
    }

    private List<string> RenameFilesInDirectories(ILogger? logger, long ticks, DirectoryInfo directoryInfo)
    {
        List<string> old = [];
        IRename rename = this;
        List<ExifDirectory> exifDirectories = [];
        bool runToDoCollectionFirst = GetRunToDoCollectionFirst(ticks, directoryInfo);
        IEnumerable<string> files = Directory.EnumerateFiles(directoryInfo.FullName, "*", SearchOption.AllDirectories);
        A_Metadata metadata = new(_MetadataConfiguration, _Configuration.ForceMetadataLastWriteTimeToCreationTime, _Configuration.PropertiesChangedForMetadata);
        if (runToDoCollectionFirst)
            GetResultCollection(rename, exifDirectories, files, metadata);
        else
        {
            ParallelOptions parallelOptions = new() { MaxDegreeOfParallelism = _AppSettings.MaxDegreeOfParallelism };
            ProgressBar progressBar = new(123000, "EnumerateFiles load", new ProgressBarOptions() { ProgressCharacter = '─', ProgressBarOnBottom = true, DisableBottomPercentage = true });
            files.AsParallel().ForAll(A_Metadata.GetResultCollection(rename, _MetadataConfiguration, metadata, exifDirectories, () => progressBar.Tick()));
            if (progressBar.CurrentTick != exifDirectories.Count)
                throw new NotSupportedException();
        }
        return old;
    }

}