// 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.Globalization;
using System.IO;
using System.Threading;
using Deltares.DamEngine.Data.General;
using Deltares.DamEngine.Data.Geotechnics;
using Deltares.DamEngine.Data.Standard.Calculation;
using Deltares.DamEngine.Interface;
using Deltares.DamEngine.Io;
using Deltares.DamEngine.Io.XmlOutput;
using Deltares.DamEngine.TestHelpers;
using NUnit.Framework;
using ConversionHelper = Deltares.DamEngine.Interface.ConversionHelper;

namespace Deltares.DamEngine.IntegrationTests.IntegrationTests;

[TestFixture]
public class WtiPipingSellmeijerRevisedTests
{
    private const double tolerance = 0.0005;
    private const string workingDir = @"TestFiles\";
    private string oldWorkingDir;

    [SetUp]
    public void TestFixtureSetup()
    {
        oldWorkingDir = Directory.GetCurrentDirectory();
        Directory.SetCurrentDirectory(workingDir);
    }

    [TearDown]
    public void TestFixtureTearDown()
    {
        Directory.SetCurrentDirectory(oldWorkingDir);
    }

    /// <summary>Test for different segmentFailureMechanismType</summary>
    /// <param name="segmentFailureMechanismType">The soilprobabilities are set tot the specified segmentFailureMechanismType</param>
    [Test]
    [TestCase(ConversionHelper.InputSegmentFailureMechanismPiping)]
    [TestCase(ConversionHelper.InputSegmentFailureMechanismAll)]
    public void CanPerformWtiDesignNoAdaptionPipingVoorbeeld1(int segmentFailureMechanismType)
    {
        // Based on ".\data\DamEngineTestProjects\PipingVoorbeeld1\PipingVoorbeeld1.damx"
        // Set Analysis type to "No Adaption"
        // Change Failure mechanism Piping to model Sellmeijer Revised (WBI)
        const string fileName = @"PipingVoorbeeld1_WtiSellmeijerRevisedInputFile.xml";
        string inputString = File.ReadAllText(fileName);
        inputString = XmlAdapter.ChangeValueInXml(inputString, "SegmentFailureMechanismType", segmentFailureMechanismType.ToString());

        Output output = GeneralHelper.RunAfterInputValidation(inputString);

        DamProjectData actualDamProjectData = FillDamFromXmlOutput.CreateDamProjectData(null, output);
        SurfaceLine2 redesignedSurfaceLine = actualDamProjectData.DesignCalculations[0].PipingDesignResults.RedesignedSurfaceLine;

        // The expected values below where calculated with DamEngine rev.2012,
        // Piping factor = 0.432
        Assert.That(output.Results.CalculationResults[0].PipingDesignResults.Wti2017FactorOverall, Is.EqualTo(0.432).Within(tolerance));
        // H critical = 1.983
        Assert.That(output.Results.CalculationResults[0].PipingDesignResults.Wti2017HcriticalOverall, Is.EqualTo(1.983).Within(tolerance));
        // Piping exit point = 35.0
        Assert.That(output.Results.CalculationResults[0].PipingDesignResults.ExitPointX, Is.EqualTo(35.0).Within(tolerance));
        // Dike length = 25.00
        Assert.That(redesignedSurfaceLine.GetDikeLength(), Is.EqualTo(25.00).Within(tolerance));
        // Uplift = true
        Assert.That(output.Results.CalculationResults[0].PipingDesignResults.UpliftSituation.IsUplift, Is.EqualTo(true));
        // Uplift factor = 0.582
        Assert.That(output.Results.CalculationResults[0].PipingDesignResults.UpliftFactor, Is.EqualTo(0.582).Within(tolerance));
        // The adjusted PL3/PL4: for piping no adjustment has to be made
        Assert.That(output.Results.CalculationResults[0].PipingDesignResults.UpliftSituation.Pl3MinUplift, Is.EqualTo(0.0).Within(tolerance));
        Assert.That(output.Results.CalculationResults[0].PipingDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(0.0).Within(tolerance));
        Assert.That(output.Results.CalculationResults[0].PipingDesignResults.UpliftSituation.Pl3LocationXMinUplift, Is.EqualTo(0.0).Within(tolerance));
        Assert.That(output.Results.CalculationResults[0].PipingDesignResults.UpliftSituation.Pl4MinUplift, Is.EqualTo(0.0).Within(tolerance));
        Assert.That(output.Results.CalculationResults[0].PipingDesignResults.UpliftSituation.Pl4HeadAdjusted, Is.EqualTo(0.0).Within(tolerance));
        Assert.That(output.Results.CalculationResults[0].PipingDesignResults.UpliftSituation.Pl4LocationXMinUplift, Is.EqualTo(0.0).Within(tolerance));
    }

