// 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.Collections.Generic;
using System.Data;
using Deltares.DamEngine.Calculators.KernelWrappers.Common;
using Deltares.DamEngine.Calculators.KernelWrappers.Interfaces;
using Deltares.DamEngine.Calculators.KernelWrappers.WtiPipingSellmeijerRevised;
using Deltares.DamEngine.Data.Design;
using Deltares.DamEngine.Data.General;
using Deltares.DamEngine.Data.General.Results;
using Deltares.DamEngine.Data.Geotechnics;
using Deltares.DamEngine.Data.Standard.Calculation;
using Deltares.DamEngine.Data.Standard.Logging;
using Deltares.DamEngine.TestHelpers.Factories;
using Deltares.WTIPiping;
using NUnit.Framework;

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

[TestFixture]
public class WtiPipingSellmeijerRevisedKernelWrapperTests
{
    [Test]
    public void TestValidate()
    {
        var kernelWrapper = new WtiPipingSellmeijerRevisedKernelWrapper();

        // Validate without setting values. Expected error messages.
        var pipingInput = new WtiPipingSellmeijerRevisedInput();
        var pipingOutput = new WtiPipingSellmeijerRevisedOutput();
        kernelWrapper.Validate(pipingInput, pipingOutput, out List<LogMessage> messages);
        Assert.That(messages, Is.Not.Empty);

        // Validate the input when valid input is provided. Expected no messages.
        pipingInput = new WtiPipingSellmeijerRevisedInput
        {
            HRiver = 1.0,
            HExit = 0.0,
            Rc = 0.3,
            DTotal = 2.0,
            DAquifer = 8.0,
            SeepageLength = 40.5,
            D70 = 200.0,
            KinematicViscosityWater = 1.33E-06,
            DarcyPermeability = 0.0001,
            RExit = 0.25
        };
        messages.Clear();
        kernelWrapper.Validate(pipingInput, pipingOutput, out messages);
        Assert.That(messages, Is.Empty);
    }

