// Copyright (C) Stichting Deltares 2024. All rights reserved.
// 
// This file is part of the Dam Engine.
// 
// The Dam Engine is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
// 
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// 
// All names, logos, and references to "Deltares" are registered trademarks of
// Stichting Deltares and remain full property of Stichting Deltares at all times.
// All rights reserved.

using System;
using Deltares.DamEngine.Data.General;
using Deltares.DamEngine.Data.Geotechnics;
using Deltares.DamEngine.Data.Standard.Calculation;
using Deltares.DamEngine.Data.Standard.Logging;
using Deltares.MacroStability.CSharpWrapper;
using Deltares.MacroStability.CSharpWrapper.Input;
using Deltares.MacroStability.CSharpWrapper.Output;
using KellermanSoftware.CompareNetObjects;
using NUnit.Framework;
using CharacteristicPoint = Deltares.MacroStability.CSharpWrapper.Input.CharacteristicPointType;
using CharacteristicPointType = Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType;
using ConversionHelper = Deltares.DamEngine.Calculators.KernelWrappers.MacroStabilityCommon.MacroStabilityIo.ConversionHelper;
using Soil = Deltares.MacroStability.CSharpWrapper.Input.Soil;

namespace Deltares.DamEngine.Calculators.Tests.KernelWrappers.MacroStabilityCommon;

[TestFixture]
public class ConversionHelperTests
{
    #region Soil

    [TestCase(DilatancyType.MinusPhi)]
    [TestCase(DilatancyType.Phi)]
    [TestCase(DilatancyType.Zero)]
    public void GivenMacroStabilitySoilWhenConvertingToDamSoilAndBackThenResultEqualsOriginal(DilatancyType dilatancyType)
    {
        // Given MacroStability Soil
        var macroStabilitySoil = new Soil
        {
            Name = "MacroStabilitySoil",
            AbovePhreaticLevel = 1.01,
            BelowPhreaticLevel = 1.02,
            Cohesion = 1.03,
            FrictionAngle = 1.04,
            Dilatancy = 0,
            RRatio = 1.05,
            RatioCuPc = 1.06,
            ShearStrengthAbovePhreaticLevelModel = ShearStrengthModelType.MohrCoulomb,
            ShearStrengthBelowPhreaticLevelModel = ShearStrengthModelType.MohrCoulomb,
            //RheologicalCoefficient = 1.07, Not yet to be used
            StrengthIncreaseExponent = 1.08,
            UseSoilClassification = false, // must be false
            BondStressCurve = null // must be null
        };
        switch (dilatancyType)
        {
            case DilatancyType.MinusPhi:
            {
                macroStabilitySoil.Dilatancy = macroStabilitySoil.FrictionAngle * -1;
                break;
            }
            case DilatancyType.Phi:
            {
                macroStabilitySoil.Dilatancy = macroStabilitySoil.FrictionAngle;
                break;
            }
            case DilatancyType.Zero:
            {
                macroStabilitySoil.Dilatancy = 0;
                break;
            }
        }

        // When Converting to DamSoil and back
        Data.Geotechnics.Soil damSoil = ConversionHelper.ConvertToDamSoil(macroStabilitySoil);
        Soil actualMacroStabilitySoil = ConversionHelper.ConvertToMacroStabilitySoil(damSoil);

        // Then result equals original
        var compare = new CompareLogic
        {
            Config =
            {
                MaxDifferences = 100
            }
        };
        ComparisonResult result = compare.Compare(macroStabilitySoil, actualMacroStabilitySoil);
        Assert.That(result.Differences.Count, Is.EqualTo(0), "Differences found converting/reconverting Soil but this ok now if diff = 3");
    }

    #endregion

    [TestCase(CalculationResult.NoInput, CalculationResultType.NoInput)]
    [TestCase(CalculationResult.NoRun, CalculationResultType.NoRun)]
    [TestCase(CalculationResult.Succeeded, CalculationResultType.Succeeded)]
    [TestCase(CalculationResult.InvalidInputData, CalculationResultType.InvalidInputData)]
    [TestCase(CalculationResult.InvalidInputStructure, CalculationResultType.InvalidInputStructure)]
    [TestCase(CalculationResult.NoLicense, CalculationResultType.NoLicense)]
    [TestCase(CalculationResult.RunFailed, CalculationResultType.RunFailed)]
    [TestCase(CalculationResult.UnexpectedError, CalculationResultType.UnexpectedError)]
    [TestCase(CalculationResult.UserAbort, CalculationResultType.UserAbort)]
    public void CanConvertToMacroStabilityResultType(CalculationResult calculationResult, CalculationResultType calculationResultType)
    {
        Assert.That(ConversionHelper.ConvertToMacroStabilityResultType(calculationResult), Is.EqualTo(calculationResultType));
    }

