// Copyright (C) Stichting Deltares 2018. 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;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Deltares.Dam.Data;
using Deltares.Dam.Data.DamEngineIo;
using Deltares.Dam.Data.Importers;
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.StabilityKernelType = StabilityKernelType.DamClassic;
                damProjectData.DamProjectCalculationSpecification.CurrentSpecification.StabilityModelType = MStabModelType.Bishop;
                damProjectData.DamProjectCalculationSpecification.CurrentSpecification.FailureMechanismeParamatersMStab.MStabParameters.GridPosition = MStabGridPosition.Left;

                DamEngine.Io.XmlInput.Input input = FillXmlInputFromDamUi.CreateInput(damProjectData);
                string inputXml = DamXmlSerialization.SaveInputAsXmlString(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);
                    FillDamUiFromXmlOutput.AddOutputToDamProjectData(damProjectData, output);
                }
                var allCalculationresults = damProjectData.DesignCalculations;
                return allCalculationresults;
            }
        }

        [Test, Category("Work_In_Progress")]
        public void TestStabilityClassicOutsideWith2DstiFiles()
        {
            const double diff = 0.001;
            string projectFilename = @"..\..\..\data\DamEngineTestProjects\DAM Tutorial Design\DAM Tutorial Design.damx";

            var allCalculationresults = ComputeStabilityOutsideProjectUsingClassic(projectFilename, 23);
            Assert.AreEqual(1, allCalculationresults.Count);
//             * Results as found with Dam Classic. These should be reprocduced in the first place, however wrong these might be ;-)            
//             * location (name) DWP_1
            Assert.AreEqual("DWP_1", allCalculationresults[0].LocationName);
//             * Calculation Result = Succeeded
            Assert.AreEqual(CalculationResult.Succeeded, allCalculationresults[0].CalculationResult);
//             * Global X = 99718.000
            Assert.AreEqual(99718.000, allCalculationresults[0].X);
//             * Global Y = 437106.000
            Assert.AreEqual(437106.000, allCalculationresults[0].Y);
//             * Analysis = No Adaption
            Assert.AreEqual(AnalysisType.NoAdaption, allCalculationresults[0].AnalysisType);
//             * Probabilistic = Deterministic
            Assert.AreEqual(ProbabilisticType.Deterministic, allCalculationresults[0].ProbabilisticType);
//             * Uplift = true ??? MUST BE FALSE?! is not relevant for outside
            //Assert.AreEqual(true, allCalculationresults[0].IsUplift);  <++++++++++
            Assert.AreEqual(false, allCalculationresults[0].IsUplift);
//             * Profile = "" (empty) but must be name of profile (1D: profile name, 2D-sti: name of stifile used as base, in future with real 2D: profile name)
           // Assert.AreEqual(null, allCalculationresults[0].ProfileName);  <++++++++++++++++
            Assert.AreEqual("DWP_1.sti", allCalculationresults[0].ProfileName);
//             * Profile probability = 100
            Assert.AreEqual(100, allCalculationresults[0].ProfileProbability);
//             * Stability model = Bishop
            Assert.AreEqual(MStabModelType.Bishop, allCalculationresults[0].StabilityModel);
//             * Safety factor = 0.698
            Assert.AreEqual(0.698, allCalculationresults[0].SafetyFactor);
//             * 3 empty fields (shoulder height, toe polder, height toe polder)
            Assert.AreEqual(null, allCalculationresults[0].ShoulderHeight);
            Assert.AreEqual(null, allCalculationresults[0].ToeAtPolderX);
            Assert.AreEqual(null, allCalculationresults[0].ToeAtPolderZ);
//             * Required safety folder = 1.170
            Assert.AreEqual(1.170, allCalculationresults[0].RequiredSafetyFactor);
//             * River level = 4.4
            Assert.AreEqual(4.4, allCalculationresults[0].RiverLevel);
//             * River level low = 0.000
            Assert.AreEqual(0.000, allCalculationresults[0].RiverLevelLow);
//             * Dike table height = 4.900
            Assert.AreEqual(4.900, allCalculationresults[0].DikeTableHeight);
//             * Slope damping factor = 0.000
            Assert.AreEqual(0.000, allCalculationresults[0].SlopeDampingPiezometricHeightPolderSide);
//             * Zone 1 entry point (X local) = 30.684
            Assert.AreEqual(30.684, allCalculationresults[0].LocalZone1EntryPointX);
//             * Zone 1 entry point (Y global) = 0.000
            Assert.AreEqual(0.000, allCalculationresults[0].Zone1EntryPointY);
//             * Zone 1 exit point (X local) = 13.532
            Assert.AreEqual(13.532, allCalculationresults[0].LocalZone1ExitPointX);
//             * Zone 1 exit point (Y global) = 0.000
            Assert.AreEqual(0.000, allCalculationresults[0].Zone1ExitPointY);
//             * 4 lege velden voor zone 2 punten
            Assert.AreEqual(null, allCalculationresults[0].LocalZone2EntryPointX);
            Assert.AreEqual(null, allCalculationresults[0].Zone2EntryPointY);
            Assert.AreEqual(null, allCalculationresults[0].LocalZone2ExitPointX);
            Assert.AreEqual(null, allCalculationresults[0].Zone2ExitPointY);
//             * Dike length = 36.150
            Assert.AreEqual(36.150, allCalculationresults[0].DikeLength);
//             * PL3 Min uplift = 1.141
            // Assert.AreEqual(1.141, allCalculationresults[0].Pl3MinUplift);  <+++++++++++++++ Dam classic geeft toch waarde terwijl niet aan voorwaarde wordt voldaan! getallen zijn gelijk (upliftFactor < pl3MinUplift) in UpdateOutputValuesForPl3_4
            Assert.AreEqual(0.000, allCalculationresults[0].Pl3MinUplift);
//             * PL3 Head adjusted = 4.400
            Assert.AreEqual(0.000, allCalculationresults[0].Pl3HeadAdjusted);
//             * PL3 Min uplift (X local) = 60.640
            Assert.AreEqual(0.000, allCalculationresults[0].Pl3LocalLocationXMinUplift);
//             * PL3 Min uplift (X global) = 69.060
            Assert.AreEqual(8.42, allCalculationresults[0].Pl3LocationXMinUplift);
//             * PL3 Min uplift (Y global) = 0.000
            Assert.AreEqual(0.000, allCalculationresults[0].Pl3LocationYMinUplift);
//             * PL4 Min uplift = 0.000
            Assert.AreEqual(0.000, allCalculationresults[0].Pl4MinUplift);
//             * PL4 Head adjusted = 0.000
            Assert.AreEqual(0.000, allCalculationresults[0].Pl4HeadAdjusted);
//             * PL4 Min uplift (X local) = 0.000
            Assert.AreEqual(0.000, allCalculationresults[0].Pl4LocalLocationXMinUplift);
//             * PL4 Min uplift (X global) = 8.420
            Assert.AreEqual(8.420, allCalculationresults[0].Pl4LocationXMinUplift);
//             * PL4 Min uplift (Y global) = 0.000
            Assert.AreEqual(0.000, allCalculationresults[0].Pl4LocationYMinUplift);
//             * Piping entrypoint (X local) = 16.190 THIS SHOULD BE NULL! 
            Assert.AreEqual(16.190, allCalculationresults[0].LocalPipingEntryPointX, diff);
//             * Piping entry point (X global) = 24.610 THIS SHOULD BE NULL!           
            Assert.AreEqual(24.610, allCalculationresults[0].PipingEntryPointX, diff);
//             * Piping entry point (Y global) = 0.00 THIS SHOULD BE NULL! 
            Assert.AreEqual(0.000, allCalculationresults[0].PipingEntryPointY);
//             * 7 empty fields (3 * piping exit pount, seepage length piping, message, Heave factor, Notes)
            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")]
        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 reprocduced in the first place, however wrong these might be ;-)