    [Test]
    public void TestPostProcess()
    {
        var kernelWrapper = new WtiPipingSellmeijerRevisedKernelWrapper();

        var subSoilScenario = new SoilGeometryProbability
        {
            SoilProfile1D = FactoryForSoilProfiles.CreatePipingSellmeijerProfileWithOneSandLayer(out _),
            SegmentFailureMechanismType = SegmentFailureMechanismType.Piping
        };
        var damFailureMechanismeCalculationSpecification = new DamFailureMechanismeCalculationSpecification
        {
            FailureMechanismSystemType = FailureMechanismSystemType.Piping,
            PipingModelType = PipingModelType.Wti2017
        };
        var input = new DamKernelInput
        {
            Location = new Location(),
            SubSoilScenario = subSoilScenario,
            DamFailureMechanismeCalculationSpecification = damFailureMechanismeCalculationSpecification
        };
        input.Location = new Location();

        var upliftSituation = new UpliftSituation
        {
            IsUplift = true
        };
        var calculationResult = CalculationResult.Succeeded;
        var output = new WtiPipingSellmeijerRevisedOutput
        {
            SeepageLength = 30,
            FoSbe = 1.1,
            Hcbe = 2.2,
            DeltaPhiCbe = 1.3,
            DeltaPhibe = 11.3,
            ExitPointX = 3.3,
            UpliftFactor = 4.4,
            UpliftSituation = upliftSituation,
            CalculationResult = calculationResult,
            FoSu = 5.5,
            Hcu = 6.6,
            DeltaPhiCu = 7.7,
            FoSh = 3.4,
            Hch = 11.1,
            Gradient = 1.11,
            EffectiveStress = 321.21
        };

        var designScenario = new DesignScenario
        {
            LocationName = input.Location.Name
        };
        kernelWrapper.PostProcess(input, output, designScenario, "", out List<DesignResult> results);
        foreach (DesignResult result in results)
        {
            Assert.Multiple(() =>
            {
                Assert.That(result.PipingDesignResults.Wti2017BackwardErosionSafetyFactor, Is.EqualTo(output.FoSbe));
                Assert.That(result.PipingDesignResults.Wti2017BackwardErosionHcritical, Is.EqualTo(output.Hcbe));
                Assert.That(result.PipingDesignResults.Wti2017BackwardErosionDeltaPhiC, Is.EqualTo(output.DeltaPhiCbe));
                Assert.That(result.PipingDesignResults.Wti2017BackwardErosionDeltaPhiReduced, Is.EqualTo(output.DeltaPhibe));
                Assert.That(result.PipingDesignResults.Wti2017UpliftSafetyFactor, Is.EqualTo(output.FoSu));
                Assert.That(result.PipingDesignResults.Wti2017UpliftHcritical, Is.EqualTo(output.Hcu));
                Assert.That(result.PipingDesignResults.Wti2017UpliftDeltaPhiC, Is.EqualTo(output.DeltaPhiCu));
                Assert.That(result.PipingDesignResults.Wti2017HeaveSafetyFactor, Is.EqualTo(output.FoSh));
                Assert.That(result.PipingDesignResults.Wti2017HeaveHcritical, Is.EqualTo(output.Hch));
                Assert.That(result.PipingDesignResults.Wti2017Gradient, Is.EqualTo(output.Gradient));
                Assert.That(result.PipingDesignResults.EffectiveStress, Is.EqualTo(output.EffectiveStress));
                // CCreep is calculated by hand.
                Assert.That(result.PipingDesignResults.CCreep, Is.EqualTo(23.076923076923077));

                // Overall results (FoS and Hc) are taken from the case with maximum FoS from Uplift (u), Heave (h) and Backward Erorsion  (be)
                // Here this is uplift, so the results must be equal to those of Uplift.
                Assert.That(result.PipingDesignResults.Wti2017SafetyFactorOverall, Is.EqualTo(output.FoSu));
                Assert.That(result.PipingDesignResults.Wti2017HcriticalOverall, Is.EqualTo(output.Hcu));

                Assert.That(result.PipingDesignResults.LocalExitPointX, Is.EqualTo(output.ExitPointX));
                Assert.That(result.PipingDesignResults.UpliftFactor, Is.EqualTo(output.UpliftFactor));
                Assert.That(result.PipingDesignResults.UpliftSituation, Is.EqualTo(output.UpliftSituation));
                Assert.That(result.CalculationResult, Is.EqualTo(output.CalculationResult));

                Assert.That(result.PipingDesignResults.RedesignedSurfaceLine, Is.EqualTo(input.Location.SurfaceLine));
            });
        }
    }

    [Test]
    [SetUICulture("nl-NL")]
    public void TestLanguageNLThrowsExceptionInExecuteWhenInputIsNull()
    {
        var kernelWrapper = new WtiPipingSellmeijerRevisedKernelWrapper();
        List<LogMessage> messages;
        Assert.That(() => kernelWrapper.Execute(null, null, out messages), Throws.InstanceOf<NoNullAllowedException>().With.Message.EqualTo("Geen invoer object gedefinieerd voor WTI Sellmeijer Revised"));
    }

    [Test]
    [SetUICulture("en-US")]
    public void TestLanguageENThrowsExceptionInExecuteWhenInputIsNull()
    {
        var kernelWrapper = new WtiPipingSellmeijerRevisedKernelWrapper();
        List<LogMessage> messages;
        Assert.That(() => kernelWrapper.Execute(null, null, out messages), Throws.InstanceOf<NoNullAllowedException>().With.Message.EqualTo("No input object defined for WTI Sellmeijer Revised"));
    }

    [Test]
    [SetUICulture("nl-NL")]
    public void TestThrowsExceptionInPostProcessWhenOutputIsNull()
    {
        var kernelWrapper = new WtiPipingSellmeijerRevisedKernelWrapper();
        List<DesignResult> results;
        Assert.That(() => kernelWrapper.PostProcess(new DamKernelInput(), null, null, "", out results), Throws.InstanceOf<NoNullAllowedException>().With.Message.EqualTo("Geen uitvoer object gedefinieerd voor WTI Sellmeijer Revised"));
    }

