view-by-distance-mklink-console/Tests/UnitTestResize.cs

using Microsoft.Extensions.Configuration;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Phares.Shared;
using System.Diagnostics;
using System.Drawing.Imaging;
using System.Reflection;
using System.Text.Json;
using View_by_Distance.Metadata.Models;
using View_by_Distance.Property.Models;
using View_by_Distance.Resize.Models;
using View_by_Distance.Shared.Models;
using View_by_Distance.Shared.Models.Stateless.Methods;
using View_by_Distance.Tests.Models;

namespace View_by_Distance.Tests;

[TestClass]
public class UnitTestResize
{

    private readonly AppSettings _AppSettings;
    private readonly string _WorkingDirectory;
    private readonly IsEnvironment _IsEnvironment;
    private readonly Models.Configuration _Configuration;
    private readonly IConfigurationRoot _ConfigurationRoot;
    private readonly Property.Models.Configuration _PropertyConfiguration;

    public UnitTestResize()
    {
        AppSettings appSettings;
        string workingDirectory;
        IsEnvironment isEnvironment;
        Models.Configuration configuration;
        IConfigurationRoot configurationRoot;
        Property.Models.Configuration propertyConfiguration;
        Assembly assembly = Assembly.GetExecutingAssembly();
        bool debuggerWasAttachedAtLineZero = Debugger.IsAttached || assembly.Location.Contains(@"\bin\Debug");
        isEnvironment = new(processesCount: null, nullASPNetCoreEnvironmentIsDevelopment: debuggerWasAttachedAtLineZero, nullASPNetCoreEnvironmentIsProduction: !debuggerWasAttachedAtLineZero);
        IConfigurationBuilder configurationBuilder = new ConfigurationBuilder()
            .AddEnvironmentVariables()
            .AddUserSecrets<UnitTestResize>();
        configurationRoot = configurationBuilder.Build();
        appSettings = Models.Binder.AppSettings.Get(configurationRoot);
        if (string.IsNullOrEmpty(appSettings.WorkingDirectoryName))
            throw new Exception("Working directory name must have a value!");
        workingDirectory = IWorkingDirectory.GetWorkingDirectory(assembly.GetName().Name, appSettings.WorkingDirectoryName);
        Environment.SetEnvironmentVariable(nameof(workingDirectory), workingDirectory);
        propertyConfiguration = Property.Models.Binder.Configuration.Get(isEnvironment, configurationRoot);
        configuration = Models.Binder.Configuration.Get(isEnvironment, configurationRoot, propertyConfiguration);
        Property.Models.Configuration.Verify(propertyConfiguration, requireExist: false);
        _AppSettings = appSettings;
        _Configuration = configuration;
        _IsEnvironment = isEnvironment;
        _WorkingDirectory = workingDirectory;
        _ConfigurationRoot = configurationRoot;
        _PropertyConfiguration = propertyConfiguration;
    }

    private static void NonThrowTryCatch()
    {
        try
        { throw new Exception(); }
        catch (Exception) { }
    }

    [TestMethod]
    public void TestMethodNull()
    {
        Assert.IsFalse(_AppSettings is null);
        Assert.IsFalse(_Configuration is null);
        Assert.IsFalse(_IsEnvironment is null);
        Assert.IsFalse(_WorkingDirectory is null);
        Assert.IsFalse(_ConfigurationRoot is null);
        Assert.IsFalse(_PropertyConfiguration is null);
        NonThrowTryCatch();
    }

    private A_Property GetPropertyLogic(bool reverse, string aResultsFullGroupDirectory)
    {
        A_Property result;
        if (_Configuration?.PropertyConfiguration is null)
            throw new NullReferenceException(nameof(_PropertyConfiguration));
        result = new(_AppSettings.MaxDegreeOfParallelism, _PropertyConfiguration, _Configuration.OutputExtension, reverse, aResultsFullGroupDirectory);
        return result;
    }

    private (string, string) GetResultsFullGroupDirectories()
    {
        string aResultsFullGroupDirectory = Property.Models.Stateless.IResult.GetResultsFullGroupDirectory(
            _PropertyConfiguration,
            nameof(A_Property),
            string.Empty,
            includeResizeGroup: false,
            includeModel: false,
            includePredictorModel: false);
        string bResultsFullGroupDirectory = Property.Models.Stateless.IResult.GetResultsFullGroupDirectory(
            _PropertyConfiguration,
            nameof(B_Metadata),
            string.Empty,
            includeResizeGroup: false,
            includeModel: false,
            includePredictorModel: false);
        return new(aResultsFullGroupDirectory, bResultsFullGroupDirectory);
    }

    private (string, string, string) GetResultsFullGroupDirectories(string outputResolution)
    {
        string cResultsFullGroupDirectory = Property.Models.Stateless.IResult.GetResultsFullGroupDirectory(
            _PropertyConfiguration,
            nameof(C_Resize),
            outputResolution,
            includeResizeGroup: true,
            includeModel: false,
            includePredictorModel: false);
        string dResultsFullGroupDirectory = string.Empty;
        string d2ResultsFullGroupDirectory = string.Empty;
        return new(cResultsFullGroupDirectory, dResultsFullGroupDirectory, d2ResultsFullGroupDirectory);
    }

