// 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 NUnit.Framework;

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Deltares.DamEngine.Calculators.DikesOperational;
using Deltares.DamEngine.Data.General.TimeSeries;
using Deltares.DamEngine.Io;
using Deltares.DamEngine.Io.XmlOutput;
using KellermanSoftware.CompareNetObjects;
using NUnit.Framework;
using TimeSerie = Deltares.DamEngine.Data.General.TimeSeries.TimeSerie;

namespace Deltares.DamEngine.IntegrationTests.IntegrationTests;

//[TestFixture]
public static class CheckLargeResultsSets
{
    private const double tol2Digits = 0.005;
    private const double tolerance = 0.0005;

    private static readonly List<string> resultsParametersToIgnore = new List<string>
    {
        "CalculationSubDir"
    };

    //[Test]
    public static void CheckResultsOperationalBeeSwarmMultiCoreWithXmlInputFile(List<TimeSerie> series)
    {
        var seriesCount = 0;
        var resultsCount = 0;
        const double cTolerance = 0.0005;

        foreach (TimeSerie timeSeries in series)
        {
            //Assert.IsTrue(validParameterIDs.Any(n => n == timeSeries.ParameterId));
            //Assert.IsTrue(locations.Any(l => l.Name == timeSeries.LocationId));
            // StabilityInside check
            if (timeSeries.ParameterId == TimeSerieParameters.StabilityInsideFactor.ToString())
            {
                if (timeSeries.LocationId == "Purmer_PU0042+00_K")
                {
                    TimeSerieEntry firstEntry = timeSeries.Entries.First();
                    Assert.That(firstEntry.Value, Is.EqualTo(1.185).Within(cTolerance), "The computed safety factory is not correct");
                    resultsCount++;
                    TimeSerieEntry lastEntry = timeSeries.Entries.Last();
                    Assert.That(lastEntry.Value, Is.EqualTo(1.419).Within(cTolerance), "The computed safety factory is not correct");
                    resultsCount++;
                }

                if (timeSeries.LocationId == "Purmer_PU0042+00_K_V")
                {
                    TimeSerieEntry firstEntry = timeSeries.Entries.First();
                    Assert.That(firstEntry.Value, Is.EqualTo(1.110).Within(cTolerance), "The computed safety factory is not correct");
                    resultsCount++;
                    TimeSerieEntry lastEntry = timeSeries.Entries.Last();
                    Assert.That(lastEntry.Value, Is.EqualTo(1.326).Within(cTolerance), "The computed safety factory is not correct");
                    resultsCount++;
                }

                if (timeSeries.LocationId == "Purmer_PU0042+00_R")
                {
                    TimeSerieEntry firstEntry = timeSeries.Entries.First();
                    Assert.That(firstEntry.Value, Is.EqualTo(1.012).Within(cTolerance), "The computed safety factory is not correct");
                    resultsCount++;
                    TimeSerieEntry lastEntry = timeSeries.Entries.Last();
                    Assert.That(lastEntry.Value, Is.EqualTo(1.217).Within(cTolerance), "The computed safety factory is not correct");
                    resultsCount++;
                }

                if (timeSeries.LocationId == "Purmer_PU0042+00_R_V")
                {
                    TimeSerieEntry firstEntry = timeSeries.Entries.First();
                    Assert.That(firstEntry.Value, Is.EqualTo(0.949).Within(cTolerance), "The computed safety factory is not correct");
                    resultsCount++;
                    TimeSerieEntry lastEntry = timeSeries.Entries.Last();
                    Assert.That(lastEntry.Value, Is.EqualTo(1.137).Within(cTolerance), "The computed safety factory is not correct");
                    resultsCount++;
                }

                if (timeSeries.LocationId == "Purmer_PU0110+20_K")
                {
                    TimeSerieEntry firstEntry = timeSeries.Entries.First();
                    Assert.That(firstEntry.Value, Is.EqualTo(double.NaN).Within(cTolerance), "The computed safety factory is not correct");
                    resultsCount++;
                    TimeSerieEntry lastEntry = timeSeries.Entries.Last();
                    Assert.That(lastEntry.Value, Is.EqualTo(double.NaN).Within(cTolerance), "The computed safety factory is not correct");
                    resultsCount++;
                }

                if (timeSeries.LocationId == "Purmer_PU0110+20_K_V")
                {
                    TimeSerieEntry firstEntry = timeSeries.Entries.First();
                    Assert.That(firstEntry.Value, Is.EqualTo(double.NaN).Within(cTolerance), "The computed safety factory is not correct");
                    resultsCount++;
                    TimeSerieEntry lastEntry = timeSeries.Entries.Last();
                    Assert.That(lastEntry.Value, Is.EqualTo(double.NaN).Within(cTolerance), "The computed safety factory is not correct");
                    resultsCount++;
                }

                if (timeSeries.LocationId == "Purmer_PU0110+20_R")
                {
                    TimeSerieEntry firstEntry = timeSeries.Entries.First();
                    Assert.That(firstEntry.Value, Is.EqualTo(double.NaN).Within(cTolerance), "The computed safety factory is not correct");
                    resultsCount++;
                    TimeSerieEntry lastEntry = timeSeries.Entries.Last();
                    Assert.That(lastEntry.Value, Is.EqualTo(double.NaN).Within(cTolerance), "The computed safety factory is not correct");
                    resultsCount++;
                }

                if (timeSeries.LocationId == "Purmer_PU0110+20_R_V")
                {
                    TimeSerieEntry firstEntry = timeSeries.Entries.First();
                    Assert.That(firstEntry.Value, Is.EqualTo(double.NaN).Within(cTolerance), "The computed safety factory is not correct");
                    resultsCount++;
                    TimeSerieEntry lastEntry = timeSeries.Entries.Last();
                    Assert.That(lastEntry.Value, Is.EqualTo(double.NaN).Within(cTolerance), "The computed safety factory is not correct");
                    resultsCount++;
                }
            }

            seriesCount++;
        }

        Assert.That(seriesCount, Is.GreaterThan(0), "No output time series");
        Assert.That(resultsCount, Is.EqualTo(16), "Incorrect number of results");
    }

