// Copyright (C) Stichting Deltares 2023. All rights reserved.
// 
// This file is part of the application DAM - UI.
// 
// 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.Collections.Generic;
using Deltares.Dam.Data;
using Deltares.Dam.Data.DamEngineIo;
using Deltares.Dam.TestHelper;
using Deltares.DamEngine.Interface;
using Deltares.DamEngine.Io;
using Deltares.Standard;
using NUnit.Framework;

namespace Deltares.Dam.Tests
{
    [TestFixture]
    public class FailureMechanismTests
    {
        /// <summary>
        /// Compute project
        /// </summary>
        /// <param name="projectFilename"></param>
        /// <returns></returns>
        private static List<CsvExportData> ComputeStabilityOutsideProjectUsingClassic(string projectFilename, int expectedLocations)
        {
            // Read dikering
            using (var damProjectData = ProjectLoader.LoadProjectData(projectFilename))
            {
                Assert.AreEqual(1, damProjectData.WaterBoard.Dikes.Count);
                var dike = damProjectData.WaterBoard.Dikes[0];
                Assert.AreEqual(expectedLocations, dike.Locations.Count);
                damProjectData.DamProjectCalculationSpecification.CurrentSpecification.StabilityModelType = MStabModelType.Bishop;
                damProjectData.DamProjectCalculationSpecification.CurrentSpecification.FailureMechanismeParamatersMStab.MStabParameters.GridPosition = MStabGridPosition.Left;
                damProjectData.DamProjectCalculationSpecification.CurrentSpecification.FailureMechanismSystemType = FailureMechanismSystemType.StabilityOutside;
                DamEngine.Io.XmlInput.Input input = FillXmlInputFromDamUi.CreateInput(damProjectData);
                string inputXml = DamXmlSerialization.SaveInputAsXmlString(input);
                // Enable next line for debugging
                // DamXmlSerialization.SaveInputAsXmlFile("InputForDebugging.xml", input);

                var damEnginInterface = new EngineInterface(inputXml);
                string validationMessages = damEnginInterface.Validate();

                if (string.IsNullOrEmpty(validationMessages))
                {
                    // only if validation is ok, then
                    string outputXml = damEnginInterface.Run();
                    var output = DamXmlSerialization.LoadOutputFromXmlString(outputXml);
                    // Enable next line for debugging
                    // DamXmlSerialization.SaveOutputAsXmlFile("OutputForDebugging.xml", output);
                    FillDamUiFromXmlOutput.AddOutputToDamProjectData(damProjectData, output);
                }
                return damProjectData.DesignCalculations;
            }
        }