    [Test]
    [SetUICulture("nl-NL")]
    public void TestThrowsExceptionInPostProcessWhenInputIsNull()
    {
        var kernelWrapper = new WtiPipingSellmeijerRevisedKernelWrapper();
        List<DesignResult> results;
        Assert.That(() => kernelWrapper.PostProcess(null, new WtiPipingSellmeijerRevisedOutput(), null, "", out results), Throws.InstanceOf<NoNullAllowedException>().With.Message.EqualTo("Geen invoer object gedefinieerd voor WTI Sellmeijer Revised"));
    }

    [Test]
    public void TestConvertToPipingSurfaceLine()
    {
        var kernelWrapper = new WtiPipingSellmeijerRevisedKernelWrapper();
        const double diff = 0.0001;
        SurfaceLine2 surfaceLine = FactoryForSurfaceLines.CreateSurfaceLineForWtiPiping(true);
        PipingSurfaceLine surfaceLinePiping = kernelWrapper.ConvertToPipingSurfaceLine(surfaceLine);
        Assert.That(surfaceLinePiping.Points, Has.Count.EqualTo(12));
        Assert.Multiple(() =>
        {
            // Check some coordinates and types
            Assert.That(surfaceLinePiping.Points[2].X, Is.EqualTo(34.5).Within(diff));
            Assert.That(surfaceLinePiping.Points[2].Z, Is.EqualTo(5).Within(diff));
            Assert.That(surfaceLinePiping.Points[2].Type, Is.EqualTo(PipingCharacteristicPointType.None));

            Assert.That(surfaceLinePiping.Points[4].X, Is.EqualTo(38.5).Within(diff));
            Assert.That(surfaceLinePiping.Points[4].Z, Is.EqualTo(5).Within(diff));
            Assert.That(surfaceLinePiping.Points[4].Type, Is.EqualTo(PipingCharacteristicPointType.None));

            Assert.That(surfaceLinePiping.Points[7].X, Is.EqualTo(58.5).Within(diff));
            Assert.That(surfaceLinePiping.Points[7].Z, Is.EqualTo(0).Within(diff));
            Assert.That(surfaceLinePiping.Points[7].Type, Is.EqualTo(PipingCharacteristicPointType.DitchDikeSide));

            Assert.That(surfaceLinePiping.Points[9].X, Is.EqualTo(61.5).Within(diff));
            Assert.That(surfaceLinePiping.Points[9].Z, Is.EqualTo(-1).Within(diff));
            Assert.That(surfaceLinePiping.Points[9].Type, Is.EqualTo(PipingCharacteristicPointType.BottomDitchPolderSide));
        });
    }

    [Test]
    public void TestConvertToPipingProfile()
    {
        const double diff = 0.0001;
        var kernelWrapper = new WtiPipingSellmeijerRevisedKernelWrapper();
        SoilProfile1D profile = FactoryForSoilProfiles.CreatePipingSellmeijerProfileWithOneSandLayer(out _);
        PipingProfile profilePiping = kernelWrapper.ConvertToPipingProfile(profile);
        Assert.That(profilePiping.Layers, Has.Count.EqualTo(2));

        Assert.Multiple(() =>
        {
            Assert.That(profilePiping.Layers[0].TopLevel, Is.EqualTo(10).Within(diff));
            Assert.That(profilePiping.Layers[0].AbovePhreaticLevel, Is.EqualTo(11).Within(diff));
            Assert.That(profilePiping.Layers[0].BelowPhreaticLevel, Is.EqualTo(14).Within(diff));
            Assert.That(profilePiping.Layers[0].IsAquifer, Is.EqualTo(false));
            Assert.That(profilePiping.Layers[0].DryUnitWeight, Is.EqualTo(11).Within(diff));

            Assert.That(profilePiping.Layers[1].TopLevel, Is.EqualTo(-2).Within(diff));
            Assert.That(profilePiping.Layers[1].AbovePhreaticLevel, Is.EqualTo(20).Within(diff));
            Assert.That(profilePiping.Layers[1].BelowPhreaticLevel, Is.EqualTo(22).Within(diff));
            Assert.That(profilePiping.Layers[1].IsAquifer, Is.EqualTo(true));
            Assert.That(profilePiping.Layers[1].DryUnitWeight, Is.EqualTo(20).Within(diff));

            Assert.That(profilePiping.BottomLevel, Is.EqualTo(-10).Within(diff));
        });
    }

