// Copyright (C) Stichting Deltares 2023. 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;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using Deltares.Dam.Data.DataPlugins;
using Deltares.Dam.Data.DataPlugins.Configuration;
using Deltares.Geometry;
using Deltares.Geotechnics.GeotechnicalGeometry;
using Deltares.Geotechnics.IO;
using Deltares.Geotechnics.Soils;
using Deltares.Geotechnics.SurfaceLines;
using Deltares.Maps;
using Deltares.Standard;
using Deltares.Standard.EventPublisher;
using Deltares.Standard.Logging;
using ProgressDelegate = Deltares.DamEngine.Data.Standard.Calculation.ProgressDelegate;

namespace Deltares.Dam.Data;

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 ();

    /// <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="damProjectType">Type of the dam project.</param>
    private WaterBoardImporter(string dataFolder, DataSourceContainer dataSourceContainer, DamProjectType damProjectType)
    {
        importer = CreateDataPlugin(dataFolder, dataSourceContainer);
        importer.DamProjectType = damProjectType;
    }

    /// <summary>
    /// Gets the import CSV log messages.
    /// </summary>
    /// <value>
    /// The import CSV log messages.
    /// </value>
    private List<LogMessage> ImportCsvLogMessages { get; } = new ();

    /// <summary>
    /// Imports the dike ring ids.
    /// </summary>
    /// <param name="dataFolder">The data folder.</param>
    /// <param name="dataSourceContainer">The data source container.</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, DamProjectType damProjectType, out List<LogMessage> importLogMessages)
    {
        var importer = new WaterBoardImporter(dataFolder, dataSourceContainer, damProjectType);

        IEnumerable<string> 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="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, DamProjectType damProjectType, ProgressDelegate progress,
                                           out List<LogMessage> logMessages)
    {
        DataPluginImporter importer = CreateDataPlugin(dataFolder, dataSourceContainer);
        IEnumerable<string> dikeRingIds = importer.GetDikeRingIdList();
        WaterBoard waterboard = ImportDataForDikeRings("", dataFolder, dataSourceContainer,
                                                       dikeRingIds, damProjectType, progress, out logMessages);
        return waterboard;
    }

    /// <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="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,
                                                    DamProjectType damProjectType, ProgressDelegate progress, out List<LogMessage> logMessages)
    {
        var importer = new WaterBoardImporter(dataFolder, dataSourceContainer, damProjectType);

        logMessages = new List<LogMessage>();
        var 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>
    /// Gets all dike ring ids.
    /// </summary>
    /// <value>
    /// All dike ring i ds.
    /// </value>
    private IEnumerable<string> AllDikeRingIDs
    {
        get
        {
            ImportCsvLogMessages.Clear();
            List<string> dikeRingIdList = importer.GetDikeRingIdList().ToList();
            ImportCsvLogMessages.AddRange(importer.ImportLogMessages);
            return dikeRingIdList;
        }
    }

    /// <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 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, ProgressDelegate progress)
    {
        List<string> dikeRingList = ValidateDikeRingIDs(dikeRingIds);

        importer.DamProjectFolder = damProjectFolder;

        // Import dikes
        bool importOk = ImportDikes(progress);

        if (!importOk)
        {
            return waterBoard;
        }

        // import data for dike rings
        foreach (string dikeRingId in dikeRingList)
        {
            // Add dikes to waterboard
            List<Soil> importedCsvSoils = importer.WaterBoard.Dikes.First(d => d.Name == dikeRingId).ImportedCsvSoils;
            Dike dike = ImportDataForDikeRing(importedCsvSoils, 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().ToList()
                   : (dikeRingIds as List<string> ?? dikeRingIds.ToList());
    }

    /// <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);
    }

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

    /// <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
        };
        IEnumerable<NameValueParameter> soilDetails = importer.GetSoilDetails(dikeRingID, soilID);

        foreach (NameValueParameter 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="importedCsvSoils">The soils as imported from the csv file</param>
    /// <param name="dikeRingId">The dike ring identifier.</param>
    /// <returns></returns>
    private Dike ImportDataForDikeRing(List<Soil> importedCsvSoils, 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 introducing SurfaceLine2
        DataEventPublisher.InvokeWithoutPublishingEvents(() =>
        {
            var dikeCoordinateSystemConverter = new DikeCoordinateSystemConverter();
            if (dike.Locations.Count > 0)
            {
                dikeCoordinateSystemConverter.CreateLocalXZObjects(dike);
            }
        });

        ImportCsvLogMessages.AddRange(dike.MakeDataConsistent(importedCsvSoils));

        DisposeImportedItem(dikeRingId);

        return dike;
    }

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

    /// <summary>
    /// Imports all specified dikes.
    /// </summary>
    /// <param name="progress">The progress.</param>
    /// <returns></returns>
    private bool ImportDikes(ProgressDelegate progress)
    {
        // Import dikes
        importer.ImportDataForDikeRings(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()
    {
        IEnumerable<Feature> geometryFeatures = importer.MapGeometryIdList
                                                        .Select(id => importer.GetMapGeometry(id))
                                                        .Select(Feature.Create);

        foreach (Feature 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 (Location location in dike.Locations)
        {
            IEnumerable<string> scenarioList = importer.GetScenarioList(dikeRingId, location.Name);
            foreach (string scenarioId in scenarioList)
            {
                IEnumerable<NameValueParameter> nameValues =
                    importer.GetScenarioDetails(dikeRingId, location.Name, scenarioId);
                var scenario = new Scenario
                {
                    LocationScenarioID = scenarioId
                };
                foreach (NameValueParameter 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)
    {
        IEnumerable<string> locationIdList = importer.GetLocationIdList(dikeRingId);

        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;
            dike.Locations.Add(location);
        }

        dike.SortLocations();
    }

    /// <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)
    {
        IEnumerable<NameValueParameter> 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(() =>
        {
            IEnumerable<string> surfaceLineIdList = importer.GetSurfaceLineIdList(dikeRingId);
            foreach (string surfaceLineId in surfaceLineIdList)
            {
                var surfaceLine = new SurfaceLine2
                {
                    Name = surfaceLineId,
                    Geometry = new LocalizedGeometryPointString(),
                    CharacteristicPoints =
                    {
                        GeometryMustContainPoint = true
                    }
                };

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

                // load the characteristic points
                IEnumerable<DpCharacteristicPoint> characteristicPoints = importer.GetSurfaceLineCharacteristicPoints(dikeRingId, surfaceLineId);
                foreach (DpCharacteristicPoint 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)
    {
        IEnumerable<string> segmentIdList = importer.GetSegmentIdList(dikeRingID);
        foreach (string 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)
    {
        IEnumerable<string> profile1DIdListForSegment = importer.GetProfile1DIdListForSegment(dikeRingID, segmentID, failureMechanismSystemType);

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

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

            double probability = 0;
            foreach (NameValueParameter 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)
    {
        IEnumerable<string> profile2DIdListForSegment = importer.GetProfile2DIdListForSegment(dikeRingID, segmentID, failureMechanismSystemType);
        foreach (string soilGeometry2DName in profile2DIdListForSegment)
        {
            var numberFormatInfo = new NumberFormatInfo
            {
                NumberDecimalSeparator = "."
            };
            IEnumerable<NameValueParameter> soilProfile2DDetails = importer.GetSegmentProfile2DDetails(dikeRingID, segmentID, soilGeometry2DName, failureMechanismSystemType);
            var probability = 0.0;
            foreach (NameValueParameter 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)
    {
        IEnumerable<string> soilProfile1DIdList = importer.GetSoilProfile1DIdList(dikeRingId);
        foreach (string 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
        };
        var bottomLevel = 0.0;

        DpSoilProfile dpSoilProfile = importer.GetSoilProfile1DDetails(dikeRingId, soilProfile1DId);
        for (var layerIndex = 0; layerIndex < dpSoilProfile.Layers.Count; layerIndex++)
        {
            DpLayer 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($"Soil '{dpSoilProfile.Layers[layerIndex].SoilName}' not found in 1d-profile '{soilProfile1DId}'");
                }

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

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

        return soilProfile;
    }
}