        [Test]
        [Category("Work_In_Progress")]
        [Ignore("DamMacroStability kernel is being replaced by Macrostability kernel in DamEngine")] 
        public void TestStabilityClassicOutsideWith2DstiFiles()
        {
            const double diff = 0.001;
            string projectFilename = @"..\..\..\data\DamEngineTestProjects\DAM Tutorial Design\DAM Tutorial Design.damx";

            var allCalculationresults = ComputeStabilityOutsideProjectUsingClassic(projectFilename, 19);
            Assert.AreEqual(1, allCalculationresults.Count);
            // Results as found with Dam Classic. These should be reproduced in the first place, however wrong these might be ;-)            
            Assert.AreEqual("DWP_1", allCalculationresults[0].LocationName);
            Assert.AreEqual(CalculationResult.Succeeded, allCalculationresults[0].CalculationResult);
            Assert.AreEqual(99718.000, allCalculationresults[0].X);
            Assert.AreEqual(437106.000, allCalculationresults[0].Y);
            Assert.AreEqual(AnalysisType.NoAdaption, allCalculationresults[0].AnalysisType);
            Assert.AreEqual(false, allCalculationresults[0].IsUplift);
            Assert.AreEqual("DWP_1.sti", allCalculationresults[0].ProfileName);
            Assert.AreEqual(100, allCalculationresults[0].ProfileProbability);
            Assert.AreEqual(MStabModelType.Bishop, allCalculationresults[0].StabilityModel);
            Assert.That(allCalculationresults[0].SafetyFactor, Is.EqualTo(1.545).Within(diff));
            Assert.That(allCalculationresults[0].ShoulderHeight, Is.Null);
            Assert.That(allCalculationresults[0].ToeAtPolderX, Is.Null);
            Assert.That(allCalculationresults[0].ToeAtPolderZ, Is.Null);
            Assert.AreEqual(1.170, allCalculationresults[0].RequiredSafetyFactor);
            Assert.AreEqual(4.4, allCalculationresults[0].RiverLevel);
            Assert.AreEqual(0.63, allCalculationresults[0].RiverLevelLow);
            Assert.AreEqual(4.900, allCalculationresults[0].DikeTableHeight);
            Assert.AreEqual(0.000, allCalculationresults[0].SlopeDampingPiezometricHeightPolderSide);
            Assert.AreEqual(36.150, allCalculationresults[0].DikeLength);
            Assert.That(allCalculationresults[0].Pl3MinUplift, Is.EqualTo(1.837).Within(diff));
            Assert.AreEqual(1.60, allCalculationresults[0].Pl3HeadAdjusted);
            Assert.That(allCalculationresults[0].Pl3LocalLocationXMinUplift, Is.EqualTo(106).Within(diff));
            Assert.That(allCalculationresults[0].Pl3LocationXMinUplift, Is.EqualTo(114.42).Within(diff));
            Assert.AreEqual(0.000, allCalculationresults[0].Pl3LocationYMinUplift);
            Assert.AreEqual(0.000, allCalculationresults[0].Pl4MinUplift);
            Assert.AreEqual(0.000, allCalculationresults[0].Pl4HeadAdjusted);
            Assert.AreEqual(0.000, allCalculationresults[0].Pl4LocalLocationXMinUplift);
            Assert.AreEqual(8.420, allCalculationresults[0].Pl4LocationXMinUplift);
            Assert.AreEqual(0.000, allCalculationresults[0].Pl4LocationYMinUplift);
            Assert.That(allCalculationresults[0].LocalPipingEntryPointX, Is.EqualTo(16.190).Within(diff));
            Assert.That(allCalculationresults[0].PipingEntryPointX, Is.EqualTo(24.610).Within(diff));
            Assert.AreEqual(0.000, allCalculationresults[0].PipingEntryPointY);
            Assert.AreEqual(null, allCalculationresults[0].LocalPipingExitPointX);
            Assert.AreEqual(null, allCalculationresults[0].PipingExitPointX);
            Assert.AreEqual(null, allCalculationresults[0].PipingExitPointY);
            Assert.AreEqual(null, allCalculationresults[0].SeepageLength);
            Assert.AreEqual("", allCalculationresults[0].ResultMessage);
            Assert.AreEqual(null, allCalculationresults[0].HeaveFactor);
            Assert.AreEqual("", allCalculationresults[0].Notes);
            // * Number of iterations = 0
            Assert.AreEqual(0, allCalculationresults[0].NumberOfIterations);
            // * Evaluation = not evaluated
            Assert.AreEqual(ResultEvaluation.NotEvaluated, allCalculationresults[0].ResultEvaluation);
            // * 1 leeg veld (Uplift Factor)
            Assert.AreEqual(null, allCalculationresults[0].UpliftFactor);
        }