    [Test]
    public void TestAssignFailedValuesWtiUplift()
    {
        var kernelWrapper = new WtiPipingSellmeijerRevisedKernelWrapper();
        var output = new WtiPipingSellmeijerRevisedOutput();
        //  Uplift 
        output.FoSu = 1;
        output.Hcu = 1;
        output.DeltaPhiCu = 1;
        // Heave
        output.FoSh = 1;
        output.Hch = 1;
        output.Gradient = 1;
        // Sellmeijer revised
        output.FoSbe = 1;
        output.Hcbe = 1;
        output.DeltaPhiCbe = 1;
        kernelWrapper.AssignFailedValuesWtiUplift(output);
        Assert.Multiple(() =>
        {
            //  Uplift 
            Assert.That(output.FoSu, Is.EqualTo(0));
            Assert.That(output.Hcu, Is.EqualTo(0));
            Assert.That(output.DeltaPhiCu, Is.EqualTo(0));
            // Heave
            Assert.That(output.FoSh, Is.EqualTo(1));
            Assert.That(output.Hch, Is.EqualTo(1));
            Assert.That(output.Gradient, Is.EqualTo(1));
            // Sellmeijer revised
            Assert.That(output.FoSbe, Is.EqualTo(1));
            Assert.That(output.Hcbe, Is.EqualTo(1));
            Assert.That(output.DeltaPhiCbe, Is.EqualTo(1));
        });
    }

    [Test]
    public void TestAssignFailedValuesWtiHeave()
    {
        var kernelWrapper = new WtiPipingSellmeijerRevisedKernelWrapper();
        var output = new WtiPipingSellmeijerRevisedOutput();
        //  Uplift 
        output.FoSu = 1;
        output.Hcu = 1;
        output.DeltaPhiCu = 1;
        // Heave
        output.FoSh = 1;
        output.Hch = 1;
        output.Gradient = 1;
        // Sellmeijer revised
        output.FoSbe = 1;
        output.Hcbe = 1;
        output.DeltaPhiCbe = 1;
        kernelWrapper.AssignFailedValuesWtiHeave(output);
        Assert.Multiple(() =>
        {
            //  Uplift 
            Assert.That(output.FoSu, Is.EqualTo(1));
            Assert.That(output.Hcu, Is.EqualTo(1));
            Assert.That(output.DeltaPhiCu, Is.EqualTo(1));
            // Heave
            Assert.That(output.FoSh, Is.EqualTo(0));
            Assert.That(output.Hch, Is.EqualTo(0));
            Assert.That(output.Gradient, Is.EqualTo(0));
            // Sellmeijer revised
            Assert.That(output.FoSbe, Is.EqualTo(1));
            Assert.That(output.Hcbe, Is.EqualTo(1));
            Assert.That(output.DeltaPhiCbe, Is.EqualTo(1));
        });
    }