    [TestMethod]
    public void TestMethodResize()
    {
        if (_PropertyConfiguration.NumberOfJitters is null)
            throw new NullReferenceException(nameof(_PropertyConfiguration.NumberOfJitters));
        if (_PropertyConfiguration.NumberOfTimesToUpsample is null)
            throw new NullReferenceException(nameof(_PropertyConfiguration.NumberOfTimesToUpsample));
        // string sourceFileName = "100000507001158650387.jpg";
        // string sourceDirectoryName = "Facebook/2023.2 Summer Facebook";
        string sourceFileName = "105131603001106320328.jpg";
        string sourceDirectoryName = "Mike iCloud Have Date Taken 2022 !9";
        Item item;
        bool reverse = false;
        bool isArchive = false;
        FileHolder resizedFileHolder;
        List<string> parseExceptions = [];
        Shared.Models.Property? property = null;
        const bool isValidImageFormatExtension = true;
        List<Tuple<string, DateTime>> subFileTuples = [];
        int length = _PropertyConfiguration.RootDirectory.Length;
        string[] changesFrom = [nameof(A_Property)];
        string outputResolution = _Configuration.OutputResolutions[0];
        bool outputResolutionHasNumber = outputResolution.Any(char.IsNumber);
        (string cResultsFullGroupDirectory, _, _) = GetResultsFullGroupDirectories(outputResolution);
        (string aResultsFullGroupDirectory, string bResultsFullGroupDirectory) = GetResultsFullGroupDirectories();
        Shared.Models.Methods.IBlurHasher blurHasher = new BlurHash.Models.C2_BlurHasher(_PropertyConfiguration);
        A_Property propertyLogic = GetPropertyLogic(reverse, aResultsFullGroupDirectory);
        string aPropertySingletonDirectory = Path.Combine(aResultsFullGroupDirectory, "{}");
        if (!Directory.Exists(aPropertySingletonDirectory))
            _ = Directory.CreateDirectory(aPropertySingletonDirectory);
        (ImageCodecInfo imageCodecInfo, EncoderParameters encoderParameters, string filenameExtension) = C_Resize.GetTuple(_Configuration.OutputExtension, _Configuration.OutputQuality);
        B_Metadata metadata = new(_PropertyConfiguration, _Configuration.ForceMetadataLastWriteTimeToCreationTime, _Configuration.PropertiesChangedForMetadata, bResultsFullGroupDirectory);
        _ = metadata.ToString();
        C_Resize resize = new(_PropertyConfiguration, _Configuration.ForceResizeLastWriteTimeToCreationTime, _Configuration.OverrideForResizeImages, _Configuration.PropertiesChangedForResize, _Configuration.ValidResolutions, imageCodecInfo, encoderParameters, filenameExtension);
        _ = resize.ToString();
        bool isUniqueFileName = false;
        bool? isNotUniqueAndNeedsReview = null;
        FileHolder sourceDirectoryFileHolder = IFileHolder.Get(".json");
        string sourceDirectory = Path.GetFullPath(Path.Combine(_PropertyConfiguration.RootDirectory, sourceDirectoryName));
        FileHolder fileHolder = IFileHolder.Get(Path.Combine(sourceDirectory, sourceFileName));
        FilePath filePath = FilePath.Get(_PropertyConfiguration, fileHolder, index: null);
        Assert.IsNotNull(filePath.Id);
        string relativePath = IPath.GetRelativePath(fileHolder.FullName, length);
        string propertyLogicSourceDirectory = Path.GetFullPath(Path.Combine(aPropertySingletonDirectory, sourceDirectoryName));
        propertyLogic.SetAngleBracketCollection(aResultsFullGroupDirectory, propertyLogicSourceDirectory);
        if (outputResolutionHasNumber)
            resize.SetAngleBracketCollection(cResultsFullGroupDirectory, sourceDirectory);
        resize.Update(cResultsFullGroupDirectory);
        blurHasher.Update(cResultsFullGroupDirectory);
        item = Item.Get(filePath, sourceDirectoryFileHolder, relativePath, isArchive, isNotUniqueAndNeedsReview, isUniqueFileName, isValidImageFormatExtension, property, false, false, false);
        if (item.Property is null)
        {
            property = propertyLogic.GetProperty(metadata, item, subFileTuples, parseExceptions);
            item.Update(property);
        }
        if (property is null || item.Property is null)
            throw new NullReferenceException(nameof(property));
        resizedFileHolder = resize.GetResizedFileHolder(cResultsFullGroupDirectory, item, outputResolutionHasNumber, filePath.Id.Value);
        item.SetResizedFileHolder(resize.FileNameExtension, resizedFileHolder);
        MappingFromItem mappingFromItem = IMappingFromItem.GetMappingFromItem(item);
        Dictionary<string, int[]> outputResolutionToResize = resize.GetResizeKeyValuePairs(_PropertyConfiguration, cResultsFullGroupDirectory, item.FilePath, subFileTuples, parseExceptions, item.Property, mappingFromItem);
        Assert.IsNotNull(mappingFromItem.ResizedFileHolder);
        resize.SaveResizedSubfile(_PropertyConfiguration, outputResolution, cResultsFullGroupDirectory, subFileTuples, item, item.Property, mappingFromItem, outputResolutionToResize);
        string blurHash = blurHasher.Encode(resizedFileHolder);
        Assert.IsNotNull(blurHash);
        ExifDirectory exifDirectory = metadata.GetMetadataCollection(item.FilePath, subFileTuples, parseExceptions, changesFrom, mappingFromItem);
        string json = JsonSerializer.Serialize(exifDirectory, ExifDirectoryBaseSourceGenerationContext.Default.ExifDirectoryBase);
        File.WriteAllText("../../../.json", json);
        MetadataExtractor.GeoLocation? geoLocation = Metadata.Models.Stateless.Methods.IMetadata.GeoLocation(exifDirectory);
        double? distance = geoLocation is null ? null : Metadata.Models.Stateless.Methods.IMetadata.GetDistance(1, 1, geoLocation.Latitude, geoLocation.Longitude);
        NonThrowTryCatch();
    }

}