// Copyright (C) Stichting Deltares 2020. All rights reserved.
//
// This file is part of the application DAM - Clients Library.
//
// 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
{
    [TestFixture]
    [Category("Integration")]
    public class DamLiveStabilityDrainedTest
    {
        #region Test Setup

        const string projectStabilityFilename = @"DAM Live - Gedraineerd.damx";
        const string input1aFilename = @"live.InputTimeSeries.xml";
        const string output1aFilename = @"live.OutputTimeSeries.xml";
        const string calculationParametersStabilityFilename = @"live.ParametersFile.xml";

        const string testWorkingFolder = @".\DamLiveStabilityDrained";
        private const string testStablityDataFolder = @"..\..\..\data\Projects\BishopDrained";

        private List<Location> locations;

        private string inputFile;
        private string outputFile;
        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()
        {
            var actualTestPath = Path.GetFullPath(testWorkingFolder);

            Directory.CreateDirectory(actualTestPath);

            DirectoryHelper.CopyRecursive(actualTestPath, testStablityDataFolder);

            inputFile = Path.Combine(actualTestPath, input1aFilename);
            outputFile = Path.Combine(actualTestPath, output1aFilename);
            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(inputFile);
            ShortenTimeSeries(inputTimeSeries);
            inputTimeSeries.Save(Path.ChangeExtension(inputFile, "short.xml"));

            runner = new DamEngineRunner
            {
                DamXFile = new FileInfo(projectFile),
                ParametersFile = new FileInfo(parameterFile),
                FewsInputFile = new FileInfo(inputFile),
                FewsOutputFile = new FileInfo(outputFile),
                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)
            {
                var middle = Math.Floor(serie.Entries.Count / 2.0);
                if (middle < 3)
                {
                    middle = 10;
                }

                for (int i = serie.Entries.Count - 2; i > 0; i--)
                {
                    if (Math.Abs(i - middle) > 0.1) // 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")]
        public void CalculateStabilityUsingTestFilesHasExpectedResultsInOutputFile()
        {
            const double cTolerance = 0.0005;
            SetupStabilityProject();
            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();
            //runner.WriteResultsToFile(outputFile);

            AssertNoErrors();

            // Assertions

            var series = runner.OutputTimeSeriesCollection.Series;

            int seriesCount = 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));
                // StabilityInside check
                if (timeSeries.ParameterId == TimeSerieParameters.StabilityInsideFactor.ToString())
                {
                    if (timeSeries.LocationId == "grebbedijk1a")
                    {
                        var firstEntry = timeSeries.Entries.First();
                        Assert.AreEqual(1.603, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
                    }
                    if (timeSeries.LocationId == "grebbedijk3a")
                    {
                        var firstEntry = timeSeries.Entries.First();
                        // Following value was 0.590 in the previous DamLive version, but that has to do with how the 
                        // reference level Su is handled in D-GeoStability 18.1 and D-GeoStability 15.1
                        Assert.AreEqual(1.007, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
                    }
                }

                seriesCount++;
            }

            Assert.IsTrue(seriesCount > 0, "No output time series");
        }
    }
}