// 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 System.Collections.Generic;
using System.Linq;
using Deltares.DamEngine.Calculators.KernelWrappers.Common;
using Deltares.DamEngine.Calculators.KernelWrappers.MacroStabilityCommon;
using Deltares.DamEngine.Calculators.KernelWrappers.MacroStabilityCommon.MacroStabilityIo;
using Deltares.DamEngine.Data.General;
using Deltares.DamEngine.Data.Geometry;
using Deltares.DamEngine.Data.Geotechnics;
using Deltares.DamEngine.TestHelpers.Factories;
using Deltares.MacroStability.Io.XmlInput;
using KellermanSoftware.CompareNetObjects;
using NUnit.Framework;
using CharacteristicPointType = Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType;
using Point2D = Deltares.DamEngine.Data.Geometry.Point2D;
using Soil = Deltares.DamEngine.Data.Geotechnics.Soil;
using SoilProfileType = Deltares.MacroStability.Io.XmlInput.SoilProfileType;
using UpliftVanCalculationGrid = Deltares.DamEngine.Calculators.KernelWrappers.MacroStabilityCommon.UpliftVanCalculationGrid;

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

[TestFixture]
public class EngineToMacroStabilityKernelInputTests
{
    private static readonly List<string> soilParametersToIgnore =
    [
        "RRatio",
        "RheologicalCoefficient",
        "BondStressCurve",
        "UseSoilType",
        "UseDefaultShearStrengthModel"
    ];