    public static void CheckResultsDesignBishopWithScenariosForHeadPl3CalculatesCorrect(DesignResult[] calculationResults)
    {
        foreach (DesignResult designResult in calculationResults)
        {
            if (designResult.BaseFileName.Equals("Loc(KR093_0013)_Sce(3)_Pro(segment_627_1D1-KR093_0013-1)"))
            {
                Assert.Multiple(() =>
                {
                    Assert.That(designResult.StabilityDesignResults.SafetyFactor, Is.EqualTo(9.090).Within(tolerance));
                    Assert.That(designResult.ScenarioName, Is.EqualTo("3"));
                    Assert.That(designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(-0.94).Within(tol2Digits));
                });
            }

            if (designResult.BaseFileName.Equals("Loc(KR093_0013)_Sce(4)_Pro(segment_627_1D1-KR093_0013-1)"))
            {
                Assert.Multiple(() =>
                {
                    Assert.That(designResult.StabilityDesignResults.SafetyFactor, Is.EqualTo(8.148).Within(tolerance));
                    Assert.That(designResult.ScenarioName, Is.EqualTo("4"));
                    Assert.That(designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(-0.37).Within(tol2Digits));
                });
            }

            if (designResult.BaseFileName.Equals("Loc(KR093_0013)_Sce(3)_Pro(segment_627_1D2-KR093_0013-2)"))
            {
                Assert.That(designResult.StabilityDesignResults.SafetyFactor, Is.EqualTo(6.991).Within(tolerance));
                Assert.That(designResult.ScenarioName, Is.EqualTo("3"));
                Assert.That(designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(-0.94).Within(tol2Digits));
            }

            if (designResult.BaseFileName.Equals("Loc(KR093_0013)_Sce(4)_Pro(segment_627_1D2-KR093_0013-2)"))
            {
                Assert.That(designResult.StabilityDesignResults.SafetyFactor, Is.EqualTo(6.080).Within(tolerance));
                Assert.That(designResult.ScenarioName, Is.EqualTo("4"));
                Assert.That(designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(-0.37).Within(tol2Digits));
            }

            if (designResult.BaseFileName.Equals("Loc(KR093_0013)_Sce(3)_Pro(segment_627_1D3-KR093_0013-3)"))
            {
                Assert.That(designResult.StabilityDesignResults.SafetyFactor, Is.EqualTo(7.990).Within(tolerance));
                Assert.That(designResult.ScenarioName, Is.EqualTo("3"));
                Assert.That(designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(-0.94).Within(tol2Digits));
            }

            if (designResult.BaseFileName.Equals("Loc(KR093_0013)_Sce(4)_Pro(segment_627_1D3-KR093_0013-3)"))
            {
                Assert.That(designResult.StabilityDesignResults.SafetyFactor, Is.EqualTo(7.244).Within(tolerance));
                Assert.That(designResult.ScenarioName, Is.EqualTo("4"));
                Assert.That(designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(-0.37).Within(tol2Digits));
            }

            if (designResult.BaseFileName.Equals("Loc(KR093_0018)_Sce(3)_Pro(segment_629_1D1-KR093_0018-1)"))
            {
                Assert.That(designResult.StabilityDesignResults.SafetyFactor, Is.EqualTo(7.353).Within(tolerance));
                Assert.That(designResult.ScenarioName, Is.EqualTo("3"));
                Assert.That(designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(-1.00).Within(tol2Digits));
            }

            if (designResult.BaseFileName.Equals("Loc(KR093_0018)_Sce(4)_Pro(segment_629_1D1-KR093_0018-1)"))
            {
                Assert.That(designResult.StabilityDesignResults.SafetyFactor, Is.EqualTo(6.278).Within(tolerance));
                Assert.That(designResult.ScenarioName, Is.EqualTo("4"));
                Assert.That(designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(-0.61).Within(tol2Digits));
            }

            if (designResult.BaseFileName.Equals("Loc(KR093_0018)_Sce(3)_Pro(segment_629_1D2-KR093_0018-2)"))
            {
                Assert.That(designResult.StabilityDesignResults.SafetyFactor, Is.EqualTo(5.945).Within(tolerance));
                Assert.That(designResult.ScenarioName, Is.EqualTo("3"));
                Assert.That(designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(-1.00).Within(tol2Digits));
            }

            if (designResult.BaseFileName.Equals("Loc(KR093_0018)_Sce(4)_Pro(segment_629_1D2-KR093_0018-2)"))
            {
                Assert.That(designResult.StabilityDesignResults.SafetyFactor, Is.EqualTo(1.225).Within(tolerance));
                Assert.That(designResult.ScenarioName, Is.EqualTo("4"));
                Assert.That(designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(-0.37).Within(tol2Digits));
            }

            if (designResult.BaseFileName.Equals("Loc(KR093_0018)_Sce(3)_Pro(segment_629_1D3-KR093_0018-3)"))
            {
                Assert.That(designResult.StabilityDesignResults.SafetyFactor, Is.EqualTo(1.404).Within(tolerance));
                Assert.That(designResult.ScenarioName, Is.EqualTo("3"));
                Assert.That(designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(-1.00).Within(tol2Digits));
            }

            if (designResult.BaseFileName.Equals("Loc(KR093_0018)_Sce(4)_Pro(segment_629_1D3-KR093_0018-3)"))
            {
                Assert.That(designResult.StabilityDesignResults.SafetyFactor, Is.EqualTo(1.404).Within(tolerance));
                Assert.That(designResult.ScenarioName, Is.EqualTo("4"));
                Assert.That(designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(-0.37).Within(tol2Digits));
            }

            if (designResult.BaseFileName.Equals("Loc(KR093_0019)_Sce(3)_Pro(segment_629_1D1-KR093_0019-1)"))
            {
                Assert.That(designResult.StabilityDesignResults.SafetyFactor, Is.EqualTo(4.557).Within(tolerance));
                Assert.That(designResult.ScenarioName, Is.EqualTo("3"));
                Assert.That(designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(-1.03).Within(tol2Digits));
            }

            if (designResult.BaseFileName.Equals("Loc(KR093_0019)_Sce(4)_Pro(segment_629_1D1-KR093_0019-1)"))
            {
                Assert.That(designResult.StabilityDesignResults.SafetyFactor, Is.EqualTo(3.985).Within(tolerance));
                Assert.That(designResult.ScenarioName, Is.EqualTo("4"));
                Assert.That(designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(-0.57).Within(tol2Digits));
            }

            if (designResult.BaseFileName.Equals("Loc(KR093_0019)_Sce(3)_Pro(segment_629_1D2-KR093_0019-2)"))
            {
                Assert.That(designResult.StabilityDesignResults.SafetyFactor, Is.EqualTo(4.087).Within(tolerance));
                Assert.That(designResult.ScenarioName, Is.EqualTo("3"));
                Assert.That(designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(-1.03).Within(tol2Digits));
            }

            if (designResult.BaseFileName.Equals("Loc(KR093_0019)_Sce(4)_Pro(segment_629_1D2-KR093_0019-2)"))
            {
                Assert.That(designResult.StabilityDesignResults.SafetyFactor, Is.EqualTo(3.418).Within(tolerance));
                Assert.That(designResult.ScenarioName, Is.EqualTo("4"));
                Assert.That(designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(-0.37).Within(tol2Digits));
            }

            if (designResult.BaseFileName.Equals("Loc(KR093_0019)_Sce(3)_Pro(segment_629_1D3-KR093_0019-3)"))
            {
                Assert.That(designResult.StabilityDesignResults.SafetyFactor, Is.EqualTo(4.420).Within(tolerance));
                Assert.That(designResult.ScenarioName, Is.EqualTo("3"));
                Assert.That(designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(-1.03).Within(tol2Digits));
            }

            if (designResult.BaseFileName.Equals("Loc(KR093_0019)_Sce(4)_Pro(segment_629_1D3-KR093_0019-3)"))
            {
                Assert.That(designResult.StabilityDesignResults.SafetyFactor, Is.EqualTo(3.952).Within(tolerance));
                Assert.That(designResult.ScenarioName, Is.EqualTo("4"));
                Assert.That(designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(-0.37).Within(tol2Digits));
            }
        }
    }

