// Copyright (C) Stichting Deltares 2019. All rights reserved.
//
// This file is part of the Dam Engine.
//
// The Dam Engine is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero 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.IO;
using System.Linq;
using Deltares.DamEngine.Data.Design;
using Deltares.DamEngine.Data.General;
using Deltares.DamEngine.Data.General.Sensors;
using Deltares.DamEngine.Data.General.TimeSeries;
using Deltares.DamEngine.Data.Geometry;
using Deltares.DamEngine.Data.Geotechnics;
using Deltares.DamEngine.Data.Standard.Logging;
using Deltares.DamEngine.Interface.Properties;
using Deltares.DamEngine.Io.XmlInput;
using Location = Deltares.DamEngine.Data.General.Location;
using Segment = Deltares.DamEngine.Data.General.Segment;
using Soil = Deltares.DamEngine.Io.XmlInput.Soil;
using SoilProfile1D = Deltares.DamEngine.Data.Geotechnics.SoilProfile1D;
using SoilProfile2D = Deltares.DamEngine.Data.Geotechnics.SoilProfile2D;
using TimeSerie = Deltares.DamEngine.Io.XmlInput.TimeSerie;

namespace Deltares.DamEngine.Interface
{
    /// <summary>
    /// Fill Dam Engine data object from Input serializer object
    /// </summary>
    public class FillDamFromXmlInput
    {
        /// <summary>
        /// Creates the dam project data from an Input serializer object
        /// </summary>
        /// <param name="input">The input.</param>
        /// <returns></returns>
        public static DamProjectData CreateDamProjectData(Input input)
        {
            ValidateInput(input);
            var damProjectData = new DamProjectData
            {
                Dike = new Dike()
            };

            Dike dike = damProjectData.Dike;

            damProjectData.ProjectPath = input.ProjectPath;
            damProjectData.CalculationMap = input.CalculationMap;
            if (input.MaxCalculationCoresSpecified)
            {
                damProjectData.MaxCalculationCores = input.MaxCalculationCores;
            }
            TransferAnalysisSpecification(input, damProjectData);
            TransferStabilityParameters(input, damProjectData);

            TransferSurfaceLines(input.SurfaceLines, dike.SurfaceLines2);
            dike.SoilList = new SoilList();
            TransferSoils(input.Soils, dike.SoilList.Soils);
            var messages = TransferAquiferSoils(input.AquiferSoils, dike.SoilList);
            if (messages.Count > 0)
            {
                damProjectData.CalculationMessages = messages;
            }
            TransferSoilProfiles1D(input.SoilProfiles1D, dike.SoilProfiles, dike.SoilList);
            TransferSoilProfiles2D(input.SoilProfiles2D, dike.SoilProfiles2D, dike.SoilList);
            TransferSegments(input.Segments, damProjectData.Segments);
            TransferLocations(input.ProjectPath, input.Locations, dike.Locations, dike.SurfaceLines2, damProjectData.Segments);
            if (input.OperationalInputTimeSeries != null)
            {
                dike.InputTimeSerieCollection = new TimeSerieCollection();
                TransferInputTimeSeries(input.OperationalInputTimeSeries, dike.InputTimeSerieCollection);
            }
            if (input.SensorData != null)
            {
                damProjectData.SensorData = new SensorData();
                TransferSensorData(input.SensorData, damProjectData.SensorData, damProjectData.Dike.Locations);
            }

            PostProcess(damProjectData);

            return damProjectData;
        }

        private static void TransferSensorData(InputSensorData inputSensorData, SensorData sensorData, IList<Location> locations)
        {
            // Transfer sensors
            foreach (var inputSensor in inputSensorData.Sensors)
            {
                var plLineMappings = new PlLineType[inputSensor.PlLineMapping.Length];
                int plLineMappingIndex = 0;
                foreach (var plLineMapping in inputSensor.PlLineMapping)
                {
                    plLineMappings[plLineMappingIndex] = ConversionHelper.ConvertToPlLineType(plLineMapping.PLineType);
                    plLineMappingIndex++;
                }
                sensorData.Sensors.Add(new Data.General.Sensors.Sensor()
                {
                    ID = inputSensor.Id,
                    Name = inputSensor.Name,
                    RelativeLocation = inputSensor.RelativeLocation,
                    SensorType = ConversionHelper.ConvertToSensorType(inputSensor.SensorType),
                    PlLineMappings = plLineMappings
                });
            }

            // Transfer sensorgroups
            foreach (var inputSensorGroup in inputSensorData.SensorGroups)
            {
                var sensorGroup = new Data.General.Sensors.SensorGroup();
                sensorGroup.ID = inputSensorGroup.Id;
                foreach (var sensorId in inputSensorGroup.SensorIds)
                {
                    var sensor = sensorData.Sensors.First(s => s.ID.Equals(sensorId.SensorId));
                    sensorGroup.Add(sensor);
                }
                sensorData.SensorGroups.Add(sensorGroup);
            }

            // Transfer sensorlocations
            foreach (var inputSensorLocation in inputSensorData.SensorLocations)
            {
                var sensorLocation = new Data.General.Sensors.SensorLocation();
                sensorLocation.Location = locations.First(l => l.Name.Equals(inputSensorLocation.LocationId));
                sensorLocation.Location.SensorLocation = sensorLocation;
                sensorLocation.SensorGroup = sensorData.SensorGroups.First(sg => sg.ID.Equals(inputSensorLocation.GroupId));
                sensorLocation.SourceTypePl1PlLineOffsetBelowDikeTopAtPolder = ConversionHelper.ConvertToDataSourceTypeSensors(inputSensorLocation.SourceTypePl1PlLineOffsetBelowDikeTopAtPolder);
                sensorLocation.SourceTypePl1PlLineOffsetBelowDikeToeAtPolder = ConversionHelper.ConvertToDataSourceTypeSensors(inputSensorLocation.SourceTypePl1PlLineOffsetBelowDikeToeAtPolder);
                sensorLocation.SourceTypePl1PlLineOffsetBelowDikeTopAtRiver = ConversionHelper.ConvertToDataSourceTypeSensors(inputSensorLocation.SourceTypePl1PlLineOffsetBelowDikeTopAtRiver);
                sensorLocation.SourceTypePl1PlLineOffsetBelowShoulderBaseInside = ConversionHelper.ConvertToDataSourceTypeSensors(inputSensorLocation.SourceTypePl1PlLineOffsetBelowShoulderBaseInside);
                sensorLocation.SourceTypePl1WaterLevelAtPolder = ConversionHelper.ConvertToDataSourceTypeSensors(inputSensorLocation.SourceTypePl1WaterLevelAtPolder);
                sensorLocation.SourceTypePl1WaterLevelAtRiver = ConversionHelper.ConvertToDataSourceTypeSensors(inputSensorLocation.SourceTypePl1WaterLevelAtRiver);
                sensorLocation.SourceTypePl3 = ConversionHelper.ConvertToDataSourceTypeSensors(inputSensorLocation.SourceTypePl3);
                sensorLocation.SourceTypePl4 = ConversionHelper.ConvertToDataSourceTypeSensors(inputSensorLocation.SourceTypePl4);
                sensorData.SensorLocations.Add(sensorLocation);
            }
        }

