//-----------------------------------------------------------------------
// <copyright file="WaterBoardImporterTests.cs" company="Deltares">     
//  Copyright (c) 2011 Deltares. All rights reserved.
// </copyright>
// <author>Tom The</author>
// <email>tom.the@deltares.nl</email>
// <date>05-04-2011</date>
// <summary>Tests for Import Waterboard data</summary>
//-----------------------------------------------------------------------

using System.Collections.Generic;
using System.IO;
using System.Linq;
using Deltares.Standard;
using NUnit.Framework;
using Deltares.Geometry;
using Deltares.Geotechnics;
using Deltares.Probabilistic;
using Deltares.Dam.Data;
using Deltares.Dam.Data.DataPlugins;
using Deltares.Dam.Data.DataPlugins.Configuration;
using Deltares.Geotechnics.Soils;
using Deltares.Geotechnics.SurfaceLines;
using Deltares.Standard.Logging;
using Deltares.Standard.TestUtils;

using Segment = Deltares.Dam.Data.Segment;

namespace Deltares.Dam.Tests
{
    [TestFixture]
    public class WaterBoardImporterTests
    {
        const string DirectoryWithCsvFiles = @"..\..\..\data\Dam\Waterboards\Groot Salland\Binnenwaarts";
        List<DataSource> srcDataSources;
        DataPluginImporter dataPluginImporter;
        DataSourceContainer dataSourceContainer;

        public void SetupForCsvFilesImport()
        {
            srcDataSources = new List<DataSource>
                    {
                        new DataSource
                            {
                                DataSourceType = DataSourceType.CsvFiles,
                                DataLocation = DirectoryWithCsvFiles
                            }
                    };
            dataPluginImporter = new DataPluginImporter();
            dataPluginImporter.SetDataSources("", srcDataSources);
            dataSourceContainer = new DataSourceContainer { DataSourceList = srcDataSources };
        }

        [Test]
        [Category(Categories.Slow)]
        public void WaterBoardImportedWithCsvFilesHasValidData()
        {
            const string soilKleiDuin = "klei duin";
            const string soilProfileId = "10Z_275_STBI_p";
            const string segmentId = "segment_dijkring10_dwp02_4";
            const string surfacelineId = "dijkring10_dwp40_0";
            const string locationId = "dwp02_4";
            const double cTolerance = 0.00001;
            const double cToleranceCoordinate = 0.00001;
            SetupForCsvFilesImport();
            using (var waterBoard = WaterBoardImporter.ImportAllData("", dataSourceContainer, DamType.Primary, DamProjectType.Calamity, null))
            {
                // Check Dike
                Assert.AreEqual(1, waterBoard.Dikes.Count);
                Dike dike = waterBoard.Dikes[0];

                //Check Soils
                Assert.AreEqual(47, dike.SoilList.Soils.Count);
                Soil soil = dike.SoilList.Soils[dike.SoilList.GetSoilIndexByName(soilKleiDuin)];
                Assert.AreEqual(15.7, soil.AbovePhreaticLevel, cTolerance);

                // Check Soilprofiles
                Assert.AreEqual(26, dike.SoilProfiles.Count);
                SoilProfile1D soilProfile = dike.SoilProfiles.First(x => x.Name.Equals(soilProfileId));
                Assert.AreEqual(soilKleiDuin, soilProfile.Layers[0].Soil.Name);

                // Check Segments
                Assert.AreEqual(24, waterBoard.Segments.Count);
                Segment segment = waterBoard.Segments.First(x => x.Name.Equals(segmentId));
                Assert.AreEqual("10Y_024_STBI.sti", segment.SoilProfileProbabilities[0].SoilGeometryName);
                Assert.AreEqual(100.0, segment.SoilProfileProbabilities[0].Probability, cTolerance);
                Assert.IsTrue(segment.SoilProfileProbabilities[0].SegmentFailureMechanismType.Equals(FailureMechanismSystemType.StabilityInside));
                // Check segment with stability and piping
                segment = waterBoard.Segments.Where(x => x.Name.Equals("segment_dijkring10_dwp02_4")).FirstOrDefault();
                Assert.AreEqual("10Y_024_STBI.sti", segment.SoilProfileProbabilities[0].SoilGeometryName);
                Assert.AreEqual(100.0, segment.SoilProfileProbabilities[0].Probability, cTolerance);
                Assert.IsTrue(segment.SoilProfileProbabilities[0].SegmentFailureMechanismType.Equals(FailureMechanismSystemType.StabilityInside));
                Assert.AreEqual("10Y_024_STBI.sti", segment.SoilProfileProbabilities[1].SoilGeometryName);
                Assert.AreEqual(100.0, segment.SoilProfileProbabilities[1].Probability, cTolerance);
                Assert.IsTrue(segment.SoilProfileProbabilities[1].SegmentFailureMechanismType.Equals(FailureMechanismSystemType.Piping));

                // Check surfacelines 
                Assert.AreEqual(24, dike.SurfaceLines2.Count);
                SurfaceLine2 surfaceline = dike.SurfaceLines2.First(x => x.Name.Equals(surfacelineId));
                Assert.IsTrue(surfaceline.Geometry.Points.Any());
                Assert.AreEqual(0.0, surfaceline.Geometry.Points[0].X, cToleranceCoordinate);
                Assert.AreEqual(0.0, surfaceline.Geometry.Points[0].Y, cToleranceCoordinate);
                Assert.AreEqual(-0.48, surfaceline.Geometry.Points[0].Z, cToleranceCoordinate);
                int lastPointIndex = surfaceline.Geometry.Count - 1;
                Assert.AreEqual(71.25, surfaceline.Geometry.Points[lastPointIndex].X, cToleranceCoordinate);
                Assert.AreEqual(0.0, surfaceline.Geometry.Points[lastPointIndex].Y, cToleranceCoordinate);
                Assert.AreEqual(-0.36, surfaceline.Geometry.Points[lastPointIndex].Z, cToleranceCoordinate);

                GeometryPoint point = surfaceline.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelInside);
                Assert.AreEqual(71.25, point.X, cToleranceCoordinate);
                Assert.AreEqual(0.0, point.Y, cToleranceCoordinate);
                Assert.AreEqual(-0.36, point.Z, cToleranceCoordinate);

                // Check locations
                Assert.AreEqual(24, dike.Locations.Count);
                Location location = dike.Locations.First(x => x.Name.Equals(locationId));
                Assert.AreEqual(-0.35, location.PolderLevel, cTolerance);
//                Assert.AreEqual(0.5, location.LevelReductionInside, cTolerance); // is default from modelparameters
//                Assert.AreEqual(0.6, location.LevelReductionOutside, cTolerance); // is default from modelparameters
//                Assert.AreEqual(0.25, location.MinimalCircleDepth, cTolerance); // is default from modelparameters
//                Assert.AreEqual(0.05, location.LayerHeightDeviation, cTolerance); // is default from modelparameters
//                Assert.AreEqual(DistributionType.LogNormal, location.LayerHeightDistribution); // is default from modelparameters

                Assert.AreEqual("segment_dijkring10_dwp02_4", location.Segment.Name);
                Assert.AreEqual("dijkring10_dwp02_4", location.SurfaceLine2.Name);

                dike.Validate();
            }
        }