    [Test]
    public void TestAssignFailedValuesWtiSellmeijerRevised()
    {
        var kernelWrapper = new WtiPipingSellmeijerRevisedKernelWrapper();
        var output = new WtiPipingSellmeijerRevisedOutput();
        //  Uplift 
        output.FoSu = 1;
        output.Hcu = 1;
        output.DeltaPhiCu = 1;
        // Heave
        output.FoSh = 1;
        output.Hch = 1;
        output.Gradient = 1;
        // Sellmeijer revised
        output.FoSbe = 1;
        output.Hcbe = 1;
        output.DeltaPhiCbe = 1;
        kernelWrapper.AssignFailedValuesWtiSellmeijerRevised(output);
        Assert.Multiple(() =>
        {
            //  Uplift 
            Assert.That(output.FoSu, Is.EqualTo(1));
            Assert.That(output.Hcu, Is.EqualTo(1));
            Assert.That(output.DeltaPhiCu, Is.EqualTo(1));
            // Heave
            Assert.That(output.FoSh, Is.EqualTo(1));
            Assert.That(output.Hch, Is.EqualTo(1));
            Assert.That(output.Gradient, Is.EqualTo(1));
            // Sellmeijer revised
            Assert.That(output.FoSbe, Is.EqualTo(0));
            Assert.That(output.Hcbe, Is.EqualTo(0));
            Assert.That(output.DeltaPhiCbe, Is.EqualTo(0));
        });
    }

    [Test]
    public void TestAddMessageToCalculationMessages()
    {
        var kernelDataOutput = new WtiPipingSellmeijerRevisedOutput();
        var message = new LogMessage
        {
            Message = "Warning during calculation",
            MessageType = LogMessageType.Warning
        };
        kernelDataOutput.Message = message;
        var logMessages = new List<LogMessage>();
        IKernelWrapper kernelWrapper = new WtiPipingSellmeijerRevisedKernelWrapper();

        kernelWrapper.AddMessageToCalculationMessages(kernelDataOutput, logMessages);

        Assert.That(logMessages, Has.Count.EqualTo(1));
        Assert.That(logMessages[0], Is.EqualTo(message));
    }