        private static void TransferInputTimeSeries(TimeSerie[] inputOperationalInputTimeSeries, TimeSerieCollection timeSerieCollection)
        {
            foreach (var inputTimeSerie in inputOperationalInputTimeSeries)
            {
                var timeSerie = timeSerieCollection.AddNewSeries(inputTimeSerie.LocationId);
                timeSerie.ParameterId = inputTimeSerie.ParameterId;
                timeSerie.ForecastDateTime = inputTimeSerie.ForecastDateTime;
                timeSerie.Type = inputTimeSerie.Type;
                timeSerie.StartDateTime = inputTimeSerie.StartDateTime;
                timeSerie.EndDateTime = inputTimeSerie.EndDateTime;
                timeSerie.MissVal = inputTimeSerie.MissVal;
                timeSerie.LongName = inputTimeSerie.LongName;
                timeSerie.StationName = inputTimeSerie.StationName;
                timeSerie.Units = inputTimeSerie.Units;
                timeSerie.SourceOrganisation = inputTimeSerie.SourceOrganisation;
                timeSerie.SourceSystem = inputTimeSerie.SourceSystem;
                timeSerie.FileDescription = inputTimeSerie.FileDescription;
                timeSerie.Region = inputTimeSerie.Region;
                timeSerie.TimeStep.Multiplier = inputTimeSerie.TimeStep.Multiplier;
                timeSerie.TimeStep.Divider = inputTimeSerie.TimeStep.Divider;
                timeSerie.TimeStep.MultiplierSpecified = inputTimeSerie.TimeStep.MultiplierSpecified1;
                timeSerie.TimeStep.DividerSpecified = inputTimeSerie.TimeStep.DividerSpecified1;
                timeSerie.TimeStep.Unit = ConversionHelper.ConvertToTimeStepUnit(inputTimeSerie.TimeStep.TimeStepUnit);
                if (inputTimeSerie.Entries.TimeSerieEntry != null)
                {
                    for (int i = 0; i < inputTimeSerie.Entries.TimeSerieEntry.Length; i++)
                    {
                        var entry = inputTimeSerie.Entries.TimeSerieEntry[i];
                        Stochast stochastValue = null;
                        if (entry.StochastValue != null)
                        {
                            stochastValue = new Stochast()
                            {
                                Distribution = entry.StochastValue.Distribution,
                                Mean = entry.StochastValue.Mean,
                                StandardDeviation = entry.StochastValue.StandardDeviation
                            };
                        }
                        TimeSerieEntry timeSerieEntry = new TimeSerieEntry()
                        {
                            DateTime = entry.DateTime,
                            Value = entry.Value,
                            BasisFileName = entry.BasisFileNameWMF,
                            Flag = entry.Flagnietechtgebruikt,
                            RelativeCalculationPathName = entry.RelativeCalculationPathName,
                            StochastValue = stochastValue
                        };
                        timeSerie.Entries.Add(timeSerieEntry);
                    }
                }
            }
        }

        private static List<LogMessage> TransferAquiferSoils(InputAquiferSoil[] inputAquiferSoils, SoilList soilList)
        {
            List<LogMessage> validationMessages = new List<LogMessage>();
            if (inputAquiferSoils != null)
            {
                soilList.AquiferDictionary = new Dictionary<Data.Geotechnics.Soil, bool>();
                foreach (InputAquiferSoil aquiferSoil in inputAquiferSoils)
                {
                    var soil = soilList.GetSoilByName(aquiferSoil.Soilname);
                    if (!soilList.AquiferDictionary.ContainsKey(soil))
                    {
                        soilList.AquiferDictionary.Add(soil, aquiferSoil.IsAquifer);
                    }
                    else
                    {
                        // If a soil is (wrongly) in the list more than once, then prefer aquifer true. 
                        if (aquiferSoil.IsAquifer)
                        {
                            validationMessages.Add(new LogMessage(LogMessageType.Warning, aquiferSoil, string.Format(Resources.DoubleAquiferSoil, aquiferSoil.Soilname)));
                            soilList.AquiferDictionary[soil] = true;
                        }
                    }
                }
            }
            return validationMessages;
        }