    [TestCase(CalculationResultType.NoInput, CalculationResult.NoInput)]
    [TestCase(CalculationResultType.NoRun, CalculationResult.NoRun)]
    [TestCase(CalculationResultType.Succeeded, CalculationResult.Succeeded)]
    [TestCase(CalculationResultType.InvalidInputData, CalculationResult.InvalidInputData)]
    [TestCase(CalculationResultType.InvalidInputStructure, CalculationResult.InvalidInputStructure)]
    [TestCase(CalculationResultType.NoLicense, CalculationResult.NoLicense)]
    [TestCase(CalculationResultType.RunFailed, CalculationResult.RunFailed)]
    [TestCase(CalculationResultType.UnexpectedError, CalculationResult.UnexpectedError)]
    [TestCase(CalculationResultType.UserAbort, CalculationResult.UserAbort)]
    public void CanConvertToDamResultType(CalculationResultType calculationResultType, CalculationResult calculationResult)
    {
        Assert.That(ConversionHelper.ConvertToDamResultType(calculationResultType), Is.EqualTo(calculationResult));
    }

    #region SearchMethod

    [Test]
    [TestCase(SearchAlgorithm.Grid, MStabSearchMethod.Grid)]
    [TestCase(SearchAlgorithm.BeeswarmAndLevenbergMarquardt, MStabSearchMethod.BeeSwarm)]
    public void CanConvertToDamSearchMethod(SearchAlgorithm searchAlgorithm, MStabSearchMethod mStabSearchMethod)
    {
        Assert.That(ConversionHelper.ConvertToDamSearchMethod(searchAlgorithm), Is.EqualTo(mStabSearchMethod));
    }

    [TestCase(SearchAlgorithm.Beeswarm)]
    [TestCase(SearchAlgorithm.LevenbergMarquardt)]
    [TestCase(SearchAlgorithm.Single)]
    public void CanConvertToDamSearchMethodHandleException(SearchAlgorithm searchAlgorithm)
    {
        Assert.That(() => ConversionHelper.ConvertToDamSearchMethod(searchAlgorithm), Throws.InstanceOf<ArgumentException>());
    }

    [Test]
    [TestCase(MStabSearchMethod.Grid, SearchAlgorithm.Grid)]
    [TestCase(MStabSearchMethod.BeeSwarm, SearchAlgorithm.BeeswarmAndLevenbergMarquardt)]
    public void ConvertToMacroStabilitySearchMethod(MStabSearchMethod mStabSearchMethod, SearchAlgorithm searchAlgorithm)
    {
        Assert.That(ConversionHelper.ConvertToMacroStabilitySearchMethod(mStabSearchMethod), Is.EqualTo(searchAlgorithm));
    }

    #endregion

    #region ModelType

    [Test]
    [TestCase(StabilityModelOptionType.Bishop, MStabModelType.Bishop)]
    [TestCase(StabilityModelOptionType.UpliftVan, MStabModelType.UpliftVan)]
    public void CanConvertToMStabModelType(StabilityModelOptionType modelOption, MStabModelType mStabModelType)
    {
        Assert.That(ConversionHelper.ConvertToMStabModelType(modelOption), Is.EqualTo(mStabModelType));
    }

    [Test]
    [TestCase(MStabModelType.UpliftVan, StabilityModelOptionType.UpliftVan)]
    public void CanConvertToModelOptions(MStabModelType mStabModelType, StabilityModelOptionType modelOption)
    {
        Assert.That(ConversionHelper.ConvertToModelOptions(mStabModelType), Is.EqualTo(modelOption));
    }

    [Test]
    [TestCase(MStabModelType.Bishop, StabilityModelOptionType.Bishop)]
    [TestCase(MStabModelType.UpliftVan, StabilityModelOptionType.UpliftVan)]
    public void CanConvertToModelOptionsOutput(MStabModelType mStabModelType, StabilityModelOptionType modelOption)
    {
        Assert.That(ConversionHelper.ConvertToModelOptionsOutput(mStabModelType), Is.EqualTo(modelOption));
    }

    [TestCase(MStabModelType.BishopUpliftVan)]
    public void CanConvertToModelOptionsHandleException(MStabModelType mStabModelType)
    {
        Assert.That(() => ConversionHelper.ConvertToModelOptions(mStabModelType), Throws.InstanceOf<ArgumentException>());
    }

    [TestCase(MStabModelType.BishopUpliftVan)]
    public void CanConvertToModelOptionsOutputHandleException(MStabModelType mStabModelType)
    {
        Assert.That(() => ConversionHelper.ConvertToModelOptionsOutput(mStabModelType), Throws.InstanceOf<ArgumentException>());
    }

    #endregion

    #region GridOrientation