    [TestCase(0, 49.5, 1860.9050036726026, 1302.9335025708217, 1302.6335025708217, 0.037999943884683543)]
    [TestCase(10, 59.5, 2196.3999536424808, 1537.7799675497363, 1537.4799675497363, 0.038699691219277771)]
    [TestCase(-10, 39.5, 1519.6869237263827, 1064.0808466084677, 1063.7808466084678, 0.037131708214086942)]
    public void TestFullCalculation(double distanceToEntryPoint, double expectedSeepageLength, double expectedFoSbe, double expectedHcbe,
                                    double expectedDeltaPhiCbe, double expectedCcreep)
    {
        // expected results are based on test in Sellmeijer2011CalculatorTests, CalculateTestValues
        // as performed in the Wti kernel itself.

        const double diff = 0.0001;

        var subSoilScenario = new SoilGeometryProbability
        {
            SoilProfile1D = FactoryForSoilProfiles.CreatePipingSellmeijerProfileWithOneSandLayer(out SoilList soilList),
            SegmentFailureMechanismType = SegmentFailureMechanismType.Piping
        };

        var location = new Location("Location 1")
        {
            DistanceToEntryPoint = distanceToEntryPoint,
            SurfaceLine = FactoryForSurfaceLines.CreateSurfaceLineForWtiPiping(),
            ModelParametersForPlLines =
            {
                DampingFactorPl3 = 0.25,
                DampingFactorPl4 = 0.10
            },
            DikeEmbankmentMaterial = soilList.Soils[0].Name,
            SoilList = soilList
        };

        var designScenario = new DesignScenario
        {
            LocationScenarioID = "1",
            LocationName = location.Name,
            UpliftCriterionPiping = 1.0
        };
        location.CurrentScenario = designScenario;

        var damFailureMechanismeCalculationSpecification = new DamFailureMechanismeCalculationSpecification
        {
            FailureMechanismSystemType = FailureMechanismSystemType.Piping,
            PipingModelType = PipingModelType.Wti2017
        };
        var damKernelInput = new DamKernelInput
        {
            Location = location,
            SubSoilScenario = subSoilScenario,
            RiverLevelHigh = 1.0,
            DamFailureMechanismeCalculationSpecification = damFailureMechanismeCalculationSpecification
        };

        var kernelWrapper = new WtiPipingSellmeijerRevisedKernelWrapper();

        // Prepare the wrapper. Result is input for the calculation dll
        kernelWrapper.Prepare(damKernelInput, 0, out IKernelDataInput pipingInput, out IKernelDataOutput kernelDataOutput);

        // The factory used here in the Engine to create the soilprofile uses Physics.FactorMicroMeterToMeter in setting the D70.
        // The original test in WTI piping kernel uses the D70 without this factor so in order to get the same results here, 
        // correct the D70 for this here.
        (pipingInput as WtiPipingSellmeijerRevisedInput).D70 = (pipingInput as WtiPipingSellmeijerRevisedInput).D70 * (1 / Physics.FactorMicroMeterToMeter);

        // Validate the input
        List<LogMessage> messages;
        kernelWrapper.Validate(pipingInput, kernelDataOutput, out messages);
        Assert.That(messages, Is.Empty);

        // Run the dll. All expected results are from calculation by hand.
        kernelWrapper.Execute(pipingInput, kernelDataOutput, out messages);
        var pipingOutput = (WtiPipingSellmeijerRevisedOutput) kernelDataOutput;
        Assert.Multiple(() =>
        {
            Assert.That(messages, Is.Empty);
            Assert.That(pipingOutput.FoSbe, Is.EqualTo(expectedFoSbe).Within(diff));
            Assert.That(pipingOutput.Hcbe, Is.EqualTo(expectedHcbe).Within(diff));
            Assert.That(pipingOutput.DeltaPhiCbe, Is.EqualTo(expectedDeltaPhiCbe).Within(diff));
            Assert.That(pipingOutput.FoSu, Is.EqualTo(0.56948691811077123).Within(diff));
            Assert.That(pipingOutput.Hcu, Is.EqualTo(0.56948691811077123).Within(diff));
            Assert.That(pipingOutput.DeltaPhiCu, Is.EqualTo(0.4271151885830784).Within(diff));
            Assert.That(pipingOutput.EffectiveStress, Is.EqualTo(4.19).Within(diff));
            Assert.That(pipingOutput.SeepageLength, Is.EqualTo(expectedSeepageLength).Within(diff));
        });

        // Fill the design results
        List<DesignResult> results;
        kernelWrapper.PostProcess(damKernelInput, pipingOutput, designScenario, "", out results);
        foreach (DesignResult result in results)
        {
            Assert.Multiple(() =>
            {
                Assert.That(result.DamFailureMechanismeCalculation.FailureMechanismSystemType, Is.EqualTo(FailureMechanismSystemType.Piping));
                Assert.That(result.DamFailureMechanismeCalculation.PipingModelType, Is.EqualTo(PipingModelType.Wti2017));
                Assert.That(result.LocationName, Is.Not.Null.Or.Empty);
                Assert.That(result.ScenarioName, Is.Not.Null.Or.Empty);
                Assert.That(result.ProfileName, Is.Not.Null.Or.Empty);
                Assert.That(result.PipingDesignResults.Wti2017BackwardErosionSafetyFactor, Is.EqualTo(90).Within(diff));
                Assert.That(result.PipingDesignResults.Wti2017BackwardErosionHcritical, Is.EqualTo(expectedHcbe).Within(diff));
                Assert.That(result.PipingDesignResults.Wti2017BackwardErosionDeltaPhiC, Is.EqualTo(expectedDeltaPhiCbe).Within(diff));
                Assert.That(result.PipingDesignResults.Wti2017BackwardErosionDeltaPhiReduced, Is.EqualTo(0.70).Within(diff));
                Assert.That(result.PipingDesignResults.Wti2017UpliftSafetyFactor, Is.EqualTo(0.56948691811077123).Within(diff));
                Assert.That(result.PipingDesignResults.Wti2017UpliftHcritical, Is.EqualTo(0.56948691811077123).Within(diff));
                Assert.That(result.PipingDesignResults.Wti2017UpliftDeltaPhiC, Is.EqualTo(0.4271151885830784).Within(diff));
                Assert.That(result.PipingDesignResults.Wti2017HeaveSafetyFactor, Is.EqualTo(0.40).Within(diff));
                Assert.That(result.PipingDesignResults.Wti2017HeaveHcritical, Is.EqualTo(0.40).Within(diff));
                Assert.That(result.PipingDesignResults.Wti2017Gradient, Is.EqualTo(0.75).Within(diff));
                Assert.That(result.PipingDesignResults.EffectiveStress, Is.EqualTo(4.19).Within(diff));
                Assert.That(result.PipingDesignResults.CCreep, Is.EqualTo(expectedCcreep).Within(diff));

                Assert.That(result.PipingDesignResults.Wti2017SafetyFactorOverall, Is.EqualTo(90).Within(diff));
                Assert.That(result.PipingDesignResults.Wti2017HcriticalOverall, Is.EqualTo(expectedHcbe).Within(diff));

                Assert.That(result.PipingDesignResults.LocalExitPointX, Is.EqualTo(59.5));
                Assert.That(result.PipingDesignResults.UpliftFactor, Is.EqualTo(0.88258734130293759));
                Assert.That(result.PipingDesignResults.UpliftSituation != null && ((UpliftSituation) result.PipingDesignResults.UpliftSituation).IsUplift, Is.EqualTo(true));
                Assert.That(result.CalculationResult, Is.EqualTo(CalculationResult.Succeeded));

                Assert.That(result.PipingDesignResults.RedesignedSurfaceLine, Is.EqualTo(location.SurfaceLine));
            });
        }
    }

