// Copyright (C) Stichting Deltares 2025. 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.Dam.Data.Importers;
using Deltares.Standard.Language;
using NUnit.Framework;
using DataAttribute = Deltares.Dam.Data.DataPlugins.Configuration.DataAttribute;

namespace Deltares.Dam.Tests
{
    [TestFixture]
    public class DataPluginImporterTests
    {
        private const string Location1Id = "RK210-560";
        private const string Location2Id = "RK210-570";

        private const string HemPolderLocationId1 = "TPL_Hempolder_0010";
        private const string HemPolderLocationId2 = "TPL_Hempolder_0020";
        readonly string directoryWithCsvFiles = Path.Combine(Directory.GetCurrentDirectory(), @"TestData\GrootSallandBinnenwaarts\");

        //Project Invoer1 uses both a locations.csv and a cross section shapefile
        readonly string invoer1DirectoryWithCsvFiles =
            Path.Combine(Directory.GetCurrentDirectory(), @"TestData\Invoer1-STBI-toDesign\csvfiles\");

        readonly string invoer1DirectoryWithDataShapeFiles =
            Path.Combine(Directory.GetCurrentDirectory(), @"TestData\Invoer1-STBI-toDesign\shapefiles\");

        private string tmpTestFolder;

        List<DataSource> srcDataSources;
        DataPluginImporter dataPluginImporter;

        [SetUp]
        public void FixtureSetup()
        {
            tmpTestFolder = Path.Combine(Directory.GetCurrentDirectory(), "TmpDataPluginImporterTests");
            if (!Directory.Exists(tmpTestFolder))
            {
                Directory.CreateDirectory(tmpTestFolder);
            }
        }

        [TearDown]
        public void FixtureTearDown()
        {
            if (Directory.Exists(tmpTestFolder))
            {
                Directory.Delete(tmpTestFolder, true);
            }
        }

        [Test]
        public void CanDefineDataSources()
        {
            var srcDataSources = new List<DataSource>();
            var dataPluginImporter = new DataPluginImporter();

            srcDataSources.Add(new DataSource
            {
                DataSourceType = DataSourceType.CsvFiles,
                DataLocation = directoryWithCsvFiles
            });
            dataPluginImporter.SetDataSources("", srcDataSources);
            //var destDataSources = dataPluginImporter.DataSources.ToList();
            List<DataSource> destDataSources = dataPluginImporter.DataSources.ToList();
            Assert.That(destDataSources.Count(), Is.EqualTo(srcDataSources.Count));
            Assert.That(srcDataSources[0].Equals(destDataSources.FirstOrDefault()), Is.True);
        }

        [Test]
        public void ThrowsExceptionWhenRequestingDataWhenDataSourcesNotDefined()
        {
            var dataPluginImporter = new DataPluginImporter();
            Assert.That(() => dataPluginImporter.DikeInfo, Throws.InstanceOf<DataPluginImporterException>());
        }

        [Test]
        [Category("Slow")]
        public void CanRetrieveDikeInfo()
        {
            var srcDataSources = new List<DataSource>
            {
                new DataSource
                {
                    DataSourceType = DataSourceType.CsvFiles,
                    DataLocation = directoryWithCsvFiles
                }
            };
            var dataPluginImporter = new DataPluginImporter();
            dataPluginImporter.SetDataSources("", srcDataSources);
            dataPluginImporter.ImportDataForDike(null);

            Info info = dataPluginImporter.DikeInfo;
            if (LocalizationManager.CurrentLanguage == LanguageType.Dutch)
            {
                Assert.That(info.Description, Is.EqualTo("Dijk"));
            }
            else
            {
                Assert.That(info.Description, Is.EqualTo("Dike"));
            }

            Assert.That(info.Name, Is.EqualTo("Kering"));
        }

        /// <summary>
        /// Some parameters for location can be read from either locations.csv or shapefile
        /// The value from shapefile overwrites the value from locations.csv
        /// In this test the values for headpl2 in the import files are:
        /// In shapefiles: -5.37 for both locations
        /// In locations.csv: -99 for both locations
        /// Expected value in the scenario of the location will be -5.37 for both locations
        /// </summary>
        [Test]
        public void ValuesFromShapeFileOverwriteValuesFromLocationsCsv()
        {
            SetupInvoer1WithShapeFiles();
            dataPluginImporter.ImportDataForDike(null);

            string scenarioIdOne = dataPluginImporter.GetScenarioList(Location1Id).FirstOrDefault();
            NameValueParameter[] scenarioDetailsOne = dataPluginImporter.GetScenarioDetails(Location1Id, scenarioIdOne).ToArray();
            Assert.That(scenarioDetailsOne, Is.Not.Empty);
            NameValueParameter headPl2ValueOne = scenarioDetailsOne.SingleOrDefault(x => x.ParameterName.Equals("HeadPL2"));
            Assert.That(headPl2ValueOne.ParameterValue, Is.EqualTo("-5.37"));

            string scenarioIdTwo = dataPluginImporter.GetScenarioList(Location2Id).FirstOrDefault();
            NameValueParameter[] scenarioDetailsTwo = dataPluginImporter.GetScenarioDetails(Location2Id, scenarioIdTwo).ToArray();
            Assert.That(scenarioDetailsTwo, Is.Not.Empty);
            NameValueParameter headPl2ValueTwo = scenarioDetailsTwo.SingleOrDefault(x => x.ParameterName.Equals("HeadPL2"));
            Assert.That(headPl2ValueTwo.ParameterValue, Is.EqualTo("-5.37"));
        }

        /// <summary>
        /// Some parameters for scenario can be read from either locations.csv, shapefile or scenarios.csv
        /// The value from scenarios.csv overwrites the value from shapefile, which overwrites the value from locations.csv
        /// In this test the values for headpl3 in the import files are:
        /// In scenarios.csv: not defined
        /// In shapefiles: not defined
        /// In locations.csv: -99 for both locations
        /// Expected value in scenario will be -99
        /// </summary>
        [Test]
        public void ValuesFromLocationsCsvAreCopiedToScenarioIfNotDefinedInScenariosCsvOrShapeFile()
        {
            SetupInvoer1WithoutShapeFiles();
            dataPluginImporter.ImportDataForDike(null);

            string scenarioId = dataPluginImporter.GetScenarioList(Location1Id).FirstOrDefault();
            IEnumerable<NameValueParameter> scenarioDetails = dataPluginImporter.GetScenarioDetails(Location1Id, scenarioId);
            NameValueParameter[] nameValueParameters = scenarioDetails as NameValueParameter[] ?? scenarioDetails.ToArray();
            Assert.That(nameValueParameters.Any(), Is.True);
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL3")).ParameterValue, Is.EqualTo("-99"));

            scenarioDetails = dataPluginImporter.GetScenarioDetails(Location2Id, scenarioId);
            Assert.That(scenarioDetails.First(x => x.ParameterName.Equals("HeadPL3")).ParameterValue, Is.EqualTo("-99"));
        }

        /// <summary>
        /// Some parameters for scenario can be read from either locations.csv, shapefile or scenarios.csv
        /// The value from scenarios.csv overwrites the value from shapefile, which overwrites the value from locations.csv
        /// In this test the values for headpl3 in the import files are:
        /// In scenarios.csv: not defined
        /// In shapefiles: -3.651 for location 1, -3.632 for location 2
        /// In locations.csv: -99 for both locations
        /// Expected value in scenario will be -3.651 for location 1, -3.632 for location 2
        /// </summary>
        [Test]
        public void ValuesFromShapeFileAreCopiedToScenarioIfNotDefinedInScenariosCsv()
        {
            SetupInvoer1WithShapeFiles();
            dataPluginImporter.ImportDataForDike(null);

            string scenarioId = dataPluginImporter.GetScenarioList(Location1Id).FirstOrDefault();
            IEnumerable<NameValueParameter> scenarioDetails = dataPluginImporter.GetScenarioDetails(Location1Id, scenarioId);
            NameValueParameter[] nameValueParameters = scenarioDetails as NameValueParameter[] ?? scenarioDetails.ToArray();
            Assert.That(nameValueParameters.Any(), Is.True);
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL3")).ParameterValue, Is.EqualTo("-3.651"));

            scenarioDetails = dataPluginImporter.GetScenarioDetails(Location2Id, scenarioId);
            Assert.That(scenarioDetails.First(x => x.ParameterName.Equals("HeadPL3")).ParameterValue, Is.EqualTo("-3.632"));
        }

        /// <summary>
        /// RiverLevel must be specified in locations.csv, shapefile or scenarios.csv
        /// In this test reading from shapefile is skipped, RiverLevel is defined in locations, not in scenarios
        /// </summary>
        [Test]
        public void ImportRiverLevelFromLocationsTest()
        {
            // Setup folder for situation where RiverLevel is specified in locations
            string importFolder = Path.Combine(tmpTestFolder, "TmpImportFilesRiverLevelFromLocations");
            if (!Directory.Exists(importFolder))
            {
                Directory.CreateDirectory(importFolder);
            }

            srcDataSources = new List<DataSource>
            {
                new DataSource
                {
                    DataSourceType = DataSourceType.CsvFiles,
                    DataLocation = importFolder
                }
            };
            // Create basic datafiles that are needed to succeed the import method
            CreateBasicDataFiles(importFolder);
            // Create locations.csv that includes RiverLevel
            string importLocationsFile = importFolder + "\\locations.csv";
            CreateLocationsFileWithRiverLevel(importLocationsFile);
            // Create scenarios.csv that does NOT include RiverLevel
            string importScenarioFile = importFolder + "\\scenarios.csv";
            CreateScenariosFileWithoutRiverLevel(importScenarioFile);

            dataPluginImporter = new DataPluginImporter();
            dataPluginImporter.SetDataSources("", srcDataSources);
            dataPluginImporter.ImportDataForDike(null);

            // Expected: The values of location are used for scenario, because it was not specified in scenarios.csv
            string scenarioId = dataPluginImporter.GetScenarioList("RK210-560").FirstOrDefault();
            IEnumerable<NameValueParameter> scenarioDetails = dataPluginImporter.GetScenarioDetails("RK210-560", scenarioId);
            NameValueParameter[] nameValueParameters = scenarioDetails as NameValueParameter[] ?? scenarioDetails.ToArray();
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevel")).ParameterValue, Is.EqualTo("1.2"));
            scenarioId = dataPluginImporter.GetScenarioList("RK210-570").FirstOrDefault();
            scenarioDetails = dataPluginImporter.GetScenarioDetails("RK210-570", scenarioId);
            nameValueParameters = scenarioDetails as NameValueParameter[] ?? scenarioDetails.ToArray();
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevel")).ParameterValue, Is.EqualTo("2.2"));
            // Expected: no error messages
            Assert.That(dataPluginImporter.ImportLogMessages.Count, Is.EqualTo(0));
        }

        /// <summary>
        /// RiverLevel must be specified in locations.csv, shapefile or scenarios.csv
        /// In this test reading from shapefile is skipped, RiverLevel is defined in locations and in scenarios
        /// </summary>
        [Test]
        public void ImportRiverLevelFromScenariosTest()
        {
            // Setup folder for situation where RiverLevel is specified in locations and scenarios
            string importFolder = Path.Combine(tmpTestFolder, "TmpImportFilesRiverLevelFromScenarios");
            if (!Directory.Exists(importFolder))
            {
                Directory.CreateDirectory(importFolder);
            }

            srcDataSources = new List<DataSource>
            {
                new DataSource
                {
                    DataSourceType = DataSourceType.CsvFiles,
                    DataLocation = importFolder
                }
            };
            // Create basic datafiles that are needed to succeed the import method
            CreateBasicDataFiles(importFolder);
            // Create locations.csv that includes RiverLevel
            string importLocationsFile = importFolder + "\\locations.csv";
            CreateLocationsFileWithRiverLevel(importLocationsFile);
            // Create scenarios.csv that includes RiverLevel
            string importScenarioFile = importFolder + "\\scenarios.csv";
            CreateScenariosFileWithRiverLevel(importScenarioFile);

            dataPluginImporter = new DataPluginImporter();
            dataPluginImporter.SetDataSources("", srcDataSources);
            dataPluginImporter.ImportDataForDike(null);

            // Expected: The values of scenarios are used for scenario
            string scenarioId = dataPluginImporter.GetScenarioList("RK210-560").FirstOrDefault();
            IEnumerable<NameValueParameter> scenarioDetails = dataPluginImporter.GetScenarioDetails("RK210-560", scenarioId);
            NameValueParameter[] nameValueParameters = scenarioDetails as NameValueParameter[] ?? scenarioDetails.ToArray();
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevel")).ParameterValue, Is.EqualTo("0.1"));
            scenarioId = dataPluginImporter.GetScenarioList("RK210-570").FirstOrDefault();
            scenarioDetails = dataPluginImporter.GetScenarioDetails("RK210-570", scenarioId);
            nameValueParameters = scenarioDetails as NameValueParameter[] ?? scenarioDetails.ToArray();
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevel")).ParameterValue, Is.EqualTo("0.2"));
            // Expected: no error messages
            Assert.That(dataPluginImporter.ImportLogMessages.Count, Is.EqualTo(0));
        }

        /// <summary>
        /// RiverLevel must be specified in locations.csv, shapefile or scenarios.csv
        /// In this test reading from shapefile is skipped, RiverLevel is NOT defined in locations or scenarios
        /// </summary>
        [Test]
        public void ImportRiverLevelNotSpecifiedTest()
        {
            // Setup folder for situation where RiverLevel is NOT specified in locations and scenarios
            string importFolder = Path.Combine(tmpTestFolder, "TmpImportFilesRiverLevelNotSpecified");
            if (!Directory.Exists(importFolder))
            {
                Directory.CreateDirectory(importFolder);
            }

            srcDataSources = new List<DataSource>
            {
                new DataSource
                {
                    DataSourceType = DataSourceType.CsvFiles,
                    DataLocation = importFolder
                }
            };
            // Create basic datafiles that are needed to succeed the import method
            CreateBasicDataFiles(importFolder);
            // Create locations.csv that includes RiverLevel
            string importLocationsFile = importFolder + "\\locations.csv";
            CreateLocationsFileWithoutRiverLevel(importLocationsFile);
            // Create scenarios.csv that includes RiverLevel
            string importScenarioFile = importFolder + "\\scenarios.csv";
            CreateScenariosFileWithoutRiverLevel(importScenarioFile);

            dataPluginImporter = new DataPluginImporter();
            dataPluginImporter.SetDataSources("", srcDataSources);
            dataPluginImporter.ImportDataForDike(null);

            // Expected: The values are null
            string scenarioId = dataPluginImporter.GetScenarioList("RK210-560").FirstOrDefault();
            IEnumerable<NameValueParameter> scenarioDetails = dataPluginImporter.GetScenarioDetails("RK210-560", scenarioId);
            NameValueParameter[] nameValueParameters = scenarioDetails as NameValueParameter[] ?? scenarioDetails.ToArray();
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevel")).ParameterValue, Is.EqualTo(null));
            scenarioId = dataPluginImporter.GetScenarioList("RK210-570").FirstOrDefault();
            scenarioDetails = dataPluginImporter.GetScenarioDetails("RK210-570", scenarioId);
            nameValueParameters = scenarioDetails as NameValueParameter[] ?? scenarioDetails.ToArray();
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevel")).ParameterValue, Is.EqualTo(null));
            // Expected: no error messages
            Assert.That(dataPluginImporter.ImportLogMessages.Count, Is.EqualTo(0));
        }

        /// <summary>
        /// Test for values that can be read from both scenarios.csv and locations.csv/shapefile for situation:
        /// Locations.csv: filled with only required values (none)
        /// Shapefiles: none
        /// Scenarios.csv: filled with only required values (none)
        /// Expected result: scenario will be filled with defaults
        /// See Log.xlsx for all the values that are in all the files, expected values in column Locations_basic.csv + Scenario_basic.csv
        /// </summary>
        [Test]
        public void ImportHemPolderScenarioDefaultsTest()
        {
            // Copy import data to test folder
            string importFolder = Path.Combine(tmpTestFolder, "ImportHemPolderScenarioDefaultsTest");
            if (Directory.Exists(importFolder))
            {
                Directory.Delete(importFolder, true);
            }

            if (!Directory.Exists(importFolder))
            {
                Directory.CreateDirectory(importFolder);
            }

            string testDataFolderCsv = Path.Combine(Directory.GetCurrentDirectory(), @"TestData\HempolderImport\csvfiles");
            File.Copy(Path.Combine(testDataFolderCsv, "characteristicpoints.csv"), Path.Combine(importFolder, "characteristicpoints.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "segments.csv"), Path.Combine(importFolder, "segments.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "soilprofiles.csv"), Path.Combine(importFolder, "soilprofiles.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "surfacelines.csv"), Path.Combine(importFolder, "surfacelines.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "locations_basic.csv"), Path.Combine(importFolder, "locations.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "scenarios_basic.csv"), Path.Combine(importFolder, "scenarios.csv"));
            // create importer
            SetupInvoerHemPolderWithoutShapeFiles(importFolder);
            dataPluginImporter.ImportDataForDike(null);
            // check values for location 1
            string scenarioId = dataPluginImporter.GetScenarioList(HemPolderLocationId1).FirstOrDefault();
            IEnumerable<NameValueParameter> scenarioDetails = dataPluginImporter.GetScenarioDetails(HemPolderLocationId1, scenarioId);
            NameValueParameter[] nameValueParameters = scenarioDetails as NameValueParameter[] ?? scenarioDetails.ToArray();
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL3")).ParameterValue, Is.EqualTo(null));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL4")).ParameterValue, Is.EqualTo(null));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtRiver")).ParameterValue, Is.EqualTo("0.5"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtPolder")).ParameterValue, Is.EqualTo("1.5"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowShoulderBaseInside")).ParameterValue, Is.EqualTo("0.1"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeToeAtPolder")).ParameterValue, Is.EqualTo("0.1"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetBelowDikeCrestMiddle")).ParameterValue, Is.EqualTo(null));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeCrestMiddle")).ParameterValue, Is.EqualTo(null));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetFactorBelowShoulderCrest")).ParameterValue, Is.EqualTo(null));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetFactorBelowShoulderCrest")).ParameterValue, Is.EqualTo(null));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionStability")).ParameterValue, Is.EqualTo("1.2"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionPiping")).ParameterValue, Is.EqualTo("1.2"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("DikeTableHeight")).ParameterValue, Is.EqualTo(null));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevel")).ParameterValue, Is.EqualTo(null));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevelLow")).ParameterValue, Is.EqualTo(null));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorPiping")).ParameterValue, Is.EqualTo("1"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityInnerSlope")).ParameterValue, Is.EqualTo("1"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityOuterSlope")).ParameterValue, Is.EqualTo("1"));
            // check values for location 2
            scenarioId = dataPluginImporter.GetScenarioList(HemPolderLocationId2).FirstOrDefault();
            scenarioDetails = dataPluginImporter.GetScenarioDetails(HemPolderLocationId2, scenarioId);
            nameValueParameters = scenarioDetails as NameValueParameter[] ?? scenarioDetails.ToArray();
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL3")).ParameterValue, Is.EqualTo(null));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL4")).ParameterValue, Is.EqualTo(null));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtRiver")).ParameterValue, Is.EqualTo("0.5"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtPolder")).ParameterValue, Is.EqualTo("1.5"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowShoulderBaseInside")).ParameterValue, Is.EqualTo("0.1"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeToeAtPolder")).ParameterValue, Is.EqualTo("0.1"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetBelowDikeCrestMiddle")).ParameterValue, Is.EqualTo(null));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeCrestMiddle")).ParameterValue, Is.EqualTo(null));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetFactorBelowShoulderCrest")).ParameterValue, Is.EqualTo(null));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetFactorBelowShoulderCrest")).ParameterValue, Is.EqualTo(null));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionStability")).ParameterValue, Is.EqualTo("1.2"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionPiping")).ParameterValue, Is.EqualTo("1.2"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("DikeTableHeight")).ParameterValue, Is.EqualTo(null));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevel")).ParameterValue, Is.EqualTo(null));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevelLow")).ParameterValue, Is.EqualTo(null));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorPiping")).ParameterValue, Is.EqualTo("1"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityInnerSlope")).ParameterValue, Is.EqualTo("1"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityOuterSlope")).ParameterValue, Is.EqualTo("1"));
        }

        /// <summary>
        /// Test for values that can be read from both scenarios.csv and locations.csv/shapefile for situation:
        /// Locations.csv: completely filled
        /// Shapefiles: none
        /// Scenarios.csv: filled with only required values (waterheight)
        /// Expected result: scenario will be filled with values from locations.csv
        /// See Log.xlsx for all the values that are in all the files, expected values in column Locations_complete.csv + Scenario_basic.csv
        /// </summary>
        [Test]
        public void ImportHemPolderScenarioFromLocationsCsvTest()
        {
            // Copy import data to test folder
            string importFolder = Path.Combine(tmpTestFolder, "ImportHemPolderScenarioFromLocationsCsvTest");
            if (Directory.Exists(importFolder))
            {
                Directory.Delete(importFolder, true);
            }

            if (!Directory.Exists(importFolder))
            {
                Directory.CreateDirectory(importFolder);
            }

            string testDataFolderCsv = Path.Combine(Directory.GetCurrentDirectory(), @"TestData\HempolderImport\csvfiles");
            File.Copy(Path.Combine(testDataFolderCsv, "characteristicpoints.csv"), Path.Combine(importFolder, "characteristicpoints.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "segments.csv"), Path.Combine(importFolder, "segments.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "soilprofiles.csv"), Path.Combine(importFolder, "soilprofiles.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "surfacelines.csv"), Path.Combine(importFolder, "surfacelines.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "locations_complete.csv"), Path.Combine(importFolder, "locations.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "scenarios_basic.csv"), Path.Combine(importFolder, "scenarios.csv"));
            // create importer
            SetupInvoerHemPolderWithoutShapeFiles(importFolder);
            dataPluginImporter.ImportDataForDike(null);
            // check values for location 1
            string scenarioId = dataPluginImporter.GetScenarioList(HemPolderLocationId1).FirstOrDefault();
            IEnumerable<NameValueParameter> scenarioDetails = dataPluginImporter.GetScenarioDetails(HemPolderLocationId1, scenarioId);
            NameValueParameter[] nameValueParameters = scenarioDetails as NameValueParameter[] ?? scenarioDetails.ToArray();
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL3")).ParameterValue, Is.EqualTo("0.11"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL4")).ParameterValue, Is.EqualTo("2.11"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtRiver")).ParameterValue, Is.EqualTo("0.55"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtPolder")).ParameterValue, Is.EqualTo("0.56"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowShoulderBaseInside")).ParameterValue, Is.EqualTo("0.57"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeToeAtPolder")).ParameterValue, Is.EqualTo("0.58"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetBelowDikeCrestMiddle")).ParameterValue, Is.EqualTo("True"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeCrestMiddle")).ParameterValue, Is.EqualTo("0.59"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetFactorBelowShoulderCrest")).ParameterValue, Is.EqualTo("True"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetFactorBelowShoulderCrest")).ParameterValue, Is.EqualTo("0.6"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionStability")).ParameterValue, Is.EqualTo("0.88"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionPiping")).ParameterValue, Is.EqualTo("0.77"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("DikeTableHeight")).ParameterValue, Is.EqualTo("2.88"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevel")).ParameterValue, Is.EqualTo("1.11"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevelLow")).ParameterValue, Is.EqualTo("1.77"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorPiping")).ParameterValue, Is.EqualTo("1.09"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityInnerSlope")).ParameterValue, Is.EqualTo("1.12"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityOuterSlope")).ParameterValue, Is.EqualTo("1.14"));
            // check values for location 2
            scenarioId = dataPluginImporter.GetScenarioList(HemPolderLocationId2).FirstOrDefault();
            scenarioDetails = dataPluginImporter.GetScenarioDetails(HemPolderLocationId2, scenarioId);
            nameValueParameters = scenarioDetails as NameValueParameter[] ?? scenarioDetails.ToArray();
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL3")).ParameterValue, Is.EqualTo("1.11"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL4")).ParameterValue, Is.EqualTo("3.11"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtRiver")).ParameterValue, Is.EqualTo("0.65"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtPolder")).ParameterValue, Is.EqualTo("0.66"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowShoulderBaseInside")).ParameterValue, Is.EqualTo("0.67"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeToeAtPolder")).ParameterValue, Is.EqualTo("0.68"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetBelowDikeCrestMiddle")).ParameterValue, Is.EqualTo("True"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeCrestMiddle")).ParameterValue, Is.EqualTo("0.69"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetFactorBelowShoulderCrest")).ParameterValue, Is.EqualTo("True"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetFactorBelowShoulderCrest")).ParameterValue, Is.EqualTo("0.7"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionStability")).ParameterValue, Is.EqualTo("0.99"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionPiping")).ParameterValue, Is.EqualTo("0.66"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("DikeTableHeight")).ParameterValue, Is.EqualTo("2.99"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevel")).ParameterValue, Is.EqualTo("1.22"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevelLow")).ParameterValue, Is.EqualTo("1.88"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorPiping")).ParameterValue, Is.EqualTo("1.1"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityInnerSlope")).ParameterValue, Is.EqualTo("1.13"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityOuterSlope")).ParameterValue, Is.EqualTo("1.15"));
        }

        /// <summary>
        /// Test for values that can be read from both scenarios.csv and locations.csv/shapefile for situation:
        /// Locations.csv: filled completely
        /// Shapefiles: line shapes filled completely
        /// Scenarios.csv: filled with only required values (waterheight)
        /// Expected result: scenario will be filled with values from shapefiles
        /// See Log.xlsx for all the values that are in all the files, expected values in column Locations_complete.csv + LijnScenario.shp + Scenario_basic.csv
        /// </summary>
        [Test]
        public void ImportHemPolderLineShapeOverLocationsCsvTest()
        {
            // Copy import data to test folder
            string importFolder = Path.Combine(tmpTestFolder, "ImportHemPolderLineShapeOverLocationsCsvTest");
            if (Directory.Exists(importFolder))
            {
                Directory.Delete(importFolder, true);
            }

            if (!Directory.Exists(importFolder))
            {
                Directory.CreateDirectory(importFolder);
            }

            string testDataFolderCsv = Path.Combine(Directory.GetCurrentDirectory(), @"TestData\HempolderImport\csvfiles");
            string testDataFolderShape = Path.Combine(Directory.GetCurrentDirectory(), @"TestData\HempolderImport\shapefiles");
            File.Copy(Path.Combine(testDataFolderCsv, "characteristicpoints.csv"), Path.Combine(importFolder, "characteristicpoints.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "segments.csv"), Path.Combine(importFolder, "segments.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "soilprofiles.csv"), Path.Combine(importFolder, "soilprofiles.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "surfacelines.csv"), Path.Combine(importFolder, "surfacelines.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "locations_complete.csv"), Path.Combine(importFolder, "locations.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "scenarios_basic.csv"), Path.Combine(importFolder, "scenarios.csv"));
            string[] shapefiles = Directory.GetFiles(testDataFolderShape);
            foreach (string shapefile in shapefiles)
            {
                string fileName = Path.GetFileName(shapefile);
                File.Copy(Path.Combine(testDataFolderShape, fileName), Path.Combine(importFolder, fileName));
            }

            // create importer
            SetupInvoerHemPolderWithShapeFiles(importFolder, "LijnScenario.shp");
            dataPluginImporter.ImportDataForDike(null);
            // check values for location 1
            string scenarioId = dataPluginImporter.GetScenarioList(HemPolderLocationId1).FirstOrDefault();
            IEnumerable<NameValueParameter> scenarioDetails = dataPluginImporter.GetScenarioDetails(HemPolderLocationId1, scenarioId);
            NameValueParameter[] nameValueParameters = scenarioDetails as NameValueParameter[] ?? scenarioDetails.ToArray();
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL3")).ParameterValue, Is.EqualTo("1.99"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL4")).ParameterValue, Is.EqualTo("3.99"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtRiver")).ParameterValue, Is.EqualTo("0.2"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtPolder")).ParameterValue, Is.EqualTo("0.21"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowShoulderBaseInside")).ParameterValue, Is.EqualTo("0.22"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeToeAtPolder")).ParameterValue, Is.EqualTo("0.23"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetBelowDikeCrestMiddle")).ParameterValue, Is.EqualTo("False"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeCrestMiddle")).ParameterValue, Is.EqualTo("0.24"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetFactorBelowShoulderCrest")).ParameterValue, Is.EqualTo("False"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetFactorBelowShoulderCrest")).ParameterValue, Is.EqualTo("0.25"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionStability")).ParameterValue, Is.EqualTo("3"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionPiping")).ParameterValue, Is.EqualTo("5"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("DikeTableHeight")).ParameterValue, Is.EqualTo("4"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevel")).ParameterValue, Is.EqualTo("3.5"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevelLow")).ParameterValue, Is.EqualTo("2.5"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorPiping")).ParameterValue, Is.EqualTo("0.6"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityInnerSlope")).ParameterValue, Is.EqualTo("0.63"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityOuterSlope")).ParameterValue, Is.EqualTo("0.66"));
            // check values for location 2
            scenarioId = dataPluginImporter.GetScenarioList(HemPolderLocationId2).FirstOrDefault();
            scenarioDetails = dataPluginImporter.GetScenarioDetails(HemPolderLocationId2, scenarioId);
            nameValueParameters = scenarioDetails as NameValueParameter[] ?? scenarioDetails.ToArray();
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL3")).ParameterValue, Is.EqualTo("0.99"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL4")).ParameterValue, Is.EqualTo("2.99"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtRiver")).ParameterValue, Is.EqualTo("0.1"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtPolder")).ParameterValue, Is.EqualTo("0.11"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowShoulderBaseInside")).ParameterValue, Is.EqualTo("0.12"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeToeAtPolder")).ParameterValue, Is.EqualTo("0.13"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetBelowDikeCrestMiddle")).ParameterValue, Is.EqualTo("False"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeCrestMiddle")).ParameterValue, Is.EqualTo("0.14"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetFactorBelowShoulderCrest")).ParameterValue, Is.EqualTo("True"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetFactorBelowShoulderCrest")).ParameterValue, Is.EqualTo("0.15"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionStability")).ParameterValue, Is.EqualTo("2"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionPiping")).ParameterValue, Is.EqualTo("4"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("DikeTableHeight")).ParameterValue, Is.EqualTo("3"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevel")).ParameterValue, Is.EqualTo("3"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevelLow")).ParameterValue, Is.EqualTo("2"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorPiping")).ParameterValue, Is.EqualTo("0.5"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityInnerSlope")).ParameterValue, Is.EqualTo("0.53"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityOuterSlope")).ParameterValue, Is.EqualTo("0.56"));
        }

        /// <summary>
        /// Test for values that can be read from both scenarios.csv and locations.csv/shapefile for situation:
        /// Locations.csv: filled completely
        /// Shapefiles: area shapes filled completely
        /// Scenarios.csv: filled with only required values (waterheight)
        /// Expected result: scenario will be filled with values from shapefiles
        /// See Log.xlsx for all the values that are in all the files, expected values in column Locations_complete.csv + VlakScenario.shp + Scenario_basic.csv
        /// </summary>
        [Test]
        public void ImportHemPolderAreaShapeOverLocationsCsvTest()
        {
            // Copy import data to test folder
            string importFolder = Path.Combine(tmpTestFolder, "ImportHemPolderAreaShapeOverLocationsCsvTest");
            if (Directory.Exists(importFolder))
            {
                Directory.Delete(importFolder, true);
            }

            if (!Directory.Exists(importFolder))
            {
                Directory.CreateDirectory(importFolder);
            }

            string testDataFolderCsv = Path.Combine(Directory.GetCurrentDirectory(), @"TestData\HempolderImport\csvfiles");
            string testDataFolderShape = Path.Combine(Directory.GetCurrentDirectory(), @"TestData\HempolderImport\shapefiles");
            File.Copy(Path.Combine(testDataFolderCsv, "characteristicpoints.csv"), Path.Combine(importFolder, "characteristicpoints.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "segments.csv"), Path.Combine(importFolder, "segments.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "soilprofiles.csv"), Path.Combine(importFolder, "soilprofiles.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "surfacelines.csv"), Path.Combine(importFolder, "surfacelines.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "locations_complete.csv"), Path.Combine(importFolder, "locations.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "scenarios_basic.csv"), Path.Combine(importFolder, "scenarios.csv"));
            string[] shapefiles = Directory.GetFiles(testDataFolderShape);
            foreach (string shapefile in shapefiles)
            {
                string fileName = Path.GetFileName(shapefile);
                File.Copy(Path.Combine(testDataFolderShape, fileName), Path.Combine(importFolder, fileName));
            }

            // create importer
            SetupInvoerHemPolderWithShapeFiles(importFolder, "VlakScenario.shp");
            dataPluginImporter.ImportDataForDike(null);
            // check values for location 1
            string scenarioId = dataPluginImporter.GetScenarioList(HemPolderLocationId1).FirstOrDefault();
            IEnumerable<NameValueParameter> scenarioDetails = dataPluginImporter.GetScenarioDetails(HemPolderLocationId1, scenarioId);
            NameValueParameter[] nameValueParameters = scenarioDetails as NameValueParameter[] ?? scenarioDetails.ToArray();
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL3")).ParameterValue, Is.EqualTo("0.9"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL4")).ParameterValue, Is.EqualTo("2.9"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtRiver")).ParameterValue, Is.EqualTo("0.05"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtPolder")).ParameterValue, Is.EqualTo("0.06"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowShoulderBaseInside")).ParameterValue, Is.EqualTo("0.07"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeToeAtPolder")).ParameterValue, Is.EqualTo("0.08"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetBelowDikeCrestMiddle")).ParameterValue, Is.EqualTo("True"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeCrestMiddle")).ParameterValue, Is.EqualTo("0.09"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetFactorBelowShoulderCrest")).ParameterValue, Is.EqualTo("False"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetFactorBelowShoulderCrest")).ParameterValue, Is.EqualTo("0.1"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionStability")).ParameterValue, Is.EqualTo("4"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionPiping")).ParameterValue, Is.EqualTo("6"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("DikeTableHeight")).ParameterValue, Is.EqualTo("5"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevel")).ParameterValue, Is.EqualTo("4.5"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevelLow")).ParameterValue, Is.EqualTo("3.5"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorPiping")).ParameterValue, Is.EqualTo("0.81"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityInnerSlope")).ParameterValue, Is.EqualTo("0.83"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityOuterSlope")).ParameterValue, Is.EqualTo("0.85"));
            // check values for location 2
            scenarioId = dataPluginImporter.GetScenarioList(HemPolderLocationId2).FirstOrDefault();
            scenarioDetails = dataPluginImporter.GetScenarioDetails(HemPolderLocationId2, scenarioId);
            nameValueParameters = scenarioDetails as NameValueParameter[] ?? scenarioDetails.ToArray();
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL3")).ParameterValue, Is.EqualTo("1.9"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL4")).ParameterValue, Is.EqualTo("3.9"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtRiver")).ParameterValue, Is.EqualTo("0.15"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtPolder")).ParameterValue, Is.EqualTo("0.16"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowShoulderBaseInside")).ParameterValue, Is.EqualTo("0.17"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeToeAtPolder")).ParameterValue, Is.EqualTo("0.18"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetBelowDikeCrestMiddle")).ParameterValue, Is.EqualTo("False"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeCrestMiddle")).ParameterValue, Is.EqualTo("0.19"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetFactorBelowShoulderCrest")).ParameterValue, Is.EqualTo("True"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetFactorBelowShoulderCrest")).ParameterValue, Is.EqualTo("0.2"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionStability")).ParameterValue, Is.EqualTo("3"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionPiping")).ParameterValue, Is.EqualTo("5"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("DikeTableHeight")).ParameterValue, Is.EqualTo("4"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevel")).ParameterValue, Is.EqualTo("4"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevelLow")).ParameterValue, Is.EqualTo("3"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorPiping")).ParameterValue, Is.EqualTo("0.7"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityInnerSlope")).ParameterValue, Is.EqualTo("0.75"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityOuterSlope")).ParameterValue, Is.EqualTo("0.8"));
        }

        /// <summary>
        /// Test for values that can be read from both scenarios.csv and locations.csv/shapefile for situation:
        /// Locations.csv: filled completely
        /// Shapefiles: line shapes filled completely
        /// Scenarios.csv: filled completely
        /// Expected result: scenario will be filled with values from scenarios.csv
        /// See Log.xlsx for all the values that are in all the files, expected values in column Locations_complete.csv + LijnScenario.shp + Scenario_complete.csv
        /// </summary>
        [Test]
        public void ImportHemPolderScenarioOverShapeAndLocationsCsvTest()
        {
            // Copy import data to test folder
            string importFolder = Path.Combine(tmpTestFolder, "ImportHemPolderScenarioOverShapeAndLocationsCsvTest");
            if (Directory.Exists(importFolder))
            {
                Directory.Delete(importFolder, true);
            }

            if (!Directory.Exists(importFolder))
            {
                Directory.CreateDirectory(importFolder);
            }

            string testDataFolderCsv = Path.Combine(Directory.GetCurrentDirectory(), @"TestData\HempolderImport\csvfiles");
            string testDataFolderShape = Path.Combine(Directory.GetCurrentDirectory(), @"TestData\HempolderImport\shapefiles");
            File.Copy(Path.Combine(testDataFolderCsv, "characteristicpoints.csv"), Path.Combine(importFolder, "characteristicpoints.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "segments.csv"), Path.Combine(importFolder, "segments.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "soilprofiles.csv"), Path.Combine(importFolder, "soilprofiles.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "surfacelines.csv"), Path.Combine(importFolder, "surfacelines.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "locations_complete.csv"), Path.Combine(importFolder, "locations.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "scenarios_complete.csv"), Path.Combine(importFolder, "scenarios.csv"));
            string[] shapefiles = Directory.GetFiles(testDataFolderShape);
            foreach (string shapefile in shapefiles)
            {
                string fileName = Path.GetFileName(shapefile);
                File.Copy(Path.Combine(testDataFolderShape, fileName), Path.Combine(importFolder, fileName));
            }

            // create importer
            SetupInvoerHemPolderWithShapeFiles(importFolder, "LijnScenario.shp");
            dataPluginImporter.ImportDataForDike(null);
            // check values for location 1
            string scenarioId = dataPluginImporter.GetScenarioList(HemPolderLocationId1).FirstOrDefault();
            IEnumerable<NameValueParameter> scenarioDetails = dataPluginImporter.GetScenarioDetails(HemPolderLocationId1, scenarioId);
            NameValueParameter[] nameValueParameters = scenarioDetails as NameValueParameter[] ?? scenarioDetails.ToArray();
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL3")).ParameterValue, Is.EqualTo("0.25"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL4")).ParameterValue, Is.EqualTo("2.25"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtRiver")).ParameterValue, Is.EqualTo("0.75"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtPolder")).ParameterValue, Is.EqualTo("0.76"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowShoulderBaseInside")).ParameterValue, Is.EqualTo("0.77"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeToeAtPolder")).ParameterValue, Is.EqualTo("0.78"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetBelowDikeCrestMiddle")).ParameterValue, Is.EqualTo("True"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeCrestMiddle")).ParameterValue, Is.EqualTo("0.79"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetFactorBelowShoulderCrest")).ParameterValue, Is.EqualTo("True"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetFactorBelowShoulderCrest")).ParameterValue, Is.EqualTo("0.8"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionStability")).ParameterValue, Is.EqualTo("0.9"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionPiping")).ParameterValue, Is.EqualTo("0.91"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("DikeTableHeight")).ParameterValue, Is.EqualTo("0.92"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevel")).ParameterValue, Is.EqualTo("1.5"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevelLow")).ParameterValue, Is.EqualTo("1.25"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorPiping")).ParameterValue, Is.EqualTo("0.93"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityInnerSlope")).ParameterValue, Is.EqualTo("0.94"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityOuterSlope")).ParameterValue, Is.EqualTo("0.95"));
            // check values for location 2
            scenarioId = dataPluginImporter.GetScenarioList(HemPolderLocationId2).FirstOrDefault();
            scenarioDetails = dataPluginImporter.GetScenarioDetails(HemPolderLocationId2, scenarioId);
            nameValueParameters = scenarioDetails as NameValueParameter[] ?? scenarioDetails.ToArray();
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL3")).ParameterValue, Is.EqualTo("1.25"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL4")).ParameterValue, Is.EqualTo("3.25"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtRiver")).ParameterValue, Is.EqualTo("1.75"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtPolder")).ParameterValue, Is.EqualTo("1.76"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowShoulderBaseInside")).ParameterValue, Is.EqualTo("1.77"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeToeAtPolder")).ParameterValue, Is.EqualTo("1.78"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetBelowDikeCrestMiddle")).ParameterValue, Is.EqualTo("True"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeCrestMiddle")).ParameterValue, Is.EqualTo("1.79"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetFactorBelowShoulderCrest")).ParameterValue, Is.EqualTo("True"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetFactorBelowShoulderCrest")).ParameterValue, Is.EqualTo("0.9"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionStability")).ParameterValue, Is.EqualTo("1.9"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionPiping")).ParameterValue, Is.EqualTo("1.91"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("DikeTableHeight")).ParameterValue, Is.EqualTo("1.92"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevel")).ParameterValue, Is.EqualTo("2.5"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevelLow")).ParameterValue, Is.EqualTo("2.25"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorPiping")).ParameterValue, Is.EqualTo("1.93"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityInnerSlope")).ParameterValue, Is.EqualTo("1.94"));
            Assert.That(nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityOuterSlope")).ParameterValue, Is.EqualTo("1.95"));
        }

        private void SetupInvoer1WithShapeFiles()
        {
            srcDataSources = new List<DataSource>
            {
                new DataSource
                {
                    DataSourceType = DataSourceType.CsvFiles,
                    DataLocation = invoer1DirectoryWithCsvFiles
                },
                new DataSource
                {
                    DataSourceType = DataSourceType.DataShapeFiles,
                    DataLocation = invoer1DirectoryWithDataShapeFiles
                }
            };
            dataPluginImporter = new DataPluginImporter
            {
                Attributes = new[]
                {
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.LocationAttributeId,
                        AttributeName = "LocationId",
                        DataSource = "Locationv2.shp"
                    },
                    // Head Pl2 will be put in location, Head Pl3 will be put in scenario if not already imported from scenarios.csv
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.HeadPl3AttributeId,
                        AttributeName = "stijgh_m",
                        DataSource = "winterstijg_zonderDSM.shp"
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.HeadPl2AttributeId,
                        AttributeName = "PLHIGH",
                        DataSource = "Polderpeilen.shp"
                    }
                }
            };

            dataPluginImporter.SetDataSources("", srcDataSources);
        }

        private void SetupInvoer1WithoutShapeFiles()
        {
            srcDataSources = new List<DataSource>
            {
                new DataSource
                {
                    DataSourceType = DataSourceType.CsvFiles,
                    DataLocation = invoer1DirectoryWithCsvFiles
                }
            };
            dataPluginImporter = new DataPluginImporter();
            dataPluginImporter.SetDataSources("", srcDataSources);
        }

        private void SetupInvoerHemPolderWithShapeFiles(string folder, string shapefile)
        {
            srcDataSources = new List<DataSource>
            {
                new DataSource
                {
                    DataSourceType = DataSourceType.CsvFiles,
                    DataLocation = folder
                },
                new DataSource
                {
                    DataSourceType = DataSourceType.DataShapeFiles,
                    DataLocation = folder
                }
            };
            dataPluginImporter = new DataPluginImporter
            {
                Attributes = new[]
                {
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.LocationAttributeId,
                        AttributeName = "LocationId",
                        DataSource = "Locations.shp"
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.HeadPl3AttributeId,
                        AttributeName = "HEADPL3",
                        DataSource = shapefile
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.HeadPl4AttributeId,
                        AttributeName = "HEADPL4",
                        DataSource = shapefile
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.PlLineOffsetBelowDikeTopAtRiverAttributeId,
                        AttributeName = "PLOBDTOPR",
                        DataSource = shapefile
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.PlLineOffsetBelowDikeTopAtPolderAttributeId,
                        AttributeName = "PLOBDTOPP",
                        DataSource = shapefile
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.PlLineOffsetBelowShoulderBaseInsideAttributeId,
                        AttributeName = "PLOBSB",
                        DataSource = shapefile
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.PlLineOffsetBelowDikeToeAtPolderAttributeId,
                        AttributeName = "PLOBDTOEP",
                        DataSource = shapefile
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.UsePlLineOffsetBelowDikeCrestMiddleAttributeId,
                        AttributeName = "USEPLOBDCM",
                        DataSource = shapefile
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.PlLineOffsetBelowDikeCrestMiddleAttributeId,
                        AttributeName = "PLOBDCM",
                        DataSource = shapefile
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.UsePlLineOffsetFactorBelowShoulderCrestAttributeId,
                        AttributeName = "USEPLOFBSC",
                        DataSource = shapefile
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.PlLineOffsetFactorBelowShoulderCrestAttributeId,
                        AttributeName = "PLOFBSC",
                        DataSource = shapefile
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.UpliftCriterionStabilityAttributeId,
                        AttributeName = "UPLSTAB",
                        DataSource = shapefile
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.UpliftCriterionPipingAttributeId,
                        AttributeName = "UPLPIPING",
                        DataSource = shapefile
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.DikeTableHeightAttributeId,
                        AttributeName = "DTH",
                        DataSource = shapefile
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.RiverLevelAttributeId,
                        AttributeName = "WHEIGHT",
                        DataSource = shapefile
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.RiverLevelLowAttributeId,
                        AttributeName = "WHEIGHTLOW",
                        DataSource = shapefile
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.RequiredSafetyFactorPipingAttributeId,
                        AttributeName = "FPIPING",
                        DataSource = shapefile
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.RequiredSafetyFactorStabilityInnerSlopeAttributeId,
                        AttributeName = "FSTABIN",
                        DataSource = shapefile
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.RequiredSafetyFactorStabilityOuterSlopeAttributeId,
                        AttributeName = "FSTABOUT",
                        DataSource = shapefile
                    }
                }
            };
            dataPluginImporter.SetDataSources("", srcDataSources);
        }

        private void SetupInvoerHemPolderWithoutShapeFiles(string folder)
        {
            srcDataSources = new List<DataSource>
            {
                new DataSource
                {
                    DataSourceType = DataSourceType.CsvFiles,
                    DataLocation = folder
                }
            };
            dataPluginImporter = new DataPluginImporter();
            dataPluginImporter.SetDataSources("", srcDataSources);
        }

        private void CreateBasicDataFiles(string importFolder)
        {
            string importFile = importFolder + "\\characteristicpoints.csv";
            if (File.Exists(importFile))
            {
                File.Delete(importFile);
            }

            using (StreamWriter writer = File.CreateText(importFile))
            {
                writer.WriteLine("LOCATIONID;X_Maaiveld binnenwaarts;Y_Maaiveld binnenwaarts;Z_Maaiveld binnenwaarts;X_Insteek sloot polderzijde;Y_Insteek sloot polderzijde;Z_Insteek sloot polderzijde;X_Slootbodem polderzijde;Y_Slootbodem polderzijde;Z_Slootbodem polderzijde;X_Slootbodem dijkzijde;Y_Slootbodem dijkzijde;Z_Slootbodem dijkzijde;X_Insteek sloot dijkzijde;Y_Insteek_sloot dijkzijde;Z_Insteek sloot dijkzijde;X_Teen dijk binnenwaarts;Y_Teen dijk binnenwaarts;Z_Teen dijk binnenwaarts;X_Kruin binnenberm;Y_Kruin binnenberm;Z_Kruin binnenberm;X_Insteek binnenberm;Y_Insteek binnenberm;Z_Insteek binnenberm;X_Kruin binnentalud;Y_Kruin binnentalud;Z_Kruin binnentalud;X_Verkeersbelasting kant binnenwaarts;Y_Verkeersbelasting kant binnenwaarts;Z_Verkeersbelasting kant binnenwaarts;X_Verkeersbelasting kant buitenwaarts;Y_Verkeersbelasting kant buitenwaarts;Z_Verkeersbelasting kant buitenwaarts;X_Kruin buitentalud;Y_Kruin buitentalud;Z_Kruin buitentalud;X_Insteek buitenberm;Y_Insteek buitenberm;Z_Insteek buitenberm;X_Kruin buitenberm;Y_Kruin buitenberm;Z_Kruin buitenberm;X_Teen dijk buitenwaarts;Y_Teen dijk buitenwaarts;Z_Teen dijk buitenwaarts;X_Insteek geul;Y_Insteek geul;Z_Insteek geul;X_Teen geul;Y_Teen geul;Z_Teen geul;X_Maaiveld buitenwaarts;Y_Maaiveld buitenwaarts;Z_Maaiveld buitenwaarts");
            }

            importFile = importFolder + "\\segments.csv";
            if (File.Exists(importFile))
            {
                File.Delete(importFile);
            }

            using (StreamWriter writer = File.CreateText(importFile))
            {
                writer.WriteLine("segment_id;soilprofile_id;probability;calculation_type");
            }

            importFile = importFolder + "\\soilprofiles.csv";
            if (File.Exists(importFile))
            {
                File.Delete(importFile);
            }

            using (StreamWriter writer = File.CreateText(importFile))
            {
                writer.WriteLine("soilprofile_id;top_level;soil_name;is_aquifer");
            }

            importFile = importFolder + "\\surfacelines.csv";
            if (File.Exists(importFile))
            {
                File.Delete(importFile);
            }

            using (StreamWriter writer = File.CreateText(importFile))
            {
                writer.WriteLine("LOCATIONID;X1;Y1;Z1;.....;Xn;Yn;Zn;(Profiel)");
            }
        }

        private void CreateLocationsFileWithRiverLevel(string importFile)
        {
            // A valid locations.csv has at least 3 columns
            // Required are location_id, surfaceline_id, segment_id.
            // For the test we need dikering_id as well.
            // Include column for RiverLevel=water_height
            if (File.Exists(importFile))
            {
                File.Delete(importFile);
            }

            using StreamWriter writer = File.CreateText(importFile);
            writer.WriteLine("location_id;surfaceline_id;segment_id;water_height");
            writer.WriteLine("RK210-560;RK210-560;1;1.2");
            writer.WriteLine("RK210-570;RK210-570;1;2.2");
        }

        private void CreateLocationsFileWithoutRiverLevel(string importFile)
        {
            // A valid locations.csv has at least 3 columns
            // Required are location_id, surfaceline_id, segment_id.
            // For the test we need dikering_id as well.
            // Do NOT include column for RiverLevel=water_height
            if (File.Exists(importFile))
            {
                File.Delete(importFile);
            }

            using StreamWriter writer = File.CreateText(importFile);
            writer.WriteLine("location_id;surfaceline_id;segment_id;polderlevel");
            writer.WriteLine("RK210-560;RK210-560;1;1.2");
            writer.WriteLine("RK210-570;RK210-570;1;2.2");
        }

        private void CreateScenariosFileWithRiverLevel(string importFile)
        {
            // A valid scenarios.csv has at least 2 columns
            // Required are location_id, location_scenario_id 
            // Include column for RiverLevel=water_height
            if (File.Exists(importFile))
            {
                File.Delete(importFile);
            }

            using StreamWriter writer = File.CreateText(importFile);
            writer.WriteLine("location_id;location_scenario_id;water_height;polderlevel");
            writer.WriteLine("RK210-560;1;0.1;3.14");
            writer.WriteLine("RK210-570;1;0.2;3.14");
        }

        private void CreateScenariosFileWithoutRiverLevel(string importFile)
        {
            // A valid scenarios.csv has at least 2 columns
            // Required are location_id, location_scenario_id
            // Do NOT include column for RiverLevel=water_height
            if (File.Exists(importFile))
            {
                File.Delete(importFile);
            }

            using StreamWriter writer = File.CreateText(importFile);
            writer.WriteLine("location_id;location_scenario_id;polderlevel");
            writer.WriteLine("RK210-560;1;3.14");
            writer.WriteLine("RK210-570;1;3.14");
        }
    }
}