        [Test]
        [Category("Work_In_Progress")]
        [Ignore("DamMacroStability kernel is being replaced by Macrostability kernel in DamEngine and Stability Outside is not yet implemented.")]
        public void TestStabilityClassicOutsideWith1DProfiles()
        {
            const double diff = 0.001;
            string projectFilename = @"..\..\..\data\DamEngineTestProjects\Actualisatie\Actualisatie.damx";

            var allCalculationresults = ComputeStabilityOutsideProjectUsingClassic(projectFilename, 56);
            Assert.AreEqual(36, allCalculationresults.Count);
            // Results for calc 2 (results[1]) as found with Dam Classic. These should be reproduced in the first place, however wrong these might be ;-)
            Assert.AreEqual("RK210-560", allCalculationresults[1].LocationName);
            Assert.AreEqual(CalculationResult.Succeeded, allCalculationresults[1].CalculationResult);
            Assert.AreEqual(88218.047, allCalculationresults[1].X, diff);
            Assert.AreEqual(448871.233, allCalculationresults[1].Y, diff);
            Assert.AreEqual(AnalysisType.NoAdaption, allCalculationresults[1].AnalysisType);
            Assert.AreEqual(false, allCalculationresults[1].IsUplift);
            Assert.AreEqual("Segment_1_1D2", allCalculationresults[1].ProfileName);
            Assert.AreEqual(2.43, allCalculationresults[1].ProfileProbability);
            Assert.AreEqual(MStabModelType.Bishop, allCalculationresults[1].StabilityModel);
            Assert.That(allCalculationresults[1].SafetyFactor, Is.EqualTo(1.079).Within(diff));
            Assert.AreEqual(null, allCalculationresults[1].ShoulderHeight);
            Assert.AreEqual(null, allCalculationresults[1].ToeAtPolderX);
            Assert.AreEqual(null, allCalculationresults[1].ToeAtPolderZ);
            Assert.AreEqual(0.900, allCalculationresults[1].RequiredSafetyFactor);
            Assert.AreEqual(-2.090, allCalculationresults[1].RiverLevel);
            Assert.AreEqual(-2.520, allCalculationresults[1].RiverLevelLow);
            Assert.That(allCalculationresults[1].DikeTableHeight, Is.EqualTo(-2.000).Within(diff));
            Assert.AreEqual(0.000, allCalculationresults[1].SlopeDampingPiezometricHeightPolderSide);
            Assert.That(allCalculationresults[1].DikeLength, Is.EqualTo(14.12).Within(diff * 10));

            //             * PL3 Min uplift = null
            Assert.AreEqual(null, allCalculationresults[1].Pl3MinUplift);
            //             * PL3 Head adjusted = null
            Assert.AreEqual(null, allCalculationresults[1].Pl3HeadAdjusted);
            //             * PL3 Min uplift (X local) = null
            Assert.AreEqual(null, allCalculationresults[1].Pl3LocalLocationXMinUplift);
            //             * PL3 Min uplift (X global) = null
            Assert.AreEqual(null, allCalculationresults[1].Pl3LocationXMinUplift);
            //             * PL3 Min uplift (Y global) = null
            Assert.AreEqual(null, allCalculationresults[1].Pl3LocationYMinUplift);
            //             * PL4 Min uplift = null
            Assert.AreEqual(null, allCalculationresults[1].Pl4MinUplift);
            //             * PL4 Head adjusted = null
            Assert.AreEqual(null, allCalculationresults[1].Pl4HeadAdjusted);
            //             * PL4 Min uplift (X local) = null
            Assert.AreEqual(null, allCalculationresults[1].Pl4LocalLocationXMinUplift);
            //             * PL4 Min uplift (X global) = null
            Assert.AreEqual(null, allCalculationresults[1].Pl4LocationXMinUplift);
            //             * PL4 Min uplift (Y global) = null
            Assert.AreEqual(null, allCalculationresults[1].Pl4LocationYMinUplift);


            Assert.That(allCalculationresults[1].LocalPipingEntryPointX, Is.EqualTo(9.798).Within(diff));
            Assert.That(allCalculationresults[1].PipingEntryPointX, Is.EqualTo(88216.844).Within(diff));
            Assert.That(allCalculationresults[1].PipingEntryPointY, Is.EqualTo(448870.287).Within(diff));
            Assert.AreEqual(null, allCalculationresults[1].LocalPipingExitPointX);
            Assert.AreEqual(null, allCalculationresults[1].PipingExitPointX);
            Assert.AreEqual(null, allCalculationresults[1].PipingExitPointY);
            Assert.AreEqual(null, allCalculationresults[1].SeepageLength);
            Assert.AreEqual("", allCalculationresults[1].ResultMessage);
            Assert.AreEqual(null, allCalculationresults[1].HeaveFactor);
            Assert.AreEqual("", allCalculationresults[1].Notes);
            Assert.AreEqual(0, allCalculationresults[1].NumberOfIterations);
            Assert.AreEqual(ResultEvaluation.NotEvaluated, allCalculationresults[1].ResultEvaluation);
            Assert.AreEqual(null, allCalculationresults[1].UpliftFactor);
        }
    }
}