// 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.IO;
using System.Linq;
using Deltares.Dam.Application.Live;
using Deltares.Dam.Data;
using Deltares.DamLive.TestHelper;
using Deltares.Standard.IO;
using NUnit.Framework;

namespace Deltares.DamLive.Tests;

[TestFixture]
[Category("Integration")]
[Category("Slow")] //takes 3 minutes
[Ignore("Hangs because of a bug in D-GeoStability (MWDAM-1000, MST-1049)")]
public class DamLiveUsingCompleteDataSetTest
{
    /// <summary>
    /// This test calls the runner's Run method. 
    /// This test is an integration test.
    /// 
    /// Required files are:
    /// - the DAMX file which contains the dike models
    /// - FEWS input file containing the water level time series for the locations 
    ///   or monitoring points
    /// - FEWS output file containing the time series results for each node 
    ///   (location/monitoring point) 
    /// 
    /// See setup method
    ///  </summary>        
    [Test, Ignore("Under construction")]
    public void Run_UsingTestFiles_HasExpectedResultsInOutputFile()
    {
        runner.Initialize();
        runner.CreateAndSetWorkingDirectories();
        runner.DeleteFormerProjectFiles();

        Assert.That(runner, Is.Not.Null);
        Assert.That(runner.ProjectData, Is.Not.Null);
        Assert.That(runner.RunnerDelegate, Is.Not.Null);
        Assert.That(runner.CalculationParameters, Is.Not.Null);
        Assert.That(runner.CalculationParameters.CalculationModules, Is.Not.Null);
        Assert.That(runner.CalculationParameters.StabilityParameters, Is.Not.Null);

        runner.Process();
        runner.WriteResultsToFile(outputFile);

        AssertNoErrors();

        // Assertions

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

        var seriesCount = 0;

        string[] validParameterIDs = Enum.GetNames(typeof(TimeSerieParameters));
        foreach (TimeSerie timeSeries in series)
        {
            Assert.That(validParameterIDs.Any(n => n == timeSeries.ParameterId), Is.True);
            Assert.That(locations.Any(l => l.Name == timeSeries.LocationId), Is.True);

            if (timeSeries.LocationId == "1C_31_5_bishop_binnen")
            {
                TimeSerieEntry firstEntry = timeSeries.Entries.First();
                Assert.That(firstEntry.Value, Is.EqualTo(1.226), "The computed safety factory is not correct");
                TimeSerieEntry lastEntry = timeSeries.Entries.Last();
                Assert.That(lastEntry.Value, Is.EqualTo(0.800), "The computed safety factory is not correct");
            }

            if (timeSeries.LocationId == "1D_34_bishop_binnen")
            {
                TimeSerieEntry firstEntry = timeSeries.Entries.First();
                Assert.That(firstEntry.Value, Is.EqualTo(1.319), "The computed safety factory is not correct");
                TimeSerieEntry lastEntry = timeSeries.Entries.Last();
                Assert.That(lastEntry.Value, Is.EqualTo(0.864), "The computed safety factory is not correct");
            }

            if (timeSeries.LocationId == "2A_37_bishop_binnen")
            {
                TimeSerieEntry firstEntry = timeSeries.Entries.First();
                Assert.That(firstEntry.Value, Is.EqualTo(1.318), "The computed safety factory is not correct");
                TimeSerieEntry lastEntry = timeSeries.Entries.Last();
                Assert.That(lastEntry.Value, Is.EqualTo(0.891), "The computed safety factory is not correct");
            }

            seriesCount++;
        }

        Assert.That(seriesCount, Is.EqualTo(locations.Count), "Number of output time series not equal to number of locations");
    }

    #region Helper methods

    /// <summary>
    /// Asserts that there are no errors in the runner
    /// </summary>
    private void AssertNoErrors()
    {
        if (runner.HasErrors)
        {
            Assert.Fail("The test failed. See the error log in the test output console for more info");
        }
    }

    #endregion

    #region Test Setup

    const string testWorkingFolder = "DamLiveUsingCompleteDataSetTest";
    private const string testDataFolder = @"TestData\DamLive\Set3";
    private List<Location> locations;

    private string inputFile;
    private string outputFile;
    private string projectFile;
    private string parameterFile;

    private TestModelRunner runner;

    [SetUp]
    public void SetupFixture()
    {
        IoHelper.RemoveTestWorkingDirectory(testWorkingFolder); // to be sure no test directory exist from previous tests
        Directory.CreateDirectory(testWorkingFolder);
    }

    [TearDown]
    public void TearDownFixture()
    {
        //IOHelper.RemoveTestWorkingDirectory(TestWorkingFolder);
    }

    [TearDown]
    public void TearDownTest()
    {
        AssertNoErrors();
    }

    [SetUp]
    public void SetupTest()
    {
        // create a random unique test directory name in the 
        // test working folder
        string actualTestPath = Guid.NewGuid().ToString().Replace("-", "");
        actualTestPath = Path.Combine(testWorkingFolder, actualTestPath);
        Directory.CreateDirectory(actualTestPath);

        DirectoryHelper.CopyRecursive(actualTestPath, testDataFolder);

        //inputFile = Path.Combine(actualTestPath, "live.FEWS.InputFile.1Step.xml");
        inputFile = Path.Combine(actualTestPath, "live.FEWS.InputFile.xml");
        outputFile = Path.Combine(actualTestPath, "live.FEWS.OutputFile.xml");
        parameterFile = Path.Combine(actualTestPath, "live.ParametersFile.xml");
        projectFile = Path.Combine(actualTestPath, "output.damx");

        DamProject.SetTestProgramVersion("19.1");
        DamProjectData damData = DamProject.LoadData(projectFile);
        locations = damData.Locations;

        // Load the sensor time serie data (see input file for details)
        TimeSerieCollection inputTimeSeries = TimeSerieCollection.LoadFromFile(inputFile);

        runner = new TestModelRunner
        {
            DamXFile = new FileInfo(projectFile),
            ParametersFile = new FileInfo(parameterFile),
            FewsInputFile = new FileInfo(inputFile),
            FewsOutputFile = new FileInfo(outputFile),
            RunnerDelegate = new SensorModelRunner(),
            InputTimeSeriesCollection = inputTimeSeries
        };
    }

    #endregion
}