        private static void TransferAnalysisSpecification(Input input, DamProjectData damProjectData)
        {
            damProjectData.DamProjectType = ConversionHelper.ConvertToDamProjectType(input.DamProjectType);

            var calculationSpecification = new DamFailureMechanismeCalculationSpecification();

            calculationSpecification.FailureMechanismSystemType = ConversionHelper.ConvertToFailureMechanismSystemType(input.FailureMechanismSystemType);

            if (input.AnalysisTypeSpecified)
            {
                DamProjectCalculationSpecification.SelectedAnalysisType = ConversionHelper.ConvertToAnalysisType(input.AnalysisType);
            }

            if (input.PipingModelTypeSpecified)
            {
                calculationSpecification.PipingModelType = ConversionHelper.ConvertToPipingModelType(input.PipingModelType);
            }

            if (input.StabilityModelTypeSpecified)
            {
                calculationSpecification.StabilityModelType = ConversionHelper.ConvertToStabilityModelType(input.StabilityModelType);
            }
            damProjectData.DamProjectCalculationSpecification.DamCalculationSpecifications.Add(calculationSpecification);
        }

        private static void TransferStabilityParameters(Input input, DamProjectData damProjectData)
        {
            if (input.StabilityParameters != null)
            {
                if (damProjectData.DamProjectCalculationSpecification != null)
                {
                    var curSpec = damProjectData.DamProjectCalculationSpecification.CurrentSpecification;
                    if (curSpec != null)
                    {
                        curSpec.FailureMechanismParametersMStab = new FailureMechanismParametersMStab();
                        curSpec.FailureMechanismParametersMStab.MStabParameters = new MStabParameters();
                        var curStabParamas = curSpec.FailureMechanismParametersMStab.MStabParameters;
                        curStabParamas.SearchMethod = ConversionHelper.ConvertToSearchMethod(input.StabilityParameters.SearchMethod);
                        // ToDo zant2bka: Is this a good place to set the model? Is was also read in TransferAnalysisSpecification
                        if (input.StabilityModelTypeSpecified)
                        {
                            curStabParamas.Model = ConversionHelper.ConvertToStabilityModelType(input.StabilityModelType);
                        }
                        curStabParamas.SlipCircleDefinition = new SlipCircleDefinition();
                        var slipCircleDefinition = curStabParamas.SlipCircleDefinition;
                        slipCircleDefinition.GridSizeDetermination = ConversionHelper.ConvertToGridDetermination(input.StabilityParameters.GridDetermination);

                        if (input.StabilityParameters.BishopTangentLinesDefinitionSpecified)
                        {
                            slipCircleDefinition.BishopTangentLinesDefinition = ConversionHelper.ConvertToTangentLinesDefinition(input.StabilityParameters.BishopTangentLinesDefinition);
                        }
                        if (input.StabilityParameters.BishopTangentLinesDistanceSpecified)
                        {
                            slipCircleDefinition.BishopTangentLinesDistance = input.StabilityParameters.BishopTangentLinesDistance;
                        }
                        if (input.StabilityParameters.BishopGridVerticalPointsCountSpecified)
                        {
                            slipCircleDefinition.BishopGridVerticalPointCount = input.StabilityParameters.BishopGridVerticalPointsCount;
                        }
                        if (input.StabilityParameters.BishopGridVerticalPointsDistanceSpecified)
                        {
                            slipCircleDefinition.BishopGridVerticalPointDistance = input.StabilityParameters.BishopGridVerticalPointsDistance;
                        }
                        if (input.StabilityParameters.BishopGridHorizontalPointsCountSpecified)
                        {
                            slipCircleDefinition.BishopGridHorizontalPointCount = input.StabilityParameters.BishopGridHorizontalPointsCount;
                        }
                        if (input.StabilityParameters.BishopGridHorizontalPointsDistanceSpecified)
                        {
                            slipCircleDefinition.BishopGridHorizontalPointDistance = input.StabilityParameters.BishopGridHorizontalPointsDistance;
                        }
                        if (input.StabilityParameters.UpliftVanTangentLinesDefinitionSpecified)
                        {
                            slipCircleDefinition.UpliftVanTangentLinesDefinition = ConversionHelper.ConvertToTangentLinesDefinition(input.StabilityParameters.UpliftVanTangentLinesDefinition);
                        }
                        if (input.StabilityParameters.UpliftVanTangentLinesDistanceSpecified)
                        {
                            slipCircleDefinition.UpliftVanTangentLinesDistance = input.StabilityParameters.UpliftVanTangentLinesDistance;
                        }
                        if (input.StabilityParameters.UpliftVanGridLeftVerticalPointsCountSpecified)
                        {
                            slipCircleDefinition.UpliftVanLeftGridVerticalPointCount = input.StabilityParameters.UpliftVanGridLeftVerticalPointsCount;
                        }
                        if (input.StabilityParameters.UpliftVanGridLeftVerticalPointsDistanceSpecified)
                        {
                            slipCircleDefinition.UpliftVanLeftGridVerticalPointDistance = input.StabilityParameters.UpliftVanGridLeftVerticalPointsDistance;
                        }
                        if (input.StabilityParameters.UpliftVanGridLeftHorizontalPointsCountSpecified)
                        {
                            slipCircleDefinition.UpliftVanLeftGridHorizontalPointCount = input.StabilityParameters.UpliftVanGridLeftHorizontalPointsCount;
                        }
                        if (input.StabilityParameters.UpliftVanGridLeftHorizontalPointsDistanceSpecified)
                        {
                            slipCircleDefinition.UpliftVanLeftGridHorizontalPointDistance = input.StabilityParameters.UpliftVanGridLeftHorizontalPointsDistance;
                        }
                        if (input.StabilityParameters.UpliftVanGridRightVerticalPointsCountSpecified)
                        {
                            slipCircleDefinition.UpliftVanRightGridVerticalPointCount = input.StabilityParameters.UpliftVanGridRightVerticalPointsCount;
                        }
                        if (input.StabilityParameters.UpliftVanGridRightVerticalPointsDistanceSpecified)
                        {
                            slipCircleDefinition.UpliftVanRightGridVerticalPointDistance = input.StabilityParameters.UpliftVanGridRightVerticalPointsDistance;
                        }
                        if (input.StabilityParameters.UpliftVanGridRightHorizontalPointsCountSpecified)
                        {
                            slipCircleDefinition.UpliftVanRightGridHorizontalPointCount = input.StabilityParameters.UpliftVanGridRightHorizontalPointsCount;
                        }
                        if (input.StabilityParameters.UpliftVanGridRightHorizontalPointsDistanceSpecified)
                        {
                            slipCircleDefinition.UpliftVanRightGridHorizontalPointDistance = input.StabilityParameters.UpliftVanGridRightHorizontalPointsDistance;
                        }
                    }
                }
            }
        }

