//-----------------------------------------------------------------------
// <copyright file="DamProjectCalculatorTest.cs" company="Deltares">
//  Copyright (c) 2011 Deltares. All rights reserved.
// </copyright>
// <author>B.S.T.I.M. The</author>
// <email>tom.the@deltares.nl</email>
// <date>03-02-2011</date>
// <summary>n.a.</summary>
//-----------------------------------------------------------------------

using Deltares.Dam.TestHelper;
using Deltares.Geotechnics.TestUtils;
using Deltares.Standard.TestUtils;

namespace Deltares.Dam.Tests
{
    using System.IO;
    using System.Collections.Generic;
    using Deltares.Dam.Data;
    using NUnit.Framework;

    [TestFixture]
    public class DamProjectCalculatorTest
    {
        [Test]
        //[Ignore("Hangs on Teamcity")]
        [Category(Categories.Slow)]
        public void SingleDamCalculationWithStablityReturnsCorrectSafetyFactor()
        {
            // Define dike data
            using (DamProjectData damProjectData = CreateDamProjectData())
            {
                DamProjectCalculator damProjectCalculator = CreateDamProjectCalculator(damProjectData);
                DamProjectCalculationSpecification.SelectedAnalysisType = AnalysisType.NoAdaption;
                var calculationScenarios = new List<Scenario>();

                // Define scenarios
                using (var location = new Location())
                using (var line = FactoryForSurfaceLineTests.CreateSurfaceLineTutorial1())
                {
                    Scenario calculationScenario = FactoryForStabilityTests.CreateScenarioForLocation(location, line);
                    calculationScenario.DikeTableHeight = 5;
                    calculationScenario.RiverLevel = 3;
                    calculationScenario.WaterHeightDecimeringsHoogte = 0.75;
                    calculationScenario.MaxWaterLevel = 10;
                    calculationScenario.Location = damProjectData.WaterBoard.Dikes[0].Locations[0];
                    calculationScenario.Location.ModelFactors.RequiredSafetyFactorStabilityInnerSlope = 1.0;
                    calculationScenario.Location.ModelFactors.UpliftCriterionStability = 1.0;
                    calculationScenarios.Add(calculationScenario);
                    List<List<CsvExportData>> allCalculationresults = damProjectCalculator.Calculate(damProjectData,
                        calculationScenarios);
                    // The expected value is read from the dumpfile itself
                    double expectedValue = 1.461;
                    Assert.AreEqual(expectedValue, allCalculationresults[0][0].StabilitySafetyFactor.Value, 0.001);
                }
            }
        }

        [Test]
        [Ignore("Design to be finalized")]
        public void SingleDesign()
        {
            // Define dike data
            using (DamProjectData damProjectData = CreateDamProjectData())
            {
                DamProjectCalculator damProjectCalculator = CreateDamProjectCalculator(damProjectData);
                DamProjectCalculationSpecification.SelectedAnalysisType = AnalysisType.AdaptGeometry;

                var calculationScenarios = new List<Scenario>();

                // Define scenarios
                using (var line = FactoryForSurfaceLineTests.CreateSurfaceLineTutorial1())
                using (var location = new Location())
                {
                    Scenario scenario = FactoryForStabilityTests.CreateScenarioForLocation(location, line);
                    scenario.DikeTableHeight = 5.5;
                    scenario.RiverLevel = 3;
                    scenario.WaterHeightDecimeringsHoogte = 0.75;
                    scenario.MaxWaterLevel = 10;
                    scenario.Location = damProjectData.WaterBoard.Dikes[0].Locations[0];
                    scenario.Location.ModelFactors.RequiredSafetyFactorStabilityInnerSlope = 1.5;
                    scenario.Location.ModelFactors.UpliftCriterionStability = 1.0;
                    calculationScenarios.Add(scenario);

                    List<List<CsvExportData>> allCalculationresults = damProjectCalculator.Calculate(damProjectData, calculationScenarios);
                    // The expected value is read from the dumpfile itself
                    double expectedValue = 1.575;
                    Assert.AreEqual(expectedValue, allCalculationresults[0][0].StabilitySafetyFactor.Value, 0.001);
                }
            }
        }