    [TestCase(Orientation.Outwards, MStabGridPosition.Left)]
    [TestCase(Orientation.Inwards, MStabGridPosition.Right)]
    public static void CanConvertToMStabGridPosition(Orientation gridOrientation, MStabGridPosition mStabGridPosition)
    {
        Assert.That(ConversionHelper.ConvertToMStabGridPosition(gridOrientation), Is.EqualTo(mStabGridPosition));
    }

    [TestCase(MStabGridPosition.Left, Orientation.Outwards)]
    [TestCase(MStabGridPosition.Right, Orientation.Inwards)]
    public static void CanConvertToGridOrientation(MStabGridPosition mStabGridPosition, Orientation gridOrientation)
    {
        Assert.That(ConversionHelper.ConvertToGridOrientation(mStabGridPosition), Is.EqualTo(gridOrientation));
    }

    #endregion

    #region ShearStrengthModel

    [TestCase(ShearStrengthModelType.MohrCoulomb, ShearStrengthModel.CPhi)]
    [TestCase(ShearStrengthModelType.Shansep, ShearStrengthModel.SuCalculated)]
    public static void CanConvertToDamShearStrengthModel(
        ShearStrengthModelType kernelShearStrengthModel, ShearStrengthModel damShearStrengthModel)
    {
        Assert.That(ConversionHelper.ConvertToDamShearStrengthModel(kernelShearStrengthModel), Is.EqualTo(damShearStrengthModel));
    }

    [TestCase(ShearStrengthModel.CPhi, ShearStrengthModelType.MohrCoulomb)]
    [TestCase(ShearStrengthModel.SuCalculated, ShearStrengthModelType.Shansep)]
    public static void CanConvertToMacroStabilityShearStrengthModel(
        ShearStrengthModel damShearStrengthModel, ShearStrengthModelType kernelShearStrengthModel)
    {
        Assert.That(ConversionHelper.ConvertToMacroStabilityShearStrengthModel(damShearStrengthModel), Is.EqualTo(kernelShearStrengthModel));
    }

    #endregion

    #region WaterpressureInterpolationModel

    [TestCase(WaterpressureInterpolationModel.Automatic, WaterPressureInterpolationModel.Automatic)]
    [TestCase(WaterpressureInterpolationModel.Hydrostatic, WaterPressureInterpolationModel.Hydrostatic)]
    public static void CanConvertToMacroStabilityWaterpressureInterpolationModel(
        WaterpressureInterpolationModel damWaterpressureInterpolationModel, WaterPressureInterpolationModel waterpressureInterpolationModel)
    {
        Assert.That(ConversionHelper.ConvertToMacroStabilityWaterpressureInterpolationModel(damWaterpressureInterpolationModel), Is.EqualTo(waterpressureInterpolationModel));
    }

    [TestCase(WaterPressureInterpolationModel.Automatic, WaterpressureInterpolationModel.Automatic)]
    [TestCase(WaterPressureInterpolationModel.Hydrostatic, WaterpressureInterpolationModel.Hydrostatic)]
    public static void CanConvertToDamWaterpressureInterpolationModel(
        WaterPressureInterpolationModel waterpressureInterpolationModel, WaterpressureInterpolationModel damWaterpressureInterpolationModel)
    {
        Assert.That(ConversionHelper.ConvertToDamWaterpressureInterpolationModel(waterpressureInterpolationModel), Is.EqualTo(damWaterpressureInterpolationModel));
    }

    #endregion

    #region CharacteristicPointType

    [TestCase(CharacteristicPointType.BottomDitchPolderSide, CharacteristicPoint.BottomDitchPolderSide)]
    [TestCase(CharacteristicPointType.BottomDitchDikeSide, CharacteristicPoint.BottomDitchDikeSide)]
    //[TestCase(CharacteristicPointType.DikeLine, CharacteristicPoint.DikeLine)]
    [TestCase(CharacteristicPointType.DikeToeAtPolder, CharacteristicPoint.DikeToeAtPolder)]
    [TestCase(CharacteristicPointType.DikeToeAtRiver, CharacteristicPoint.DikeToeAtRiver)]
    [TestCase(CharacteristicPointType.DikeTopAtPolder, CharacteristicPoint.DikeTopAtPolder)]
    [TestCase(CharacteristicPointType.DikeTopAtRiver, CharacteristicPoint.DikeTopAtRiver)]
    [TestCase(CharacteristicPointType.DitchDikeSide, CharacteristicPoint.DitchDikeSide)]
    [TestCase(CharacteristicPointType.DitchPolderSide, CharacteristicPoint.DitchPolderSide)]
    [TestCase(CharacteristicPointType.None, CharacteristicPoint.None)]
    [TestCase(CharacteristicPointType.ShoulderBaseInside, CharacteristicPoint.ShoulderBaseInside)]
    [TestCase(CharacteristicPointType.ShoulderBaseOutside, CharacteristicPoint.ShoulderBaseOutside)]
    [TestCase(CharacteristicPointType.ShoulderTopInside, CharacteristicPoint.ShoulderTopInside)]
    [TestCase(CharacteristicPointType.ShoulderTopOutside, CharacteristicPoint.ShoulderTopOutside)]
    [TestCase(CharacteristicPointType.SurfaceLevelInside, CharacteristicPoint.SurfaceLevelInside)]
    [TestCase(CharacteristicPointType.SurfaceLevelOutside, CharacteristicPoint.SurfaceLevelOutside)]
    [TestCase(CharacteristicPointType.TrafficLoadInside, CharacteristicPoint.TrafficLoadInside)]
    [TestCase(CharacteristicPointType.TrafficLoadOutside, CharacteristicPoint.TrafficLoadOutside)]
    public static void CanConvertToMacroStabilityWaterpressureInterpolationModel(
        CharacteristicPointType damCharacteristicPointType, CharacteristicPoint kernelCharacteristicPointType)
    {
        Assert.That(ConversionHelper.ConvertToMacroStabilityCharacteristicPointType(damCharacteristicPointType), Is.EqualTo(kernelCharacteristicPointType));
    }