        [Test]
        [Category(Categories.Slow)]
        public void ImportWaterBoardOnlyCsvFiles1D()
        {
            const double cTolerance = 0.0001;
            const string definitionFilename = @".\TestData\CSVData\Full1DProject\Import.defx";

            dataSourceContainer = DataSourceContainer.Deserialize(definitionFilename);
            string damImportFolder = Path.GetDirectoryName(definitionFilename);
            List<LogMessage> importLogMessages;
            IList<string> dikeList =
                WaterBoardImporter.ImportDikeRingIds(damImportFolder, dataSourceContainer, DamType.Primary, DamProjectType.Calamity, out importLogMessages).ToList();
            using (WaterBoard waterBoard = WaterBoardImporter.ImportDataForDikeRings("", damImportFolder, dataSourceContainer,
                dikeList, DamType.Primary, DamProjectType.Calamity, null))
            {
                //WaterBoard waterBoard = WaterBoardImporter.ImportAllData(damImportFolder, dataSourceContainer, DamType.Primary, null);

                // Check Dike
                Assert.AreEqual(1, waterBoard.Dikes.Count);
                Dike dike = waterBoard.Dikes[0];

                //Check locations
                Assert.AreEqual(2, dike.Locations.Count);

                // Check Soilprofiles
                Assert.AreEqual(23, dike.SoilProfiles.Count);
                SoilProfile1D soilProfile = dike.SoilProfiles.First(x => x.Name.Equals("25_2_1_bz_4"));
                Assert.AreEqual("kade", soilProfile.Layers[0].Soil.Name);

                //Check Soils
                Assert.AreEqual(51, dike.SoilList.Soils.Count);
                Soil soil = dike.SoilList.Soils[dike.SoilList.GetSoilIndexByName("kade")];
                Assert.AreEqual(17.0, soil.AbovePhreaticLevel, cTolerance);


                // Check Segments
                Assert.AreEqual(2, waterBoard.Segments.Count);
                Segment segment = waterBoard.Segments.First(x => x.Name.Equals("106"));
                Assert.AreEqual("25_2_1_bz_1", segment.SoilProfileProbabilities[0].SoilGeometryName);
                Assert.AreEqual(35.0, segment.SoilProfileProbabilities[0].Probability, cTolerance);
                Assert.IsTrue(segment.SoilProfileProbabilities[0].SegmentFailureMechanismType.Equals(FailureMechanismSystemType.StabilityInside));
            }
        }