//             * location (name) = RK210-560
            Assert.AreEqual("RK210-560", allCalculationresults[1].LocationName);
//             * Calculation Result = Succeeded
            Assert.AreEqual(CalculationResult.Succeeded, allCalculationresults[1].CalculationResult);
//             * Global X = 88218.047
            Assert.AreEqual(88218.047, allCalculationresults[1].X, diff);
//             * Global Y = 448871.233
            Assert.AreEqual(448871.233, allCalculationresults[1].Y, diff);
//             * Analysis = No Adaption
            Assert.AreEqual(AnalysisType.NoAdaption, allCalculationresults[1].AnalysisType);
//             * Probabilistic = Deterministic
            Assert.AreEqual(ProbabilisticType.Deterministic, allCalculationresults[1].ProbabilisticType);
//             * Uplift = false
            Assert.AreEqual(false, allCalculationresults[1].IsUplift);
            //             * Profile = "" (leeg) maar zou gevuld moeten zijn met naam van 1D dus Segment_1_1D2
            Assert.AreEqual("Segment_1_1D2", allCalculationresults[1].ProfileName);
//             * Profile probability = (leeg) maar zou gevuld moeten zijn met 2.43
            Assert.AreEqual(2.43, allCalculationresults[1].ProfileProbability);
//             * Stability model = Bishop
            Assert.AreEqual(MStabModelType.Bishop, allCalculationresults[1].StabilityModel);
//             * Safety factor = 1.079
            Assert.AreEqual(1.079, allCalculationresults[1].SafetyFactor);
//             * 3 lege velden (shoulder height, toe polder, height toe polder)
            Assert.AreEqual(null, allCalculationresults[1].ShoulderHeight);
            Assert.AreEqual(null, allCalculationresults[1].ToeAtPolderX);
            Assert.AreEqual(null, allCalculationresults[1].ToeAtPolderZ);
//             * Required safety folder = 0.900
            Assert.AreEqual(0.900, allCalculationresults[1].RequiredSafetyFactor);
//             * River level = -2.090
            Assert.AreEqual(-2.090, allCalculationresults[1].RiverLevel);
//             * River level low = -2.520
            Assert.AreEqual(-2.520, allCalculationresults[1].RiverLevelLow);