    [Test]
    public void CanPerformWtiSellmeijerRevisedDesignWithAdaptionPipingVoorbeeld1()
    {
        // Based on ".\data\DamEngineTestProjects\PipingVoorbeeld1\PipingVoorbeeld1.damx"
        // Set Analysis type to "Adapt geometry"
        // Change Failure mechanism Piping to model Sellmeijer Revised (WBI)
        const string fileName = @"PipingVoorbeeld1_WtiSellmeijerRevisedDesignInputFile.xml";
        string inputString = File.ReadAllText(fileName);

        Output output = GeneralHelper.RunAfterInputValidation(inputString);

        DamProjectData actualDamProjectData = FillDamFromXmlOutput.CreateDamProjectData(null, output);
        SurfaceLine2 redesignedSurfaceLine = actualDamProjectData.DesignCalculations[0].PipingDesignResults.RedesignedSurfaceLine;

        // The expected values below where calculated with DamEngine rev.2012,
        // uplift = true
        Assert.That(output.Results.CalculationResults[0].PipingDesignResults.UpliftSituation.IsUplift, Is.EqualTo(true));
        // shoulder height = 1.995
        Assert.That(redesignedSurfaceLine.DetermineShoulderHeight(), Is.EqualTo(1.995).Within(tolerance));
        // Note Bka: Answers here are 17 meter longer shoulder than Sellmeijer4Forces from which these tests are derived.
        // dike length = 66.986 + 17
        Assert.That(redesignedSurfaceLine.GetDikeLength(), Is.EqualTo(83.986).Within(tolerance));

        // ShoulderWidth = X_Kruin binnenberm - X_Insteek binnenberm = 65.01 + 17 - 29.01 = 53.0 
        Assert.That(redesignedSurfaceLine.DetermineShoulderLength(), Is.EqualTo(53.0).Within(tolerance));

        Assert.That(output.Results.CalculationResults[0].PipingDesignResults.UpliftSituation.Pl3MinUplift, Is.EqualTo(0.0).Within(tolerance));
        Assert.That(output.Results.CalculationResults[0].PipingDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(0.0).Within(tolerance));
        Assert.That(output.Results.CalculationResults[0].PipingDesignResults.UpliftSituation.Pl3LocationXMinUplift, Is.EqualTo(0.0).Within(tolerance));
        Assert.That(output.Results.CalculationResults[0].PipingDesignResults.UpliftSituation.Pl4MinUplift, Is.EqualTo(0.0).Within(tolerance));
        Assert.That(output.Results.CalculationResults[0].PipingDesignResults.UpliftSituation.Pl4HeadAdjusted, Is.EqualTo(0.0).Within(tolerance));
        Assert.That(output.Results.CalculationResults[0].PipingDesignResults.UpliftSituation.Pl4LocationXMinUplift, Is.EqualTo(0.0).Within(tolerance));

        // ExitPointX = X_Teen dijk binnenwaarts = 76.986 + 17
        Assert.That(output.Results.CalculationResults[0].PipingDesignResults.ExitPointX, Is.EqualTo(93.986).Within(tolerance));

        // expected value = 1.280
        Assert.That(output.Results.CalculationResults[0].PipingDesignResults.Wti2017BackwardErosionFactor, Is.EqualTo(1.280).Within(tolerance));
        // expected value = 4.697
        Assert.That(output.Results.CalculationResults[0].PipingDesignResults.Wti2017BackwardErosionHcritical, Is.EqualTo(4.697).Within(tolerance));

        // expected value = 0.582
        Assert.That(output.Results.CalculationResults[0].PipingDesignResults.UpliftFactor, Is.EqualTo(0.582).Within(tolerance));
    }

