using Microsoft.Extensions.Configuration;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Phares.Shared;
using Serilog;
using System.Diagnostics;
using System.Drawing.Imaging;
using System.Reflection;
using View_by_Distance.Metadata.Models;
using View_by_Distance.Resize.Models;
using View_by_Distance.Shared.Models;
using View_by_Distance.Shared.Models.Stateless;
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 ILogger _Logger;
    private readonly AppSettings _AppSettings;
    private readonly string _WorkingDirectory;
    private readonly Configuration _Configuration;
    private readonly IsEnvironment _IsEnvironment;
    private readonly IConfigurationRoot _ConfigurationRoot;
    private readonly Property.Models.Configuration _PropertyConfiguration;

    public UnitTestResize()
    {
        ILogger logger;
        AppSettings appSettings;
        string workingDirectory;
        Configuration configuration;
        IsEnvironment isEnvironment;
        IConfigurationRoot configurationRoot;
        LoggerConfiguration loggerConfiguration = new();
        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()
            .AddJsonFile(isEnvironment.AppSettingsFileName);
        configurationRoot = configurationBuilder.Build();
        appSettings = Models.Binder.AppSettings.Get(configurationRoot);
        workingDirectory = IWorkingDirectory.GetWorkingDirectory(assembly.GetName().Name, appSettings.WorkingDirectoryName);
        Environment.SetEnvironmentVariable(nameof(workingDirectory), workingDirectory);
        _ = ConfigurationLoggerConfigurationExtensions.Configuration(loggerConfiguration.ReadFrom, configurationRoot);
        Log.Logger = loggerConfiguration.CreateLogger();
        logger = Log.ForContext<UnitTestResize>();
        propertyConfiguration = Property.Models.Binder.Configuration.Get(isEnvironment, configurationRoot);
        configuration = Models.Binder.Configuration.Get(isEnvironment, configurationRoot, propertyConfiguration);
        logger.Information("Complete");
        _Logger = logger;
        _AppSettings = appSettings;
        _Configuration = configuration;
        _IsEnvironment = isEnvironment;
        _WorkingDirectory = workingDirectory;
        _ConfigurationRoot = configurationRoot;
        _PropertyConfiguration = propertyConfiguration;
    }

    [TestMethod]
    public void TestMethodNull()
    {
        Assert.IsFalse(_Logger is null);
        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);
    }

    [TestMethod]
    public void TestGetLocation()
    {
        double confidence = 0.1D;
        int left, top, right, bottom, width, height;
        left = 20;
        top = 40;
        right = 60;
        bottom = 80;
        width = 100;
        height = 100;
        Location location = new(bottom, confidence, left, null, right, top);
        _ = new Location(confidence, height, location, width, 1);
        _ = new Location(bottom, confidence, height, left, right, top, width, 1);
    }

    [TestMethod]
    public void TestGetPixelPercentage()
    {
        int normalizedPixelPercentage;
        int left, top, right, bottom, width, height;
        left = 1;
        top = 1;
        right = 10;
        bottom = 10;
        width = 100;
        height = 100;
        normalizedPixelPercentage = Location.GetNormalizedPixelPercentage(bottom, height, left, right, top, width, 1);
        Assert.IsTrue(normalizedPixelPercentage == 40500);
        left = 50;
        top = 50;
        right = 60;
        bottom = 60;
        width = 100;
        height = 100;
        normalizedPixelPercentage = Location.GetNormalizedPixelPercentage(bottom, height, left, right, top, width, 1);
        Assert.IsTrue(normalizedPixelPercentage == 545500);
    }

    [TestMethod]
    public void TestGetPixelPercentageB()
    {
        int normalizedPixelPercentage;
        int left, top, right, bottom, width, height;
        left = 240;
        top = 240;
        right = 260;
        bottom = 260;
        width = 500;
        height = 500;
        normalizedPixelPercentage = Location.GetNormalizedPixelPercentage(bottom, height, left, right, top, width, 1);
        Assert.IsTrue(normalizedPixelPercentage == 499000);
        left = 490;
        top = 490;
        right = 510;
        bottom = 510;
        width = 1000;
        height = 1000;
        normalizedPixelPercentage = Location.GetNormalizedPixelPercentage(bottom, height, left, right, top, width, 1);
        Assert.IsTrue(normalizedPixelPercentage == 499500);
    }

    [TestMethod]
    public void TestGetPixelPercentageC()
    {
        int normalizedPixelPercentage;
        int left, top, right, bottom, width, height;
        left = 20;
        top = 40;
        right = 60;
        bottom = 80;
        width = 100;
        height = 100;
        normalizedPixelPercentage = Location.GetNormalizedPixelPercentage(bottom, height, left, right, top, width, 1);
        Assert.IsTrue(normalizedPixelPercentage == 594000);
        left = 20;
        top = 40;
        right = 60;
        bottom = 80;
        width = 100;
        height = 100;
        normalizedPixelPercentage = Location.GetNormalizedPixelPercentage(bottom, height, left, right, top, width, 10);
        Assert.IsTrue(normalizedPixelPercentage == 594000);
    }

    private Property.Models.A_Property GetPropertyLogic(bool reverse, Model? model, PredictorModel? predictorModel)
    {
        Property.Models.A_Property result;
        if (_Configuration?.PropertyConfiguration is null)
            throw new NullReferenceException(nameof(_Configuration.PropertyConfiguration));
        result = new(_AppSettings.MaxDegreeOfParallelism, _Configuration.PropertyConfiguration, _Configuration.OutputExtension, reverse, model, predictorModel);
        return result;
    }

    [TestMethod]
    public void TestMethodResize()
    {
        // string sourceFileName = "IMG_0067.jpg";
        // string sourceDirectoryName = "Mackenzie Prom 2017";
        // string sourceFileName = "Fall 2005 (113).jpg";
        // string sourceDirectoryName = "=2005.3 Fall";
        string sourceFileName = "12314542_10208270578946392_3555034423896018896_o.jpg";
        string sourceDirectoryName = "Other";
        Item item;
        Model? model = null;
        bool reverse = false;
        string original = "Original";
        string aResultsFullGroupDirectory;
        string bResultsFullGroupDirectory;
        string cResultsFullGroupDirectory;
        List<string> parseExceptions = new();
        PredictorModel? predictorModel = null;
        bool isValidImageFormatExtension = true;
        Shared.Models.Property? property = null;
        Dictionary<string, int[]> imageResizeKeyValuePairs;
        List<Tuple<string, DateTime>> subFileTuples = new();
        List<KeyValuePair<string, string>> metadataCollection;
        int length = _PropertyConfiguration.RootDirectory.Length;
        string outputResolution = _Configuration.OutputResolutions[0];
        Property.Models.A_Property propertyLogic = GetPropertyLogic(reverse, model, predictorModel);
        string sourceDirectory = Path.Combine(_PropertyConfiguration.RootDirectory, sourceDirectoryName);
        _Logger.Information(_Configuration.ModelDirectory);
        aResultsFullGroupDirectory = Property.Models.Stateless.IResult.GetResultsFullGroupDirectory(
            _PropertyConfiguration, model, predictorModel, nameof(Property.Models.A_Property), outputResolution, includeResizeGroup: false, includeModel: false, includePredictorModel: false);
        bResultsFullGroupDirectory = Property.Models.Stateless.IResult.GetResultsFullGroupDirectory(
            _PropertyConfiguration, model, predictorModel, nameof(B_Metadata), outputResolution, includeResizeGroup: false, includeModel: false, includePredictorModel: false);
        cResultsFullGroupDirectory = Property.Models.Stateless.IResult.GetResultsFullGroupDirectory(
            _PropertyConfiguration, model, predictorModel, nameof(C_Resize), outputResolution, includeResizeGroup: true, includeModel: false, includePredictorModel: false);
        string aPropertySingletonDirectory = Property.Models.Stateless.IResult.GetResultsDateGroupDirectory(_PropertyConfiguration, nameof(Property.Models.A_Property), "{}");
        B_Metadata metadata = new(_Configuration.ForceMetadataLastWriteTimeToCreationTime, _Configuration.PropertiesChangedForMetadata);
        _ = metadata.ToString();
        (ImageCodecInfo imageCodecInfo, EncoderParameters encoderParameters, string filenameExtension) = C_Resize.GetTuple(_Configuration.OutputExtension, _Configuration.OutputQuality);
        C_Resize resize = new(_Configuration.ForceResizeLastWriteTimeToCreationTime, _Configuration.OverrideForResizeImages, _Configuration.PropertiesChangedForResize, _Configuration.ValidResolutions, imageCodecInfo, encoderParameters, filenameExtension);
        _ = resize.ToString();
        propertyLogic.AngleBracketCollection.AddRange(Property.Models.Stateless.IResult.GetDirectoryInfoCollection(
            _PropertyConfiguration,
            sourceDirectory,
            aResultsFullGroupDirectory,
            contentDescription: string.Empty,
            singletonDescription: "Properties for each image",
            collectionDescription: string.Empty,
            converted: false));
        metadata.AngleBracketCollection.AddRange(Property.Models.Stateless.IResult.GetDirectoryInfoCollection(
            _PropertyConfiguration,
            sourceDirectory,
            bResultsFullGroupDirectory,
            contentDescription: string.Empty,
            singletonDescription: "Metadata as key value pairs",
            collectionDescription: string.Empty,
            converted: true));
        resize.AngleBracketCollection.AddRange(Property.Models.Stateless.IResult.GetDirectoryInfoCollection(
            _PropertyConfiguration,
            sourceDirectory,
            cResultsFullGroupDirectory,
            contentDescription: "Resized image",
            singletonDescription: "Resize dimensions for each resolution",
            collectionDescription: string.Empty,
            converted: true));
        string sourceDirectoryFile = ".json";
        FileHolder fileHolder = new(Path.Combine(sourceDirectory, sourceFileName));
        string relativePath = IPath.GetRelativePath(fileHolder.FullName, length);
        sourceDirectory = Path.Combine(aPropertySingletonDirectory, sourceDirectoryName);
        item = new(sourceDirectoryFile, relativePath, fileHolder, isValidImageFormatExtension, property, false, false);
        Assert.IsNotNull(item.ImageFileHolder);
        if (item.Property is null)
        {
            property = propertyLogic.GetProperty(item, subFileTuples, parseExceptions);
            item.Update(property);
        }
        (int _, metadataCollection) = metadata.GetMetadataCollection(bResultsFullGroupDirectory, subFileTuples, parseExceptions, item);
        imageResizeKeyValuePairs = resize.GetResizeKeyValuePairs(cResultsFullGroupDirectory, subFileTuples, parseExceptions, original, metadataCollection, item);
        Assert.IsNotNull(item.ResizedFileHolder);
        resize.SaveResizedSubfile(outputResolution, cResultsFullGroupDirectory, subFileTuples, item, original, imageResizeKeyValuePairs);
    }

}