// Copyright (C) Stichting Deltares 2023. All rights reserved.
// 
// This file is part of the application DAM - Live.
// 
// DAM - Live is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
// 
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// 
// All names, logos, and references to "Deltares" are registered trademarks of
// Stichting Deltares and remain full property of Stichting Deltares at all times.
// All rights reserved.

using System;
using System.Collections.Generic;
using System.Linq;
using Deltares.DamLive.Application;
using Deltares.Dam.Data;
using Deltares.DamLive.TestHelper;
using NUnit.Framework;

namespace Deltares.DamLive.Tests;

[TestFixture]
[Category("Integration")]
public class StabilityInsideUpliftVanGridTest
{
    private const string projectIntegrationFilename = @"DAMLive.damx";
    private const string input1AFilename = @"live.InputTimeSeriesMHW.xml";
    private const string output1AFilename = @"live.OutputTimeSeriesMHW.xml";
    private const string calculationParametersIntegrationFilename = @"live.ParametersFile.xml";

    private const string testWorkingFolder = @".\damLiveUpliftVanGridWork";
    private const string testIntegrationDataFolder = @"..\..\TestData\IntegrationTests\StabilityInsideUpliftVanGrid";
    private List<Location> locations;

    private DamEngineRunner runner;
    private int maxCores;

    [SetUp]
    public void SetupFixture()
    {
        // Fails when run with multicore, so run with 1 core only
        maxCores = 1;
        IoHelper.RemoveTestWorkingDirectory(testWorkingFolder + maxCores);
    }

    [SetUp]
    public void SetupTest() {}

    [TearDown]
    public void TearDownFixture()
    {
        IoHelper.RemoveTestWorkingDirectory(testWorkingFolder + maxCores);
    }

    [Test]
    [Category("Integration")]
    public void CalculateStabilityInsideUpliftVanGridUsingTestFilesHasExpectedResultsInOutputFile()
    {
        const double cTolerance = 0.0005;
        string testFileName = "CalculateStabilityInsideUpliftVanGrid" + maxCores;
        GeneralHelper.SetupIntegrationProject(maxCores, testWorkingFolder, testIntegrationDataFolder, input1AFilename,
                                              output1AFilename, testFileName, calculationParametersIntegrationFilename,
                                              projectIntegrationFilename, out runner, out locations);
        runner.Initialize();
        runner.MaxCalculationCores = maxCores;
        Assert.That(runner, Is.Not.Null);
        Assert.Multiple(() =>
        {
            Assert.That(runner.DamProjectData, Is.Not.Null);
            Assert.That(runner.CalculationParameters, Is.Not.Null);
        });
        Assert.Multiple(() =>
        {
            Assert.That(runner.CalculationParameters.CalculationModules, Is.Not.Null);
            Assert.That(runner.CalculationParameters.StabilityParameters, Is.Not.Null);
        });

        runner.Run();
        runner.OutputTimeSeriesCollection.Save("StabilityInsideUpliftVanOutputFile" + maxCores + ".xml");

        GeneralHelper.AssertNoErrors(runner);

        // Assertions

        List<TimeSerie> series = runner.OutputTimeSeriesCollection.Series;

        var seriesCount = 0;
        var resultsCount = 0;

        string[] validParameterIDs = Enum.GetNames(typeof(TimeSerieParameters));
        foreach (TimeSerie timeSeries in series)
        {
            Assert.Multiple(() =>
            {
                Assert.That(validParameterIDs.Any(n => n == timeSeries.ParameterId), Is.True);
                Assert.That(locations.Any(l => l.Name == timeSeries.LocationId), Is.True);
            });
            // StabilityInside check
            if (timeSeries.ParameterId == TimeSerieParameters.StabilityInsideFactor.ToString())
            {
                Assert.Multiple(() =>
                {
                    if (timeSeries.LocationId == "Purmer_PU0042+00_K")
                    {
                        TimeSerieEntry firstEntry = timeSeries.Entries.First();
                        Assert.That(firstEntry.Value, Is.EqualTo(1.442).Within(cTolerance), "The computed safety factory is not correct");
                        resultsCount++;
                        TimeSerieEntry lastEntry = timeSeries.Entries.Last();
                        Assert.That(lastEntry.Value, Is.EqualTo(1.574).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.351).Within(cTolerance), "The computed safety factory is not correct");
                        resultsCount++;
                        TimeSerieEntry lastEntry = timeSeries.Entries.Last();
                        Assert.That(lastEntry.Value, Is.EqualTo(1.467).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.234).Within(cTolerance), "The computed safety factory is not correct");
                        resultsCount++;
                        TimeSerieEntry lastEntry = timeSeries.Entries.Last();
                        Assert.That(lastEntry.Value, Is.EqualTo(1.350).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(1.159).Within(cTolerance), "The computed safety factory is not correct");
                        resultsCount++;
                        TimeSerieEntry lastEntry = timeSeries.Entries.Last();
                        Assert.That(lastEntry.Value, Is.EqualTo(1.260).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.Multiple(() =>
        {
            Assert.That(seriesCount, Is.GreaterThan(0), "No output time series");
            Assert.That(resultsCount, Is.EqualTo(16), "Incorrect number of results");
        });
    }
}