    [Test]
    public void CanPerformWtiSellmeijerRevisedDesignWithAdaptionWithHeightPipingVoorbeeld1()
    {
        // Based on ".\data\DamEngineTestProjects\PipingVoorbeeld1\PipingVoorbeeld1.damx"
        // Set Analysis type to "Adapt geometry"
        // Change Failure mechanism Piping to model Sellmeijer Revised (WBI)
        // Set DTH = 4.5 for location "profiel 1"
        const string fileName = @"PipingVoorbeeld1_WtiSellmeijerRevisedDesignHeightInputFile.xml";
        string inputString = File.ReadAllText(fileName);

        Output output = GeneralHelper.RunAfterInputValidation(inputString);

        DamProjectData actualDamProjectData = FillDamFromXmlOutput.CreateDamProjectData(null, output);
        SurfaceLine2 redesignedSurfaceLine = actualDamProjectData.DesignCalculations[0].PipingDesignResults.RedesignedSurfaceLine;

        // The expected values below where calculated with DamEngine rev.2012,
        // The following test are different from CanPerformWtiSellmeijerRevisedDesignWithAdaptionPipingVoorbeeld1()
        Assert.That(redesignedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver).Z, Is.EqualTo(4.5).Within(tolerance));
        Assert.That(redesignedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z, Is.EqualTo(4.5).Within(tolerance));

        // Note Bka: Answers here are 17 meter longer shoulder than Sellmeijer4Forces from which these tests are derived.
        // ShoulderWidth = X_Kruin binnenberm - X_Insteek binnenberm = 65.01 - 32.01 = 33.0 + 17 = 50
        Assert.That(redesignedSurfaceLine.DetermineShoulderLength(), Is.EqualTo(50.0).Within(tolerance));