//             * Dike table height = -2.000
            Assert.AreEqual(-2.000, allCalculationresults[1].DikeTableHeight, diff);
//             * Slope damping factor = 0.000
            Assert.AreEqual(0.000, allCalculationresults[1].SlopeDampingPiezometricHeightPolderSide);
//             * Zone 1 entry point (X local) = 12.098
            Assert.AreEqual(12.098, allCalculationresults[1].LocalZone1EntryPointX, diff);
//             * Zone 1 entry point (Y global) = 448871.711
            Assert.AreEqual(448871.711, allCalculationresults[1].Zone1EntryPointY, diff);
//             * Zone 1 exit point (X local) = 9.067
            Assert.AreEqual(9.067, allCalculationresults[1].LocalZone1ExitPointX, diff);
//             * Zone 1 exit point (Y global) = 448869.835
            Assert.AreEqual(448869.835, allCalculationresults[1].Zone1ExitPointY, diff);
//             * 4 lege velden voor zone 2 punten
            Assert.AreEqual(null, allCalculationresults[1].LocalZone2EntryPointX);
            Assert.AreEqual(null, allCalculationresults[1].Zone2EntryPointY);
            Assert.AreEqual(null, allCalculationresults[1].LocalZone2ExitPointX);
            Assert.AreEqual(null, allCalculationresults[1].Zone2ExitPointY);
//             * Dike length = 14.12
            Assert.AreEqual(14.12, allCalculationresults[1].DikeLength, diff * 10);
//             * PL3 Min uplift = 1.851
            //Assert.AreEqual(1.851, allCalculationresults[1].Pl3MinUplift, diff);   <++++++++++++++ Uplift is false so this should be 0
            Assert.AreEqual(0.000, allCalculationresults[1].Pl3MinUplift, diff);
//             * PL3 Head adjusted = -5.370
            // Assert.AreEqual(-5.370, allCalculationresults[1].Pl3HeadAdjusted, diff);   <++++++++++++++ Uplift is false so this should be 0
            Assert.AreEqual(0.000, allCalculationresults[1].Pl3HeadAdjusted, diff);
//             * PL3 Min uplift (X local) = 31.329
            //Assert.AreEqual(31.329, allCalculationresults[1].Pl3LocalLocationXMinUplift, diff);  <++++++++++++ Uplift is false so this should be 0
            Assert.AreEqual(0.000, allCalculationresults[1].Pl3LocalLocationXMinUplift, diff);
//             * PL3 Min uplift (X global) = 88233.750
            //Assert.AreEqual(88233.750, allCalculationresults[1].Pl3LocationXMinUplift, diff);   <++++++++++++++++ Uplift is false so this should be 0
            Assert.AreEqual(88209.150, allCalculationresults[1].Pl3LocationXMinUplift, diff);
//             * PL3 Min uplift (Y global) = 448883.620
            //Assert.AreEqual(448883.620, allCalculationresults[1].Pl3LocationYMinUplift, diff);  <+++++++++++++++++++ Uplift is false so this should be 0
            Assert.AreEqual(448864.220, allCalculationresults[1].Pl3LocationYMinUplift, diff);
//             * PL4 Min uplift = 0.000
            Assert.AreEqual(0.000, allCalculationresults[1].Pl4MinUplift);
//             * PL4 Head adjusted = 0.000
            Assert.AreEqual(0.000, allCalculationresults[1].Pl4HeadAdjusted);
//             * PL4 Min uplift (X local) = 0.000
            Assert.AreEqual(0.000, allCalculationresults[1].Pl4LocalLocationXMinUplift);
//             * PL4 Min uplift (X global) = 88209.150
            Assert.AreEqual(88209.150, allCalculationresults[1].Pl4LocationXMinUplift, diff);
//             * PL4 Min uplift (Y global) = 448864.220
            Assert.AreEqual(448864.220, allCalculationresults[1].Pl4LocationYMinUplift, diff);
//             * Piping entrypoint (X local) = 9.798  THIS SHOULD BE NULL!
            Assert.AreEqual(9.798, allCalculationresults[1].LocalPipingEntryPointX, diff);
//             * Piping entry point (X global) = 88216.844  THIS SHOULD BE NULL!
            Assert.AreEqual(88216.844, allCalculationresults[1].PipingEntryPointX, diff);
//             * Piping entry point (Y global) = 448870.287  THIS SHOULD BE NULL!
            Assert.AreEqual(448870.287, allCalculationresults[1].PipingEntryPointY, diff);
//             * 7 empty fields (3 * piping exit pount, seepage length piping, message, Heave factor, Notes)
            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);
//             * Number of iterations = 0
            Assert.AreEqual(0, allCalculationresults[1].NumberOfIterations);
//             * Evaluation = not evaluated
            Assert.AreEqual(ResultEvaluation.NotEvaluated, allCalculationresults[1].ResultEvaluation);
//             * 1 leeg veld (Uplift Factor)
            Assert.AreEqual(null, allCalculationresults[1].UpliftFactor);

        }

    }
}