        private static void ValidateInput(Input input)
        {
            if (input == null)
            {
                throw new NullReferenceException(Resources.NoInputDefined);
            }
            if (input.Locations == null)
            {
                throw new NullReferenceException(Resources.NoLocationsDefined);
            }
            foreach (Io.XmlInput.Location location in input.Locations)
            {
                if (location.DesignScenarios == null)
                {
                    throw new NullReferenceException(Resources.NoDesignScenariosInLocation);
                }
            }
            if (input.SurfaceLines == null)
            {
                throw new NullReferenceException(Resources.NoSurfaceLinesDefined);
            }
            else
            {
                foreach (var surfaceLine in input.SurfaceLines)
                {
                    if ((surfaceLine.Points == null) || (surfaceLine.Points.Length < 1))
                    {
                        throw new NullReferenceException(string.Format(Resources.NoPointsInSurfaceLine, surfaceLine.Name));
                    }
                }
            }
            if (input.Soils == null)
            {
                throw new NullReferenceException(Resources.NoSoilsDefined);
            }
            if (input.Segments == null)
            {
                throw new NullReferenceException(Resources.NoSegmentsDefined);
            }
        }

        /// <summary>
        /// Postprocess: connect all objects
        /// </summary>
        /// <param name="project">The project.</param>
        private static void PostProcess(DamProjectData project)
        {
            // find proper profiles for segments
            foreach (var segment in project.Segments)
            {
                foreach (var segmentSoilProfileProbability in segment.SoilProfileProbabilities)
                {
                    if (segmentSoilProfileProbability.SoilProfileType == SoilProfileType.ProfileType1D)
                    {
                        segmentSoilProfileProbability.SoilProfile1D = FindSoilProfile1DByName(project.Dike.SoilProfiles,
                            segmentSoilProfileProbability.SoilProfile1DName);
                    }
                    else
                    {
                        segmentSoilProfileProbability.SoilProfile2D = FindSoilProfile2DByName(project.Dike.SoilProfiles2D,
                            segmentSoilProfileProbability.SoilProfile2DName);
                    }
                }
            }

            // Set locations for scenarios
            foreach (var location in project.Dike.Locations)
            {
                foreach (var designScenario in location.Scenarios)
                {
                    designScenario.Location = location;
                }
                location.SoilList = project.Dike.SoilList;
            }
        }

        private static void TransferSoils(Soil[] inputSoils, List<Data.Geotechnics.Soil> soils)
        {
            for (int i = 0; i < inputSoils.Length; i++)
            {
                var soil = new Data.Geotechnics.Soil();
                var inputSoil = inputSoils[i];
                soil.Name = inputSoil.Name;
                soil.AbovePhreaticLevel = inputSoil.AbovePhreaticLevelSpecified ? inputSoil.AbovePhreaticLevel : double.NaN;
                soil.BelowPhreaticLevel = inputSoil.BelowPhreaticLevelSpecified ? inputSoil.BelowPhreaticLevel : double.NaN;
                soil.DryUnitWeight = inputSoil.DryUnitWeightSpecified ? inputSoil.DryUnitWeight : double.NaN;
                soil.BeddingAngle = inputSoil.BeddingAngleSpecified ? inputSoil.BeddingAngle : double.NaN;
                soil.DiameterD70 = inputSoil.DiameterD70Specified ? inputSoil.DiameterD70 : double.NaN;
                soil.DiameterD90 = inputSoil.DiameterD90Specified ? inputSoil.DiameterD90 : double.NaN;
                soil.PermeabKx = inputSoil.PermeabKxSpecified ? inputSoil.PermeabKx : double.NaN;
                soil.WhitesConstant = inputSoil.WhitesConstantSpecified ? inputSoil.WhitesConstant : double.NaN;
                soil.ShearStrengthModel = inputSoil.ShearStrengthModelSpecified ?
                    (ShearStrengthModel?)ConversionHelper.ConvertToShearStrengthModel(inputSoil.ShearStrengthModel) : null;
                soil.UseDefaultShearStrengthModel = inputSoil.UseDefaultShearStrengthModelSpecified ?
                    (bool?)inputSoil.UseDefaultShearStrengthModel : null;
                soil.Cohesion = inputSoil.CohesionSpecified ? inputSoil.Cohesion : double.NaN;
                soil.FrictionAngle = inputSoil.FrictionAngleSpecified ? inputSoil.FrictionAngle : double.NaN;
                soil.Ocr = inputSoil.OcrSpecified ? inputSoil.Ocr : double.NaN;
                soil.SlopeRestProfile = inputSoil.SlopeRestProfileSpecified ? inputSoil.SlopeRestProfile : double.NaN;
                soil.DilatancyType = inputSoil.DilatancyTypeSpecified ?
                    (DilatancyType?)ConversionHelper.ConvertToDilatancyType(inputSoil.DilatancyType) : null;
                soils.Add(soil);
            }
        }