        // The following test are the same as for CanPerformWtiSellmeijerRevisedDesignWithAdaptionPipingVoorbeeld1()
        Assert.That(output.Results.CalculationResults[0].PipingDesignResults.UpliftSituation.IsUplift, Is.EqualTo(true));
        Assert.That(redesignedSurfaceLine.DetermineShoulderHeight(), Is.EqualTo(1.995).Within(tolerance));
        Assert.That(redesignedSurfaceLine.GetDikeLength(), Is.EqualTo(83.986).Within(tolerance));
        Assert.That(output.Results.CalculationResults[0].PipingDesignResults.UpliftSituation.Pl3MinUplift, Is.EqualTo(0.0).Within(tolerance));
        Assert.That(output.Results.CalculationResults[0].PipingDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(0.0).Within(tolerance));
        Assert.That(output.Results.CalculationResults[0].PipingDesignResults.UpliftSituation.Pl3LocationXMinUplift, Is.EqualTo(0.0).Within(tolerance));
        Assert.That(output.Results.CalculationResults[0].PipingDesignResults.UpliftSituation.Pl4MinUplift, Is.EqualTo(0.0).Within(tolerance));
        Assert.That(output.Results.CalculationResults[0].PipingDesignResults.UpliftSituation.Pl4HeadAdjusted, Is.EqualTo(0.0).Within(tolerance));
        Assert.That(output.Results.CalculationResults[0].PipingDesignResults.UpliftSituation.Pl4LocationXMinUplift, Is.EqualTo(0.0).Within(tolerance));
        Assert.That(output.Results.CalculationResults[0].PipingDesignResults.Wti2017BackwardErosionFactor, Is.EqualTo(1.280).Within(tolerance));
        Assert.That(output.Results.CalculationResults[0].PipingDesignResults.Wti2017BackwardErosionHcritical, Is.EqualTo(4.697).Within(tolerance));
        Assert.That(output.Results.CalculationResults[0].PipingDesignResults.UpliftFactor, Is.EqualTo(0.582).Within(tolerance));
    }

    [Test]
    public void CanPerformWtiDesignNoAdaptionRechterDiezedijk()
    {
        // Based on ".\data\DamEngineTestProjects\Larenstein_AaenMaas\Rechter Diezedijk.damx"
        // Set Analysis type to "No Adaption"
        // Set model to Piping Sellmeijer Revised (WBI)
        // Select all locations
        const string fileName = @"Rechter Diezedijk_WtiSellmeijerRevisedInputFile.xml";
        string inputString = File.ReadAllText(fileName);

        Output output = GeneralHelper.RunAfterInputValidation(inputString);

        Assert.Multiple(() =>
        {
            Assert.That(output.Results.CalculationResults, Has.Length.EqualTo(112));
            Assert.That(ConversionHelper.ConvertToCalculationResult(output.Results.CalculationResults[0].CalculationResult), Is.EqualTo(CalculationResult.Succeeded));
        });
        Assert.Multiple(() =>
        {
            Assert.That(output.Results.CalculationResults[0].PipingDesignResults.Wti2017FactorOverall, Is.EqualTo(90.000).Within(tolerance));
            Assert.That(ConversionHelper.ConvertToCalculationResult(output.Results.CalculationResults[2].CalculationResult), Is.EqualTo(CalculationResult.Succeeded));
            Assert.That(output.Results.CalculationResults[2].PipingDesignResults.Wti2017FactorOverall, Is.EqualTo(58.241).Within(tolerance));
            Assert.That(ConversionHelper.ConvertToCalculationResult(output.Results.CalculationResults[111].CalculationResult), Is.EqualTo(CalculationResult.RunFailed));
            Assert.That(output.Results.CalculationResults[111].PipingDesignResults.Wti2017FactorOverall, Is.EqualTo(0.000).Within(tolerance));
        });
    }

    [Test, Category(Categories.MultiCore)]
    // This test runs the same project as CanPerformWtiDesignNoAdaptionRechterDiezedijk
    // except that it runs it with both single core and multi core.
    // The output of both runs must be the same
    public void CompareResultFromMultiCoreRunWithSingleCoreRun()
    {
        var calcDir = "TestWtiPipingSingleCore";
        var outputFileName = @"WtiPipingSingleCore.output.xml";
        Output output = RunTestProjectCores(calcDir, outputFileName, 1);
        string outputSingleCore = DamXmlSerialization.SaveOutputAsXmlString(output);

        calcDir = "TestWtiPipingMultiCore";
        outputFileName = @"WtiPipingMultiCore.output.xml";
        output = RunTestProjectCores(calcDir, outputFileName, 4);
        string outputMultiCore = DamXmlSerialization.SaveOutputAsXmlString(output);

        Assert.That(outputMultiCore, Is.EqualTo(outputSingleCore));
    }

    [Test]
    [SetUICulture("en-US")]
    public void CanPerformWtiSellmeijerRevisedFailingDesignRechterDiezedijk1Location()
    {
        // Based on ".\data\DamEngineTestProjects\Larenstein_AaenMaas\Rechter Diezedijk.damx"
        // Set Analysis type to "No Adaption"
        // Set model to Piping Sellmeijer Revised (WBI)
        // Select first location (100)
        Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
        const string fileName = @"Rechter Diezedijk_WtiSellmeijerRevisedFailedDesignInputFile_1Location.xml";
        string inputString = File.ReadAllText(fileName);

        Output output = GeneralHelper.RunAfterInputValidation(inputString);

        Assert.That(output.Results.CalculationResults.Length, Is.EqualTo(2));
        // Expected an english message, but this can not be fixed with version 16.2 of the kernel, see MWDAM-1395
        Assert.That(output.Results.CalculationResults[1].PipingDesignResults.ResultMessage, Is.EqualTo("De effectieve spanning mag niet negatief zijn.\r\n"));
        Assert.That(ConversionHelper.ConvertToCalculationResult(output.Results.CalculationResults[1].CalculationResult), Is.EqualTo(CalculationResult.RunFailed));
        Assert.That(output.Results.CalculationMessages[0].Message1,
                    Is.EqualTo("Location '100', subsoil scenario 'segment1_1D2', design scenario '1': " +
                               "The calculation failed with error message " +
                               "'The design was not successful. " +
                               "De effectieve spanning mag niet negatief zijn.\r\n'"));
    }

    [Test]
    [TestCase(1)]
    [TestCase(4)]
    public void TestWtiPipingSellmeijerRevisedWithoutUplift(int maxCores)
    {
        Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
        const string fileName = @"WtiPipingSellmeijerRevisedWithoutUplift.xml";
        string inputString = File.ReadAllText(fileName);
        var engineInterface = new EngineInterface(inputString);
        string outputName = "Output" + maxCores + ".xml";

        Output output = GeneralHelper.RunAfterInputValidation(engineInterface, true, outputName);

        int errorCount = GeneralHelper.DetermineNumberOfCalculationErrors(engineInterface.DamProjectData.CalculationMessages);
        Assert.Multiple(() =>
        {
            Assert.That(errorCount, Is.EqualTo(0), "There should be no errors during the calculation.");
            Assert.That(output.Results.CalculationResults, Is.Not.EqualTo(null));
        });
        Assert.That(output.Results.CalculationResults, Has.Length.EqualTo(6));
        Assert.Multiple(() =>
        {
            Assert.That(output.Results.CalculationResults[0].PipingDesignResults.Wti2017FactorOverall, Is.EqualTo(26.006).Within(tolerance));
            Assert.That(output.Results.CalculationResults[1].PipingDesignResults.Wti2017FactorOverall, Is.EqualTo(90.000).Within(tolerance));
            Assert.That(output.Results.CalculationResults[2].PipingDesignResults.Wti2017FactorOverall, Is.EqualTo(90.000).Within(tolerance));
            Assert.That(output.Results.CalculationResults[3].PipingDesignResults.Wti2017FactorOverall, Is.EqualTo(90.000).Within(tolerance));
            Assert.That(output.Results.CalculationResults[4].PipingDesignResults.Wti2017FactorOverall, Is.EqualTo(9.316).Within(tolerance));
            Assert.That(output.Results.CalculationResults[5].PipingDesignResults.Wti2017FactorOverall, Is.EqualTo(90.000).Within(tolerance));
            Assert.That(output.Results.CalculationMessages, Has.Length.EqualTo(5));
        });
        Assert.Multiple(() =>
        {
            Assert.That(output.Results.CalculationMessages[0].Message1, Does.Contain("no uplift"));
            Assert.That(output.Results.CalculationMessages[1].Message1, Does.Contain("no uplift"));
            Assert.That(output.Results.CalculationMessages[2].Message1, Does.Contain("no uplift"));
            Assert.That(output.Results.CalculationMessages[3].Message1, Does.Contain("no uplift"));
            Assert.That(output.Results.CalculationMessages[3].Message1, Does.Contain("no uplift"));
        });
    }

    private Output RunTestProjectCores(string calcDir, string outputFileName, int coreCount)
    {
        Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
        if (Directory.Exists(calcDir))
        {
            Directory.Delete(calcDir, true); // delete previous results
        }

        Directory.CreateDirectory(calcDir);

        const string inputFileName = @"Rechter Diezedijk_WtiSellmeijerRevisedInputFile.xml";
        string inputString = File.ReadAllText(inputFileName);
        inputString = XmlAdapter.ChangeValueInXml(inputString, "ProjectPath", ""); // Current directory will be used
        inputString = XmlAdapter.ChangeValueInXml(inputString, "CalculationMap", calcDir); // Current directory will be used
        inputString = XmlAdapter.ChangeValueInXml(inputString, "MaxCalculationCores", coreCount.ToString());

        return GeneralHelper.RunAfterInputValidation(inputString, true, outputFileName);
    }
}