// 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.Linq;
using Deltares.Dam.Data.Sensors;
using Deltares.DamEngine.Io.XmlInput;
using Deltares.Geotechnics.SurfaceLines;
using Soil = Deltares.Geotechnics.Soils.Soil;
using SurfaceLine = Deltares.DamEngine.Io.XmlInput.SurfaceLine;

namespace Deltares.Dam.Data.DamEngineIo
{
    /// <summary>
    /// Create XML Input object from DAM UI project
    /// </summary>
    public class FillXmlInputFromDamUi
    {
        /// <summary>
        /// Creates the input.
        /// </summary>
        /// <param name="damProjectData">The dam project data.</param>
        /// <param name="projectMap">The project map.</param>
        /// <returns></returns>
        public static Input CreateInput(DamProjectData damProjectData)
        {
            ValidateDamProjectData(damProjectData);

            Input input = new Input();
            Dike dike = damProjectData.WaterBoard.Dikes[0];

            input.ProjectPath = damProjectData.ProjectPath;
            input.CalculationMap = damProjectData.CalculationMap;
            input.MaxCalculationCoresSpecified = true;
            input.MaxCalculationCores = damProjectData.MaxCalculationCores;

            TransferAnalysisSpecification(damProjectData, input);
            TransferStabilityParameters(damProjectData, input);

            // Process locations
            List<Location> localLocations = new List<Location>();
            foreach (LocationJob locationJob in damProjectData.SelectedLocationJobs)
            {
                localLocations.Add(locationJob.Location);
            }
            input.Locations = new DamEngine.Io.XmlInput.Location[localLocations.Count];
            TransferLocations(localLocations, input.Locations);

            // Process surfacelines
            List<SurfaceLine2> localSurfaceLines = new List<SurfaceLine2>();
            for (int i = 0; i < localLocations.Count; i++)
            {
                var crtSurfaceLine = localLocations[i].LocalXZSurfaceLine2;
                if (!localSurfaceLines.Any(sl => sl.Name.Equals(crtSurfaceLine.Name)))
                {
                    localSurfaceLines.Add(crtSurfaceLine);
                }
            }
            input.SurfaceLines = new SurfaceLine[localSurfaceLines.Count];
            TransferSurfaceLines(localSurfaceLines, input.SurfaceLines);

            // Process soils
            input.Soils = new DamEngine.Io.XmlInput.Soil[dike.SoilList.Soils.Count];
            TransferSoils(dike.SoilList.Soils, input.Soils);
            TransferAquiferSoils(dike.SoilList.AquiferDictionary, input);

            // Process soilprofiles
            if (dike.SoilProfiles != null)
            {
                var profilesCount = dike.SoilProfiles.Count;
                input.SoilProfiles1D = new DamEngine.Io.XmlInput.SoilProfile1D[profilesCount];
                TransferSoilProfiles1D(dike.SoilProfiles, input.SoilProfiles1D);
            }

            var localSegments = EnsureInputLocationsSegmentsAreInSegments(damProjectData.WaterBoard.Segments, localLocations);
            // Process segments
            if (localSegments != null)
            {
                input.Segments = new DamEngine.Io.XmlInput.Segment[localSegments.Count];
                TransferSegments(localSegments, input.Segments);
            }

            if (damProjectData.InputTimeSerieCollection != null)
            {
                input.OperationalInputTimeSeries = new DamEngine.Io.XmlInput.TimeSerie[damProjectData.InputTimeSerieCollection.Series.Count];
                TransferInputTimeSeries(damProjectData.InputTimeSerieCollection, input.OperationalInputTimeSeries);
            }

            if (damProjectData.SensorData != null)
            {
                input.SensorData = new InputSensorData();
                TransferSensorData(damProjectData.SensorData, input.SensorData);
            }
            return input;
        }