    [TestCase(0, 49.5)]
    [TestCase(10, 59.5)]
    [TestCase(-10, 39.5)]
    public void TestPrepareWithInfluenceOfDistanceToEntryPoint(double distanceToEntryPoint, double expectedSeepageLength)
    {
        const double diff = 0.0001;

        var subSoilScenario = new SoilGeometryProbability
        {
            SoilProfile1D = FactoryForSoilProfiles.CreatePipingSellmeijerProfileWithOneSandLayer(out SoilList soilList),
            SegmentFailureMechanismType = SegmentFailureMechanismType.Piping
        };
        var location = new Location
        {
            DistanceToEntryPoint = distanceToEntryPoint,
            SurfaceLine = FactoryForSurfaceLines.CreateSurfaceLineForWtiPiping(),
            ModelParametersForPlLines =
            {
                DampingFactorPl3 = 0.25,
                DampingFactorPl4 = 0.10
            },
            CurrentScenario = new DesignScenario(),
            DikeEmbankmentMaterial = soilList.Soils[0].Name,
            SoilList = soilList
        };
        location.CurrentScenario.UpliftCriterionPiping = 1.0;
        var damFailureMechanismeCalculationSpecification = new DamFailureMechanismeCalculationSpecification
        {
            FailureMechanismSystemType = FailureMechanismSystemType.Piping,
            PipingModelType = PipingModelType.Wti2017
        };

        var damKernelInput = new DamKernelInput
        {
            Location = location,
            SubSoilScenario = subSoilScenario,
            RiverLevelHigh = 1.0,
            DamFailureMechanismeCalculationSpecification = damFailureMechanismeCalculationSpecification
        };
        var kernelWrapper = new WtiPipingSellmeijerRevisedKernelWrapper();
        IKernelDataInput kernelDataInput;
        IKernelDataOutput kernelDataOutput;
        kernelWrapper.Prepare(damKernelInput, 0, out kernelDataInput, out kernelDataOutput);
        var pipingInput = (WtiPipingSellmeijerRevisedInput) kernelDataInput;
        var pipingOutput = (WtiPipingSellmeijerRevisedOutput) kernelDataOutput;
        Assert.Multiple(() =>
        {
            Assert.That(pipingInput.HRiver, Is.EqualTo(1.0).Within(diff));
            Assert.That(pipingInput.HExit, Is.EqualTo(0.0).Within(diff));
            Assert.That(pipingInput.Rc, Is.EqualTo(0.3).Within(diff));
            Assert.That(pipingInput.DTotal, Is.EqualTo(1.0).Within(diff));
            Assert.That(pipingInput.DAquifer, Is.EqualTo(8.0).Within(diff));
            Assert.That(pipingInput.SeepageLength, Is.EqualTo(expectedSeepageLength).Within(diff));
            Assert.That(pipingInput.D70, Is.EqualTo(0.000200).Within(diff));
            Assert.That(pipingInput.WhitesDragCoefficient, Is.EqualTo(0.25).Within(diff));
            Assert.That(pipingInput.BeddingAngle, Is.EqualTo(37.0).Within(diff));
            Assert.That(pipingInput.KinematicViscosityWater, Is.EqualTo(1.33E-06).Within(diff));
            Assert.That(pipingInput.DarcyPermeability, Is.EqualTo(0.0001).Within(diff));
            Assert.That(pipingInput.ModelFactorUplift, Is.EqualTo(1.000).Within(diff));
            Assert.That(pipingInput.EffectiveStress, Is.EqualTo(4.19).Within(diff));
            Assert.That(pipingInput.PhiExit, Is.EqualTo(0.75).Within(diff));
            Assert.That(pipingInput.RExit, Is.EqualTo(0.75).Within(diff));
            Assert.That(pipingInput.PhiPolder, Is.EqualTo(0.00).Within(diff));
            // All expected results are from calculation by hand.
            Assert.That(pipingOutput.EffectiveStress, Is.EqualTo(4.19).Within(diff));
            Assert.That(pipingOutput.ExitPointX, Is.EqualTo(59.50).Within(diff));
            Assert.That(pipingOutput.UpliftFactor, Is.EqualTo(0.88258734130293759).Within(diff));
            Assert.That(pipingOutput.UpliftSituation.IsUplift, Is.EqualTo(true));
        });
    }