        private static void TransferSurfaceLines(SurfaceLine[] inputSurfaceLines, IList<SurfaceLine2> dikeSurfaceLines)
        {
            for (int i = 0; i < inputSurfaceLines.Length; i++)
            {
                var surfaceLine = new SurfaceLine2();
                var inputSurfaceLine = inputSurfaceLines[i];
                surfaceLine.Name = inputSurfaceLine.Name;
                surfaceLine.CharacteristicPoints.Geometry = surfaceLine.Geometry;
                AddPointsToSurfaceLine(inputSurfaceLine, surfaceLine);
                dikeSurfaceLines.Add(surfaceLine);
            }
        }

        private static void AddPointsToSurfaceLine(SurfaceLine inputSurfaceLine, SurfaceLine2 surfaceLine)
        {
            surfaceLine.Geometry = new GeometryPointString();
            for (int j = 0; j < inputSurfaceLine.Points.Length; j++)
            {
                var inputPoint = inputSurfaceLine.Points[j];
                var geometryPoint = new GeometryPoint()
                {
                    X = inputPoint.X,
                    Y = 0.0,
                    Z = inputPoint.Z
                };
                surfaceLine.AddCharacteristicPoint(geometryPoint, ConversionHelper.ConvertToDamPointType(inputPoint.PointType));
            }
            surfaceLine.Geometry.SyncCalcPoints();
        }

