// Copyright (C) Stichting Deltares 2018. 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.General;
using Deltares.DamEngine.Data.Geotechnics;
using Deltares.DamEngine.Interface.Properties;
using Deltares.DamEngine.Io.XmlInput;
using Input = Deltares.DamEngine.Io.XmlInput.Input;
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;

namespace Deltares.DamEngine.Interface
{
    public class FillXmlInputFromDam
    {

        /// <summary>
        /// Creates the input from Dam data.
        /// </summary>
        /// <param name="damProjectData">The dam project data.</param>
        /// <returns></returns>
        public static Input CreateInput(DamProjectData damProjectData)
        {
            ValidateDamProjectData(damProjectData);

            Input input = new Input();
            input.ProjectPath = damProjectData.ProjectPath;
            input.CalculationMap = damProjectData.CalculationMap;
            input.MaxCalculationCoresSpecified = true;
            input.MaxCalculationCores = damProjectData.MaxCalculationCores;
            TransferAnalysisSpecification(damProjectData, input);
            TransferStabilityParameters(damProjectData, input);

            Dike dike = damProjectData.Dike;
            input.Locations = new Io.XmlInput.Location[dike.Locations.Count];
            TransferLocations(damProjectData.ProjectPath, dike.Locations, input.Locations);
            input.SurfaceLines = new SurfaceLine[dike.SurfaceLines2.Count];
            TransferSurfaceLines(dike.SurfaceLines2, input.SurfaceLines);
            input.Soils = new Soil[dike.SoilList.Soils.Count];
            TransferSoils(dike.SoilList.Soils, input.Soils);
            if (dike.SoilProfiles != null)
            {
                var profilesCount = dike.SoilProfiles.Count;
                input.SoilProfiles1D = new Io.XmlInput.SoilProfile1D[profilesCount];
                TransferSoilProfiles1D(dike.SoilProfiles, input.SoilProfiles1D);
            }
            if (dike.SoilProfiles2D != null)
            {
                var profilesCount = dike.SoilProfiles2D.Count;
                input.SoilProfiles2D = new Io.XmlInput.SoilProfile2D[profilesCount];
                TransferSoilProfiles2D(dike.SoilProfiles2D, input.SoilProfiles2D);
            }
            if (damProjectData.Segments != null)
            {
                input.Segments = new Io.XmlInput.Segment[damProjectData.Segments.Count];
                TransferSegments(damProjectData.Segments, input.Segments);
            }
            return input;
        }

        private static void TransferAnalysisSpecification(DamProjectData damProjectData, Input input)
        {
            input.DamProjectType = ConversionHelper.ConvertToInputDamProjectType(damProjectData.DamProjectType);
            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);
            if (input.PipingModelTypeSpecified)
            {
                input.PipingModelType = ConversionHelper.ConvertToInputPipingModelType(damProjectData.DamProjectCalculationSpecification.CurrentSpecification.PipingModelType);
            }