    [TestCase(StabilityModelType.UpliftVan, TangentLinesDefinition.OnBoundaryLines)]
    [TestCase(StabilityModelType.UpliftVan, TangentLinesDefinition.Specified)]
    [TestCase(StabilityModelType.Bishop, TangentLinesDefinition.Specified)]
    public void GivenDamEngineDataModelWhenTransferToKernelInputThenDataIsEqual(StabilityModelType stabilityModelType, TangentLinesDefinition tangentLinesDefinition)
    {
        // Given DamEngine data (DamProjectData)
        DamProjectData expectedDamProjectData = FactoryForDamProjectData.CreateExampleDamProjectData();
        expectedDamProjectData.DamProjectCalculationSpecification.DamCalculationSpecifications[0]
                              .StabilityModelType = stabilityModelType;
        Waternet expectedWaternet = CreateExampleWaternet();

        Location expectedLocation = expectedDamProjectData.Dike.Locations[0];
        SoilList expectedSoilList = expectedDamProjectData.Dike.SoilList;
        SoilProfile2D expectedSoilProfile2D = expectedLocation.Segment.SoilProfileProbabilities[0].SoilProfile2D;
        SurfaceLine2 expectedSurfaceLine2D = expectedLocation.SurfaceLine;
        IList<TrafficLoadDegreeOfConsolidation> expectedConsolidationValues = expectedLocation.TrafficLoadDegreeOfConsolidations;
        FailureMechanismParametersMStab expectedParametersMStab = expectedDamProjectData.DamProjectCalculationSpecification.CurrentSpecification.FailureMechanismParametersMStab;
        var damKernelInput = new DamKernelInput
        {
            SubSoilScenario = expectedLocation.Segment.SoilProfileProbabilities[0],
            Location = expectedLocation,
            DamFailureMechanismeCalculationSpecification = expectedDamProjectData.DamProjectCalculationSpecification.CurrentSpecification
        };

        // Determine the proper values for grid and traffic load using the helper methods
        UpliftVanCalculationGrid expectedUpliftVanCalculationGrid = null;
        BishopCalculationGrid expectedBishopCalculationGrid = null;
        double xCoordinateLowestUpliftFactorPoint = 0.0;
        if (stabilityModelType == StabilityModelType.UpliftVan)
        {
            damKernelInput.DamFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.SlipCircleDefinition.UpliftVanTangentLinesDefinition = tangentLinesDefinition;
            xCoordinateLowestUpliftFactorPoint = (expectedSurfaceLine2D.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DikeTopAtPolder).X +
                                                         expectedSurfaceLine2D.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DikeToeAtPolder).X) * 0.5;
            expectedUpliftVanCalculationGrid = MacroStabilityCommonHelper.DetermineUpliftVanCalculationGrid(damKernelInput, xCoordinateLowestUpliftFactorPoint);
        }
        else
        {
            //Note: Bishop only uses auto search area setting, not the tangent line definition 
            expectedBishopCalculationGrid = MacroStabilityCommonHelper.DetermineBishopCalculationGrid(damKernelInput);
        }
        TrafficLoad expectedTrafficLoad = MacroStabilityCommonHelper.FillTrafficLoad(damKernelInput);
        
        // When transfer to kernel input
        FullInputModelType fullInputModel = FillMacroStabilityKernelInputFromEngine.CreateFullInputModel(
            damKernelInput, expectedParametersMStab.MStabParameters, expectedWaternet, xCoordinateLowestUpliftFactorPoint);
        Assert.That(fullInputModel, Is.Not.Null);
        
        // Then the data models are equal
        CompareStabilityModel(expectedParametersMStab, fullInputModel.StabilityModel);
        CompareSoilModel(expectedSoilList, fullInputModel.StabilityModel.Soils);
        CompareSoilProfile2D(expectedSoilProfile2D, fullInputModel.StabilityModel.ConstructionStages[0].SoilProfile, fullInputModel.StabilityModel.Soils);
        CompareSurfaceLine(expectedSurfaceLine2D, fullInputModel.PreprocessingInput.PreConstructionStages[0].Surfaceline);
        CompareTrafficLoad(expectedTrafficLoad, fullInputModel.StabilityModel.ConstructionStages[0].UniformLoads[0]);
        CompareTrafficLoadDegreeOfConsolidations(expectedConsolidationValues, fullInputModel.StabilityModel.ConstructionStages[0].ConsolidationValues,
                                                 fullInputModel.StabilityModel.ConstructionStages[0].SoilProfile.SoilSurfaces, fullInputModel.StabilityModel.Soils);
        if (stabilityModelType == StabilityModelType.UpliftVan)
        {
            SlipCircleDefinition expectedUpliftVanSlipCircleDefinition = expectedParametersMStab.MStabParameters.SlipCircleDefinition;
            CompareUpliftVanCalculationGridSettings(expectedUpliftVanSlipCircleDefinition, fullInputModel.PreprocessingInput.SearchAreaConditions);
            bool areTangentLineSpecified = expectedUpliftVanSlipCircleDefinition.UpliftVanTangentLinesDefinition == TangentLinesDefinition.Specified;
            CompareUpliftVanSlipCircleDefinition(expectedUpliftVanCalculationGrid, fullInputModel.StabilityModel.UpliftVanCalculationGrid, areTangentLineSpecified);
        }
        else
        {
            SlipCircleDefinition expectedBishopSlipCircleDefinition = expectedParametersMStab.MStabParameters.SlipCircleDefinition;
            CompareBishopCalculationGridSettings(expectedBishopSlipCircleDefinition, fullInputModel.PreprocessingInput.SearchAreaConditions);
            CompareBishopCalculationGrid(expectedBishopCalculationGrid, fullInputModel.StabilityModel.BishopCalculationCircle);
        }
        CompareWaternet(expectedWaternet, fullInputModel.StabilityModel.ConstructionStages[0].Waternet);
    }

    private static Waternet CreateExampleWaternet()
    {
        var waterNet = new Waternet
        {
            IsGenerated = false,
            UnitWeight = 9.81,
            Name = "Test Waternet"
        };

        var random = new Random(21);
        var phreaticLine = new PhreaticLine
        {
            Name = "Test Phreatic line"
        };
        waterNet.PhreaticLine = phreaticLine;
        FillGeometryPointString(phreaticLine, random.Next());

        // Head line
        const int nrOfHeadLines = 10;
        for (var i = 0; i < nrOfHeadLines; i++)
        {
            var headLine = new HeadLine
            {
                Name = $"Test Head line{i}"
            };
            FillGeometryPointString(headLine, random.Next());
            waterNet.HeadLineList.Add(headLine);
        }

        // Waternet line
        for (var i = 0; i < nrOfHeadLines; i++)
        {
            var waternetLine = new WaternetLine
            {
                Name = $"Test Waternet line {i}",
                HeadLine = waterNet.HeadLineList[i]
            };
            FillGeometryPointString(waternetLine, random.Next());
            waterNet.WaternetLineList.Add(waternetLine);
        }

        return waterNet;
    }

    private static void FillGeometryPointString(GeometryPointString geometry, int seed)
    {
        var random = new Random(seed);
        for (var i = 0; i < 10; i++)
        {
            geometry.Points.Add(new Point2D(random.NextDouble(), random.NextDouble()));
        }
    }

    private static void CompareTrafficLoad(TrafficLoad expectedTrafficLoad, UniformLoadType actualTrafficLoad)
    {
        Assert.Multiple(() =>
        {
            Assert.That(actualTrafficLoad.XStart, Is.EqualTo(expectedTrafficLoad.XStart).Within(GeometryConstants.Tolerance));
            Assert.That(actualTrafficLoad.XEnd, Is.EqualTo(expectedTrafficLoad.XEnd).Within(GeometryConstants.Tolerance));
            Assert.That(actualTrafficLoad.Pressure, Is.EqualTo(expectedTrafficLoad.Pressure).Within(GeometryConstants.Tolerance));
            Assert.That(actualTrafficLoad.DistributionAngle, Is.EqualTo(expectedTrafficLoad.DistributionAngle).Within(GeometryConstants.Tolerance));
        });
    }

    private static void CompareTrafficLoadDegreeOfConsolidations(IList<TrafficLoadDegreeOfConsolidation> expectedDegreeOfConsolidations,
                                                                 ConsolidationValuesTypeConsolidationValue[] actualDegreeOfConsolidations,
                                                                 SoilSurfaceType[] actualSurfaceTypes, SoilType[] actualSoils)
    {
        int expectedNrOfDegreeOfConsolidation = expectedDegreeOfConsolidations.Count;
        Assert.That(actualDegreeOfConsolidations, Has.Length.EqualTo(expectedNrOfDegreeOfConsolidation));
        for (var i = 0; i < expectedNrOfDegreeOfConsolidation; i++)
        {
            SoilSurfaceType actualSurfaceType = FindSurfaceByKey(actualDegreeOfConsolidations[i].Consolidated, actualSurfaceTypes);
            Soil damSoil = InputConversionHelper.ConvertToDamSoil(actualSoils[actualSurfaceType.Soil]);
            Assert.Multiple(() =>
            {
                Assert.That(actualDegreeOfConsolidations[i].Value, Is.EqualTo(expectedDegreeOfConsolidations[i].DegreeOfConsolidation).Within(GeometryConstants.Tolerance));
                // There is only ever 1 Traffic load (as Consolidator)to refer to so do not check
                Assert.That(damSoil.Name, Is.EqualTo(expectedDegreeOfConsolidations[i].SoilName));
            });
        }
    }

    private static SoilSurfaceType FindSurfaceByKey(int key, SoilSurfaceType[] types)
    {
        foreach (SoilSurfaceType soilSurfaceType in types)
        {
            if (soilSurfaceType.Key == key)
            {
                return soilSurfaceType;
            }
        }

        return null;
    }

    private static void CompareUpliftVanCalculationGridSettings(SlipCircleDefinition expectedSlipCircleDefinition,
                                                                SearchAreaConditionsType actualSearchAreaConditionsType)
    {
        Assert.That(actualSearchAreaConditionsType.AutoSearchArea, Is.EqualTo(expectedSlipCircleDefinition.UpliftVanGridSizeDetermination == GridSizeDetermination.Automatic));
        if (actualSearchAreaConditionsType.AutoTangentLines)
        {
            Assert.That(actualSearchAreaConditionsType.OnlyAbovePleistoceen, Is.EqualTo(expectedSlipCircleDefinition.UpliftVanTangentLinesDefinition == TangentLinesDefinition.Automatic));
        }
        else
        {
            Assert.That(expectedSlipCircleDefinition.UpliftVanTangentLinesDefinition, Is.EqualTo(TangentLinesDefinition.Specified));
        }
    }
    
    private static void CompareBishopCalculationGridSettings(SlipCircleDefinition expectedSlipCircleDefinition,
                                                                SearchAreaConditionsType actualSearchAreaConditionsType)
    {
        Assert.Multiple(() =>
        {
            Assert.That(actualSearchAreaConditionsType.AutoSearchArea, Is.EqualTo(expectedSlipCircleDefinition.BishopSearchAreaDetermination == GridSizeDetermination.Automatic));
            Assert.That(actualSearchAreaConditionsType.AutoTangentLines, Is.False);
        });
    }

    private static void CompareUpliftVanSlipCircleDefinition(UpliftVanCalculationGrid expectedSlipPlaneUpliftVan,
                                                        UpliftVanCalculationGridType actualSlipPlaneUpliftVan, bool areTangentLineSpecified)
    {
        Assert.Multiple(() =>
        {
            Assert.That(actualSlipPlaneUpliftVan.LeftGrid.GridXLeft, Is.EqualTo(expectedSlipPlaneUpliftVan.LeftGridXLeft));
            Assert.That(actualSlipPlaneUpliftVan.LeftGrid.GridXRight, Is.EqualTo(expectedSlipPlaneUpliftVan.LeftGridXRight));
            Assert.That(actualSlipPlaneUpliftVan.LeftGrid.GridZTop, Is.EqualTo(expectedSlipPlaneUpliftVan.LeftGridZTop));
            Assert.That(actualSlipPlaneUpliftVan.LeftGrid.GridZBottom, Is.EqualTo(expectedSlipPlaneUpliftVan.LeftGridZBottom));
            Assert.That(actualSlipPlaneUpliftVan.LeftGrid.GridXNumber, Is.EqualTo(expectedSlipPlaneUpliftVan.LeftGridXCount));
            Assert.That(actualSlipPlaneUpliftVan.LeftGrid.GridZNumber, Is.EqualTo(expectedSlipPlaneUpliftVan.LeftGridZCount));

            Assert.That(actualSlipPlaneUpliftVan.RightGrid.GridXLeft, Is.EqualTo(expectedSlipPlaneUpliftVan.RightGridXLeft));
            Assert.That(actualSlipPlaneUpliftVan.RightGrid.GridXRight, Is.EqualTo(expectedSlipPlaneUpliftVan.RightGridXRight));
            Assert.That(actualSlipPlaneUpliftVan.RightGrid.GridZTop, Is.EqualTo(expectedSlipPlaneUpliftVan.RightGridZTop));
            Assert.That(actualSlipPlaneUpliftVan.RightGrid.GridZBottom, Is.EqualTo(expectedSlipPlaneUpliftVan.RightGridZBottom));
            Assert.That(actualSlipPlaneUpliftVan.RightGrid.GridXNumber, Is.EqualTo(expectedSlipPlaneUpliftVan.RightGridXCount));
            Assert.That(actualSlipPlaneUpliftVan.RightGrid.GridZNumber, Is.EqualTo(expectedSlipPlaneUpliftVan.RightGridZCount));
        });

        if (areTangentLineSpecified)
        {
            Assert.That(actualSlipPlaneUpliftVan.TangentLines, Is.EqualTo(expectedSlipPlaneUpliftVan.TangentLineLevels).AsCollection);
        }
    }
    
    private static void CompareBishopCalculationGrid(BishopCalculationGrid expectedSlipCircleBishop,
                                                        BishopCalculationCircle actualSlipCircleBishop)
    {
        Assert.Multiple(() =>
        {
            Assert.That(actualSlipCircleBishop.Grid.GridXLeft, Is.EqualTo(expectedSlipCircleBishop.GridXLeft));
            Assert.That(actualSlipCircleBishop.Grid.GridXRight, Is.EqualTo(expectedSlipCircleBishop.GridXRight));
            Assert.That(actualSlipCircleBishop.Grid.GridZTop, Is.EqualTo(expectedSlipCircleBishop.GridZTop));
            Assert.That(actualSlipCircleBishop.Grid.GridZBottom, Is.EqualTo(expectedSlipCircleBishop.GridZBottom));
            Assert.That(actualSlipCircleBishop.Grid.GridXNumber, Is.EqualTo(expectedSlipCircleBishop.GridXCount));
            Assert.That(actualSlipCircleBishop.Grid.GridZNumber, Is.EqualTo(expectedSlipCircleBishop.GridZCount));
        });

        Assert.That(actualSlipCircleBishop.TangentLines, Is.EqualTo(expectedSlipCircleBishop.TangentLineLevels).AsCollection);
    }

    private static void CompareWaternet(Waternet expectedWaternet, WaternetType actualWaternet)
    {
        Assert.That(actualWaternet.Name, Is.EqualTo(expectedWaternet.Name));
        CompareHeadLine(expectedWaternet.PhreaticLine, actualWaternet.PhreaticLine);
        CompareWaternetHeadLines(expectedWaternet.HeadLineList, actualWaternet.HeadLines);
        CompareWaternetLines(expectedWaternet.WaternetLineList, actualWaternet.WaternetLines, actualWaternet.HeadLines);
    }

    private static void CompareWaternetLines(List<WaternetLine> expectedWaternetLines,
                                             WaternetTypeWaternetLine[] actualWaternetLines, HeadLineType[] actualHeadLines)
    {
        Assert.That(actualWaternetLines.Count, Is.EqualTo(expectedWaternetLines.Count));
        for (var i = 0; i < expectedWaternetLines.Count; i++)
        {
            WaternetLine expectedWaternetLine = expectedWaternetLines.ElementAt(i);
            WaternetTypeWaternetLine actualWaternetLine = actualWaternetLines[i];
            CompareWaternetLine(expectedWaternetLine, actualWaternetLine);
            HeadLineType associatedHeadLine = FindAssociatedHeadLine(actualWaternetLine.AssociatedHeadLine, actualHeadLines);
            CompareHeadLine(expectedWaternetLine.HeadLine, associatedHeadLine);
        }
    }

    private static HeadLineType FindAssociatedHeadLine(int associatedHeadLine, HeadLineType[] actualHeadLines)
    {
        foreach (HeadLineType headLine in actualHeadLines)
        {
            if (headLine.Key == associatedHeadLine)
            {
                return headLine;
            }
        }

        return null;
    }

    private static void CompareWaternetHeadLines(List<HeadLine> expectedHeadLines,
                                                 HeadLineType[] actualHeadLines)
    {
        Assert.That(actualHeadLines.Count, Is.EqualTo(expectedHeadLines.Count));

        for (var i = 0; i < expectedHeadLines.Count; i++)
        {
            HeadLine expectedHeadLine = expectedHeadLines.ElementAt(i);
            HeadLineType actualHeadLine = actualHeadLines.ElementAt(i);
            CompareHeadLine(expectedHeadLine, actualHeadLine);
        }
    }

    private static void CompareHeadLine(GeometryPointString expectedHeadLine, HeadLineType actualHeadLine)
    {
        Assert.That(actualHeadLine.WaternetLine.Name, Is.EqualTo(expectedHeadLine.Name));
        List<Point2D> expectedPoints = expectedHeadLine.Points;
        List<Point2DType> actualPoints = actualHeadLine.WaternetLine.Points.ToList();
        Assert.That(actualPoints, Has.Count.EqualTo(expectedPoints.Count));
        for (var i = 0; i < expectedPoints.Count; i++)
        {
            Point2D expectedCoordinate = expectedPoints[i];
            var actualCoordinateAsPoint2D = new Point2D(actualPoints[i].X, actualPoints[i].Z);
            Assert.That(expectedCoordinate.LocationEquals(actualCoordinateAsPoint2D), Is.True);
        }
    }

    private static void CompareWaternetLine(GeometryPointString expectedWaternetLine, WaternetTypeWaternetLine actualWaternetLine)
    {
        Assert.That(actualWaternetLine.Name, Is.EqualTo(expectedWaternetLine.Name));

        List<Point2D> expectedPoints = expectedWaternetLine.Points;
        List<Point2DType> actualPoints = actualWaternetLine.Points.ToList();
        Assert.That(actualPoints, Has.Count.EqualTo(expectedPoints.Count));
        for (var i = 0; i < expectedPoints.Count; i++)
        {
            Point2D expectedCoordinate = expectedPoints[i];
            var actualCoordinateAsPoint2D = new Point2D(actualPoints[i].X, actualPoints[i].Z);
            Assert.That(expectedCoordinate.LocationEquals(actualCoordinateAsPoint2D), Is.True);
        }
    }

    private static void CompareSurfaceLine(SurfaceLine2 expectedSurfaceLine2, SurfaceLineType actualSurfaceLine2)
    {
        CharacteristicPointSet expectedCharacteristicPoints = expectedSurfaceLine2.CharacteristicPoints;
        SurfaceLineTypeCharacteristicPoint[] actualCharacteristicPoints = actualSurfaceLine2.CharacteristicPoints;
        Assert.That(actualCharacteristicPoints, Has.Length.EqualTo(expectedCharacteristicPoints.Count));
        for (var i = 0; i < actualCharacteristicPoints.Length; i++)
        {
            Assert.Multiple(() =>
            {
                Assert.That(actualCharacteristicPoints[i].CharacteristicPointType,
                            Is.EqualTo(InputConversionHelper.ConvertToMacroStabilityCharacteristicPointType(
                                           expectedSurfaceLine2.CharacteristicPoints[i].CharacteristicPointType)));
                Assert.That(actualCharacteristicPoints[i].GeometryPoint.X, Is.EqualTo(expectedSurfaceLine2.CharacteristicPoints[i].Point.X).Within(GeometryConstants.Tolerance));
                Assert.That(actualCharacteristicPoints[i].GeometryPoint.Z, Is.EqualTo(expectedSurfaceLine2.CharacteristicPoints[i].Point.Z).Within(GeometryConstants.Tolerance));
            });
        }
    }

    private static void CompareSoilProfile2D(SoilProfile2D expectedSoilProfile, SoilProfileType actualSoilProfile, SoilType[] actualSoils)
    {
        Assert.Multiple(() =>
        {
            Assert.That(actualSoilProfile.SoilSurfaces, Has.Length.EqualTo(expectedSoilProfile.Surfaces.Count));
            Assert.That(actualSoilProfile.Geometry.Points, Has.Length.EqualTo(expectedSoilProfile.Geometry.Points.Count));
            Assert.That(actualSoilProfile.Geometry.Curves, Has.Length.EqualTo(expectedSoilProfile.Geometry.Curves.Count));
            Assert.That(actualSoilProfile.Geometry.GeometrySurfaces, Has.Length.EqualTo(expectedSoilProfile.Geometry.Surfaces.Count));
        });
        for (var i = 0; i < expectedSoilProfile.Surfaces.Count; i++)
        {
            Soil damSoil = InputConversionHelper.ConvertToDamSoil(actualSoils[actualSoilProfile.SoilSurfaces[i].Soil]);
            CompareSoil(damSoil, expectedSoilProfile.Surfaces[i].Soil);
            Assert.Multiple(() =>
            {
                Assert.That(actualSoilProfile.SoilSurfaces[i].WaterPressureInterpolationModel, Is.EqualTo(
                                InputConversionHelper.ConvertToMacroStabilityWaterPressureInterpolationModel(expectedSoilProfile.Surfaces[i].WaterpressureInterpolationModel)));
                Assert.That(actualSoilProfile.SoilSurfaces[i].IsAquifer, Is.EqualTo(expectedSoilProfile.Surfaces[i].IsAquifer));
            });
        }

        for (var j = 0; j < expectedSoilProfile.Geometry.Points.Count; j++)
        {
            Assert.Multiple(() =>
            {
                Assert.That(actualSoilProfile.Geometry.Points[j].X, Is.EqualTo(expectedSoilProfile.Geometry.Points[j].X).Within(GeometryConstants.Tolerance));
                Assert.That(actualSoilProfile.Geometry.Points[j].Z, Is.EqualTo(expectedSoilProfile.Geometry.Points[j].Z).Within(GeometryConstants.Tolerance));
            });
        }

        for (var j = 0; j < expectedSoilProfile.Geometry.Curves.Count; j++)
        {
            PointType headPoint = FindPointByKey(actualSoilProfile.Geometry.Curves[j].HeadPoint, actualSoilProfile.Geometry.Points);
            PointType endPoint = FindPointByKey(actualSoilProfile.Geometry.Curves[j].EndPoint, actualSoilProfile.Geometry.Points);
            Assert.Multiple(() =>
            {
                Assert.That(headPoint.X, Is.EqualTo(expectedSoilProfile.Geometry.Curves[j].HeadPoint.X).Within(GeometryConstants.Tolerance));
                Assert.That(headPoint.Z, Is.EqualTo(expectedSoilProfile.Geometry.Curves[j].HeadPoint.Z).Within(GeometryConstants.Tolerance));
                Assert.That(endPoint.X, Is.EqualTo(expectedSoilProfile.Geometry.Curves[j].EndPoint.X).Within(GeometryConstants.Tolerance));
                Assert.That(endPoint.Z, Is.EqualTo(expectedSoilProfile.Geometry.Curves[j].EndPoint.Z).Within(GeometryConstants.Tolerance));
            });
        }
    }

    private static PointType FindPointByKey(int pointKey, PointType[] points)
    {
        foreach (PointType point in points)
        {
            if (point.Key == pointKey)
            {
                return point;
            }
        }

        return null;
    }

    private static void CompareSoilModel(SoilList expectedSoils, SoilType[] actualSoils)
    {
        Assert.That(actualSoils, Has.Length.EqualTo(expectedSoils.Soils.Count), "Soil Count does not match");
        var i = 0;
        foreach (Soil expectedSoil in expectedSoils.Soils)
        {
            Soil actualSoil = InputConversionHelper.ConvertToDamSoil(actualSoils[i]);
            CompareSoil(actualSoil, expectedSoil);
            i++;
        }
    }

    private static void CompareSoil(Soil actualSoil, Soil expectedSoil)
    {
        Assert.Multiple(() =>
        {
            Assert.That(actualSoil.Name, Is.EqualTo(expectedSoil.Name));
            Assert.That(actualSoil, Is.Not.Null, $"Soil {expectedSoil.Name} not found");
        });
        var compare = new CompareLogic
        {
            Config =
            {
                MaxDifferences = 100,
                MembersToIgnore = soilParametersToIgnore
            }
        };
        ComparisonResult result = compare.Compare(expectedSoil, actualSoil);
        Assert.That(result.Differences, Is.Empty, "Differences found read/write kernel SoilModel");
    }

    private static void CompareStabilityModel(FailureMechanismParametersMStab expectedStabilityModel, StabilityInputType actualStabilityModel)
    {
        Assert.Multiple(() =>
        {
            Assert.That(actualStabilityModel.SearchAlgorithm, Is.EqualTo(InputConversionHelper.ConvertToMacroStabilitySearchMethod(expectedStabilityModel.MStabParameters.SearchMethod)));
            Assert.That(actualStabilityModel.ModelOption, Is.EqualTo(InputConversionHelper.ConvertToMacroStabilityModelOption(expectedStabilityModel.MStabParameters.Model)));
            Assert.That(actualStabilityModel.Orientation, Is.EqualTo(InputConversionHelper.ConvertToMacroStabilityGridOrientation(expectedStabilityModel.MStabParameters.GridPosition)));
        });
    }

    public class GivenDamKernelInput
    {
        private readonly DamKernelInput damKernelInput = CreateDamKernelInputWithForbiddenZone();
    
        [Test]
        [TestCase(0.0, 5.0)]
        [TestCase(0.2, 6.0)]
        [TestCase(1.0, 10.0)]
        public void WithForbiddenZone_WhenTransferSlipPlaneConstraints_ThenSlipPlaneConstraintsAreSet(double forbiddenZoneFactor,double xEntryMax)
        {
            damKernelInput.Location.StabilityOptions.ForbiddenZoneFactor = forbiddenZoneFactor;
            var macroStabilityInput = new FullInputModelType
            {
                StabilityModel = new StabilityInputType
                {
                    SlipPlaneConstraints = new SlipPlaneConstraintsType()
                }
            };
            // When
            FillMacroStabilityKernelInputFromEngine.DetermineSlipPlaneConstraints(damKernelInput.Location, macroStabilityInput.StabilityModel.SlipPlaneConstraints);
            Assert.Multiple(() =>
            {
                // Then
                Assert.That(macroStabilityInput.StabilityModel.SlipPlaneConstraints.SlipPlaneMinDepth, Is.EqualTo(1.5));
                Assert.That(macroStabilityInput.StabilityModel.SlipPlaneConstraints.XEntryMin, Is.EqualTo(1.0));
                Assert.That(macroStabilityInput.StabilityModel.SlipPlaneConstraints.XEntryMax, Is.EqualTo(xEntryMax));
            });
        }
    
        [Test]
        public void WithNoZones_WhenTransferSlipPlaneConstraints_ThenXEntryIsNotSet()
        {
            damKernelInput.Location.StabilityOptions.StabilityZoneType = StabilityZoneType.NoZones;
            var macroStabilityInput = new FullInputModelType
            {
                StabilityModel = new StabilityInputType
                {
                    SlipPlaneConstraints = new SlipPlaneConstraintsType()
                }
            };
            // When
            FillMacroStabilityKernelInputFromEngine.DetermineSlipPlaneConstraints(damKernelInput.Location, macroStabilityInput.StabilityModel.SlipPlaneConstraints);
            Assert.Multiple(() =>
            {
                // Then
                Assert.That(macroStabilityInput.StabilityModel.SlipPlaneConstraints.SlipPlaneMinDepth, Is.EqualTo(1.5));
                Assert.That(macroStabilityInput.StabilityModel.SlipPlaneConstraints.XEntryMin, Is.NaN);
                Assert.That(macroStabilityInput.StabilityModel.SlipPlaneConstraints.XEntryMax, Is.NaN);
            });
        }
    
        private static DamKernelInput CreateDamKernelInputWithForbiddenZone()
        {
            var surfaceLine = new SurfaceLine2()
            {
                CharacteristicPoints =
                {
                    GeometryMustContainPoint = true
                },
                Geometry = new GeometryPointString()
            };
            surfaceLine.EnsurePointOfType(1.0, 0, CharacteristicPointType.DikeTopAtRiver);
            surfaceLine.EnsurePointOfType(5.0, 0, CharacteristicPointType.DikeTopAtPolder);
            surfaceLine.EnsurePointOfType(10.0, 0, CharacteristicPointType.DikeToeAtPolder);
            var damKernelInput = new DamKernelInput
            {
                Location = new Location()
                {
                    SurfaceLine = surfaceLine,
                    StabilityOptions = new StabilityOptions
                    {
                        MinimalCircleDepth = 1.5,
                        StabilityZoneType = StabilityZoneType.ForbiddenZone,
                        ForbiddenZoneFactor = 0.2
                    }
                }
            };
            return damKernelInput;
        }
    }
}