        private static void TransferSensorData(SensorData sensorData, InputSensorData inputSensorData)
        {
            // Transfer sensorgroups
            int sensorGroupIndex = 0;
            inputSensorData.SensorGroups = new DamEngine.Io.XmlInput.SensorGroup[sensorData.SensorGroups.Count];
            foreach (var sensorGroup in sensorData.SensorGroups)
            {
                var inputSensorGroup = new DamEngine.Io.XmlInput.SensorGroup();
                inputSensorGroup.SensorIds = new SensorGroupSensorIds[sensorGroup.SensorCount];
                inputSensorGroup.Id = sensorGroup.ID;
                int sensorIdIndex = 0;
                foreach (var sensor in sensorGroup.SensorArray)
                {
                    inputSensorGroup.SensorIds[sensorIdIndex] = new SensorGroupSensorIds() { SensorId = sensor.ID };
                    sensorIdIndex++;
                }
                inputSensorData.SensorGroups[sensorGroupIndex] = inputSensorGroup;
                sensorGroupIndex++;
            }

            // Transfer sensorlocations
            int senserLocationIndex = 0;
            inputSensorData.SensorLocations = new DamEngine.Io.XmlInput.SensorLocation[sensorData.SensorLocations.Count];
            foreach (var sensorLocation in sensorData.SensorLocations)
            {
                var inputSensorLocation = new DamEngine.Io.XmlInput.SensorLocation();
                inputSensorLocation.GroupId = sensorLocation.GroupID;
                inputSensorLocation.LocationId = sensorLocation.LocationName;
                inputSensorLocation.SourceTypePl1PlLineOffsetBelowDikeToeAtPolder = ConversionHelper.ConvertToInputDataSourceTypeSensors(sensorLocation.SourceTypePl1PlLineOffsetBelowDikeToeAtPolder);
                inputSensorLocation.SourceTypePl1PlLineOffsetBelowDikeTopAtPolder = ConversionHelper.ConvertToInputDataSourceTypeSensors(sensorLocation.SourceTypePl1PlLineOffsetBelowDikeTopAtPolder);
                inputSensorLocation.SourceTypePl1PlLineOffsetBelowDikeTopAtRiver = ConversionHelper.ConvertToInputDataSourceTypeSensors(sensorLocation.SourceTypePl1PlLineOffsetBelowDikeTopAtRiver);
                inputSensorLocation.SourceTypePl1PlLineOffsetBelowShoulderBaseInside = ConversionHelper.ConvertToInputDataSourceTypeSensors(sensorLocation.SourceTypePl1PlLineOffsetBelowShoulderBaseInside);
                inputSensorLocation.SourceTypePl1WaterLevelAtRiver = ConversionHelper.ConvertToInputDataSourceTypeSensors(sensorLocation.SourceTypePl1WaterLevelAtRiver);
                inputSensorLocation.SourceTypePl1WaterLevelAtPolder = ConversionHelper.ConvertToInputDataSourceTypeSensors(sensorLocation.SourceTypePl1WaterLevelAtPolder);
                inputSensorLocation.SourceTypePl3 = ConversionHelper.ConvertToInputDataSourceTypeSensors(sensorLocation.SourceTypePl3);
                inputSensorLocation.SourceTypePl4 = ConversionHelper.ConvertToInputDataSourceTypeSensors(sensorLocation.SourceTypePl4);
                inputSensorData.SensorLocations[senserLocationIndex] = inputSensorLocation;
                senserLocationIndex++;
            }

            // Transfer sensors
            inputSensorData.Sensors = new DamEngine.Io.XmlInput.Sensor[sensorData.Sensors.Count];
            int sensorIndex = 0;
            foreach (var sensor in sensorData.Sensors)
            {
                var inputSensor = new DamEngine.Io.XmlInput.Sensor();
                inputSensor.Id = sensor.ID;
                inputSensor.RelativeLocation = sensor.RelativeLocation;
                inputSensor.SensorType = ConversionHelper.ConvertToInputSensorType(sensor.Type);
                inputSensor.PlLineMapping = new SensorPlLineMapping[sensor.PLLineMappings.Length];
                int mappingIndex = 0;
                foreach (var plLineMapping in sensor.PLLineMappings)
                {
                    inputSensor.PlLineMapping[mappingIndex] = new SensorPlLineMapping() { PLineType = ConversionHelper.ConvertToInputPlLineType(plLineMapping) };
                    mappingIndex++;
                }
                inputSensorData.Sensors[sensorIndex] = inputSensor;
                sensorIndex++;
            }
        }

        private static void TransferInputTimeSeries(TimeSerieCollection inputTimeSerieCollection, DamEngine.Io.XmlInput.TimeSerie[] operationalInputTimeSeries)
        {
            int timeSerieIndex = 0;
            foreach (var timeSerie in inputTimeSerieCollection.Series)
            {
                var inputTimeSerie = new DamEngine.Io.XmlInput.TimeSerie();
                inputTimeSerie.Entries = new TimeSerieEntries();
                inputTimeSerie.Entries.TimeSerieEntry = new TimeSerieEntriesTimeSerieEntry[timeSerie.Entries.Count];
                inputTimeSerie.TimeStep = new TimeSerieTimeStep();
                inputTimeSerie.LocationId = timeSerie.LocationId;
                inputTimeSerie.ParameterId = timeSerie.ParameterId;
                inputTimeSerie.ForecastDateTime = timeSerie.ForecastDateTime;
                inputTimeSerie.Type = timeSerie.Type;
                inputTimeSerie.StartDateTime = timeSerie.StartDateTime;
                inputTimeSerie.EndDateTime = timeSerie.EndDateTime;
                inputTimeSerie.MissVal = timeSerie.MissVal;
                inputTimeSerie.LongName = timeSerie.LongName;
                inputTimeSerie.StationName = timeSerie.StationName;
                inputTimeSerie.Units = timeSerie.Units;
                inputTimeSerie.SourceOrganisation = timeSerie.SourceOrganisation;
                inputTimeSerie.SourceSystem = timeSerie.SourceSystem;
                inputTimeSerie.FileDescription = timeSerie.FileDescription;
                inputTimeSerie.Region = timeSerie.Region;
                inputTimeSerie.TimeStep.Multiplier = timeSerie.TimeStep.Multiplier;
                inputTimeSerie.TimeStep.Divider = timeSerie.TimeStep.Divider;
                inputTimeSerie.TimeStep.MultiplierSpecified1 = timeSerie.TimeStep.MultiplierSpecified;
                inputTimeSerie.TimeStep.DividerSpecified1 = timeSerie.TimeStep.DividerSpecified;
                inputTimeSerie.TimeStep.TimeStepUnit = ConversionHelper.ConvertToInputTimeStepUnit(timeSerie.TimeStep.Unit);
                int timeSerieEntryIndex = 0;
                foreach (var timestepEntry in timeSerie.Entries)
                {
                    TimeSerieEntriesTimeSerieEntryStochastValue stochastValue = null;
                    if (timestepEntry.StochastValue != null)
                    {
                        stochastValue = new TimeSerieEntriesTimeSerieEntryStochastValue()
                        {
                            Distribution = timestepEntry.StochastValue.Distribution,
                            Mean = timestepEntry.StochastValue.Mean,
                            StandardDeviation = timestepEntry.StochastValue.StandardDeviation
                        };
                        TimeSerieEntriesTimeSerieEntry timeStep = new TimeSerieEntriesTimeSerieEntry()
                        {
                            DateTime = timestepEntry.DateTime,
                            Value = timestepEntry.Value,
                            BasisFileNameWMF = timestepEntry.BasisFileName,
                            Flagnietechtgebruikt = timestepEntry.Flag,
                            RelativeCalculationPathName = timestepEntry.RelativeCalculationPathName,
                            StochastValue = stochastValue
                        };
                        inputTimeSerie.Entries.TimeSerieEntry[timeSerieEntryIndex] = timeStep;
                        timeSerieEntryIndex++;
                    }
                }
                operationalInputTimeSeries[timeSerieIndex] = inputTimeSerie;
                timeSerieIndex++;
            }
        }

