// Copyright (C) Stichting Deltares 2021. 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 Deltares.Standard.Logging;
using Deltares.Standard.TestUtils;
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, out List<LogMessage> calculationMessages)
        {
            // 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);
                }
                var allCalculationresults = damProjectData.DesignCalculations;
                calculationMessages = damProjectData.CalculationMessages;
                return allCalculationresults;
            }
        }

        [Test, Ignore]
        [Category(Categories.WorkInProgress)] // 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";

            List<LogMessage> calculationMessages;
            var allCalculationresults = ComputeStabilityOutsideProjectUsingClassic(projectFilename, 19, out calculationMessages);
            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.AreEqual(1.545, allCalculationresults[0].SafetyFactor, diff);
            Assert.AreEqual(null, allCalculationresults[0].ShoulderHeight);
            Assert.AreEqual(null, allCalculationresults[0].ToeAtPolderX);
            Assert.AreEqual(null, allCalculationresults[0].ToeAtPolderZ);
            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.AreEqual(1.837, allCalculationresults[0].Pl3MinUplift, diff);
            Assert.AreEqual(1.60, allCalculationresults[0].Pl3HeadAdjusted);
            Assert.AreEqual(106, allCalculationresults[0].Pl3LocalLocationXMinUplift, diff);
            Assert.AreEqual(114.42, allCalculationresults[0].Pl3LocationXMinUplift, 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.AreEqual(16.190, allCalculationresults[0].LocalPipingEntryPointX, diff);
            Assert.AreEqual(24.610, allCalculationresults[0].PipingEntryPointX, 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, Ignore]
        [Category(Categories.WorkInProgress)] // DamMacroStability kernel is being replaced by Macrostability kernel in DamEngine 
        public void TestStabilityClassicOutsideWith1DProfiles()
        {
            const double diff = 0.001;
            string projectFilename = @"..\..\..\data\DamEngineTestProjects\Actualisatie\Actualisatie.damx";

            List<LogMessage> calculationMessages;
            var allCalculationresults = ComputeStabilityOutsideProjectUsingClassic(projectFilename, 56, out calculationMessages);
            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.AreEqual(1.079, allCalculationresults[1].SafetyFactor, 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.AreEqual(-2.000, allCalculationresults[1].DikeTableHeight, diff);
            Assert.AreEqual(0.000, allCalculationresults[1].SlopeDampingPiezometricHeightPolderSide);
            Assert.AreEqual(14.12, allCalculationresults[1].DikeLength, diff * 10);
            Assert.AreEqual(1.851, allCalculationresults[1].Pl3MinUplift, diff);
            Assert.AreEqual(-5.370, allCalculationresults[1].Pl3HeadAdjusted, diff);
            Assert.AreEqual(31.329, allCalculationresults[1].Pl3LocalLocationXMinUplift, diff);
            Assert.AreEqual(88233.750, allCalculationresults[1].Pl3LocationXMinUplift, diff);
            Assert.AreEqual(448883.620, allCalculationresults[1].Pl3LocationYMinUplift, diff);
            Assert.AreEqual(0.000, allCalculationresults[1].Pl4MinUplift);
            Assert.AreEqual(0.000, allCalculationresults[1].Pl4HeadAdjusted);
            Assert.AreEqual(0.000, allCalculationresults[1].Pl4LocalLocationXMinUplift);
            Assert.AreEqual(88209.150, allCalculationresults[1].Pl4LocationXMinUplift, diff);
            Assert.AreEqual(448864.220, allCalculationresults[1].Pl4LocationYMinUplift, diff);
            Assert.AreEqual(9.798, allCalculationresults[1].LocalPipingEntryPointX, diff);
            Assert.AreEqual(88216.844, allCalculationresults[1].PipingEntryPointX, diff);
            Assert.AreEqual(448870.287, allCalculationresults[1].PipingEntryPointY, 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);
        }
    }
}