    [TestCase(CharacteristicPointType.BottomDitchPolderSide, PipingCharacteristicPointType.BottomDitchPolderSide)]
    [TestCase(CharacteristicPointType.BottomDitchDikeSide, PipingCharacteristicPointType.BottomDitchDikeSide)]
    [TestCase(CharacteristicPointType.DikeLine, PipingCharacteristicPointType.None)]
    [TestCase(CharacteristicPointType.DikeToeAtPolder, PipingCharacteristicPointType.DikeToeAtPolder)]
    [TestCase(CharacteristicPointType.DikeToeAtRiver, PipingCharacteristicPointType.None)]
    [TestCase(CharacteristicPointType.DikeTopAtPolder, PipingCharacteristicPointType.None)]
    [TestCase(CharacteristicPointType.DikeTopAtRiver, PipingCharacteristicPointType.None)]
    [TestCase(CharacteristicPointType.DitchDikeSide, PipingCharacteristicPointType.DitchDikeSide)]
    [TestCase(CharacteristicPointType.DitchPolderSide, PipingCharacteristicPointType.DitchPolderSide)]
    [TestCase(CharacteristicPointType.None, PipingCharacteristicPointType.None)]
    [TestCase(CharacteristicPointType.ShoulderBaseInside, PipingCharacteristicPointType.ShoulderBaseInside)]
    [TestCase(CharacteristicPointType.ShoulderBaseOutside, PipingCharacteristicPointType.None)]
    [TestCase(CharacteristicPointType.ShoulderTopInside, PipingCharacteristicPointType.None)]
    [TestCase(CharacteristicPointType.ShoulderTopOutside, PipingCharacteristicPointType.None)]
    [TestCase(CharacteristicPointType.SurfaceLevelInside, PipingCharacteristicPointType.None)]
    [TestCase(CharacteristicPointType.SurfaceLevelOutside, PipingCharacteristicPointType.None)]
    [TestCase(CharacteristicPointType.TrafficLoadInside, PipingCharacteristicPointType.None)]
    [TestCase(CharacteristicPointType.TrafficLoadOutside, PipingCharacteristicPointType.None)]
    public void TestConvertToPipingPointType(CharacteristicPointType charPointType, PipingCharacteristicPointType pipingCharacteristicPointType)
    {
        var kernelWrapper = new WtiPipingSellmeijerRevisedKernelWrapper();
        Assert.That(kernelWrapper.ConvertToPipingPointType(charPointType), Is.EqualTo(pipingCharacteristicPointType));
    }
}