        private static void TransferAquiferSoils(Dictionary<Soil, bool> aquiferDictionary, Input input)
        {
            InputAquiferSoil[] aquiferSoils;
            if (aquiferDictionary != null && aquiferDictionary.Count > 0)
            {
                aquiferSoils = new InputAquiferSoil[aquiferDictionary.Count];
                int soilIndex = 0;
                foreach (KeyValuePair<Soil, bool> keyValuePair in aquiferDictionary)
                {
                    aquiferSoils[soilIndex] = new InputAquiferSoil() { Soilname = keyValuePair.Key.Name, IsAquifer = keyValuePair.Value };
                    soilIndex++;
                }
            }
            else
            {
                aquiferSoils = null;
            }
            input.AquiferSoils = aquiferSoils;
        }

        private static IList<Segment> EnsureInputLocationsSegmentsAreInSegments(IList<Segment> segments, List<Location> localLocations)
        {
            var localSegments = new List<Segment>();
            localSegments.AddRange(segments);
            foreach (var localLocation in localLocations)
            {
                var seg = localSegments.FirstOrDefault(x => x.Name == localLocation.Segment.Name);
                if (seg == null)
                {
                    localSegments.Add(localLocation.Segment);
                }
            }
            return localSegments;
        }

        private static void TransferAnalysisSpecification(DamProjectData damProjectData, Input input)
        {
            input.DamProjectType = ConversionHelper.ConvertToInputDamProjectType(damProjectData.DamProjectType);
            if (damProjectData.DamProjectCalculationSpecification.CurrentSpecification != null)
            {
                input.FailureMechanismSystemType = ConversionHelper.ConvertToInputFailureMechanismSystemType(damProjectData.DamProjectCalculationSpecification.CurrentSpecification.FailureMechanismSystemType);

                input.AnalysisTypeSpecified = (input.DamProjectType == InputDamProjectType.Design);
                if (input.AnalysisTypeSpecified)
                {
                    input.AnalysisType = ConversionHelper.ConvertToInputAnalysisType(DamProjectCalculationSpecification.SelectedAnalysisType);
                }

                input.PipingModelTypeSpecified = (input.FailureMechanismSystemType == ConversionHelper.InputFailureMechanismPiping) || (input.DamProjectType == InputDamProjectType.AssessmentRegional);
                if (input.PipingModelTypeSpecified)
                {
                    input.PipingModelType = ConversionHelper.ConvertToInputPipingModelType(damProjectData.DamProjectCalculationSpecification.CurrentSpecification.PipingModelType);
                }

                input.StabilityModelTypeSpecified = (input.FailureMechanismSystemType == ConversionHelper.InputFailureMechanismStabilityInside) || (input.FailureMechanismSystemType == ConversionHelper.InputFailureMechanismStabilityOutside) || (input.DamProjectType == InputDamProjectType.AssessmentRegional);
                if (input.StabilityModelTypeSpecified)
                {
                    input.StabilityModelType = ConversionHelper.ConvertToInputStabilityModelType(damProjectData.DamProjectCalculationSpecification.CurrentSpecification.StabilityModelType);
                }
            }
        }