        [Test]
        [Ignore("Design to be finalized")]
        public void MultipleDesign()
        {
            // Define dike data
            using (DamProjectData damProjectData = CreateDamProjectData())
            {
                DamProjectCalculator damProjectCalculator = CreateDamProjectCalculator(damProjectData);
                DamProjectCalculationSpecification.SelectedAnalysisType = AnalysisType.AdaptGeometry;

                var calculationScenarios = new List<Scenario>();

                // Define scenarios
                using (var line = FactoryForSurfaceLineTests.CreateSurfaceLineTutorial1())
                using (var line2 = FactoryForSurfaceLineTests.CreateSurfaceLineTutorial1())
                using (var location1 = new Location())
                using (var location2 = new Location())
                {
                    Scenario scenario = FactoryForStabilityTests.CreateScenarioForLocation(location1, line);
                    scenario.DikeTableHeight = 5;
                    scenario.RiverLevel = 3;
                    scenario.WaterHeightDecimeringsHoogte = 0.75;
                    scenario.MaxWaterLevel = 10;
                    scenario.Location = damProjectData.WaterBoard.Dikes[0].Locations[0];
                    scenario.Location.ModelFactors.RequiredSafetyFactorStabilityInnerSlope = 1.5;
                    scenario.Location.ModelFactors.UpliftCriterionStability = 1.0;
                    calculationScenarios.Add(scenario);

                    // Define scenarios
                    Scenario scenario2 = FactoryForStabilityTests.CreateScenarioForLocation(location2, line2);
                    scenario2.DikeTableHeight = 6;
                    scenario2.RiverLevel = 4;
                    scenario2.WaterHeightDecimeringsHoogte = 0.65;
                    scenario2.MaxWaterLevel = 13;
                    scenario2.Location = damProjectData.WaterBoard.Dikes[0].Locations[0];
                    scenario2.Location.ModelFactors.RequiredSafetyFactorStabilityInnerSlope = 1.5;
                    scenario2.Location.ModelFactors.UpliftCriterionStability = 1.0;
                    calculationScenarios.Add(scenario2);

                    List<List<CsvExportData>> allCalculationresults = damProjectCalculator.Calculate(damProjectData, calculationScenarios);
                    // The expected value is read from the dumpfile itself
                    double expectedValueScenario1 = 1.630;
                    Assert.AreEqual(expectedValueScenario1, allCalculationresults[0][0].StabilitySafetyFactor.Value, 0.001);
                    double expectedValueScenario2 = 1.554;
                    Assert.AreEqual(expectedValueScenario2, allCalculationresults[1][0].StabilitySafetyFactor.Value, 0.001);
                }
            }
        }

        private DamProjectData CreateDamProjectData()
        {
            var damProjectData = new DamProjectData();
            damProjectData.WaterBoard.Dikes.Add(FactoryForStabilityTests.CreateDike());
            MStabParameters mstabParameters = FactoryForStabilityTests.CreateMStabParameters();
            DamProject.ProjectWorkingPathLocation = ProjectPathLocation.InUserMap;
            DamProject.UserWorkingPath = Path.GetFullPath("DamCalculation");
            var damCalculationSpecification = new DamFailureMechanismeCalculationSpecification()
                                                  {
                                                      FailureMechanismSystemType = FailureMechanismSystemType.StabilityInside,
                                                      FailureMechanismeParamatersMStab = new FailureMechanismeParamatersMStab()
                                                                                             {
                                                                                                 MStabParameters = mstabParameters
                                                                                             }
                                                  };
            DamProjectCalculationSpecification.SelectedAnalysisType = AnalysisType.NoAdaption;
            damProjectData.DamProjectCalculationSpecification.SelectedProbabilisticType = ProbabilisticType.Deterministic;
            damProjectData.DamProjectCalculationSpecification.DamCalculationSpecifications.Add(damCalculationSpecification);
            return damProjectData;
        }

        private DamProjectCalculator CreateDamProjectCalculator(DamProjectData damProjectData)
        {
            const string cmstabProgramPath = ".\\DGeoStability.exe";
            var damProjectCalculator = new DamProjectCalculator(damProjectData);
            damProjectCalculator.MStabProgramPath = cmstabProgramPath;
            damProjectCalculator.CalculationBaseDirectory = Path.GetTempFileName();
            if (File.Exists(damProjectCalculator.CalculationBaseDirectory))
                File.Delete(damProjectCalculator.CalculationBaseDirectory);
            return damProjectCalculator;
        }
    }
}