// Copyright (C) Stichting Deltares 2018. All rights reserved.
//
// This file is part of the application DAM - Clients Library.
//
// DAM - UI is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// All names, logos, and references to "Deltares" are registered trademarks of
// Stichting Deltares and remain full property of Stichting Deltares at all times.
// All rights reserved.

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using Deltares.Standard.EventPublisher;
using Deltares.Geotechnics.GeotechnicalGeometry;
using Deltares.Geotechnics.IO;
using Deltares.Geotechnics.Soils;
using Deltares.Geotechnics.SurfaceLines;
using Deltares.Standard.Logging;

namespace Deltares.Dam.Data
{
    using DataPlugins.Configuration;
    using DataPlugins;
    using Standard;
    using Maps;

    public class WaterBoardImporterException : Exception
    {
        public WaterBoardImporterException(string message)
            : base(message)
        {
        }
    }

    /// <summary>
    /// Import all data into Waterboard
    /// </summary>
    public class WaterBoardImporter
    {
        //
        // Members & Properties
        //
        private readonly IDataPlugin importer;

        private readonly WaterBoard waterBoard = new WaterBoard();

        private readonly DamType damType;
        private readonly DamProjectType damProjectType;
        private readonly List<LogMessage> importCsvLogMessages = new List<LogMessage>();

        /// <summary>
        /// Gets the import CSV log messages.
        /// </summary>
        /// <value>
        /// The import CSV log messages.
        /// </value>
        public List<LogMessage> ImportCsvLogMessages
        {
            get { return importCsvLogMessages; }
        }

        /// <summary>
        /// Gets all dike ring ids.
        /// </summary>
        /// <value>
        /// All dike ring i ds.
        /// </value>
        private IEnumerable<string> AllDikeRingIDs
        {
            get
            {
                importCsvLogMessages.Clear();
                var dikeRingIdList = importer.GetDikeRingIdList(damType).ToList();
                importCsvLogMessages.AddRange(importer.ImportLogMessages);
                return dikeRingIdList;
            }
        }

        /// <summary>
        /// Gets the data source list.
        /// </summary>
        /// <value>
        /// The data source list.
        /// </value>
        private IEnumerable<DataSource> DataSourceList
        {
            get { return importer.DataSources; }
        }