        private static void TransferStabilityParameters(DamProjectData damProjectData, Input input)
        {
            if (damProjectData.DamProjectCalculationSpecification != null && damProjectData.DamProjectCalculationSpecification.CurrentSpecification != null)
            {
                var curSpec = damProjectData.DamProjectCalculationSpecification.CurrentSpecification;
                if (curSpec.FailureMechanismeParamatersMStab != null && curSpec.FailureMechanismeParamatersMStab.MStabParameters != null)
                {
                    input.StabilityParameters = new StabilityParameters();
                    input.StabilityParameters.SearchMethod = ConversionHelper.ConvertToInputSearchMethod(curSpec.FailureMechanismeParamatersMStab.MStabParameters.SearchMethod);
                    var slipCircleDefinition = curSpec.FailureMechanismeParamatersMStab.MStabParameters.SlipCircleDefinition;
                    if (slipCircleDefinition != null)
                    {
                        input.StabilityParameters.GridDetermination = ConversionHelper.ConvertToInputGridDetermination(slipCircleDefinition.GridSizeDetermination);
                        input.StabilityParameters.BishopTangentLinesDefinitionSpecified = true;
                        input.StabilityParameters.BishopTangentLinesDefinition = ConversionHelper.ConvertToInputTangentLinesDefinition(slipCircleDefinition.BishopTangentLinesDefinition);
                        input.StabilityParameters.BishopTangentLinesDistanceSpecified = true;
                        input.StabilityParameters.BishopTangentLinesDistance = slipCircleDefinition.BishopTangentLinesDistance;
                        input.StabilityParameters.BishopGridVerticalPointsCountSpecified = true;
                        input.StabilityParameters.BishopGridVerticalPointsCount = slipCircleDefinition.BishopGridVerticalPointCount;
                        input.StabilityParameters.BishopGridVerticalPointsDistanceSpecified = true;
                        input.StabilityParameters.BishopGridVerticalPointsDistance = slipCircleDefinition.BishopGridVerticalPointDistance;
                        input.StabilityParameters.BishopGridHorizontalPointsCountSpecified = true;
                        input.StabilityParameters.BishopGridHorizontalPointsCount = slipCircleDefinition.BishopGridHorizontalPointCount;
                        input.StabilityParameters.BishopGridHorizontalPointsDistanceSpecified = true;
                        input.StabilityParameters.BishopGridHorizontalPointsDistance = slipCircleDefinition.BishopGridHorizontalPointDistance;
                        input.StabilityParameters.UpliftVanTangentLinesDefinitionSpecified = true;
                        input.StabilityParameters.UpliftVanTangentLinesDefinition = ConversionHelper.ConvertToInputTangentLinesDefinition(slipCircleDefinition.UpliftVanTangentLinesDefinition);
                        input.StabilityParameters.UpliftVanTangentLinesDistanceSpecified = true;
                        input.StabilityParameters.UpliftVanTangentLinesDistance = slipCircleDefinition.UpliftVanTangentLinesDistance;
                        input.StabilityParameters.UpliftVanGridLeftVerticalPointsCountSpecified = true;
                        input.StabilityParameters.UpliftVanGridLeftVerticalPointsCount = slipCircleDefinition.UpliftVanLeftGridVerticalPointCount;
                        input.StabilityParameters.UpliftVanGridLeftVerticalPointsDistanceSpecified = true;
                        input.StabilityParameters.UpliftVanGridLeftVerticalPointsDistance = slipCircleDefinition.UpliftVanLeftGridVerticalPointDistance;
                        input.StabilityParameters.UpliftVanGridLeftHorizontalPointsCountSpecified = true;
                        input.StabilityParameters.UpliftVanGridLeftHorizontalPointsCount = slipCircleDefinition.UpliftVanLeftGridHorizontalPointCount;
                        input.StabilityParameters.UpliftVanGridLeftHorizontalPointsDistanceSpecified = true;
                        input.StabilityParameters.UpliftVanGridLeftHorizontalPointsDistance = slipCircleDefinition.UpliftVanLeftGridHorizontalPointDistance;
                        input.StabilityParameters.UpliftVanGridRightVerticalPointsCountSpecified = true;
                        input.StabilityParameters.UpliftVanGridRightVerticalPointsCount = slipCircleDefinition.UpliftVanRightGridVerticalPointCount;
                        input.StabilityParameters.UpliftVanGridRightVerticalPointsDistanceSpecified = true;
                        input.StabilityParameters.UpliftVanGridRightVerticalPointsDistance = slipCircleDefinition.UpliftVanRightGridVerticalPointDistance;
                        input.StabilityParameters.UpliftVanGridRightHorizontalPointsCountSpecified = true;
                        input.StabilityParameters.UpliftVanGridRightHorizontalPointsCount = slipCircleDefinition.UpliftVanRightGridHorizontalPointCount;
                        input.StabilityParameters.UpliftVanGridRightHorizontalPointsDistanceSpecified = true;
                        input.StabilityParameters.UpliftVanGridRightHorizontalPointsDistance = slipCircleDefinition.UpliftVanRightGridHorizontalPointDistance;
                    }
                }
            }
        }

        private static void ValidateDamProjectData(DamProjectData damProjectData)
        {
            if (damProjectData.WaterBoard == null)
            {
                throw new NullReferenceException("No dike defined in this project");
            }
            if (damProjectData.WaterBoard.Dikes == null || damProjectData.WaterBoard.Dikes.Count != 1)
            {
                throw new NullReferenceException("The project should contain exactly 1 dike");
            }
            var dike = damProjectData.WaterBoard.Dikes[0];
            if (dike.Locations == null)
            {
                throw new NullReferenceException("No locations defined in this project");
            }
            foreach (Location location in dike.Locations)
            {
                if (location.Scenarios == null)
                {
                    throw new NullReferenceException("No scenarios defined in location");
                }
            }
            if (dike.SurfaceLines2 == null)
            {
                throw new NullReferenceException("No surfacelines defined in this project");
            }
            else
            {
                foreach (var surfaceLine in dike.SurfaceLines2)
                {
                    if ((surfaceLine.CharacteristicPoints == null) || (surfaceLine.CharacteristicPoints.Count < 1))
                    {
                        throw new NullReferenceException(string.Format("Surfaceline '{0}' has no characteristic points", surfaceLine.Name));
                    }
                    if ((surfaceLine.Geometry == null) || (surfaceLine.Geometry.Count < 2))
                    {
                        throw new NullReferenceException(string.Format("Surfaceline '{0}' has no points", surfaceLine.Name));
                    }
                }
            }
            if (dike.SoilList == null)
            {
                throw new NullReferenceException("No soils defined in this project");
            }
            if (dike.SoilList.Soils == null)
            {
                throw new NullReferenceException("No soils defined in this project");
            }
            if (dike.SoilProfiles == null)
            {
                throw new NullReferenceException("No soilprofiles1D defined in this project");
            }
        }