        [Test]
        [Category(Categories.Slow)]
        public void ImportWaterBoardOnlyCsvFiles2D()
        {
            //const double cTolerance = 0.0001;
            const string definitionFilename = @".\TestData\CSVData\Full2DProject\Import.defx";
            const string projectFilename = @".\TestData\TestWithGeometries2D.damx";
            using (DamProject damProject = new DamProject())
            {
                dataSourceContainer = DataSourceContainer.Deserialize(definitionFilename);
                string damImportFolder = Path.GetDirectoryName(definitionFilename);
                List<LogMessage> importLogMessages;
                IList<string> dikeList = WaterBoardImporter.ImportDikeRingIds(damImportFolder, dataSourceContainer, DamType.Primary, DamProjectType.Calamity, out importLogMessages).ToList();
                damProject.DamProjectData.WaterBoard = WaterBoardImporter.ImportDataForDikeRings("", damImportFolder, dataSourceContainer,
                                                                                  dikeList, DamType.Primary, DamProjectType.Calamity, null);
                damProject.AssignGeometry2DMapnameIfNotAssigned(Path.Combine(damImportFolder, dataSourceContainer.MapSoilProfile2D));

                // Save the data
                damProject.SaveXMLProject(projectFilename, damProject);


                // Check Dike
                Assert.AreEqual(1, damProject.DamProjectData.WaterBoard.Dikes.Count);
                Dike dike = damProject.DamProjectData.WaterBoard.Dikes[0];

                //Check locations
                Assert.AreEqual(32, dike.Locations.Count);
            }
        }

        [Test]
        [Category(Categories.Slow)]
        public void ImportWaterBoardOnlyWithoutPl3AndPl4CsvFiles()
        {
            const string definitionFilename = @".\TestData\CSVData\DataWithoutPl3AndPl4\Import.defx";

            dataSourceContainer = DataSourceContainer.Deserialize(definitionFilename);
            string damImportFolder = Path.GetDirectoryName(definitionFilename);
            List<LogMessage> importLogMessages;
            IList<string> dikeList =
                WaterBoardImporter.ImportDikeRingIds(damImportFolder, dataSourceContainer, DamType.Primary, DamProjectType.Calamity, out importLogMessages).ToList();
            using (WaterBoard waterBoard = WaterBoardImporter.ImportDataForDikeRings("", damImportFolder, dataSourceContainer,
                dikeList, DamType.Primary, DamProjectType.Calamity, null))
            {
                //WaterBoard waterBoard = WaterBoardImporter.ImportAllData(damImportFolder, dataSourceContainer, DamType.Primary, null);

                // Check Dike
                Assert.AreEqual(1, waterBoard.Dikes.Count);
                Dike dike = waterBoard.Dikes[0];

                //Check locations
                Assert.AreEqual(2, dike.Locations.Count);

                Assert.IsNull(dike.Locations[0].HeadPL2);
                Assert.IsNull(dike.Locations[0].HeadPl3);
                Assert.IsNull(dike.Locations[0].HeadPl4);
            }
        }