        private static void TransferLocations(string projectPath, Io.XmlInput.Location[] inputLocations,
            IList<Location> dikeLocations, IList<SurfaceLine2> dikeSurfaceLines, IList<Segment> segments)
        {
            for (int i = 0; i < inputLocations.Length; i++)
            {
                var location = new Location();
                var inputLocation = inputLocations[i];
                location.Name = inputLocation.Name;
                if (inputLocation.DistanceToEntryPointSpecified)
                {
                    location.DistanceToEntryPoint = inputLocation.DistanceToEntryPoint;
                }
                if (inputLocation.XSoilGeometry2DOriginSpecified) location.XSoilGeometry2DOrigin = inputLocation.XSoilGeometry2DOrigin;
                // Waternet options
                var waternetOptions = inputLocation.WaternetOptions;
                location.ModelParametersForPlLines.PlLineCreationMethod = ConversionHelper.ConvertToPhreaticLineCreationMethod(waternetOptions.PhreaticLineCreationMethod);
                location.IntrusionVerticalWaterPressure = ConversionHelper.ConvertToIntrusionVerticalWaterPressure(waternetOptions.IntrusionVerticalWaterPressure);
                location.PolderLevel = waternetOptions.PolderLevel;
                location.ModelParametersForPlLines.DampingFactorPl4 = waternetOptions.DampingFactorPl3;
                location.ModelParametersForPlLines.DampingFactorPl3 = waternetOptions.DampingFactorPl4;
                location.ModelParametersForPlLines.PenetrationLength = waternetOptions.PenetrationLength;
                location.HeadPl2 = (waternetOptions.HeadPl2Specified ? (double?)waternetOptions.HeadPl2 : null);
                location.DikeSoilScenario = ConversionHelper.ConvertToDikeSoilScenario(waternetOptions.DikeSoilScenario);
                location.SlopeDampingPiezometricHeightPolderSide = waternetOptions.SlopeDampingFactor;
                
                // Design options
                var designOptions = inputLocation.DesignOptions;
                if (designOptions != null)
                {
                    location.RedesignDikeHeight = designOptions.RedesignDikeHeight;
                    location.RedesignDikeShoulder = designOptions.RedesignDikeShoulder;
                    location.ShoulderEmbankmentMaterial = designOptions.ShoulderEmbankmentMaterial;
                    location.StabilityShoulderGrowSlope = designOptions.StabilityShoulderGrowSlope;
                    location.StabilityShoulderGrowDeltaX = designOptions.StabilityShoulderGrowDeltaX;
                    location.StabilitySlopeAdaptionDeltaX = designOptions.StabilitySlopeAdaptionDeltaX;
                    location.SlopeAdaptionStartCotangent = designOptions.SlopeAdaptionStartCotangent;
                    location.SlopeAdaptionEndCotangent = designOptions.SlopeAdaptionEndCotangent;
                    location.SlopeAdaptionStepCotangent = designOptions.SlopeAdaptionStepCotangent;
                    location.UseNewDikeTopWidth = designOptions.NewDikeTopWidthSpecified;
                    if (designOptions.NewDikeTopWidthSpecified) location.NewDikeTopWidth = designOptions.NewDikeTopWidth;
                    location.UseNewDikeSlopeInside = designOptions.NewDikeSlopeInsideSpecified;
                    if (designOptions.NewDikeSlopeInsideSpecified) location.NewDikeSlopeInside = designOptions.NewDikeSlopeInside;
                    location.UseNewDikeSlopeOutside = designOptions.NewDikeSlopeOutsideSpecified;
                    if (designOptions.NewDikeSlopeOutsideSpecified) location.NewDikeSlopeOutside = designOptions.NewDikeSlopeOutside;
                    location.UseNewShoulderTopSlope = designOptions.NewShoulderTopSlopeSpecified;
                    if (designOptions.NewShoulderTopSlopeSpecified) location.NewShoulderTopSlope = designOptions.NewShoulderTopSlope;
                    location.UseNewShoulderBaseSlope = designOptions.NewShoulderBaseSlopeSpecified;
                    if (designOptions.NewShoulderBaseSlopeSpecified) location.NewShoulderBaseSlope = designOptions.NewShoulderBaseSlope;
                    location.UseNewMaxHeightShoulderAsFraction = designOptions.NewMaxHeightShoulderAsFractionSpecified;
                    if (designOptions.NewMaxHeightShoulderAsFractionSpecified) location.NewMaxHeightShoulderAsFraction = designOptions.NewMaxHeightShoulderAsFraction;
                    location.UseNewMinDistanceDikeToeStartDitch = designOptions.NewMinDistanceDikeToeStartDitchSpecified;
                    if (designOptions.NewMinDistanceDikeToeStartDitchSpecified) location.NewMinDistanceDikeToeStartDitch = designOptions.NewMinDistanceDikeToeStartDitch;
                    location.UseNewDitchDefinition = designOptions.UseNewDitchDefinition;
                    if (designOptions.NewWidthDitchBottomSpecified) location.NewWidthDitchBottom = designOptions.NewWidthDitchBottom;
                    if (designOptions.NewSlopeAngleDitchSpecified) location.NewSlopeAngleDitch = designOptions.NewSlopeAngleDitch;
                    if (designOptions.NewDepthDitchSpecified) location.NewDepthDitch = designOptions.NewDepthDitch;
                    location.StabilityDesignMethod = ConversionHelper.ConvertToDamStabilityDesignMethod(designOptions.StabilityDesignMethod);
                }

                SurfaceLine2 surfaceLine = dikeSurfaceLines.First(n => n.Name.Equals(inputLocation.SurfaceLineName));
                location.SurfaceLine = surfaceLine;
                Segment segment = null;
                if (segments.Count > 0)
                {
                    segment = segments.First(s => s.Name.Equals(inputLocation.SegmentName));
                }
                location.Segment = segment;

                if (inputLocation.DesignScenarios != null)
                {
                    for (int j = 0; j < inputLocation.DesignScenarios.Length; j++)
                    {
                        var designScenario = new DesignScenario();
                        var inputLocationDesignScenario = inputLocation.DesignScenarios[j];
                        designScenario.LocationScenarioID = inputLocationDesignScenario.Id;
                        designScenario.RiverLevel = inputLocationDesignScenario.RiverLevel;
                        designScenario.RiverLevelLow = (inputLocationDesignScenario.RiverLevelLowSpecified ? (double?)inputLocationDesignScenario.RiverLevelLow : null);
                        designScenario.DikeTableHeight = (inputLocationDesignScenario.DikeTableHeightSpecified ? (double?)inputLocationDesignScenario.DikeTableHeight : null);
                        designScenario.PlLineOffsetBelowDikeTopAtRiver = (inputLocationDesignScenario.PlLineOffsetBelowDikeTopAtRiverSpecified ? (double?)inputLocationDesignScenario.PlLineOffsetBelowDikeTopAtRiver : null);
                        designScenario.PlLineOffsetBelowDikeTopAtPolder = (inputLocationDesignScenario.PlLineOffsetBelowDikeTopAtPolderSpecified ? (double?)inputLocationDesignScenario.PlLineOffsetBelowDikeTopAtPolder : null);
                        designScenario.PlLineOffsetBelowShoulderBaseInside = (inputLocationDesignScenario.PlLineOffsetBelowShoulderBaseInsideSpecified ? (double?)inputLocationDesignScenario.PlLineOffsetBelowShoulderBaseInside : null);
                        designScenario.PlLineOffsetBelowDikeToeAtPolder = (inputLocationDesignScenario.PlLineOffsetBelowDikeToeAtPolderSpecified ? (double?)inputLocationDesignScenario.PlLineOffsetBelowDikeToeAtPolder : null);
                        designScenario.UsePlLineOffsetBelowDikeCrestMiddle = inputLocationDesignScenario.PlLineOffsetBelowDikeCrestMiddleSpecified;
                        designScenario.PlLineOffsetBelowDikeCrestMiddle = inputLocationDesignScenario.PlLineOffsetBelowDikeCrestMiddle;
                        designScenario.UsePlLineOffsetFactorBelowShoulderCrest = inputLocationDesignScenario.PlLineOffsetFactorBelowShoulderCrestSpecified;
                        designScenario.PlLineOffsetFactorBelowShoulderCrest = inputLocationDesignScenario.PlLineOffsetFactorBelowShoulderCrest;
                        designScenario.HeadPl3 = (inputLocationDesignScenario.HeadPl3Specified ? (double?)inputLocationDesignScenario.HeadPl3 : null);
                        designScenario.HeadPl4 = (inputLocationDesignScenario.HeadPl4Specified ? (double?)inputLocationDesignScenario.HeadPl4 : null);
                        designScenario.UpliftCriterionStability = (inputLocationDesignScenario.UpliftCriterionStabilitySpecified ? (double?)inputLocationDesignScenario.UpliftCriterionStability : null);
                        designScenario.UpliftCriterionPiping = (inputLocationDesignScenario.UpliftCriterionPipingSpecified ? (double?)inputLocationDesignScenario.UpliftCriterionPiping : null);
                        designScenario.RequiredSafetyFactorStabilityInnerSlope = (inputLocationDesignScenario.RequiredSafetyFactorStabilityInnerSlopeSpecified ? (double?)inputLocationDesignScenario.RequiredSafetyFactorStabilityInnerSlope : null);
                        designScenario.RequiredSafetyFactorStabilityOuterSlope = (inputLocationDesignScenario.RequiredSafetyFactorStabilityOuterSlopeSpecified ? (double?)inputLocationDesignScenario.RequiredSafetyFactorStabilityOuterSlope : null);
                        designScenario.RequiredSafetyFactorPiping = (inputLocationDesignScenario.RequiredSafetyFactorPipingSpecified ? (double?)inputLocationDesignScenario.RequiredSafetyFactorPiping : null);

                        location.Scenarios.Add(designScenario);
                    }
                }
                location.DikeEmbankmentMaterial = inputLocation.DikeEmbankmentMaterial;
                if (inputLocation.StabilityOptions != null)
                {
                    var tmpPath = projectPath ?? Directory.GetCurrentDirectory();
                    location.StabilityOptions = new StabilityOptions
                    {
                        SoilGeometries2DPath = Path.Combine(tmpPath, inputLocation.StabilityOptions.MapForSoilgeometries2D),
                        SoilDatabaseName = inputLocation.StabilityOptions.SoilDatabaseName,
                        StabilityZoneType = ConversionHelper.ConvertToZoneType(inputLocation.StabilityOptions.ZoneType)
                    };
                    if (inputLocation.StabilityOptions.ForbiddenZoneFactorSpecified)
                    {
                        location.StabilityOptions.ForbiddenZoneFactor = inputLocation.StabilityOptions.ForbiddenZoneFactor;
                    }
                    if (inputLocation.StabilityOptions.ZoneAreaRestSlopeCrestWidthSpecified)
                    {
                        location.StabilityOptions.ZoneAreaRestSlopeCrestWidth = inputLocation.StabilityOptions.ZoneAreaRestSlopeCrestWidth;
                    }
                    if (inputLocation.StabilityOptions.TrafficLoadSpecified)
                    {
                        location.StabilityOptions.TrafficLoad = inputLocation.StabilityOptions.TrafficLoad;
                    }
                    if (inputLocation.StabilityOptions.TrafficLoadDegreeOfConsolidationSpecified)
                    {
                        location.StabilityOptions.TrafficLoadDegreeOfConsolidation = inputLocation.StabilityOptions.TrafficLoadDegreeOfConsolidation;
                    }
                    if (inputLocation.StabilityOptions.MinimumCircleDepthSpecified)
                    {
                        location.StabilityOptions.MinimalCircleDepth = inputLocation.StabilityOptions.MinimumCircleDepth;
                    }
                }
                dikeLocations.Add(location);
            }
        }