        private static void TransferSoils(List<Soil> soils, DamEngine.Io.XmlInput.Soil[] inputSoils)
        {
            for (int i = 0; i < soils.Count; i++)
            {
                var soil = soils[i];
                var inputSoil = new DamEngine.Io.XmlInput.Soil();
                inputSoil.Name = soil.Name;
                inputSoil.AbovePhreaticLevelSpecified = !Double.IsNaN(soil.AbovePhreaticLevel);
                inputSoil.AbovePhreaticLevel = soil.AbovePhreaticLevel;
                inputSoil.BelowPhreaticLevelSpecified = !Double.IsNaN(soil.BelowPhreaticLevel);
                inputSoil.BelowPhreaticLevel = soil.BelowPhreaticLevel;
                inputSoil.DryUnitWeightSpecified = !Double.IsNaN(soil.DryUnitWeight);
                inputSoil.DryUnitWeight = soil.DryUnitWeight;
                inputSoil.BeddingAngleSpecified = !Double.IsNaN(soil.BeddingAngle);
                inputSoil.BeddingAngle = soil.BeddingAngle;
                inputSoil.DiameterD70Specified = !Double.IsNaN(soil.DiameterD70);
                inputSoil.DiameterD70 = soil.DiameterD70;
                inputSoil.DiameterD90Specified = !Double.IsNaN(soil.DiameterD70);
                inputSoil.DiameterD90 = soil.DiameterD90;
                inputSoil.PermeabKxSpecified = !Double.IsNaN(soil.DiameterD90);
                inputSoil.PermeabKx = soil.PermeabKx;
                inputSoil.WhitesConstantSpecified = !Double.IsNaN(soil.WhitesConstant);
                inputSoil.WhitesConstant = soil.WhitesConstant;
                inputSoil.ShearStrengthModelSpecified = true;
                inputSoil.ShearStrengthModel = ConversionHelper.ConvertToSoilShearStrengthModel(soil.ShearStrengthModel);
                inputSoil.UseDefaultShearStrengthModelSpecified = true;
                inputSoil.UseDefaultShearStrengthModel = soil.UseDefaultShearStrengthModel;
                inputSoil.CohesionSpecified = !Double.IsNaN(soil.Cohesion);
                inputSoil.Cohesion = soil.Cohesion;
                inputSoil.FrictionAngleSpecified = !Double.IsNaN(soil.FrictionAngle);
                inputSoil.FrictionAngle = soil.FrictionAngle;
                inputSoil.OcrSpecified = !Double.IsNaN(soil.OCR);
                inputSoil.Ocr = soil.OCR;
                inputSoil.SlopeRestProfileSpecified = !Double.IsNaN(soil.RestSlope);
                inputSoil.SlopeRestProfile = soil.RestSlope;
                inputSoil.DilatancyTypeSpecified = true;
                inputSoil.DilatancyType = ConversionHelper.ConvertToSoilDilatancyType(soil.DilatancyType);
                inputSoil.SoilType = ConversionHelper.ConvertToInputSoilType(soil.SoilType);
                inputSoil.SoilTypeSpecified = true;
                inputSoils[i] = inputSoil;
            }
        }