        [Test]
        [Category(Categories.Slow)]
        public void ImportWaterBoardOnlyCsvFiles1DRelativeSoilProfiles()
        {
            const double cTolerance = 0.0001;
            const string definitionFilename = @".\TestData\CSVData\Full1DProject\Import relative soilprofiles.defx";

            dataSourceContainer = DataSourceContainer.Deserialize(definitionFilename);
            string damImportFolder = Path.GetDirectoryName(definitionFilename);
            List<LogMessage> importLogMessages;
            IList<string> dikeList =
                WaterBoardImporter.ImportDikeRingIds(damImportFolder, dataSourceContainer, DamType.Primary, DamProjectType.Calamity, out importLogMessages).ToList();
            using(WaterBoard waterBoard = WaterBoardImporter.ImportDataForDikeRings("", damImportFolder, dataSourceContainer,
                dikeList, DamType.Primary, DamProjectType.Calamity, null))
            using (WaterBoard referenceWaterBoard = WaterBoardImporter.ImportDataForDikeRings("", damImportFolder, dataSourceContainer,
                    dikeList, DamType.Primary, DamProjectType.Calamity, null))
            {
                // If profiles are defined as relative profiles, new absolute profiles will be generated for each location
                if (dataSourceContainer.IsImportAsRelativeProfiles)
                {
                    WaterBoardPostProcessRelativeProfiles.CreateAbsoluteProfiles(waterBoard, dataSourceContainer.SoilProfileCharacteristicPointReference);
                }

                // Check Dike
                Assert.AreEqual(1, waterBoard.Dikes.Count);
                Dike dike = waterBoard.Dikes[0];

                //Check locations
                Assert.AreEqual(2, dike.Locations.Count);

                // Check Soilprofiles
                Assert.AreEqual(23, dike.SoilProfiles.Count);
                SoilProfile1D soilProfile = dike.SoilProfiles.First(x => x.Name.Equals("25_2_1_bz_4"));
                Assert.AreEqual("kade", soilProfile.Layers[0].Soil.Name);
                Assert.AreEqual(60.0, soilProfile.TopLevel);

                // Check if all profiles are made absolute from relative
                foreach (var location in waterBoard.Locations)
                {
                    foreach (var soilProfileProbability in location.Segment.SoilProfileProbabilities)
                    {
                        var dikeToeAtPolder = location.SurfaceLine2.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
                        Assert.AreEqual(soilProfileProbability.SoilProfile.TopLevel, dikeToeAtPolder.Z, cTolerance);
                    }
                }

                // Compare reference waterboard to converted waterboard
                foreach (var location in waterBoard.Locations)
                {
                    Location referenceLocation = referenceWaterBoard.Locations.Find(l => l.Name.Equals(location.Name));
                    foreach (var soilProfileProbability in location.Segment.SoilProfileProbabilities)
                    {
                        SoilGeometryProbability referenceSoilProfileProbability =
                            referenceLocation.Segment.SoilProfileProbabilities.Find(s => s.SoilProfile.Name.Equals(soilProfileProbability.SoilProfile.Name));
                        for (int layerIndex = 0; layerIndex < soilProfileProbability.SoilProfile.LayerCount; layerIndex++)
                        {
                            Assert.AreEqual(referenceSoilProfileProbability.SoilProfile.Layers[layerIndex].Height,
                                soilProfileProbability.SoilProfile.Layers[layerIndex].Height, cTolerance,
                                string.Format("Location {0} Segment {1} soilProfile {2} Layer {3} ({4}/{5}), Org ({6}/{7})",
                                location.Name, location.Segment.Name, soilProfileProbability.SoilProfile.Name,
                                soilProfileProbability.SoilProfile.Layers[layerIndex].ToString(),
                                soilProfileProbability.SoilProfile.Layers[layerIndex].TopLevel,
                                soilProfileProbability.SoilProfile.Layers[layerIndex].BottomLevel,
                                referenceSoilProfileProbability.SoilProfile.Layers[layerIndex].TopLevel,
                                referenceSoilProfileProbability.SoilProfile.Layers[layerIndex].BottomLevel));
                        }
                    }
                }
            }
        }

        [Test]
        [Category(Categories.Slow)]
        public void IsZoneDataReadCorrectlyFromCsvFiles()
        {
            const double cTolerance = 0.0001;
            const string definitionFilename = @".\TestData\CSVData\ProjectZoneType\Import.defx";

            dataSourceContainer = DataSourceContainer.Deserialize(definitionFilename);
            string damImportFolder = Path.GetDirectoryName(definitionFilename);
            List<LogMessage> importLogMessages;
            IList<string> dikeList =
                WaterBoardImporter.ImportDikeRingIds(damImportFolder, dataSourceContainer, DamType.Primary, DamProjectType.Calamity, out importLogMessages).ToList();
            using (WaterBoard waterBoard = WaterBoardImporter.ImportDataForDikeRings("", damImportFolder, dataSourceContainer,
                dikeList, DamType.Primary, DamProjectType.Calamity, null))
            {
                // Check Dike
                Assert.AreEqual(1, waterBoard.Dikes.Count);
                Dike dike = waterBoard.Dikes[0];

                //Check locations
                Assert.AreEqual(2, dike.Locations.Count);
                Assert.AreEqual(MStabZonesType.ZoneAreas, dike.Locations[0].StabilityZoneType);
                Assert.AreEqual(0.5, dike.Locations[0].ForbiddenZoneFactor, cTolerance);
                Assert.AreEqual(1.6, dike.Locations[0].ZoneAreaRestSlopeCrestWidth, cTolerance);
                Assert.AreEqual(MStabZonesType.ForbiddenZone, dike.Locations[1].StabilityZoneType);
                Assert.AreEqual(0.9, dike.Locations[1].ForbiddenZoneFactor, cTolerance);
                Assert.AreEqual(2.1, dike.Locations[1].ZoneAreaRestSlopeCrestWidth, cTolerance);
            }
        }
    }
}