// Copyright (C) Stichting Deltares 2023. 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;

namespace Deltares.DamEngine.IntegrationTests.IntegrationTests;

//[TestFixture]
public static class CheckLargeResultsSets
{
    private const double tol2Digits = 0.005;
    private const double tolerance = 0.0005;
    //[Test]
    public static void CheckResultsOperationalBeeSwarmMultiCoreWithXmlInputFile(List<Data.General.TimeSeries.TimeSerie> series)
    {
        var seriesCount = 0;
        var resultsCount = 0;
        const double cTolerance = 0.0005;
        
        foreach (Data.General.TimeSeries.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.AreEqual(1.442, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
                    resultsCount++;
                    TimeSerieEntry lastEntry = timeSeries.Entries.Last();
                    Assert.AreEqual(1.579, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
                    resultsCount++;
                }

                if (timeSeries.LocationId == "Purmer_PU0042+00_K_V")
                {
                    TimeSerieEntry firstEntry = timeSeries.Entries.First();
                    Assert.AreEqual(1.365, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
                    resultsCount++;
                    TimeSerieEntry lastEntry = timeSeries.Entries.Last();
                    Assert.AreEqual(1.481, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
                    resultsCount++;
                }

                if (timeSeries.LocationId == "Purmer_PU0042+00_R")
                {
                    TimeSerieEntry firstEntry = timeSeries.Entries.First();
                    Assert.AreEqual(1.239, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
                    resultsCount++;
                    TimeSerieEntry lastEntry = timeSeries.Entries.Last();
                    Assert.AreEqual(1.355, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
                    resultsCount++;
                }
                if (timeSeries.LocationId == "Purmer_PU0042+00_R_V")
                {
                    TimeSerieEntry firstEntry = timeSeries.Entries.First();
                    Assert.AreEqual(1.168, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
                    resultsCount++;
                    TimeSerieEntry lastEntry = timeSeries.Entries.Last();
                    Assert.AreEqual(1.272, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
                    resultsCount++;
                }
                
                if (timeSeries.LocationId == "Purmer_PU0110+20_K")
                {
                    TimeSerieEntry firstEntry = timeSeries.Entries.First();
                    Assert.AreEqual(Double.NaN, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
                    resultsCount++;
                    TimeSerieEntry lastEntry = timeSeries.Entries.Last();
                    Assert.AreEqual(Double.NaN, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
                    resultsCount++;
                }
                
                if (timeSeries.LocationId == "Purmer_PU0110+20_K_V")
                {
                    TimeSerieEntry firstEntry = timeSeries.Entries.First();
                    Assert.AreEqual(Double.NaN, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
                    resultsCount++;
                    TimeSerieEntry lastEntry = timeSeries.Entries.Last();
                    Assert.AreEqual(Double.NaN, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
                    resultsCount++;
                }
                
                if (timeSeries.LocationId == "Purmer_PU0110+20_R")
                {
                    TimeSerieEntry firstEntry = timeSeries.Entries.First();
                    Assert.AreEqual(Double.NaN, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
                    resultsCount++;
                    TimeSerieEntry lastEntry = timeSeries.Entries.Last();
                    Assert.AreEqual(Double.NaN, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
                    resultsCount++;
                }

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

            seriesCount++;
        }

        Assert.IsTrue(seriesCount > 0, "No output time series");
        Assert.AreEqual(16, resultsCount, "Incorrect number of results");
        
    }

    public static void CheckResultsDesignBishopWithScenariosForHeadPl3CalculatesCorrect(DesignResult[] calculationResults)
    {
        foreach (var designResult in calculationResults)
        {
            if (designResult.BaseFileName.Equals("Loc(KR093_0013)_Sce(3)_Pro(segment_627_1D1-KR093_0013-1)"))
            {
                Assert.AreEqual(9.300, designResult.StabilityDesignResults.SafetyFactor, tolerance);
                Assert.AreEqual("3", designResult.ScenarioName);
                Assert.AreEqual(-0.94, designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, tol2Digits);                    
            }
            if (designResult.BaseFileName.Equals("Loc(KR093_0013)_Sce(4)_Pro(segment_627_1D1-KR093_0013-1)"))
            {
                Assert.AreEqual(7.888, designResult.StabilityDesignResults.SafetyFactor, tolerance);
                Assert.AreEqual("4", designResult.ScenarioName);
                Assert.AreEqual(-0.37, designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, tol2Digits);                    
            }
            if (designResult.BaseFileName.Equals("Loc(KR093_0013)_Sce(3)_Pro(segment_627_1D2-KR093_0013-2)"))
            {
                Assert.AreEqual(7.023, designResult.StabilityDesignResults.SafetyFactor, tolerance);
                Assert.AreEqual("3", designResult.ScenarioName);
                Assert.AreEqual(-0.94, designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, tol2Digits);                    
            }
            if (designResult.BaseFileName.Equals("Loc(KR093_0013)_Sce(4)_Pro(segment_627_1D2-KR093_0013-2)"))
            {
                Assert.AreEqual(5.968, designResult.StabilityDesignResults.SafetyFactor, tolerance);
                Assert.AreEqual("4", designResult.ScenarioName);
                Assert.AreEqual(-0.37, designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, tol2Digits);                    
            }
            if (designResult.BaseFileName.Equals("Loc(KR093_0013)_Sce(3)_Pro(segment_627_1D3-KR093_0013-3)"))
            {
                Assert.AreEqual(7.555, designResult.StabilityDesignResults.SafetyFactor, tolerance);
                Assert.AreEqual("3", designResult.ScenarioName);
                Assert.AreEqual(-0.94, designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, tol2Digits);                    
            }
            if (designResult.BaseFileName.Equals("Loc(KR093_0013)_Sce(4)_Pro(segment_627_1D3-KR093_0013-3)"))
            {
                Assert.AreEqual(6.477, designResult.StabilityDesignResults.SafetyFactor, tolerance);
                Assert.AreEqual("4", designResult.ScenarioName);
                Assert.AreEqual(-0.37, designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, tol2Digits);                    
            }
            if (designResult.BaseFileName.Equals("Loc(KR093_0018)_Sce(3)_Pro(segment_629_1D1-KR093_0018-1)"))
            {
                Assert.AreEqual(7.353, designResult.StabilityDesignResults.SafetyFactor, tolerance);
                Assert.AreEqual("3", designResult.ScenarioName);
                Assert.AreEqual(-1.00, designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, tol2Digits);                    
            }
            if (designResult.BaseFileName.Equals("Loc(KR093_0018)_Sce(4)_Pro(segment_629_1D1-KR093_0018-1)"))
            {
                Assert.AreEqual(6.278, designResult.StabilityDesignResults.SafetyFactor, tolerance);
                Assert.AreEqual("4", designResult.ScenarioName);
                Assert.AreEqual(-0.61, designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, tol2Digits);                    
            }
            if (designResult.BaseFileName.Equals("Loc(KR093_0018)_Sce(3)_Pro(segment_629_1D2-KR093_0018-2)"))
            {
                Assert.AreEqual(5.945, designResult.StabilityDesignResults.SafetyFactor, tolerance);
                Assert.AreEqual("3", designResult.ScenarioName);
                Assert.AreEqual(-1.00, designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, tol2Digits);                    
            }
            if (designResult.BaseFileName.Equals("Loc(KR093_0018)_Sce(4)_Pro(segment_629_1D2-KR093_0018-2)"))
            {
                Assert.AreEqual(1.225, designResult.StabilityDesignResults.SafetyFactor, tolerance);
                Assert.AreEqual("4", designResult.ScenarioName);
                Assert.AreEqual(-0.37, designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, tol2Digits);                    
            }
            if (designResult.BaseFileName.Equals("Loc(KR093_0018)_Sce(3)_Pro(segment_629_1D3-KR093_0018-3)"))
            {
                Assert.AreEqual(1.608, designResult.StabilityDesignResults.SafetyFactor, tolerance);
                Assert.AreEqual("3", designResult.ScenarioName);
                Assert.AreEqual(-1.00, designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, tol2Digits);                    
            }
            if (designResult.BaseFileName.Equals("Loc(KR093_0018)_Sce(4)_Pro(segment_629_1D3-KR093_0018-3)"))
            {
                Assert.AreEqual(1.397, designResult.StabilityDesignResults.SafetyFactor, tolerance);
                Assert.AreEqual("4", designResult.ScenarioName);
                Assert.AreEqual(-0.37, designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, tol2Digits);                    
            }
            if (designResult.BaseFileName.Equals("Loc(KR093_0019)_Sce(3)_Pro(segment_629_1D1-KR093_0019-1)"))
            {
                Assert.AreEqual(4.557, designResult.StabilityDesignResults.SafetyFactor, tolerance);
                Assert.AreEqual("3", designResult.ScenarioName);
                Assert.AreEqual(-1.03, designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, tol2Digits);                    
            }
            if (designResult.BaseFileName.Equals("Loc(KR093_0019)_Sce(4)_Pro(segment_629_1D1-KR093_0019-1)"))
            {
                Assert.AreEqual(3.985, designResult.StabilityDesignResults.SafetyFactor, tolerance);
                Assert.AreEqual("4", designResult.ScenarioName);
                Assert.AreEqual(-0.57, designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, tol2Digits);                    
            }
            if (designResult.BaseFileName.Equals("Loc(KR093_0019)_Sce(3)_Pro(segment_629_1D2-KR093_0019-2)"))
            {
                Assert.AreEqual(4.087, designResult.StabilityDesignResults.SafetyFactor, tolerance);
                Assert.AreEqual("3", designResult.ScenarioName);
                Assert.AreEqual(-1.03, designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, tol2Digits);                    
            }
            if (designResult.BaseFileName.Equals("Loc(KR093_0019)_Sce(4)_Pro(segment_629_1D2-KR093_0019-2)"))
            {
                Assert.AreEqual(3.418, designResult.StabilityDesignResults.SafetyFactor, tolerance);
                Assert.AreEqual("4", designResult.ScenarioName);
                Assert.AreEqual(-0.37, designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, tol2Digits);                    
            }
            if (designResult.BaseFileName.Equals("Loc(KR093_0019)_Sce(3)_Pro(segment_629_1D3-KR093_0019-3)"))
            {
                Assert.AreEqual(4.432, designResult.StabilityDesignResults.SafetyFactor, tolerance);
                Assert.AreEqual("3", designResult.ScenarioName);
                Assert.AreEqual(-1.03, designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, tol2Digits);                    
            }
            if (designResult.BaseFileName.Equals("Loc(KR093_0019)_Sce(4)_Pro(segment_629_1D3-KR093_0019-3)"))
            {
                Assert.AreEqual(3.745, designResult.StabilityDesignResults.SafetyFactor, tolerance);
                Assert.AreEqual("4", designResult.ScenarioName);
                Assert.AreEqual(-0.37, designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, tol2Digits);                    
            }
        }
    }

    public static int CheckResultsDesignBishopAdaptionWithScenariosForHeadPl3CalculatesCorrect(DesignResult[] calculationResults)
    {
        int resultsFound = 0;
        foreach (var designResult in calculationResults)
        {
            if (designResult.BaseFileName.Equals("Loc(KR093_0013)_Sce(3)_Pro(segment_627_1D1-KR093_0013-1)_Ite(4)"))
            {
                Assert.AreEqual(5.306, designResult.StabilityDesignResults.SafetyFactor, tolerance);
                Assert.AreEqual("3", designResult.ScenarioName);
                Assert.AreEqual(-0.94, designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, tol2Digits);
                resultsFound++;
            }
            if (designResult.BaseFileName.Equals("Loc(KR093_0013)_Sce(4)_Pro(segment_627_1D1-KR093_0013-1)_Ite(4)"))
            {
                Assert.AreEqual(4.986, designResult.StabilityDesignResults.SafetyFactor, tolerance);
                Assert.AreEqual("4", designResult.ScenarioName);
                Assert.AreEqual(-0.37, designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, tol2Digits);
                resultsFound++;
            }
            if (designResult.BaseFileName.Equals("Loc(KR093_0013)_Sce(3)_Pro(segment_627_1D2-KR093_0013-2)_Ite(3)"))
            {
                Assert.AreEqual(5.155, designResult.StabilityDesignResults.SafetyFactor, tolerance);
                Assert.AreEqual("3", designResult.ScenarioName);
                Assert.AreEqual(-0.94, designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, tol2Digits);
                resultsFound++;
            }
            if (designResult.BaseFileName.Equals("Loc(KR093_0013)_Sce(4)_Pro(segment_627_1D2-KR093_0013-2)_Ite(3)"))
            {
                Assert.AreEqual(4.335, designResult.StabilityDesignResults.SafetyFactor, tolerance);
                Assert.AreEqual("4", designResult.ScenarioName);
                Assert.AreEqual(-0.37, designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, tol2Digits);
                resultsFound++;
            }
            if (designResult.BaseFileName.Equals("Loc(KR093_0013)_Sce(3)_Pro(segment_627_1D3-KR093_0013-3)_Ite(3)"))
            {
                Assert.AreEqual(5.188, designResult.StabilityDesignResults.SafetyFactor, tolerance);
                Assert.AreEqual("3", designResult.ScenarioName);
                Assert.AreEqual(-0.94, designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, tol2Digits);
                resultsFound++;
            }
            if (designResult.BaseFileName.Equals("Loc(KR093_0013)_Sce(4)_Pro(segment_627_1D3-KR093_0013-3)_Ite(3)"))
            {
                Assert.AreEqual(4.784, designResult.StabilityDesignResults.SafetyFactor, tolerance);
                Assert.AreEqual("4", designResult.ScenarioName);
                Assert.AreEqual(-0.37, designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, tol2Digits);
                resultsFound++;
            }
            if (designResult.BaseFileName.Equals("Loc(KR093_0018)_Sce(3)_Pro(segment_629_1D1-KR093_0018-1)_Ite(29)"))
            {
                Assert.AreEqual(1.752, designResult.StabilityDesignResults.SafetyFactor, tolerance);
                Assert.AreEqual("3", designResult.ScenarioName);
                Assert.AreEqual(-1.00, designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, tol2Digits);
                resultsFound++;
            }
            if (designResult.BaseFileName.Equals("Loc(KR093_0018)_Sce(4)_Pro(segment_629_1D1-KR093_0018-1)_Ite(29)"))
            {
                Assert.AreEqual(1.270, designResult.StabilityDesignResults.SafetyFactor, tolerance);
                Assert.AreEqual("4", designResult.ScenarioName);
                Assert.AreEqual(-0.52, designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, tol2Digits);
                resultsFound++;
            }
            if (designResult.BaseFileName.Equals("Loc(KR093_0018)_Sce(3)_Pro(segment_629_1D2-KR093_0018-2)_Ite(29)"))
            {
                Assert.AreEqual(1.409, designResult.StabilityDesignResults.SafetyFactor, tolerance);
                Assert.AreEqual("3", designResult.ScenarioName);
                Assert.AreEqual(-1.00, designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, tol2Digits);
                resultsFound++;
            }
            if (designResult.BaseFileName.Equals("Loc(KR093_0018)_Sce(4)_Pro(segment_629_1D2-KR093_0018-2)_Ite(29)"))
            {
                Assert.AreEqual(1.224, designResult.StabilityDesignResults.SafetyFactor, tolerance);
                Assert.AreEqual("4", designResult.ScenarioName);
                Assert.AreEqual(-0.37, designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, tol2Digits);
                resultsFound++;
            }
            if (designResult.BaseFileName.Equals("Loc(KR093_0018)_Sce(3)_Pro(segment_629_1D3-KR093_0018-3)_Ite(29)"))
            {
                Assert.AreEqual(1.598, designResult.StabilityDesignResults.SafetyFactor, tolerance);
                Assert.AreEqual("3", designResult.ScenarioName);
                Assert.AreEqual(-1.00, designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, tol2Digits);
                resultsFound++;
            }
            if (designResult.BaseFileName.Equals("Loc(KR093_0018)_Sce(4)_Pro(segment_629_1D3-KR093_0018-3)_Ite(29)"))
            {
                Assert.AreEqual(1.382, designResult.StabilityDesignResults.SafetyFactor, tolerance);
                Assert.AreEqual("4", designResult.ScenarioName);
                Assert.AreEqual(-0.37, designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, tol2Digits);
                resultsFound++;
            }
            if (designResult.BaseFileName.Equals("Loc(KR093_0019)_Sce(3)_Pro(segment_629_1D1-KR093_0019-1)_Ite(25)"))
            {
                Assert.AreEqual(5.848, designResult.StabilityDesignResults.SafetyFactor, tolerance);
                Assert.AreEqual("3", designResult.ScenarioName);
                Assert.AreEqual(-1.03, designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, tol2Digits);
                resultsFound++;
            }
            if (designResult.BaseFileName.Equals("Loc(KR093_0019)_Sce(4)_Pro(segment_629_1D1-KR093_0019-1)_Ite(25)"))
            {
                Assert.AreEqual(5.848, designResult.StabilityDesignResults.SafetyFactor, tolerance);
                Assert.AreEqual("4", designResult.ScenarioName);
                Assert.AreEqual(-0.57, designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, tol2Digits);
                resultsFound++;
            }
            if (designResult.BaseFileName.Equals("Loc(KR093_0019)_Sce(3)_Pro(segment_629_1D2-KR093_0019-2)_Ite(25)"))
            {
                Assert.AreEqual(1.552, designResult.StabilityDesignResults.SafetyFactor, tolerance);
                Assert.AreEqual("3", designResult.ScenarioName);
                Assert.AreEqual(-1.03, designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, tol2Digits);
                resultsFound++;
            }
            if (designResult.BaseFileName.Equals("Loc(KR093_0019)_Sce(4)_Pro(segment_629_1D2-KR093_0019-2)_Ite(5)"))
            {
                Assert.AreEqual(2.876, designResult.StabilityDesignResults.SafetyFactor, tolerance);
                Assert.AreEqual("4", designResult.ScenarioName);
                Assert.AreEqual(-0.37, designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, tol2Digits);
                resultsFound++;
            }
            if (designResult.BaseFileName.Equals("Loc(KR093_0019)_Sce(3)_Pro(segment_629_1D3-KR093_0019-3)_Ite(25)"))
            {
                Assert.AreEqual(3.538, designResult.StabilityDesignResults.SafetyFactor, tolerance);
                Assert.AreEqual("3", designResult.ScenarioName);
                Assert.AreEqual(-1.03, designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, tol2Digits);
                resultsFound++;
            }
            if (designResult.BaseFileName.Equals("Loc(KR093_0019)_Sce(4)_Pro(segment_629_1D3-KR093_0019-3)_Ite(25)"))
            {
                Assert.AreEqual(1.503, designResult.StabilityDesignResults.SafetyFactor, tolerance);
                Assert.AreEqual("4", designResult.ScenarioName);
                Assert.AreEqual(-0.37, designResult.StabilityDesignResults.UpliftSituation.Pl3HeadAdjusted, 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.AreEqual(output.Results.CalculationResults.Count(), calculationResults.Count(), "Results Count does not match");
        int 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.IsNotNull(actualDesignResult, $"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.AreEqual(0, totalDifferences, "Total differences found comparing design results for " + resultsFile);
    }
    
    private static readonly List<string> ResultsParametersToIgnore = new List<string>
    {
        "CalculationSubDir"
    };

    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);
        }
    }
}