        /// <summary>
        /// Gets the data folder.
        /// </summary>
        /// <value>
        /// The data folder.
        /// </value>
        private string DataFolder
        {
            get { return importer.DataFolder; }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="WaterBoardImporter"/> class.
        /// </summary>
        public WaterBoardImporter()
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="WaterBoardImporter"/> class.
        /// </summary>
        /// <param name="dataFolder">The data folder.</param>
        /// <param name="dataSourceContainer">The data source container.</param>
        /// <param name="damType">Type of the dam.</param>
        /// <param name="damProjectType">Type of the dam project.</param>
        private WaterBoardImporter(string dataFolder, DataSourceContainer dataSourceContainer, DamType damType, DamProjectType damProjectType)
        {
            this.damProjectType = damProjectType;
            importer = CreateDataPlugin(dataFolder, dataSourceContainer);
            importer.DamProjectType = damProjectType;
            this.damType = damType;
        }

        /// <summary>
        /// Creates the data plugin.
        /// </summary>
        /// <param name="dataFolder">The data folder.</param>
        /// <param name="dataSourceContainer">The data source container.</param>
        /// <returns></returns>
        private static DataPluginImporter CreateDataPlugin(string dataFolder, DataSourceContainer dataSourceContainer)
        {
            var plugin = new DataPluginImporter();
            plugin.SetDataSources(dataFolder, dataSourceContainer.DataSourceList);
            plugin.Attributes = dataSourceContainer.DataAttributes;

            return plugin;
        }

        /// <summary>
        /// Imports the dike ring ids.
        /// </summary>
        /// <param name="dataFolder">The data folder.</param>
        /// <param name="dataSourceContainer">The data source container.</param>
        /// <param name="damType">Type of the dam.</param>
        /// <param name="damProjectType">Type of the dam project.</param>
        /// <param name="importLogMessages">The import log messages.</param>
        /// <returns></returns>
        public static IEnumerable<string> ImportDikeRingIds(
            string dataFolder, DataSourceContainer dataSourceContainer, DamType damType, DamProjectType damProjectType, out List<LogMessage> importLogMessages)
        {
            var importer = new WaterBoardImporter(dataFolder, dataSourceContainer, damType, damProjectType);

            var allDikeRingIds = importer.AllDikeRingIDs;
            importLogMessages = new List<LogMessage>(importer.ImportCsvLogMessages);
            
            return allDikeRingIds;
        }

        /// <summary>
        /// Imports all data.
        /// </summary>
        /// <param name="dataFolder">The data folder.</param>
        /// <param name="dataSourceContainer">The data source container.</param>
        /// <param name="damType">Type of the dam.</param>
        /// <param name="damProjectType">Type of the dam project.</param>
        /// <param name="progress">The progress.</param>
        /// <param name="logMessages">The log messages.</param>
        /// <returns></returns>
        public static WaterBoard ImportAllData(string dataFolder,
            DataSourceContainer dataSourceContainer, DamType damType, DamProjectType damProjectType, DamEngine.Data.Standard.Calculation.ProgressDelegate progress,
            out List<LogMessage> logMessages)
        {
            var importer = CreateDataPlugin(dataFolder, dataSourceContainer);
            var dikeRingIds = importer.GetDikeRingIdList(damType);
            WaterBoard waterboard = ImportDataForDikeRings("", dataFolder, dataSourceContainer,
                dikeRingIds, damType, damProjectType, progress, out logMessages);
            return waterboard;
        }

        /// <summary>
        /// Imports all data.
        /// </summary>
        /// <param name="dataFolder">The data folder.</param>
        /// <param name="dataSourceContainer">The data source container.</param>
        /// <param name="damType">Type of the dam.</param>
        /// <param name="damProjectType">Type of the dam project.</param>
        /// <param name="progress">The progress.</param>
        /// <returns></returns>
        public static WaterBoard ImportAllData(string dataFolder,
            DataSourceContainer dataSourceContainer, DamType damType, DamProjectType damProjectType, DamEngine.Data.Standard.Calculation.ProgressDelegate progress)
        {
            List<LogMessage> dummy;
            return ImportAllData(dataFolder, dataSourceContainer, damType, damProjectType, progress, out dummy);
        }

        /// <summary>
        /// Imports the data for dike rings.
        /// </summary>
        /// <param name="damProjectFolder">The dam project folder.</param>
        /// <param name="dataFolder">The data folder.</param>
        /// <param name="dataSourceContainer">The data source container.</param>
        /// <param name="dikeRingIds">The dike ring ids.</param>
        /// <param name="damType">Type of the dam.</param>
        /// <param name="damProjectType">Type of the dam project.</param>
        /// <param name="progress">The progress.</param>
        /// <returns></returns>
        public static WaterBoard ImportDataForDikeRings(string damProjectFolder, string dataFolder,
            DataSourceContainer dataSourceContainer, IEnumerable<string> dikeRingIds,
            DamType damType, DamProjectType damProjectType, DamEngine.Data.Standard.Calculation.ProgressDelegate progress)
        {
            List<LogMessage> dummy;
            return ImportDataForDikeRings(damProjectFolder, dataFolder, dataSourceContainer,
                dikeRingIds, damType, damProjectType, progress, out dummy);
        }

        /// <summary>
        /// Imports the data for dike rings.
        /// </summary>
        /// <param name="damProjectFolder">The dam project folder.</param>
        /// <param name="dataFolder">The data folder.</param>
        /// <param name="dataSourceContainer">The data source container.</param>
        /// <param name="dikeRingIds">The dike ring ids.</param>
        /// <param name="damType">Type of the dam.</param>
        /// <param name="damProjectType">Type of the dam project.</param>
        /// <param name="progress">The progress.</param>
        /// <param name="logMessages">The log messages.</param>
        /// <returns></returns>
        public static WaterBoard ImportDataForDikeRings(string damProjectFolder, string dataFolder,
            DataSourceContainer dataSourceContainer, IEnumerable<string> dikeRingIds,
            DamType damType, DamProjectType damProjectType, DamEngine.Data.Standard.Calculation.ProgressDelegate progress, out List<LogMessage> logMessages)
        {
            var importer = new WaterBoardImporter(dataFolder, dataSourceContainer, damType, damProjectType);

            logMessages = new List<LogMessage>();
            WaterBoard waterBoard = new WaterBoard();
            try
            {
                waterBoard = importer.ImportDataForDikeRings(damProjectFolder, dikeRingIds, progress);
                foreach (Dike dike in waterBoard.Dikes)
                {
                    if (String.IsNullOrEmpty(dike.MapForSoilGeometries2D) && !String.IsNullOrEmpty(dataSourceContainer.MapSoilProfile2D))
                    {
                        dike.MapForSoilGeometries2D = dataSourceContainer.MapSoilProfile2D;
                    }
                }
            }
            catch (Exception e)
            {
                string errorMessage = e.Message;
                Exception innerException = e.InnerException;
                while (innerException != null)
                {
                    errorMessage = errorMessage + ";" + innerException.Message;
                    innerException = innerException.InnerException;
                }
                logMessages.Add(new LogMessage(LogMessageType.FatalError, null, errorMessage));
            }

            logMessages.AddRange(importer.ImportCsvLogMessages);

            return waterBoard;
        }

        /// <summary>
        /// Imports the data for dike rings.
        /// </summary>
        /// <param name="damProjectFolder">The dam project folder.</param>
        /// <param name="dikeRingIds">The dike ring ids.</param>
        /// <param name="progress">The progress.</param>
        /// <returns></returns>
        private WaterBoard ImportDataForDikeRings(string damProjectFolder, IEnumerable<string> dikeRingIds, DamEngine.Data.Standard.Calculation.ProgressDelegate progress)
        {
            var dikeRingList = ValidateDikeRingIDs(dikeRingIds);

            importer.DamProjectFolder = damProjectFolder;

            // Import dikes
            var importOk = ImportDikes(dikeRingList, progress);

            if (!importOk) return waterBoard;

            // import data for dike rings
            foreach (var dikeRingId in dikeRingList)
            {
                // Add dikes to waterboard
                var dike = ImportDataForDikeRing(dikeRingId);
                waterBoard.Dikes.Add(dike);
            }

            ImportBackground();
            return waterBoard;
        }



        /// <summary>
        /// Validates the dike ring i ds.
        /// </summary>
        /// <param name="dikeRingIds">The dike ring ids.</param>
        /// <returns></returns>
        private List<string> ValidateDikeRingIDs(IEnumerable<string> dikeRingIds)
        {
            // if no dike ring IDs specified, take all
            return dikeRingIds == null
                       ? importer.GetDikeRingIdList(damType).ToList()
                       : (dikeRingIds as List<string> ?? dikeRingIds.ToList());
        }

        /// <summary>
        /// Creates the soil base for dike.
        /// </summary>
        /// <param name="dike">The dike.</param>
        private void CreateSoilBaseForDike(Dike dike)
        {
            // TODO: soildatabase should be created. Now we make a direct link
            // must be based on dike.SoilDatabaseName
        }

        /// <summary>
        /// Determines the database name from data sources.
        /// </summary>
        /// <param name="dike">The dike.</param>
        private void DetermineDatabaseNameFromDataSources(Dike dike)
        {
            var sources = DataSourceList.ToList();

            // get the data base name from the data sources
            var dataSource =
                sources.FirstOrDefault(ds => ds.DataSourceType == DataSourceType.MSoilBase) ??
                sources.FirstOrDefault(ds => ds.DataSourceType == DataSourceType.CsvFiles);

            if (dataSource != null)
            {
                if (dataSource.DataSourceType == DataSourceType.MSoilBase)
                {
                    dike.SoilDatabaseName = Path.Combine(DataFolder, dataSource.DataLocation);
                }
                else
                {
                    var subFolder = Path.Combine(DataFolder, dataSource.DataLocation);
                    dike.SoilDatabaseName = Path.Combine(subFolder, "soilmaterials.mdb");
                }
            }
        }

        /// <summary>
        /// Imports the soils.
        /// </summary>
        /// <param name="dikeRingID">The dike ring identifier.</param>
        /// <param name="dike">The dike.</param>
        private void ImportSoils(string dikeRingID, Dike dike)
        {
            dike.SoilList = GetSoils(dikeRingID);
            DetermineDatabaseNameFromDataSources(dike);
            dike.FillDataBaseSoilListFromSoilBase();
        }

        /// <summary>
        /// Gets the soils.
        /// </summary>
        /// <param name="dikeRingID">The dike ring identifier.</param>
        /// <returns></returns>
        private SoilList GetSoils(string dikeRingID)
        {
            var soilIdList = importer.GetSoilIdList(dikeRingID);
            var soils = soilIdList
                .Select(soilID => ImportSoil(dikeRingID, soilID))
                .ToList();

            var aquifers = importer.GetSoilAquiferValues(dikeRingID);
            var soilList = new SoilList();
            soilList.Soils = soils;

            foreach (var nameValueParameter in aquifers)
            {
                bool vala;
                bool.TryParse(nameValueParameter.ParameterValue, out vala);
                soilList.AquiferDictionary.Add(soilList.GetSoilByName(nameValueParameter.ParameterName), vala);
            }
            return soilList;
        }

        /// <summary>
        /// Imports a soil.
        /// </summary>
        /// <param name="dikeRingID">The dike ring identifier.</param>
        /// <param name="soilID">The soil identifier.</param>
        /// <returns></returns>
        private Soil ImportSoil(string dikeRingID, string soilID)
        {
            var soil = new Soil { Name = soilID };
            var soilDetails = importer.GetSoilDetails(dikeRingID, soilID);

            foreach (var soilDetail in soilDetails)
            {
                SoilUtils.SetParameterFromNameValuePair(soil, soilDetail.ParameterName, soilDetail.ParameterValue);
                DataSourceManager.SetSource(soil, soilDetail.ParameterName, soilDetail.Source);
            }

            return soil;
        }

        /// <summary>
        /// Imports the data for dike ring.
        /// </summary>
        /// <param name="dikeRingId">The dike ring identifier.</param>
        /// <returns></returns>
        private Dike ImportDataForDikeRing(string dikeRingId)
        {
            var dike = new Dike { Name = dikeRingId };
            ImportSoils(dikeRingId, dike);

            ImportSoilProfiles1D(dikeRingId, dike);

            ImportSegments(dikeRingId, dike);

            ImportSurfaceLines(dikeRingId, dike);

            ImportModelParameters(dikeRingId, dike);

            // TODO: Import PL1-lines 

            ImportLocations(dikeRingId, dike);

            //ImportScenarios(importer, dikeRingId, dike, waterBoard);
            ImportScenarios(dikeRingId, dike);

            // Use InvokeWithoutPublishingEvents for performance reasons after introducint SurfaceLine2
            DataEventPublisher.InvokeWithoutPublishingEvents(() =>
            {
                var dikeCoordinateSystemConverter = new DikeCoordinateSystemConverter();
                if (dike.Locations.Count > 0)
                {
                    dikeCoordinateSystemConverter.CreateLocalXZObjects(dike);
                }
            });

            ImportCsvLogMessages.AddRange(dike.MakeDataConsistent());

            CreateSoilBaseForDike(dike);

            DisposeImportedItem(dikeRingId);

            return dike;
        }

        private void DisposeImportedItem(string dikeRingId)
        {
            importer.DisposeImportedItem(dikeRingId);
        }

        /// <summary>
        /// Imports all specified dikes.
        /// </summary>
        /// <param name="dikeRingIds">The dike ring ids.</param>
        /// <param name="progress">The progress.</param>
        /// <returns></returns>
        private bool ImportDikes(IEnumerable<string> dikeRingIds, DamEngine.Data.Standard.Calculation.ProgressDelegate progress)
        {
            // Import dikes
            importer.ImportDataForDikeRings(dikeRingIds, damType, progress);

            // add log messages
            ImportCsvLogMessages.AddRange(importer.ImportLogMessages);

            // import is ok if no fatal messages
            return ImportCsvLogMessages.All(message => message.MessageType != LogMessageType.FatalError);
        }

        /// <summary>
        /// Imports the background layer.
        /// </summary>
        private void ImportBackground()
        {
            var geometryFeatures = importer.MapGeometryIdList
                .Select(id => importer.GetMapGeometry(id))
                .Select(Feature.Create);

            foreach (var geometry in geometryFeatures)
            {
                waterBoard.AddBackgroundGeometry(geometry);
            }
            waterBoard.FillFeatureList();
        }

        /// <summary>
        /// Imports the scenarios.
        /// </summary>
        /// <param name="dikeRingId">The dike ring identifier.</param>
        /// <param name="dike">The dike.</param>
        private void ImportScenarios(string dikeRingId, Dike dike)
        {

            AddScenariosToLocations(dike, dikeRingId);

        }

        /// <summary>
        /// Adds the scenarios to locations.
        /// </summary>
        /// <param name="dike">The dike.</param>
        /// <param name="dikeRingId">The dike ring identifier.</param>
        private void AddScenariosToLocations(Dike dike, string dikeRingId)
        {
            foreach (var location in dike.Locations)
            {
                var scenarioList = importer.GetScenarioList(dikeRingId, location.Name);
                foreach (var scenarioId in scenarioList)
                {
                    var nameValues =
                        importer.GetScenarioDetails(dikeRingId, location.Name, scenarioId);
                    var scenario = new Scenario { LocationScenarioID = scenarioId };
                    foreach (var nameValueParameter in nameValues)
                    {
                        scenario.SetParameterFromNameValuePair(
                            nameValueParameter.ParameterName,
                            nameValueParameter.ParameterValue);
                    }
                    scenario.Location = location;
                    location.Scenarios.Add(scenario);
                }
            }
        }

        /// <summary>
        /// Imports the locations.
        /// </summary>
        /// <param name="dikeRingId">The dike ring identifier.</param>
        /// <param name="dike">The dike.</param>
        private void ImportLocations(string dikeRingId, Dike dike)
        {
            var locationIdList = importer.GetLocationIdList(dikeRingId, damType);

            foreach (string locationId in locationIdList)
            {
                var location = new Location
                {
                    Name = locationId
                };

                Info locationInfo = importer.GetLocationInfo(dikeRingId, locationId);

                location.Name = locationInfo.Name;
                DataSourceManager.SetSource(location, "Name", locationInfo.Source);

                location.Description = locationInfo.Description;
                DataSourceManager.SetSource(location, "Description", locationInfo.Source);

                IEnumerable<NameValueParameter> locationDetails = importer.GetLocationDetails(dikeRingId, locationId);
                foreach (NameValueParameter locationDetail in locationDetails)
                {
                    location.SetParameterFromNameValuePair(locationDetail.ParameterName, locationDetail.ParameterValue);
                    DataSourceManager.SetSource(location, locationDetail.ParameterName, locationDetail.Source);
                    if (locationDetail.ParameterName.Equals(LocationParameterNames.SegmentId))
                    {
                        Segment segment = waterBoard.Segments.FirstOrDefault(x => x.Name.Equals(locationDetail.ParameterValue));
                        location.Segment = segment;
                    }
                    // See comment below: the test WaterBoardImportedWithCsvFilesHasValidData using Groot Salland\Binnenwaarts proves Erik wrong
                    if (locationDetail.ParameterName.Equals(LocationParameterNames.SurfaceLineId))
                    {
                        SurfaceLine2 surfaceLine = dike.SurfaceLines2.FirstOrDefault(x => x.Name.Equals(locationDetail.ParameterValue));
                        location.SurfaceLine2 = surfaceLine;
                    }
                    // TODO: Assign PL1-line 
                }
                // According to Erik Vastenburg, locations and surfacelines must match for matching pairs! So to find proper surfaceline
                // for location, just search for it by name in surfacelines. SurfaceLineId can and should be removed entirely! But see above!
                if (location.SurfaceLine2 == null)
                {
                    location.SurfaceLine2 = dike.SurfaceLines2.FirstOrDefault(s => s.Name == location.Name);
                }
                location.SoilList = dike.SoilList;
                CheckModelFactorsForLocation(location);
                dike.Locations.Add(location);
            }
            dike.SortLocations();

        }

        /// <summary>
        /// Checks the model factors for location.
        /// </summary>
        /// <param name="location">The location.</param>
        private static void CheckModelFactorsForLocation(Location location)
        {
            ModelParameters.AssignDefaultToNullValues(location.ModelFactors);
        }

        /// <summary>
        /// Imports the model parameters.
        /// </summary>
        /// <param name="dikeRingId">The dike ring identifier.</param>
        /// <param name="dike">The dike.</param>
        private void ImportModelParameters(string dikeRingId, Dike dike)
        {
            var modelParameters = importer.GetDikeParameters(dikeRingId);
            foreach (NameValueParameter modelParameter in modelParameters)
            {
                dike.SetParameterFromNameValuePair(modelParameter.ParameterName, modelParameter.ParameterValue);
                DataSourceManager.SetSource(dike, modelParameter.ParameterName, modelParameter.Source);
            }
        }

        /// <summary>
        /// Imports the surface lines.
        /// </summary>
        /// <param name="dikeRingId">The dike ring identifier.</param>
        /// <param name="dike">The dike.</param>
        private void ImportSurfaceLines(string dikeRingId, Dike dike)
        {
            // Use InvokeWithoutPublishingEvents for performance reasons after introducint SurfaceLine2
            DataEventPublisher.InvokeWithoutPublishingEvents(() =>
            {
                var surfaceLineIdList = importer.GetSurfaceLineIdList(dikeRingId);
                foreach (var surfaceLineId in surfaceLineIdList)
                {
                    var surfaceLine = new SurfaceLine2
                    {
                        Name = surfaceLineId,
                        Geometry = new LocalizedGeometryPointString(),
                        CharacteristicPoints = { GeometryMustContainPoint = true }
                    };

                    // load the surface line points
                    var surfaceLinePoints = importer.GetSurfaceLinePoints(dikeRingId, surfaceLineId);
                    foreach (var surfaceLinePoint in surfaceLinePoints)
                    {
                        surfaceLine.AddCharacteristicPoint(surfaceLinePoint);
                    }

                    // load the characteristic points
                    var characteristicPoints = importer.GetSurfaceLineCharacteristicPoints(dikeRingId, surfaceLineId);
                    foreach (var cp in characteristicPoints)
                    {
                        var cpType = (CharacteristicPointType)Enum.Parse(
                            typeof(CharacteristicPointType), cp.Id);
                        surfaceLine.EnsurePointOfType(cp.X, cp.Y, cp.Z, cpType);
                    }

                    // add the surface line to the dike
                    dike.SurfaceLines2.Add(surfaceLine);
                }
            });
        }

        /// <summary>
        /// Imports the segments.
        /// </summary>
        /// <param name="dikeRingID">The dike ring identifier.</param>
        /// <param name="dike">The dike.</param>
        private void ImportSegments(string dikeRingID, Dike dike)
        {
            var segmentIdList = importer.GetSegmentIdList(dikeRingID);
            foreach (var segmentID in segmentIdList)
            {
                var segment = new Segment { Name = segmentID };

                foreach (FailureMechanismSystemType failureMechanismSystemType in Enum.GetValues(typeof(FailureMechanismSystemType)))
                {
                    AddSoilProfiles(segment, dikeRingID, segmentID, failureMechanismSystemType, dike);
                    AddSoilGeometry(segment, dikeRingID, segmentID, failureMechanismSystemType);
                }

                waterBoard.Segments.Add(segment);
            }
        }

        /// <summary>
        /// Adds the soil profiles.
        /// </summary>
        /// <param name="segment">The segment.</param>
        /// <param name="dikeRingID">The dike ring identifier.</param>
        /// <param name="segmentID">The segment identifier.</param>
        /// <param name="failureMechanismSystemType">Type of the failure mechanism system.</param>
        /// <param name="dike">The dike.</param>
        private void AddSoilProfiles(Segment segment, string dikeRingID, string segmentID, FailureMechanismSystemType failureMechanismSystemType, Dike dike)
        {
            var profile1DIdListForSegment = importer.GetProfile1DIdListForSegment(dikeRingID, segmentID, failureMechanismSystemType);

            foreach (var soilProfile1DId in profile1DIdListForSegment)
            {
                var numberFormatInfo = new NumberFormatInfo { NumberDecimalSeparator = "." };

                // get soil profile
                var soilProfile1DDetails = importer.GetSegmentProfile1DDetails(dikeRingID, segmentID, soilProfile1DId, failureMechanismSystemType);
                var soilProfile1D = dike.SoilProfiles.FirstOrDefault(x => x.Name.Equals(soilProfile1DId));

                double probability = 0;
                foreach (var nameValueparameter in soilProfile1DDetails)
                {
                    if (nameValueparameter.ParameterName.Equals("Probability"))
                        probability = Convert.ToDouble(nameValueparameter.ParameterValue, numberFormatInfo);
                }
                segment.AddSoilProfileProbability(soilProfile1D, probability, failureMechanismSystemType);
            }
        }

        /// <summary>
        /// Adds the soil geometry.
        /// </summary>
        /// <param name="segment">The segment.</param>
        /// <param name="dikeRingID">The dike ring identifier.</param>
        /// <param name="segmentID">The segment identifier.</param>
        /// <param name="failureMechanismSystemType">Type of the failure mechanism system.</param>
        private void AddSoilGeometry(Segment segment, string dikeRingID, string segmentID, FailureMechanismSystemType failureMechanismSystemType)
        {
            var profile2DIdListForSegment = importer.GetProfile2DIdListForSegment(dikeRingID, segmentID, failureMechanismSystemType);
            foreach (string soilGeometry2DName in profile2DIdListForSegment)
            {
                var numberFormatInfo = new NumberFormatInfo { NumberDecimalSeparator = "." };
                var soilProfile2DDetails = importer.GetSegmentProfile2DDetails(dikeRingID, segmentID, soilGeometry2DName, failureMechanismSystemType);
                double probability = 0.0;
                foreach (var nameValueparameter in soilProfile2DDetails)
                {
                    if (nameValueparameter.ParameterName.Equals("Probability"))
                        probability = Convert.ToDouble(nameValueparameter.ParameterValue, numberFormatInfo);
                }
                segment.AddSoilGeometry2DProbability(soilGeometry2DName, probability, failureMechanismSystemType);
            }
        }

        /// <summary>
        /// Imports the soil profiles1 d.
        /// </summary>
        /// <param name="dikeRingId">The dike ring identifier.</param>
        /// <param name="dike">The dike.</param>
        private void ImportSoilProfiles1D(string dikeRingId, Dike dike)
        {
            var soilProfile1DIdList = importer.GetSoilProfile1DIdList(dikeRingId);
            foreach (var soilProfile1DId in soilProfile1DIdList)
            {
                dike.SoilProfiles.Add(ImportProfile(soilProfile1DId, dikeRingId, dike));
            }
        }

        /// <summary>
        /// Imports a profile.
        /// </summary>
        /// <param name="soilProfile1DId">The soil profile1 d identifier.</param>
        /// <param name="dikeRingId">The dike ring identifier.</param>
        /// <param name="dike">The dike.</param>
        /// <returns></returns>
        /// <exception cref="Deltares.Dam.Data.WaterBoardImporterException">
        /// </exception>
        private SoilProfile1D ImportProfile(string soilProfile1DId, string dikeRingId, Dike dike)
        {
            var soilProfile = new SoilProfile1D { Name = soilProfile1DId };
            double bottomLevel = 0.0;

            var dpSoilProfile = importer.GetSoilProfile1DDetails(dikeRingId, soilProfile1DId);
            for (int layerIndex = 0; layerIndex < dpSoilProfile.Layers.Count; layerIndex++)
            {
                var layer = dpSoilProfile.Layers[layerIndex];
                if (layer.SoilName == SoilProfile1D.SoilProfileBottomLevelId)
                {
                    // This is a hack to communicate the bottomlevel via a layer
                    bottomLevel = layer.TopLevel;
                }
                else
                {
                    int soilIndex = dike.SoilList.GetSoilIndexByName(layer.SoilName);
                    if (soilIndex < 0)
                    {
                        throw new WaterBoardImporterException(String.Format("Soil '{0}' not found in 1d-profile '{1}'",
                            dpSoilProfile.Layers[layerIndex].SoilName, soilProfile1DId));

                    }
                    soilProfile.Layers.Add(new SoilLayer1D
                    {
                        TopLevel = layer.TopLevel,
                        Soil = dike.SoilList.Soils[soilIndex]
                    });

                }
            }
            soilProfile.EnsureUniqueLayerIds();
            soilProfile.BottomLevel = bottomLevel;
            if (soilProfile.LayerCount > 0)
            {
                soilProfile.EnsureLastLayerHasHeight();
            }
            else
            {
                throw new WaterBoardImporterException(String.Format("Soil 1d-profile '{0}' has no layers", soilProfile.Name));
            }

            return soilProfile;
        }
    }
}