    [TestCase(CharacteristicPoint.BottomDitchDikeSide, CharacteristicPointType.BottomDitchDikeSide)]
    [TestCase(CharacteristicPoint.BottomDitchPolderSide, CharacteristicPointType.BottomDitchPolderSide)]
    // [TestCase(CharacteristicPoint.DikeLine, CharacteristicPointType.DikeLine)]
    [TestCase(CharacteristicPoint.DikeToeAtPolder, CharacteristicPointType.DikeToeAtPolder)]
    [TestCase(CharacteristicPoint.DikeToeAtRiver, CharacteristicPointType.DikeToeAtRiver)]
    [TestCase(CharacteristicPoint.DikeTopAtPolder, CharacteristicPointType.DikeTopAtPolder)]
    [TestCase(CharacteristicPoint.DikeTopAtRiver, CharacteristicPointType.DikeTopAtRiver)]
    [TestCase(CharacteristicPoint.DitchDikeSide, CharacteristicPointType.DitchDikeSide)]
    [TestCase(CharacteristicPoint.DitchPolderSide, CharacteristicPointType.DitchPolderSide)]
    [TestCase(CharacteristicPoint.None, CharacteristicPointType.None)]
    [TestCase(CharacteristicPoint.ShoulderBaseInside, CharacteristicPointType.ShoulderBaseInside)]
    [TestCase(CharacteristicPoint.ShoulderBaseOutside, CharacteristicPointType.ShoulderBaseOutside)]
    [TestCase(CharacteristicPoint.ShoulderTopInside, CharacteristicPointType.ShoulderTopInside)]
    [TestCase(CharacteristicPoint.ShoulderTopOutside, CharacteristicPointType.ShoulderTopOutside)]
    [TestCase(CharacteristicPoint.SurfaceLevelInside, CharacteristicPointType.SurfaceLevelInside)]
    [TestCase(CharacteristicPoint.SurfaceLevelOutside, CharacteristicPointType.SurfaceLevelOutside)]
    [TestCase(CharacteristicPoint.TrafficLoadInside, CharacteristicPointType.TrafficLoadInside)]
    [TestCase(CharacteristicPoint.TrafficLoadOutside, CharacteristicPointType.TrafficLoadOutside)]
    public static void CanConvertToDamWaterpressureInterpolationModel(
        CharacteristicPoint kernelCharacteristicPointType, CharacteristicPointType damCharacteristicPointType)
    {
        Assert.That(ConversionHelper.ConvertToDamCharacteristicPointType(kernelCharacteristicPointType), Is.EqualTo(damCharacteristicPointType));
    }

    #endregion

    #region LogMessages

    [TestCase(LogMessageType.Info, MessageType.Info)]
    [TestCase(LogMessageType.Warning, MessageType.Warning)]
    [TestCase(LogMessageType.Error, MessageType.Error)]
    public void CanConvertLogMessageTypeToKernelLogMessageType(LogMessageType logMessageType, MessageType messageType)
    {
        Assert.That(ConversionHelper.ConvertLogMessageTypeToKernelLogMessageType(logMessageType),
                    Is.EqualTo(messageType));
    }

    [TestCase(MessageType.Info, LogMessageType.Info)]
    [TestCase(MessageType.Warning, LogMessageType.Warning)]
    [TestCase(MessageType.Error, LogMessageType.Error)]
    public void CanConvertKernelLogMessageTypeToLogMessageType(MessageType kernelLogMessageType,
                                                               LogMessageType logMessageType)
    {
        Assert.That(ConversionHelper.ConvertKernelLogMessageTypeToLogMessageType(kernelLogMessageType),
                    Is.EqualTo(logMessageType));
    }

    #endregion
}