        private static void TransferSoilProfiles1D(Io.XmlInput.SoilProfile1D[] inputSoilProfiles1D,
            IList<SoilProfile1D> dikeSoilProfiles, SoilList soils)
        {
            if (inputSoilProfiles1D != null)
            {
                for (int i = 0; i < inputSoilProfiles1D.Length; i++)
                {
                    var soilProfile1D = new SoilProfile1D();
                    var inputSoilProfile1D = inputSoilProfiles1D[i];
                    soilProfile1D.Name = inputSoilProfile1D.Name;
                    soilProfile1D.BottomLevel = inputSoilProfile1D.BottomLevel;
                    AddLayers1D(inputSoilProfile1D, soilProfile1D, soils);
                    dikeSoilProfiles.Add(soilProfile1D);
                }
            }
        }

        private static void AddLayers1D(Io.XmlInput.SoilProfile1D inputSoilProfile1D, SoilProfile1D soilProfile1D, SoilList soils)
        {
            if (inputSoilProfile1D != null)
            {
                for (int i = 0; i < inputSoilProfile1D.Layers1D.Length; i++)
                {
                    var layer = new SoilLayer1D();
                    var inputLayer = inputSoilProfile1D.Layers1D[i];
                    layer.Name = inputLayer.Name;
                    layer.Soil = soils.GetSoilByName(inputLayer.SoilName);
                    layer.TopLevel = inputLayer.TopLevel;
                    layer.IsAquifer = inputLayer.IsAquifer;
                    layer.WaterpressureInterpolationModel = ConversionHelper.ConvertToWaterpressureInterpolationModel(
                        inputLayer.WaterpressureInterpolationModel);
                    soilProfile1D.Layers.Add(layer);
                }
            }
        }

        private static void TransferSoilProfiles2D(Io.XmlInput.SoilProfile2D[] inputSoilProfiles2D,
            IList<SoilProfile2D> dikeSoilProfiles, SoilList soils)
        {
            if (inputSoilProfiles2D != null)
            {
                for (int i = 0; i < inputSoilProfiles2D.Length; i++)
                {
                    var soilProfile2D = new SoilProfile2D();
                    var inputSoilProfile2D = inputSoilProfiles2D[i];
                    soilProfile2D.Name = inputSoilProfile2D.Name;
                    AddPreconsolidationStresses(inputSoilProfile2D, soilProfile2D);
                    AddLayers2D(inputSoilProfile2D, soilProfile2D, soils);
                    dikeSoilProfiles.Add(soilProfile2D);
                }
            }
        }

