// Copyright (C) Stichting Deltares 2025. 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.Calculators.KernelWrappers.MacroStabilityCommon.MacroStabilityIo;
using Deltares.DamEngine.Data.General;
using Deltares.DamEngine.Data.Geotechnics;
using Deltares.MacroStability.Io.XmlInput;
using KellermanSoftware.CompareNetObjects;
using NUnit.Framework;
using CharacteristicPointType = Deltares.MacroStability.Io.XmlInput.CharacteristicPointType;

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

[TestFixture]
public class InputConversionHelperTests
{
    [Test]
    public void GivenMacroStabilitySoilWhenConvertingToDamSoilAndBackThenResultEqualsOriginal()
    {
        // Given MacroStability Soil
        var macroStabilitySoil = new SoilType
        {
            Name = "MacroStabilitySoil",
            AbovePhreaticLevel = 1.01,
            BelowPhreaticLevel = 1.02,
            Cohesion = 1.03,
            FrictionAngle = 1.04,
            Dilatancy = 1.04,
            RatioCuPc = 1.06,
            ShearStrengthAbovePhreaticLevelModel = ShearStrengthModelType.MohrCoulomb,
            ShearStrengthBelowPhreaticLevelModel = ShearStrengthModelType.MohrCoulomb,
            StrengthIncreaseExponent = 1.08,
            UseSoilClassification = false, // must be false
            SigmaTauTable = [],
            SuTable = [],
            BondStressCurve = null // must be null
        };

        // When Converting to DamSoil and back
        Soil damSoil = InputConversionHelper.ConvertToDamSoil(macroStabilitySoil);
        SoilType actualMacroStabilitySoil = InputConversionHelper.ConvertToMacroStabilitySoil(damSoil);

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

    [Test]
    public void GivenMacroStabilitySoilWithSuAndSigmaTauTableWhenConvertingToDamSoilAndBackThenResultEqualsOriginal()
    {
        // Given MacroStability Soil with filled Su and SigmaTau table
        var sigmaTauTable = new SoilTypeSigmaTauTablePoint[2];
        sigmaTauTable[0] = new SoilTypeSigmaTauTablePoint
        {
            Sigma = 1.1,
            Tau = 2.1
        };
        sigmaTauTable[1] = new SoilTypeSigmaTauTablePoint
        {
            Sigma = 2.1,
            Tau = 3.1
        };
        var suTable = new SoilTypeSuTablePoint[2];
        suTable[0] = new SoilTypeSuTablePoint
        {
            Su = 0.1,
            EffectiveStress = 10.1
        };
        suTable[1] = new SoilTypeSuTablePoint
        {
            Su = 1.21,
            EffectiveStress = 13.4
        };
        var macroStabilitySoil = new SoilType
        {
            Name = "MacroStabilitySoil",
            AbovePhreaticLevel = 1.01,
            BelowPhreaticLevel = 1.02,
            Cohesion = 1.03,
            FrictionAngle = 1.04,
            Dilatancy = 1.04,
            RatioCuPc = 1.06,
            ShearStrengthAbovePhreaticLevelModel = ShearStrengthModelType.MohrCoulomb,
            ShearStrengthBelowPhreaticLevelModel = ShearStrengthModelType.MohrCoulomb,
            StrengthIncreaseExponent = 1.08,
            UseSoilClassification = false, // must be false
            SigmaTauTable = sigmaTauTable,
            SuTable = suTable,
            BondStressCurve = null // must be null
        };

        // When Converting to DamSoil and back
        Soil damSoil = InputConversionHelper.ConvertToDamSoil(macroStabilitySoil);
        SoilType actualMacroStabilitySoil = InputConversionHelper.ConvertToMacroStabilitySoil(damSoil);

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

    [Test]
    [TestCase(SearchAlgorithmType.Grid, StabilitySearchMethod.Grid)]
    [TestCase(SearchAlgorithmType.BeeswarmAndLevenbergMarquardt, StabilitySearchMethod.BeeSwarm)]
    public void CanConvertToDamSearchMethod(SearchAlgorithmType searchAlgorithm, StabilitySearchMethod stabilitySearchMethod)
    {
        Assert.That(InputConversionHelper.ConvertToDamSearchMethod(searchAlgorithm), Is.EqualTo(stabilitySearchMethod));
    }

    [Test]
    [TestCase(StabilitySearchMethod.Grid, SearchAlgorithmType.Grid)]
    [TestCase(StabilitySearchMethod.BeeSwarm, SearchAlgorithmType.BeeswarmAndLevenbergMarquardt)]
    public void ConvertToMacroStabilitySearchMethod(StabilitySearchMethod stabilitySearchMethod, SearchAlgorithmType searchAlgorithm)
    {
        Assert.That(InputConversionHelper.ConvertToMacroStabilitySearchMethod(stabilitySearchMethod), Is.EqualTo(searchAlgorithm));
    }

    [Test]
    [TestCase(StabilityModelOption.Bishop, StabilityModelType.Bishop)]
    [TestCase(StabilityModelOption.UpliftVan, StabilityModelType.UpliftVan)]
    public void CanConvertToMStabModelType(StabilityModelOption modelOption, StabilityModelType stabilityModelType)
    {
        Assert.That(InputConversionHelper.ConvertToDamStabilityModelType(modelOption), Is.EqualTo(stabilityModelType));
    }

    [Test]
    [TestCase(StabilityModelType.UpliftVan, StabilityModelOption.UpliftVan)]
    public void CanConvertToModelOptions(StabilityModelType stabilityModelType, StabilityModelOption modelOption)
    {
        Assert.That(InputConversionHelper.ConvertToMacroStabilityModelOption(stabilityModelType), Is.EqualTo(modelOption));
    }

    [TestCase(WaterpressureInterpolationModel.Automatic, WaterPressureInterpolationModelType.Automatic)]
    [TestCase(WaterpressureInterpolationModel.Hydrostatic, WaterPressureInterpolationModelType.Hydrostatic)]
    public static void CanConvertToMacroStabilityWaterPressureInterpolationModel(
        WaterpressureInterpolationModel damWaterPressureInterpolationModel, WaterPressureInterpolationModelType waterPressureInterpolationModel)
    {
        Assert.That(InputConversionHelper.ConvertToMacroStabilityWaterPressureInterpolationModel(damWaterPressureInterpolationModel), Is.EqualTo(waterPressureInterpolationModel));
    }

    [TestCase(WaterPressureInterpolationModelType.Automatic, WaterpressureInterpolationModel.Automatic)]
    [TestCase(WaterPressureInterpolationModelType.Hydrostatic, WaterpressureInterpolationModel.Hydrostatic)]
    public static void CanConvertToDamWaterPressureInterpolationModel(
        WaterPressureInterpolationModelType waterPressureInterpolationModel, WaterpressureInterpolationModel damWaterPressureInterpolationModel)
    {
        Assert.That(InputConversionHelper.ConvertToDamWaterPressureInterpolationModel(waterPressureInterpolationModel), Is.EqualTo(damWaterPressureInterpolationModel));
    }

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

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

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

    [TestCase(StabilityModelType.BishopUpliftVan)]
    public void CanConvertToModelOptionsHandleException(StabilityModelType stabilityModelType)
    {
        Assert.That(() => InputConversionHelper.ConvertToMacroStabilityModelOption(stabilityModelType), Throws.InstanceOf<ArgumentException>());
    }

    [TestCase(OrientationType.Outwards, StabilityGridPosition.Left)]
    [TestCase(OrientationType.Inwards, StabilityGridPosition.Right)]
    public static void CanConvertToMStabGridPosition(OrientationType gridOrientation, StabilityGridPosition stabilityGridPosition)
    {
        Assert.That(InputConversionHelper.ConvertToDamGridPosition(gridOrientation), Is.EqualTo(stabilityGridPosition));
    }

    [TestCase(StabilityGridPosition.Left, OrientationType.Outwards)]
    [TestCase(StabilityGridPosition.Right, OrientationType.Inwards)]
    public static void CanConvertToGridOrientation(StabilityGridPosition stabilityGridPosition, OrientationType gridOrientation)
    {
        Assert.That(InputConversionHelper.ConvertToMacroStabilityGridOrientation(stabilityGridPosition), Is.EqualTo(gridOrientation));
    }
}