            input.StabilityModelTypeSpecified = (input.FailureMechanismSystemType == ConversionHelper.InputFailureMechanismStabilityInside) || (input.FailureMechanismSystemType == ConversionHelper.InputFailureMechanismStabilityOutside);
            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.FailureMechanismParametersMStab != null && curSpec.FailureMechanismParametersMStab.MStabParameters != null)
                {
                    input.StabilityParameters = new StabilityParameters();
                    input.StabilityParameters.SearchMethod = ConversionHelper.ConvertToInputSearchMethod(curSpec.FailureMechanismParametersMStab.MStabParameters.SearchMethod);
                    var slipCircleDefinition = curSpec.FailureMechanismParametersMStab.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.Dike == null)
            {
                throw new NullReferenceException(Resources.NoDikeInProject);
            }
            if (damProjectData.Dike.Locations == null)
            {
                throw new NullReferenceException(Resources.NoLocationsInProject);
            }
            foreach (Location location in damProjectData.Dike.Locations)
            {
                if (location.Scenarios == null)
                {
                    throw new NullReferenceException(Resources.NoDesignScenariosInLocationProject);
                }
            }
            if (damProjectData.Dike.SurfaceLines2 == null)
            {
                throw new NullReferenceException(Resources.NoSurfaceLinesInProject);
            }
            else
            {
                foreach (var surfaceLine in damProjectData.Dike.SurfaceLines2)
                {
                    if ((surfaceLine.CharacteristicPoints == null) || (surfaceLine.CharacteristicPoints.Count < 1))
                    {
                        throw new NullReferenceException(string.Format(Resources.NoCharacteristicPointsInSurfaceLineProject, surfaceLine.Name));
                    }
                    if ((surfaceLine.Geometry == null) || (surfaceLine.Geometry.Count < 2))
                    {
                        throw new NullReferenceException(string.Format(Resources.NoPointsInSurfaceLineProject, surfaceLine.Name));
                    }
                }
            }
            if (damProjectData.Dike.SoilList == null)
            {
                throw new NullReferenceException(Resources.NoSoilsInProject);
            }
            if (damProjectData.Dike.SoilList.Soils == null)
            {
                throw new NullReferenceException(Resources.NoSoilsInProject);
            }
            if (damProjectData.Dike.SoilProfiles == null)
            {
                throw new NullReferenceException(Resources.NoSoilProfiles1DInProject);
            }
        }

        private static void TransferSoils(List<Data.Geotechnics.Soil> soils, Soil[] inputSoils)
        {
            for (int i = 0; i < soils.Count; i++)
            {
                var soil = soils[i];
                var inputSoil = new 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 = (soil.ShearStrengthModel != null);
                if (inputSoil.ShearStrengthModelSpecified)
                {
                    inputSoil.ShearStrengthModel = ConversionHelper.ConvertToSoilShearStrengthModel(soil.ShearStrengthModel.Value);
                }
                inputSoil.UseDefaultShearStrengthModelSpecified = (soil.UseDefaultShearStrengthModel != null);
                if (inputSoil.ShearStrengthModelSpecified)
                {
                    inputSoil.UseDefaultShearStrengthModel = soil.UseDefaultShearStrengthModel.Value;
                }
                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.SlopeRestProfile);
                inputSoil.SlopeRestProfile = soil.SlopeRestProfile;
                inputSoil.DilatancyTypeSpecified = (soil.DilatancyType != null);
                if (inputSoil.DilatancyTypeSpecified)
                {
                    inputSoil.DilatancyType = ConversionHelper.ConvertToSoilDilatancyType(soil.DilatancyType.Value);
                }
                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(string projectPath, IList<Location> dikeLocations, Io.XmlInput.Location[] inputLocations)
        {
            int locationCount = dikeLocations.Count;
            for (int i = 0; i < locationCount; i++)
            {
                var location = dikeLocations[i];

                var inputLocation = new Io.XmlInput.Location();
                inputLocation.Name = location.Name;
                inputLocation.XSoilGeometry2DOrigin = location.XSoilGeometry2DOrigin;
                inputLocation.XSoilGeometry2DOriginSpecified = true;
                inputLocation.SurfaceLineName = location.SurfaceLine.Name;
                inputLocation.SegmentName = location.Segment.Name;
                var waternetOptions = new LocationWaternetOptions();
                waternetOptions.PhreaticLineCreationMethod = ConversionHelper.ConvertToInputPhreaticLineCreationMethod(location.ModelParametersForPlLines.PlLineCreationMethod);
                waternetOptions.IntrusionVerticalWaterPressure = ConversionHelper.ConvertToInputIntrusionVerticalWaterPressure(location.IntrusionVerticalWaterPressure ?? IntrusionVerticalWaterPressureType.Standard);
                waternetOptions.PolderLevel = location.PolderLevel;
                waternetOptions.PolderLevelLow = location.PolderLevelLow;
                waternetOptions.PolderLevelLowSpecified = true;
                waternetOptions.DampingFactorPl3 = location.ModelParametersForPlLines.DampingFactorPl4;
                waternetOptions.DampingFactorPl4 = location.ModelParametersForPlLines.DampingFactorPl3;
                waternetOptions.PenetrationLength = location.ModelParametersForPlLines.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;

                // Design options
                var designOptions = new LocationDesignOptions();
                if (designOptions != null)
                {
                    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;
                }

                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.Value;
                    inputDesignScenario.PlLineOffsetBelowDikeCrestMiddle = designScenario.PlLineOffsetBelowDikeCrestMiddle.Value;
                    inputDesignScenario.PlLineOffsetFactorBelowShoulderCrestSpecified = designScenario.UsePlLineOffsetFactorBelowShoulderCrest.Value;
                    inputDesignScenario.PlLineOffsetFactorBelowShoulderCrest = designScenario.PlLineOffsetFactorBelowShoulderCrest.Value;
                    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;
                if (location.StabilityOptions != null)
                {
                    var tmpPath = projectPath ?? Directory.GetCurrentDirectory();
                    var tmpMap = location.StabilityOptions.SoilGeometries2DPath;
                    if (tmpMap.StartsWith(tmpPath))
                    {
                        tmpMap = tmpMap.Remove(0, tmpPath.Length);
                    }
                    if (tmpMap.StartsWith(Path.DirectorySeparatorChar.ToString()))
                    {
                        tmpMap = tmpMap.Remove(0, 1);
                    }

                    inputLocation.StabilityOptions = new LocationStabilityOptions
                    {
                        MapForSoilgeometries2D = tmpMap,
                        SoilDatabaseName = location.StabilityOptions.SoilDatabaseName,
                        ZoneType = ConversionHelper.ConvertToInputZoneType(location.StabilityOptions.StabilityZoneType),
                        ForbiddenZoneFactorSpecified = location.StabilityOptions.ForbiddenZoneFactor.HasValue
                    };
                    if (inputLocation.StabilityOptions.ForbiddenZoneFactorSpecified)
                    {
                        inputLocation.StabilityOptions.ForbiddenZoneFactor = location.StabilityOptions.ForbiddenZoneFactor.Value;
                    }
                    inputLocation.StabilityOptions.ZoneAreaRestSlopeCrestWidthSpecified = location.StabilityOptions.ZoneAreaRestSlopeCrestWidth.HasValue;
                    if (inputLocation.StabilityOptions.ZoneAreaRestSlopeCrestWidthSpecified)
                    {
                        inputLocation.StabilityOptions.ZoneAreaRestSlopeCrestWidth = location.StabilityOptions.ZoneAreaRestSlopeCrestWidth.Value;
                    }
                    inputLocation.StabilityOptions.TrafficLoadSpecified = location.StabilityOptions.TrafficLoad.HasValue;
                    if (inputLocation.StabilityOptions.TrafficLoadSpecified)
                    {
                        inputLocation.StabilityOptions.TrafficLoad = location.StabilityOptions.TrafficLoad.Value;
                    }
                    inputLocation.StabilityOptions.MinimumCircleDepthSpecified = location.StabilityOptions.MinimalCircleDepth.HasValue;
                    if (inputLocation.StabilityOptions.MinimumCircleDepthSpecified)
                    {
                        inputLocation.StabilityOptions.MinimumCircleDepth = location.StabilityOptions.MinimalCircleDepth.Value;
                    }
                }
                // 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<SoilProfile1D> dikeSoilProfiles, Io.XmlInput.SoilProfile1D[] inputSoilProfiles1D)
        {
            var profilesCount = dikeSoilProfiles.Count;
            for (int i = 0; i < profilesCount; i++)
            {
                var soilProfile1D = dikeSoilProfiles[i];
                var inputSoilProfile1D = new Io.XmlInput.SoilProfile1D
                {
                    Name = soilProfile1D.Name,
                    BottomLevel = soilProfile1D.BottomLevel,
                    Layers1D = new SoilProfile1DLayer1D[soilProfile1D.LayerCount]
                };
                AddLayers1D(soilProfile1D, inputSoilProfile1D);
                inputSoilProfiles1D[i] = inputSoilProfile1D;
            }
        }

        private static void AddLayers1D(SoilProfile1D soilProfile1D, Io.XmlInput.SoilProfile1D inputSoilProfile1D)
        {
            for (int i = 0; i < soilProfile1D.LayerCount; i++)
            {
                var layer = soilProfile1D.Layers[i];
                var inputLayer = new SoilProfile1DLayer1D
                {
                    Name = layer.Name,
                    SoilName = layer.Soil.Name,
                    TopLevel = layer.TopLevel,
                    IsAquifer = layer.IsAquifer,
                    WaterpressureInterpolationModel = ConversionHelper.ConvertToInputWaterpressureInterpolationModel(
                        layer.WaterpressureInterpolationModel)
                };
                inputSoilProfile1D.Layers1D[i] = inputLayer;
            }
        }

        private static void TransferSoilProfiles2D(IList<SoilProfile2D> dikeSoilProfiles2D,
            Io.XmlInput.SoilProfile2D[] inputSoilProfiles2D)
        {
            var profilesCount = dikeSoilProfiles2D.Count;
            for (int i = 0; i < profilesCount; i++)
            {
                var soilProfile2D = dikeSoilProfiles2D[i];
                var inputSoilProfile2D = new Io.XmlInput.SoilProfile2D
                {
                    Name = soilProfile2D.Name,
                    Layers2D = new SoilProfile2DLayer2D[soilProfile2D.Surfaces.Count]
                };
                AddPreconsolidationStresses(soilProfile2D, inputSoilProfile2D);
                AddLayers2D(soilProfile2D, inputSoilProfile2D);
                inputSoilProfiles2D[i] = inputSoilProfile2D;
            }
        }

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

        private static void AddLayers2D(SoilProfile2D soilProfile2D, Io.XmlInput.SoilProfile2D inputSoilProfile2D)
        {
            if (soilProfile2D != null)
            {
                for (int i = 0; i < soilProfile2D.Surfaces.Count; i++)
                {
                    var layer = soilProfile2D.Surfaces[i];
                    var inputLayer = new SoilProfile2DLayer2D
                    {
                        SoilName = layer.Soil.Name,
                        IsAquifer = layer.IsAquifer,
                        WaterpressureInterpolationModel = ConversionHelper.ConvertToInputWaterpressureInterpolationModel(
                            layer.WaterpressureInterpolationModel),
                        Surface = new SoilProfile2DLayer2DSurface()
                    };

                    var loop = layer.GeometrySurface.OuterLoop;
                    inputLayer.Surface.OuterLoop = new SoilProfile2DLayer2DSurfaceOuterPoint[loop.Points.Count];
                    for (int j = 0; j < loop.Points.Count; j++)
                    {
                        var point = new SoilProfile2DLayer2DSurfaceOuterPoint
                        {
                            X = loop.Points[j].X,
                            Z = loop.Points[j].Z
                        };
                        inputLayer.Surface.OuterLoop[j] = point;
                    }
                    var innerloop = layer.GeometrySurface.InnerLoops.FirstOrDefault();
                    if (innerloop != null)
                    {
                        inputLayer.Surface.Innerloop = new SoilProfile2DLayer2DSurfaceInnerPoint[innerloop.Points.Count];
                        for (int j = 0; j < innerloop.Points.Count; j++)
                        {
                            var point = new SoilProfile2DLayer2DSurfaceInnerPoint
                            {
                                X = innerloop.Points[j].X,
                                Z = innerloop.Points[j].Z
                            };
                            inputLayer.Surface.Innerloop[j] = point;
                        }
                    }
                    inputSoilProfile2D.Layers2D[i] = inputLayer;
                }
            }
        }

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

        private static void AddSoilProfileProbabilities(Segment segment, 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;
                    }
                    inputSoilGeometryProbability.SoilProfileType = ConversionHelper.ConvertToInputSoilGeometryType(soilGeometryProbability.SoilProfileType);
                    switch (soilGeometryProbability.SoilProfileType)
                    {
                        case SoilProfileType.ProfileType1D:
                            {
                                inputSoilGeometryProbability.SoilProfileName = soilGeometryProbability.SoilProfile1DName;
                                break;
                            }
                        case SoilProfileType.ProfileType2D:
                            {
                                inputSoilGeometryProbability.SoilProfileName = soilGeometryProbability.SoilProfile2DName;
                                break;
                            }
                        case SoilProfileType.ProfileTypeStiFile:
                            {
                                inputSoilGeometryProbability.SoilProfileName = soilGeometryProbability.StiFileName;
                                break;
                            }
                    }

                    inputSegment.SoilGeometryProbability[i] = inputSoilGeometryProbability;
                }
            }
        }
    }
}