    public static int CheckResultsDesignBishopAdaptionWithScenariosForHeadPl3CalculatesCorrect(DesignResult[] calculationResults)
    {
        var resultsFound = 0;
        foreach (DesignResult designResult in calculationResults)
        {
            if (designResult.BaseFileName.Equals("Loc(KR093_0013)_Sce(3)_Pro(segment_627_1D1-KR093_0013-1)_Ite(4)"))
            {
                Assert.Multiple(() =>
                {
                    Assert.That(designResult.StabilityDesignResults.SafetyFactor, Is.EqualTo(5.306).Within(tolerance));
                    Assert.That(designResult.ScenarioName, Is.EqualTo("3"));
                    Assert.That(designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(-0.94).Within(tol2Digits));
                });
                resultsFound++;
            }

            if (designResult.BaseFileName.Equals("Loc(KR093_0013)_Sce(4)_Pro(segment_627_1D1-KR093_0013-1)_Ite(4)"))
            {
                Assert.Multiple(() =>
                {
                    Assert.That(designResult.StabilityDesignResults.SafetyFactor, Is.EqualTo(5.167).Within(tolerance));
                    Assert.That(designResult.ScenarioName, Is.EqualTo("4"));
                    Assert.That(designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(-0.37).Within(tol2Digits));
                });
                resultsFound++;
            }

            if (designResult.BaseFileName.Equals("Loc(KR093_0013)_Sce(3)_Pro(segment_627_1D2-KR093_0013-2)_Ite(3)"))
            {
                Assert.Multiple(() =>
                {
                    Assert.That(designResult.StabilityDesignResults.SafetyFactor, Is.EqualTo(5.188).Within(tolerance));
                    Assert.That(designResult.ScenarioName, Is.EqualTo("3"));
                    Assert.That(designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(-0.94).Within(tol2Digits));
                });
                resultsFound++;
            }

            if (designResult.BaseFileName.Equals("Loc(KR093_0013)_Sce(4)_Pro(segment_627_1D2-KR093_0013-2)_Ite(3)"))
            {
                Assert.Multiple(() =>
                {
                    Assert.That(designResult.StabilityDesignResults.SafetyFactor, Is.EqualTo(4.420).Within(tolerance));
                    Assert.That(designResult.ScenarioName, Is.EqualTo("4"));
                    Assert.That(designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(-0.37).Within(tol2Digits));
                });
                resultsFound++;
            }

            if (designResult.BaseFileName.Equals("Loc(KR093_0013)_Sce(3)_Pro(segment_627_1D3-KR093_0013-3)_Ite(3)"))
            {
                Assert.Multiple(() =>
                {
                    Assert.That(designResult.StabilityDesignResults.SafetyFactor, Is.EqualTo(5.188).Within(tolerance));
                    Assert.That(designResult.ScenarioName, Is.EqualTo("3"));
                    Assert.That(designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(-0.94).Within(tol2Digits));
                });
                resultsFound++;
            }

            if (designResult.BaseFileName.Equals("Loc(KR093_0013)_Sce(4)_Pro(segment_627_1D3-KR093_0013-3)_Ite(3)"))
            {
                Assert.Multiple(() =>
                {
                    Assert.That(designResult.StabilityDesignResults.SafetyFactor, Is.EqualTo(4.784).Within(tolerance));
                    Assert.That(designResult.ScenarioName, Is.EqualTo("4"));
                    Assert.That(designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(-0.37).Within(tol2Digits));
                });
                resultsFound++;
            }

            if (designResult.BaseFileName.Equals("Loc(KR093_0018)_Sce(3)_Pro(segment_629_1D1-KR093_0018-1)_Ite(29)"))
            {
                Assert.Multiple(() =>
                {
                    Assert.That(designResult.StabilityDesignResults.SafetyFactor, Is.EqualTo(1.752).Within(tolerance));
                    Assert.That(designResult.ScenarioName, Is.EqualTo("3"));
                    Assert.That(designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(-1.00).Within(tol2Digits));
                });
                resultsFound++;
            }

            if (designResult.BaseFileName.Equals("Loc(KR093_0018)_Sce(4)_Pro(segment_629_1D1-KR093_0018-1)_Ite(29)"))
            {
                Assert.Multiple(() =>
                {
                    Assert.That(designResult.StabilityDesignResults.SafetyFactor, Is.EqualTo(1.270).Within(tolerance));
                    Assert.That(designResult.ScenarioName, Is.EqualTo("4"));
                    Assert.That(designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(-0.52).Within(tol2Digits));
                });
                resultsFound++;
            }

            if (designResult.BaseFileName.Equals("Loc(KR093_0018)_Sce(3)_Pro(segment_629_1D2-KR093_0018-2)_Ite(29)"))
            {
                Assert.Multiple(() =>
                {
                    Assert.That(designResult.StabilityDesignResults.SafetyFactor, Is.EqualTo(1.409).Within(tolerance));
                    Assert.That(designResult.ScenarioName, Is.EqualTo("3"));
                    Assert.That(designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(-1.00).Within(tol2Digits));
                });
                resultsFound++;
            }

            if (designResult.BaseFileName.Equals("Loc(KR093_0018)_Sce(4)_Pro(segment_629_1D2-KR093_0018-2)_Ite(29)"))
            {
                Assert.Multiple(() =>
                {
                    Assert.That(designResult.StabilityDesignResults.SafetyFactor, Is.EqualTo(1.224).Within(tolerance));
                    Assert.That(designResult.ScenarioName, Is.EqualTo("4"));
                    Assert.That(designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(-0.37).Within(tol2Digits));
                });
                resultsFound++;
            }

            if (designResult.BaseFileName.Equals("Loc(KR093_0018)_Sce(3)_Pro(segment_629_1D3-KR093_0018-3)_Ite(29)"))
            {
                Assert.That(designResult.StabilityDesignResults.SafetyFactor, Is.EqualTo(1.391).Within(tolerance));
                Assert.That(designResult.ScenarioName, Is.EqualTo("3"));
                Assert.That(designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(-1.00).Within(tol2Digits));
                resultsFound++;
            }

            if (designResult.BaseFileName.Equals("Loc(KR093_0018)_Sce(4)_Pro(segment_629_1D3-KR093_0018-3)_Ite(29)"))
            {
                Assert.Multiple(() =>
                {
                    Assert.That(designResult.StabilityDesignResults.SafetyFactor, Is.EqualTo(1.389).Within(tolerance));
                    Assert.That(designResult.ScenarioName, Is.EqualTo("4"));
                    Assert.That(designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(-0.37).Within(tol2Digits));
                });
                resultsFound++;
            }

            if (designResult.BaseFileName.Equals("Loc(KR093_0019)_Sce(3)_Pro(segment_629_1D1-KR093_0019-1)_Ite(25)"))
            {
                Assert.Multiple(() =>
                {
                    Assert.That(designResult.StabilityDesignResults.SafetyFactor, Is.EqualTo(5.848).Within(tolerance));
                    Assert.That(designResult.ScenarioName, Is.EqualTo("3"));
                    Assert.That(designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(-1.03).Within(tol2Digits));
                });
                resultsFound++;
            }

            if (designResult.BaseFileName.Equals("Loc(KR093_0019)_Sce(4)_Pro(segment_629_1D1-KR093_0019-1)_Ite(25)"))
            {
                Assert.Multiple(() =>
                {
                    Assert.That(designResult.StabilityDesignResults.SafetyFactor, Is.EqualTo(5.848).Within(tolerance));
                    Assert.That(designResult.ScenarioName, Is.EqualTo("4"));
                    Assert.That(designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(-0.57).Within(tol2Digits));
                });
                resultsFound++;
            }

            if (designResult.BaseFileName.Equals("Loc(KR093_0019)_Sce(3)_Pro(segment_629_1D2-KR093_0019-2)_Ite(25)"))
            {
                Assert.That(designResult.StabilityDesignResults.SafetyFactor, Is.EqualTo(1.552).Within(tolerance));
                Assert.That(designResult.ScenarioName, Is.EqualTo("3"));
                Assert.That(designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(-1.03).Within(tol2Digits));
                resultsFound++;
            }

            if (designResult.BaseFileName.Equals("Loc(KR093_0019)_Sce(4)_Pro(segment_629_1D2-KR093_0019-2)_Ite(5)"))
            {
                Assert.Multiple(() =>
                {
                    Assert.That(designResult.StabilityDesignResults.SafetyFactor, Is.EqualTo(2.876).Within(tolerance));
                    Assert.That(designResult.ScenarioName, Is.EqualTo("4"));
                    Assert.That(designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(-0.37).Within(tol2Digits));
                });
                resultsFound++;
            }

            if (designResult.BaseFileName.Equals("Loc(KR093_0019)_Sce(3)_Pro(segment_629_1D3-KR093_0019-3)_Ite(25)"))
            {
                Assert.Multiple(() =>
                {
                    Assert.That(designResult.StabilityDesignResults.SafetyFactor, Is.EqualTo(3.538).Within(tolerance));
                    Assert.That(designResult.ScenarioName, Is.EqualTo("3"));
                    Assert.That(designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(-1.03).Within(tol2Digits));
                });
                resultsFound++;
            }

            if (designResult.BaseFileName.Equals("Loc(KR093_0019)_Sce(4)_Pro(segment_629_1D3-KR093_0019-3)_Ite(25)"))
            {
                Assert.Multiple(() =>
                {
                    Assert.That(designResult.StabilityDesignResults.SafetyFactor, Is.EqualTo(1.515).Within(tolerance));
                    Assert.That(designResult.ScenarioName, Is.EqualTo("4"));
                    Assert.That(designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, Is.EqualTo(-0.37).Within(tol2Digits));
                });
                resultsFound++;
            }
        }

        return resultsFound;
    }