        private static void AddPreconsolidationStresses(Io.XmlInput.SoilProfile2D inputSoilProfile2D, SoilProfile2D soilProfile2D)
        {
            if (inputSoilProfile2D.PreconsolidationStresses != null)
            {
                for (int i = 0; i < inputSoilProfile2D.PreconsolidationStresses.Length; i++)
                {
                    var precon = new PreConsolidationStress();
                    var inputPrecon = inputSoilProfile2D.PreconsolidationStresses[i];
                    precon.Name = inputPrecon.Name;
                    precon.StressValue = inputPrecon.StressValue;
                    precon.X = inputPrecon.X;
                    precon.Z = inputPrecon.Z;
                    soilProfile2D.PreconsolidationStresses.Add(precon);
                }
            }
        }

        private static void AddLayers2D(Io.XmlInput.SoilProfile2D inputSoilProfile2D, SoilProfile2D soilProfile2D, SoilList soils)
        {
            if (inputSoilProfile2D != null)
            {
                for (int i = 0; i < inputSoilProfile2D.Layers2D.Length; i++)
                {
                    var layer = new SoilLayer2D
                    {
                        GeometrySurface = new GeometrySurface()
                    };
                    var inputLayer = inputSoilProfile2D.Layers2D[i];
                    layer.Name = inputLayer.SoilName;
                    layer.Soil = soils.GetSoilByName(inputLayer.SoilName);
                    layer.IsAquifer = inputLayer.IsAquifer;
                    layer.WaterpressureInterpolationModel = ConversionHelper.ConvertToWaterpressureInterpolationModel(
                        inputLayer.WaterpressureInterpolationModel);
                    var loop = inputLayer.Surface.OuterLoop;
                    for (int j = 0; j < loop.Length; j++)
                    {
                        var point = new Point2D(loop[j].X, loop[j].Z);
                        layer.GeometrySurface.OuterLoop.CalcPoints.Add(point);
                    }
                    var innerloop = inputLayer.Surface.Innerloop;
                    if (innerloop != null)
                    {
                        var newloop = new GeometryLoop();
                        for (int j = 0; j < innerloop.Length; j++)
                        {
                            var point = new Point2D(innerloop[j].X, innerloop[j].Z);
                            newloop.CalcPoints.Add(point);
                        }
                        layer.GeometrySurface.InnerLoops.Add(newloop);
                    }
                    soilProfile2D.Surfaces.Add(layer);
                }
            }
        }

        private static void TransferSegments(Io.XmlInput.Segment[] inputSegments, IList<Segment> segments)
        {
            for (int i = 0; i < inputSegments.Length; i++)
            {
                var segment = new Segment();
                var inputSegment = inputSegments[i];
                segment.Name = inputSegment.Name;
                AddSoilProfileProbabilities(inputSegment, segment);
                segments.Add(segment);
            }
        }

        private static void AddSoilProfileProbabilities(Io.XmlInput.Segment inputSegment, Segment segment)
        {
            if (inputSegment.SoilGeometryProbability != null)
            {
                for (int i = 0; i < inputSegment.SoilGeometryProbability.Length; i++)
                {
                    var soilGeometryProbability = new SoilGeometryProbability();
                    var inputSoilGeometryProbability = inputSegment.SoilGeometryProbability[i];
                    soilGeometryProbability.Probability = inputSoilGeometryProbability.Probability;
                    if (inputSoilGeometryProbability.SegmentFailureMechanismTypeSpecified)
                    {
                        soilGeometryProbability.SegmentFailureMechanismType = ConversionHelper.ConvertToSegmentFailureMechanismSystemType(inputSoilGeometryProbability.SegmentFailureMechanismType);
                    }
                    else
                    {
                        soilGeometryProbability.SegmentFailureMechanismType = null;
                    }
                    soilGeometryProbability.SoilProfileType = ConversionHelper.ConvertToSoilGeometryType(inputSoilGeometryProbability.SoilProfileType);
                    switch (soilGeometryProbability.SoilProfileType)
                    {
                        case SoilProfileType.ProfileType1D:
                            {
                                soilGeometryProbability.SoilProfile1DName = inputSoilGeometryProbability.SoilProfileName;
                                break;
                            }
                        case SoilProfileType.ProfileType2D:
                            {
                                soilGeometryProbability.SoilProfile2DName = inputSoilGeometryProbability.SoilProfileName;
                                break;
                            }
                        case SoilProfileType.ProfileTypeStiFile:
                            {
                                soilGeometryProbability.StiFileName = inputSoilGeometryProbability.SoilProfileName;
                                break;
                            }
                    }

                    segment.SoilProfileProbabilities.Add(soilGeometryProbability);
                }
            }
        }

        /// <summary>
        /// Finds the SoilProfile1D by name.
        /// </summary>
        /// <param name="soilProfiles">The soil profiles.</param>
        /// <param name="name">The name.</param>
        /// <returns></returns>
        public static SoilProfile1D FindSoilProfile1DByName(IList<SoilProfile1D> soilProfiles, string name)
        {
            foreach (var soilProfile1D in soilProfiles)
            {
                if (soilProfile1D.Name == name)
                    return soilProfile1D;
            }
            return null;
        }

        /// <summary>
        /// Finds the SoilProfile2D by name.
        /// </summary>
        /// <param name="soilProfiles">The soil profiles.</param>
        /// <param name="name">The name.</param>
        /// <returns></returns>
        public static SoilProfile2D FindSoilProfile2DByName(IList<SoilProfile2D> soilProfiles, string name)
        {
            foreach (var soilProfile2D in soilProfiles)
            {
                if (soilProfile2D.Name == name)
                    return soilProfile2D;
            }
            return null;
        }

    }
}