        private static void TransferSurfaceLines(IList<SurfaceLine2> dikeSurfaceLines, SurfaceLine[] inputSurfaceLines)
        {
            for (int i = 0; i < dikeSurfaceLines.Count; i++)
            {
                var surfaceLine = dikeSurfaceLines[i];
                var inputSurfaceLine = new SurfaceLine();
                inputSurfaceLine.Name = surfaceLine.Name;
                inputSurfaceLine.Points = new SurfaceLinePoint[surfaceLine.CharacteristicPoints.Count];
                for (int j = 0; j < surfaceLine.CharacteristicPoints.Count; j++)
                {
                    var characteristicPoint = surfaceLine.CharacteristicPoints[j];
                    var inputPoint = new SurfaceLinePoint()
                    {
                        PointType = ConversionHelper.ConvertToInputPointType(characteristicPoint.CharacteristicPointType),
                        X = characteristicPoint.X,
                        Z = characteristicPoint.Z
                    };
                    inputSurfaceLine.Points[j] = inputPoint;
                }
                inputSurfaceLines[i] = inputSurfaceLine;
            }
        }
        private static void TransferLocations(IList<Location> dikeLocations, DamEngine.Io.XmlInput.Location[] inputLocations)
        {
            for (int i = 0; i < dikeLocations.Count; i++)
            {
                var location = dikeLocations[i];
                var inputLocation = new DamEngine.Io.XmlInput.Location();
                inputLocation.Name = location.Name;
                inputLocation.XSoilGeometry2DOriginSpecified = true;
                inputLocation.XSoilGeometry2DOrigin = location.XSoilGeometry2DOrigin;

                inputLocation.SurfaceLineName = location.LocalXZSurfaceLine2.Name;
                inputLocation.SegmentName = location.Segment.Name;

                var waternetOptions = new LocationWaternetOptions();
                waternetOptions.PhreaticLineCreationMethod = ConversionHelper.ConvertToInputPhreaticLineCreationMethod(location.PLLineCreationMethod);
                waternetOptions.IntrusionVerticalWaterPressure = ConversionHelper.ConvertToInputIntrusionVerticalWaterPressure(location.IntrusionVerticalWaterPressure ?? IntrusionVerticalWaterPressureType.Standard);
                waternetOptions.PolderLevel = location.PolderLevel;
                waternetOptions.PolderLevelLow = location.PolderLevelLow;
                waternetOptions.PolderLevelLowSpecified = true;
                waternetOptions.DampingFactorPl3 = location.DampingFactorPL4;
                waternetOptions.DampingFactorPl4 = location.DampingFactorPL3;
                waternetOptions.PenetrationLength = location.PenetrationLength;
                waternetOptions.Pl1BelowCrestMiddleSpecified = location.PlLineOffsetBelowDikeCrestMiddle.HasValue;
                waternetOptions.Pl1BelowCrestMiddle = location.PlLineOffsetBelowDikeCrestMiddle ?? 0.0;
                waternetOptions.Pl1FactorBelowShoulderCrestSpecified = location.UsePlLineOffsetFactorBelowShoulderCrest ?? false;
                waternetOptions.Pl1FactorBelowShoulderCrest = location.PlLineOffsetFactorBelowShoulderCrest ?? 0.0;
                waternetOptions.DryPl1BelowCrestMiddleSpecified = location.PlLineOffsetDryBelowDikeCrestMiddle.HasValue;
                waternetOptions.DryPl1BelowCrestMiddle = location.PlLineOffsetDryBelowDikeCrestMiddle ?? 0.0;
                waternetOptions.DryPl1FactorBelowShoulderCrestSpecified = location.UsePlLineOffsetDryFactorBelowShoulderCrest ?? false;
                waternetOptions.DryPl1FactorBelowShoulderCrest = location.PlLineOffsetDryFactorBelowShoulderCrest ?? 0.0;
                waternetOptions.HeadPl2Specified = location.HeadPL2.HasValue;
                waternetOptions.HeadPl2 = location.HeadPL2 ?? 0.0;
                waternetOptions.HeadPl3Specified = location.HeadPl3.HasValue;
                waternetOptions.HeadPl3 = location.HeadPl3 ?? 0.0;
                waternetOptions.HeadPl4Specified = location.HeadPl4.HasValue;
                waternetOptions.HeadPl4 = location.HeadPl4 ?? 0.0;
                waternetOptions.SlopeDampingFactor = location.SlopeDampingPiezometricHeightPolderSide;
                waternetOptions.Pl1BelowCrestRiverside = location.PlLineOffsetBelowDikeTopAtRiver;
                waternetOptions.Pl1BelowCrestPolderside = location.PlLineOffsetBelowDikeTopAtPolder;
                waternetOptions.Pl1BelowShoulderCrestPolderside = location.PlLineOffsetBelowShoulderBaseInside;
                waternetOptions.Pl1BelowToeDikePolderside = location.PlLineOffsetBelowDikeToeAtPolder;
                waternetOptions.DryPl1BelowDikeTopAtRiver = location.PLLineOffsetDryBelowDikeTopAtRiver;
                waternetOptions.DryPl1BelowDikeTopAtRiverSpecified = true;
                waternetOptions.DryPl1DryBelowDikeTopAtPolder = location.PLLineOffsetDryBelowDikeTopAtPolder;
                waternetOptions.DryPl1DryBelowDikeTopAtPolderSpecified = true;
                waternetOptions.DryPl1BelowShoulderBaseInside = location.PLLineOffsetDryBelowShoulderBaseInside;
                waternetOptions.DryPl1BelowShoulderBaseInsideSpecified = true;
                waternetOptions.DryPl1DryBelowDikeToeAtPolder = location.PLLineOffsetDryBelowDikeToeAtPolder;
                waternetOptions.DryPl1DryBelowDikeToeAtPolderSpecified = true;
                inputLocation.WaternetOptions = waternetOptions;

                // Regional settings
                var assesmentRegionalOptions = new LocationAssesmentRegionalOptions();
                inputLocation.DikeTableHeight = location.DikeTableHeight;
                assesmentRegionalOptions.BoezemLevelHbp = location.BoezemLevelHbp;
                assesmentRegionalOptions.BoezemLevelLbp = location.BoezemLevelLbp;
                assesmentRegionalOptions.BoezemLevelTp = location.BoezemLevelTp;
                assesmentRegionalOptions.RegionalBankProtectionBottomLevel = location.RwBankProtectionBottomLevel;
                assesmentRegionalOptions.DredgingDepth = location.DredgingDepth;
                assesmentRegionalOptions.DetrimentFactor = location.DetrimentFactor;
                assesmentRegionalOptions.DikeSoilType = ConversionHelper.ConvertToInputSoilType(location.DikeMaterialType);
                assesmentRegionalOptions.DikeSoilTypeSpecified = true;
                inputLocation.AssesmentRegionalOptions = assesmentRegionalOptions;

                inputLocation.DesignScenarios = new LocationDesignScenario[location.Scenarios.Count];
                for (int j = 0; j < location.Scenarios.Count; j++)
                {
                    var designScenario = location.Scenarios[j];
                    var inputDesignScenario = new LocationDesignScenario();
                    inputDesignScenario.RiverLevel = designScenario.RiverLevel;

                    inputDesignScenario.Id = designScenario.LocationScenarioID;
                    inputDesignScenario.RiverLevelLowSpecified = designScenario.RiverLevelLow.HasValue;
                    inputDesignScenario.RiverLevelLow = designScenario.RiverLevelLow ?? 0.0;
                    inputDesignScenario.DikeTableHeightSpecified = designScenario.DikeTableHeight.HasValue;
                    inputDesignScenario.DikeTableHeight = designScenario.DikeTableHeight ?? 0.0;
                    inputDesignScenario.PlLineOffsetBelowDikeTopAtRiverSpecified = designScenario.PlLineOffsetBelowDikeTopAtRiver.HasValue;
                    inputDesignScenario.PlLineOffsetBelowDikeTopAtRiver = designScenario.PlLineOffsetBelowDikeTopAtRiver ?? 0.0;
                    inputDesignScenario.PlLineOffsetBelowDikeTopAtPolderSpecified = designScenario.PlLineOffsetBelowDikeTopAtPolder.HasValue;
                    inputDesignScenario.PlLineOffsetBelowDikeTopAtPolder = designScenario.PlLineOffsetBelowDikeTopAtPolder ?? 0.0;
                    inputDesignScenario.PlLineOffsetBelowShoulderBaseInsideSpecified = designScenario.PlLineOffsetBelowShoulderBaseInside.HasValue;
                    inputDesignScenario.PlLineOffsetBelowShoulderBaseInside = designScenario.PlLineOffsetBelowShoulderBaseInside ?? 0.0;
                    inputDesignScenario.PlLineOffsetBelowDikeToeAtPolderSpecified = designScenario.PlLineOffsetBelowDikeToeAtPolder.HasValue;
                    inputDesignScenario.PlLineOffsetBelowDikeToeAtPolder = designScenario.PlLineOffsetBelowDikeToeAtPolder ?? 0.0;
                    inputDesignScenario.PlLineOffsetBelowDikeCrestMiddleSpecified = designScenario.UsePlLineOffsetBelowDikeCrestMiddle ?? false;
                    inputDesignScenario.PlLineOffsetBelowDikeCrestMiddle = designScenario.PlLineOffsetBelowDikeCrestMiddle ?? 0.0;
                    inputDesignScenario.PlLineOffsetFactorBelowShoulderCrestSpecified = designScenario.UsePlLineOffsetFactorBelowShoulderCrest ?? false;
                    inputDesignScenario.PlLineOffsetFactorBelowShoulderCrest = designScenario.PlLineOffsetFactorBelowShoulderCrest ?? 0.0;
                    inputDesignScenario.HeadPl3Specified = designScenario.HeadPl3.HasValue;
                    inputDesignScenario.HeadPl3 = designScenario.HeadPl3 ?? 0.0;
                    inputDesignScenario.HeadPl4Specified = designScenario.HeadPl4.HasValue;
                    inputDesignScenario.HeadPl4 = designScenario.HeadPl4 ?? 0.0;
                    inputDesignScenario.UpliftCriterionStabilitySpecified = designScenario.UpliftCriterionStability.HasValue;
                    inputDesignScenario.UpliftCriterionStability = designScenario.UpliftCriterionStability ?? 0.0;
                    inputDesignScenario.UpliftCriterionPipingSpecified = designScenario.UpliftCriterionPiping.HasValue;
                    inputDesignScenario.UpliftCriterionPiping = designScenario.UpliftCriterionPiping ?? 0.0;
                    inputDesignScenario.RequiredSafetyFactorStabilityInnerSlopeSpecified = designScenario.RequiredSafetyFactorStabilityInnerSlope.HasValue;
                    inputDesignScenario.RequiredSafetyFactorStabilityInnerSlope = designScenario.RequiredSafetyFactorStabilityInnerSlope ?? 0.0;
                    inputDesignScenario.RequiredSafetyFactorStabilityOuterSlopeSpecified = designScenario.RequiredSafetyFactorStabilityOuterSlope.HasValue;
                    inputDesignScenario.RequiredSafetyFactorStabilityOuterSlope = designScenario.RequiredSafetyFactorStabilityOuterSlope ?? 0.0;
                    inputDesignScenario.RequiredSafetyFactorPipingSpecified = designScenario.RequiredSafetyFactorPiping.HasValue;
                    inputDesignScenario.RequiredSafetyFactorPiping = designScenario.RequiredSafetyFactorPiping ?? 0.0;

                    inputLocation.DesignScenarios[j] = inputDesignScenario;
                }
                inputLocation.DikeEmbankmentMaterial = location.DikeEmbankmentMaterial;
                inputLocation.StabilityOptions = new LocationStabilityOptions
                {
                    MapForSoilgeometries2D = location.MapForSoilGeometries2D,
                    SoilDatabaseName = location.SoildatabaseName,
                    ZoneType = ConversionHelper.ConvertToInputZoneType(location.StabilityZoneType),
                    ForbiddenZoneFactorSpecified = true,
                    ForbiddenZoneFactor = location.ForbiddenZoneFactor,
                    ZoneAreaRestSlopeCrestWidthSpecified = true,
                    ZoneAreaRestSlopeCrestWidth = location.ZoneAreaRestSlopeCrestWidth,
                    TrafficLoadSpecified = true,
                    TrafficLoad = location.TrafficLoad,
                    MinimumCircleDepthSpecified = true,
                    MinimumCircleDepth = location.MinimalCircleDepth
                };

                // Design options
                var designOptions = new LocationDesignOptions();
                designOptions.RedesignDikeHeight = location.RedesignDikeHeight;
                designOptions.RedesignDikeShoulder = location.RedesignDikeShoulder;
                designOptions.ShoulderEmbankmentMaterial = location.ShoulderEmbankmentMaterial;
                designOptions.StabilityShoulderGrowSlope = location.StabilityShoulderGrowSlope;
                designOptions.StabilityShoulderGrowDeltaX = location.StabilityShoulderGrowDeltaX;
                designOptions.StabilitySlopeAdaptionDeltaX = location.StabilitySlopeAdaptionDeltaX;
                designOptions.SlopeAdaptionStartCotangent = location.SlopeAdaptionStartCotangent;
                designOptions.SlopeAdaptionEndCotangent = location.SlopeAdaptionEndCotangent;
                designOptions.SlopeAdaptionStepCotangent = location.SlopeAdaptionStepCotangent;
                designOptions.NewDikeTopWidthSpecified = location.UseNewDikeTopWidth;
                designOptions.NewDikeTopWidth = location.NewDikeTopWidth;
                designOptions.NewDikeSlopeInsideSpecified = location.UseNewDikeSlopeInside;
                designOptions.NewDikeSlopeInside = location.NewDikeSlopeInside;
                designOptions.NewDikeSlopeOutsideSpecified = location.UseNewDikeSlopeOutside;
                designOptions.NewDikeSlopeOutside = location.NewDikeSlopeOutside;
                designOptions.NewShoulderTopSlopeSpecified = location.UseNewShoulderTopSlope;
                designOptions.NewShoulderTopSlope = location.NewShoulderTopSlope;
                designOptions.NewShoulderBaseSlopeSpecified = location.UseNewShoulderBaseSlope;
                designOptions.NewShoulderBaseSlope = location.NewShoulderBaseSlope;
                designOptions.NewMaxHeightShoulderAsFractionSpecified = location.UseNewMaxHeightShoulderAsFraction;
                designOptions.NewMaxHeightShoulderAsFraction = location.NewMaxHeightShoulderAsFraction;
                designOptions.NewMinDistanceDikeToeStartDitchSpecified = location.UseNewMinDistanceDikeToeStartDitch;
                designOptions.NewMinDistanceDikeToeStartDitch = location.NewMinDistanceDikeToeStartDitch;
                designOptions.UseNewDitchDefinition = location.UseNewDitchDefinition;
                designOptions.NewWidthDitchBottomSpecified = location.UseNewDitchDefinition;
                designOptions.NewWidthDitchBottom = location.NewWidthDitchBottom;
                designOptions.NewSlopeAngleDitchSpecified = location.UseNewDitchDefinition;
                designOptions.NewSlopeAngleDitch = location.NewSlopeAngleDitch;
                designOptions.NewDepthDitchSpecified = location.UseNewDitchDefinition;
                designOptions.NewDepthDitch = location.NewDepthDitch;
                designOptions.StabilityDesignMethod = ConversionHelper.ConvertToInputStabilityDesignMethod(location.StabilityDesignMethod);
                inputLocation.DesignOptions = designOptions;
                // Modelfactors
                if (location.ModelFactors != null)
                {
                    inputLocation.ModelFactors = new LocationModelFactors();
                    inputLocation.ModelFactors.RequiredSafetyFactorPipingSpecified = location.ModelFactors.RequiredSafetyFactorPiping.HasValue;
                    inputLocation.ModelFactors.RequiredSafetyFactorPiping = location.ModelFactors.RequiredSafetyFactorPiping ?? 0.0;
                    inputLocation.ModelFactors.RequiredSafetyFactorStabilityInnerSlopeSpecified = location.ModelFactors.RequiredSafetyFactorStabilityInnerSlope.HasValue;
                    inputLocation.ModelFactors.RequiredSafetyFactorStabilityInnerSlope = location.ModelFactors.RequiredSafetyFactorStabilityInnerSlope ?? 0.0;
                    inputLocation.ModelFactors.RequiredSafetyFactorStabilityOuterSlopeSpecified = location.ModelFactors.RequiredSafetyFactorStabilityOuterSlope.HasValue;
                    inputLocation.ModelFactors.RequiredSafetyFactorStabilityOuterSlope = location.ModelFactors.RequiredSafetyFactorStabilityOuterSlope ?? 0.0;
                    inputLocation.ModelFactors.UpliftCriterionPipingSpecified = location.ModelFactors.UpliftCriterionPiping.HasValue;
                    inputLocation.ModelFactors.UpliftCriterionPiping = location.ModelFactors.UpliftCriterionPiping ?? 0.0;
                    inputLocation.ModelFactors.UpliftCriterionStabilitySpecified = location.ModelFactors.UpliftCriterionStability.HasValue;
                    inputLocation.ModelFactors.UpliftCriterionStability = location.ModelFactors.UpliftCriterionStability ?? 0.0;
                }

                inputLocations[i] = inputLocation;
            }
        }
        private static void TransferSoilProfiles1D(IList<Deltares.Geotechnics.Soils.SoilProfile1D> dikeSoilProfiles, DamEngine.Io.XmlInput.SoilProfile1D[] inputSoilProfiles1D)
        {
            var profilesCount = dikeSoilProfiles.Count;
            for (int i = 0; i < profilesCount; i++)
            {
                var soilProfile1D = dikeSoilProfiles[i];
                var inputSoilProfile1D = new DamEngine.Io.XmlInput.SoilProfile1D
                {
                    Name = soilProfile1D.Name,
                    BottomLevel = soilProfile1D.BottomLevel,
                    Layers1D = new SoilProfile1DLayer1D[soilProfile1D.LayerCount]
                };
                AddLayers1D(soilProfile1D, inputSoilProfile1D);
                inputSoilProfiles1D[i] = inputSoilProfile1D;
            }
        }