    public static void CheckBasicResultsBasedOnReferenceResultsFile(string resultsFile, string outputFileName,
                                                                    DesignResult[] calculationResults)
    {
        string logFile = Path.ChangeExtension(outputFileName, ".log");
        if (File.Exists(logFile))
        {
            File.Delete(logFile);
        }

        Output output = DamXmlSerialization.LoadOutputFromXmlFile(resultsFile);
        Assert.That(calculationResults.Count(), Is.EqualTo(output.Results.CalculationResults.Count()), "Results Count does not match");
        var totalDifferences = 0;
        foreach (DesignResult expectedDesignResult in output.Results.CalculationResults)
        {
            expectedDesignResult.BaseFileName ??=
                $"Loc({expectedDesignResult.LocationName})_Sce({expectedDesignResult.ScenarioName})_Pro({expectedDesignResult.ProfileName})";
            DesignResult actualDesignResult = null;
            foreach (DesignResult calculationResult in calculationResults)
            {
                calculationResult.BaseFileName ??=
                    $"Loc({calculationResult.LocationName})_Sce({calculationResult.ScenarioName})_Pro({calculationResult.ProfileName})";

                if (!expectedDesignResult.BaseFileName.Equals(calculationResult.BaseFileName))
                {
                    continue;
                }

                actualDesignResult = calculationResult;
                break;
            }

            Assert.That(actualDesignResult, Is.Not.Null, $"Design result {expectedDesignResult.BaseFileName} not found");
            var compare = new CompareLogic
            {
                Config =
                {
                    MaxDifferences = 100,
                    MembersToIgnore = resultsParametersToIgnore,
                    DoublePrecision = 1e-6
                }
            };
            ComparisonResult result = compare.Compare(expectedDesignResult, actualDesignResult);
            WriteDifferencesToLog(logFile, expectedDesignResult.BaseFileName, result);
            totalDifferences += result.Differences.Count;
        }

        Assert.That(totalDifferences, Is.EqualTo(0), "Total differences found comparing design results for " + resultsFile);
    }

    private static void WriteDifferencesToLog(string logFile, string baseFileName, ComparisonResult result)
    {
        if (result.Differences.Any())
        {
            string res = baseFileName + ": \r\n" + result.DifferencesString;
            File.AppendAllText(logFile, res);
        }
        else
        {
            string res = baseFileName + ": No differences found at all! \r\n";
            File.AppendAllText(logFile, res);
        }
    }
}