// 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 System.IO;
using System.Linq;
using Deltares.Dam.Data;
using Deltares.Dam.Data.DataPlugins;
using Deltares.Dam.Data.DataPlugins.Configuration;
using Deltares.Geotechnics.SurfaceLines;
using NUnit.Framework;

namespace Deltares.Dam.Tests
{
    [TestFixture]
    public class WaterBoardImporterTests
    {
        private const string DirectoryWithCsvFiles = @"..\..\..\data\Dam\Waterboards\Groot Salland\Binnenwaarts";
        private List<DataSource> srcDataSources;
        private DataPluginImporter dataPluginImporter;
        private 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("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 = "dwp04_1";
            const double cTolerance = 0.00001;
            const double cToleranceCoordinate = 0.00001;
            SetupForCsvFilesImport();
            using (var waterBoard =
                   WaterBoardImporter.ImportAllData("", dataSourceContainer, DamProjectType.Calamity, null))
            {
                // Check Dike
                Assert.AreEqual(1, waterBoard.Dikes.Count);
                var dike = waterBoard.Dikes[0];

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

                // Check Soilprofiles
                Assert.AreEqual(26, dike.SoilProfiles.Count);
                var 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);
                var 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(13, dike.SurfaceLines2.Count);
                var 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);
                var 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);

                var 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(13, dike.Locations.Count);
                var location = dike.Locations.First(x => x.Name.Equals(locationId));
//                Assert.AreEqual(0.25, location.MinimalCircleDepth, cTolerance); // is default from modelparameters

                Assert.AreEqual("segment_dijkring10_dwp04_1", location.Segment.Name);
                Assert.AreEqual("dijkring10_dwp04_1", location.SurfaceLine2.Name);

                dike.Validate();
            }
        }

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

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

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

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

                // Check Soilprofiles
                Assert.AreEqual(23, dike.SoilProfiles.Count);
                var 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);
                var soil = dike.SoilList.Soils[dike.SoilList.GetSoilIndexByName("kade")];
                Assert.AreEqual(17.0, soil.AbovePhreaticLevel, cTolerance);


                // Check Segments
                Assert.AreEqual(2, waterBoard.Segments.Count);
                var 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("Slow")]
        public void ImportWaterBoardOnlyCsvFiles2D()
        {
            //const double cTolerance = 0.0001;
            const string definitionFilename = @".\TestData\CSVData\Full2DProject\Import.defx";
            const string projectFilename = @".\TestData\TestWithGeometries2D.damx";
            using (var damProject = new DamProject())
            {
                dataSourceContainer = DataSourceContainer.Deserialize(definitionFilename);
                var damImportFolder = Path.GetDirectoryName(definitionFilename);
                IList<string> dikeList = WaterBoardImporter.ImportDikeRingIds(damImportFolder, dataSourceContainer,
                    DamProjectType.Calamity, out _).ToList();
                damProject.DamProjectData.WaterBoard = WaterBoardImporter.ImportDataForDikeRings("", damImportFolder,
                    dataSourceContainer,
                    dikeList, 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);
                var dike = damProject.DamProjectData.WaterBoard.Dikes[0];

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

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

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

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

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

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

            dataSourceContainer = DataSourceContainer.Deserialize(definitionFilename);
            var damImportFolder = Path.GetDirectoryName(definitionFilename);
            IList<string> dikeList =
                WaterBoardImporter.ImportDikeRingIds(damImportFolder, dataSourceContainer, DamProjectType.Calamity,
                    out _).ToList();
            using (var waterBoard = WaterBoardImporter.ImportDataForDikeRings("", damImportFolder, dataSourceContainer,
                       dikeList, DamProjectType.Calamity, null))
            using (var referenceWaterBoard = WaterBoardImporter.ImportDataForDikeRings("", damImportFolder,
                       dataSourceContainer,
                       dikeList, 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);
                var dike = waterBoard.Dikes[0];

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

                // Check Soilprofiles
                // Count is 43: 23 (imported) + 7 (generated for first location) + 13 (generated for second location) 
                Assert.AreEqual(43, dike.SoilProfiles.Count);
                var 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.Layers[1].TopLevel, dikeToeAtPolder.Z, cTolerance);
                }

                // Compare reference waterboard to converted waterboard
                foreach (var location in waterBoard.Locations)
                {
                    var referenceLocation = referenceWaterBoard.Locations.Find(l => l.Name.Equals(location.Name));
                    var soilProbabilityIndex = 0;
                    foreach (var referenceSoilProfileProbability in referenceLocation.Segment.SoilProfileProbabilities)
                    {
                        soilProbabilityIndex++;
                        var soilProfileProbability =
                            location.Segment.SoilProfileProbabilities.Find(
                                s => s.SoilProfile.Name.Equals(string.Format("{0}-{1}-{2}", 
                                    referenceSoilProfileProbability.SoilProfile.Name, location.Name, soilProbabilityIndex)));
                        for (var layerIndex = 0;
                            layerIndex < soilProfileProbability.SoilProfile.LayerCount;
                            layerIndex++)
                        {
                            // As the moved profile has a new top layer, make sure to compare the proper layers 
                            if (layerIndex > 0)
                            {
                                Assert.AreEqual(
                                    referenceSoilProfileProbability.SoilProfile.Layers[layerIndex - 1].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],
                                        soilProfileProbability.SoilProfile.Layers[layerIndex].TopLevel,
                                        soilProfileProbability.SoilProfile.Layers[layerIndex].BottomLevel,
                                        referenceSoilProfileProbability.SoilProfile.Layers[layerIndex - 1].TopLevel,
                                        referenceSoilProfileProbability.SoilProfile.Layers[layerIndex - 1]
                                            .BottomLevel));
                            }
                        }
                    }
                }
            }
        }

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

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

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