// Copyright (C) Stichting Deltares 2019. All rights reserved.
//
// This file is part of the application DAM - Live.
//
// DAM - UI is free software: you can redistribute it and/or modify
// it under the terms of the GNU 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 General Public License for more details.
//
// You should have received a copy of the GNU 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
{
    // This test is based on a early configuration of the project Pulau Tekong for stability outward
    // It tests if having missing  values in the time serie is handled correctly
    [TestFixture]
    [Category("Integration")]
    public class PulauTekongMissingValuesTest
    {
        #region Test Setup

        private const double missingValue = -999.0;
        const string projectStabilityFilename = @"PulauTekong.damx";
        const string inputFilenameWithValues = @"live.InputTimeSeries.xml";
        const string inputFilenameWithMissingValues = @"live.InputTimeSeries - novalues.xml";
        const string outputFilename = @"live.OutputTimeSeries.xml";
        const string calculationParametersStabilityFilename = @"live.ParametersFile.xml";

        const string testWorkingFolder = @".\damLivePulauTekongWork";
        private const string testStablityDataFolder = @"..\..\..\data\Projects\Pulau Tekong";
        private List<Location> locations;

        private string inputFileFullname;
        private string outputFileFullname;
        private string projectFile;
        private string parameterFile;

        private DamEngineRunner runner;

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

        [TestFixtureTearDown]
        public void TearDownFixture()
        {
            IoHelper.RemoveTestWorkingDirectory(testWorkingFolder);
        }

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

        [SetUp]
        public void SetupTest() { }

        /// <summary>
        /// Sets up the stability project.
        /// </summary>
        private void SetupStabilityProject(string inputFilename)
        {
            var actualTestPath = Path.GetFullPath(testWorkingFolder);

            Directory.CreateDirectory(actualTestPath);

            DirectoryHelper.CopyRecursive(actualTestPath, testStablityDataFolder);

            inputFileFullname = Path.Combine(actualTestPath, inputFilename);
            outputFileFullname = Path.Combine(actualTestPath, outputFilename);
            parameterFile = Path.Combine(actualTestPath, calculationParametersStabilityFilename);
            projectFile = Path.Combine(actualTestPath, projectStabilityFilename);
            DamProject.SetTestProgramVersion("19.1");
            var damData = DamProject.LoadData(projectFile);
            locations = damData.Locations;

            // Load the sensor time serie data (see input file for details)
            var inputTimeSeries = TimeSerieCollection.LoadFromFile(inputFileFullname);
            ShortenTimeSeries(inputTimeSeries);
            inputTimeSeries.Save(Path.ChangeExtension(inputFileFullname, "short.xml"));

            if (String.IsNullOrEmpty(inputFileFullname))
            {
                throw new Exception("Inputfilename not specified");
            }
            runner = new DamEngineRunner
            {
                DamXFile = new FileInfo(projectFile),
                ParametersFile = new FileInfo(parameterFile),
                FewsInputFile = new FileInfo(inputFileFullname),
                FewsOutputFile = new FileInfo(outputFileFullname),
                Filter = "",
                InputTimeSeriesCollection = inputTimeSeries
            };
        }

        /// <summary>
        /// Make timeserie shorter for testing: the first, the last and the middle entry are only used
        /// </summary>
        /// <param name="inputTimeSeries"></param>
        private static void ShortenTimeSeries(TimeSerieCollection inputTimeSeries)
        {
            foreach (var serie in inputTimeSeries.Series)
            {
                for (int i = serie.Entries.Count - 2; i > 0; i--)
                {
                    if (i != 120) // keep the time entry in the middle of the serie
                    {
                        serie.Entries.RemoveAt(i);
                    }
                }
            }
        }

        #endregion

        #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


        /// <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]
        [Category("Integration")]
        [Category("Work_In_Progress")]
        [TestCase(inputFilenameWithValues, 2.486106, 2.114159)]
        [TestCase(inputFilenameWithMissingValues, missingValue, missingValue)]
        public void CalculateStabilityOutsideUsingTestFilesHasExpectedResultsInOutputFile(string inputTestcaseFilename, double valueEntry1, double valueEntry2)
        {
            const double cTolerance = 0.0005;
            SetupStabilityProject(inputTestcaseFilename);
            runner.Initialize();

            Assert.IsNotNull(runner);
            Assert.IsNotNull(runner.DamProjectData);
            Assert.IsNotNull(runner.CalculationParameters);
            Assert.IsNotNull(runner.CalculationParameters.CalculationModules);
            Assert.IsNotNull(runner.CalculationParameters.MStabParameters);

            runner.Run();

            AssertNoErrors();

            // Assertions

            var series = runner.OutputTimeSeriesCollection.Series;

            int seriesCount = 0;
            int calculatedLocationCount = 0;
            var validParameterIDs = Enum.GetNames(typeof(TimeSerieParameters));
            foreach (var timeSeries in series)
            {
                Assert.IsTrue(validParameterIDs.Any(n => n == timeSeries.ParameterId));
                Assert.IsTrue(locations.Any(l => l.Name == timeSeries.LocationId));
                // StabilityOutside check
                if (timeSeries.ParameterId == TimeSerieParameters.StabilityOutsideFactor.ToString())
                {

                    if (timeSeries.LocationId == "CD CS1 X1")
                    {
                        calculatedLocationCount++;
                        var firstEntry = timeSeries.Entries.First();
                        Assert.AreEqual(valueEntry1, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
                    }
                    if (timeSeries.LocationId == "CD CS2 X3")
                    {
                        calculatedLocationCount++;
                        var firstEntry = timeSeries.Entries.First();
                        Assert.AreEqual(valueEntry2, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
                    }
                }

                seriesCount++;
            }

            Assert.IsTrue(seriesCount == 0, "No output time series expected");
            Assert.IsTrue(calculatedLocationCount == 0, "No locations should have output for stability outside");
        }
    }
}