        private static void AddLayers1D(Deltares.Geotechnics.Soils.SoilProfile1D soilProfile1D, DamEngine.Io.XmlInput.SoilProfile1D inputSoilProfile1D)
        {
            for (int i = 0; i < soilProfile1D.LayerCount; i++)
            {
                var layer = soilProfile1D.Layers[i];
                var inputLayer = new SoilProfile1DLayer1D
                {
                    Name = layer.Id,
                    SoilName = layer.Soil.Name,
                    TopLevel = layer.TopLevel,
                    IsAquifer = layer.IsAquifer,
                    WaterpressureInterpolationModel = ConversionHelper.ConvertToInputWaterpressureInterpolationModel(
                        layer.WaterpressureInterpolationModel)
                };
                inputSoilProfile1D.Layers1D[i] = inputLayer;
            }
        }
        private static void TransferSegments(IList<Segment> segments, DamEngine.Io.XmlInput.Segment[] inputSegments)
        {
            for (int i = 0; i < segments.Count; i++)
            {
                var segment = segments[i];
                var inputSegment = new DamEngine.Io.XmlInput.Segment
                {
                    Name = segment.Name
                };
                AddSoilProfileProbabilities(segment, inputSegment);
                inputSegments[i] = inputSegment;
            }
        }

        private static void AddSoilProfileProbabilities(Segment segment, DamEngine.Io.XmlInput.Segment inputSegment)
        {
            if (segment.SoilProfileProbabilities != null)
            {
                var probabilityCount = segment.SoilProfileProbabilities.Count;
                inputSegment.SoilGeometryProbability = new SegmentSoilGeometryProbability[probabilityCount];
                for (int i = 0; i < probabilityCount; i++)
                {
                    var soilGeometryProbability = segment.SoilProfileProbabilities[i];
                    var inputSoilGeometryProbability = new SegmentSoilGeometryProbability();
                    inputSoilGeometryProbability.Probability = soilGeometryProbability.Probability;
                    if (soilGeometryProbability.SegmentFailureMechanismType.HasValue)
                    {
                        inputSoilGeometryProbability.FailureMechanismSystemType = ConversionHelper.ConvertToInputFailureMechanismSystemType(soilGeometryProbability.SegmentFailureMechanismType.Value);
                        inputSoilGeometryProbability.FailureMechanismSystemTypeSpecified = true;
                    }
                    else
                    {
                        inputSoilGeometryProbability.FailureMechanismSystemTypeSpecified = false;
                    }
                    if (soilGeometryProbability.SoilGeometryType == SoilGeometryType.SoilGeometry1D)
                    {
                        inputSoilGeometryProbability.SoilProfileName = soilGeometryProbability.SoilGeometryName;
                    }
                    else
                    {
                        inputSoilGeometryProbability.SoilProfileName = soilGeometryProbability.SoilGeometry2DName;
                    }
                    inputSoilGeometryProbability.SoilProfileType = ConversionHelper.ConvertToInputSoilGeometryType(soilGeometryProbability.SoilGeometryType);
                    inputSegment.SoilGeometryProbability[i] = inputSoilGeometryProbability;
                }
            }
        }
    }
}