// 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.Linq;
using Deltares.DamEngine.Data.Design;
using Deltares.DamEngine.Data.General.Gauges;
using Deltares.DamEngine.Data.General.PlLines;
using Deltares.DamEngine.Data.General.Sensors;
using Deltares.DamEngine.Data.Geometry;
using Deltares.DamEngine.Data.Geotechnics;
using Deltares.DamEngine.Data.Standard.Validation;

namespace Deltares.DamEngine.Data.General
{

    public class Location
    {
        // Added initial value as these properties must be tested for real values on import
        private static DamProjectType damProjectType = DamProjectType.Operational;
        private readonly List<DesignScenario> scenarios = new List<DesignScenario>();
        
        private ModelParametersForPlLines modelParametersForPlLines = new ModelParametersForPlLines();
        private string dikeEmbankmentMaterial = "";
        private double dikeTableHeight;
        
        private IList<GaugePlLine> gaugePlLines = new List<GaugePlLine>();
        private IList<Gauge> gauges = new List<Gauge>();
        private double? headPl2;
        private double? headPl3;
        private double? headPl4;
        
        // Start of parameters that are also defined in modelparameters
        private Pl1Line localXzpl1Line;
        
        private StabilityOptions stabilityOptions;
        private ModelFactors modelFactors = new ModelFactors();
        private string name = "";
        private double newDepthDitch = 1.0;
        private double newDikeSlopeInside = 1.0/3.0; // as tangent
        private double newDikeSlopeOutside = 1.0/3.0; // as tangent
        private double newDikeTopWidth = 5.0;
        private double newMaxHeightShoulderAsFraction = 2.0/3.0; // as tangent
        private double newMinDistanceDikeToeStartDitch = 5.0;
        private double newShoulderBaseSlope = 1.0/3.0; // as tangent
        private double newShoulderTopSlope = 1.0/20.0; // as tangent
        private double newSlopeAngleDitch = 1.0/0.5; // as tangent
        private double newWidthDitchBottom = 1.0;
        private double pLLineOffsetBelowDikeToeAtPolder = 0.1;
        private double pLLineOffsetBelowDikeTopAtPolder = 1.5;
        private double pLLineOffsetBelowDikeTopAtRiver = 0.5;
        private double pLLineOffsetBelowShoulderBaseInside = 0.1;
        private double polderLevel;
        private bool redesignDikeHeight = true;
        private bool redesignDikeShoulder = true;
        private double scenarioRiverLevel;
        private Segment segment;
        private SensorLocation sensorLocation;
        private string shoulderEmbankmentMaterial = "";
        private double slopeAdaptionEndCotangent = 6.0;
        private double slopeAdaptionStartCotangent = 3.0;
        private double slopeAdaptionStepCotangent = 0.5;
        private double slopeDampingPiezometricHeightPolderSide;
        private StabilityDesignMethod stabilityDesignMethod = StabilityDesignMethod.OptimizedSlopeAndShoulderAdaption;
        private double stabilityShoulderGrowDeltaX = 2.0;
        private double stabilityShoulderGrowSlope = 1.0/3;
        private double stabilitySlopeAdaptionDeltaX = 2.0;
        
        private bool useNewDikeSlopeInside;
        private bool useNewDikeSlopeOutside;
        private bool useNewDikeTopWidth;
        private bool useNewDitchDefinition;
        private bool useNewMaxHeightShoulderAsFraction;
        private bool useNewMinDistanceDikeToeStartDitch;
        private bool useNewShoulderBaseSlope;
        private bool useNewShoulderTopSlope;
        private double xRdDikeLine;
        private double xSoilGeometry2DOrigin;
        
        private double? plLineOffsetFactorBelowShoulderCrest;
        private double? plLineOffsetBelowDikeCrestMiddle;
        
        private IntrusionVerticalWaterPressureType? intrusionVerticalWaterPressure = IntrusionVerticalWaterPressureType.Standard;


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

        /// <summary>
        /// Initializes a new instance of the <see cref="Location"/> class.
        /// </summary>
        /// <param name="name">The name.</param>
        public Location(string name) : this()
        {
            this.name = name;
        }

        /// <summary>
        /// Gets a value indicating whether this instance has a sensor location.
        /// </summary>
        /// <value>
        ///   <c>true</c> if this instance has a sensor location; otherwise, <c>false</c>.
        /// </value>
        public bool HasSensorLocation
        {
            get
            {
                return sensorLocation != null;
            }
        }

        /// <summary>
        /// Gets or sets the sensor location.
        /// </summary>
        /// <value>
        /// The sensor location.
        /// </value>
        public virtual SensorLocation SensorLocation
        {
            get
            {
                return sensorLocation;
            }
            set
            {
                sensorLocation = value;
                sensorLocation.Location = this;
            }
        }

        /// <summary>
        /// Gets or sets the name.
        /// </summary>
        /// <value>
        /// The name.
        /// </value>
        public virtual string Name
        {
            get
            {
                return name;
            }
            set
            {
                name = value;                
            }
        }

        /// <summary>
        /// Gets or sets the x rd dike line (for senesors).
        /// </summary>
        /// <value>
        /// The x rd dike line.
        /// </value>
        public virtual double XRdDikeLine
        {
            get
            {
                return xRdDikeLine;
            }
            set
            {
                xRdDikeLine = value;
            }
        }

        /// <summary>
        /// Gets or sets the x soil geometry2 d origin.
        /// </summary>
        /// <value>
        /// The x soil geometry2 d origin.
        /// </value>
        public virtual double XSoilGeometry2DOrigin
        {
            get
            {
                return xSoilGeometry2DOrigin;
            }
            set
            {
                xSoilGeometry2DOrigin = value;                
            }
        }

        /// <summary>
        /// Gets or sets the local XZPL1 line.
        /// </summary>
        /// <value>
        /// The local XZPL1 line.
        /// </value>
        public virtual Pl1Line LocalXzpl1Line
        {
            get
            {
                return localXzpl1Line;
            }
            set
            {
                localXzpl1Line = value;                
            }
        }

        /// <summary>
        /// The surfaceline in local coordinates 
        /// </summary>
        /// <remarks>Composite relationship.</remarks>
        [Validate]
        public virtual SurfaceLine2 SurfaceLine { get; set; }

        /// <summary>
        /// Gets or sets the Segment
        /// </summary>
        public virtual Segment Segment
        {
            get
            {
                return segment;
            }
            set
            {
                segment = value;
            }
        }

        /// <summary>
        /// Gets or sets the model factors.
        /// </summary>
        /// <value>
        /// The model factors.
        /// </value>
        public virtual ModelFactors ModelFactors
        {
            get
            {
                return modelFactors;
            }
            set
            {
                modelFactors = value;                
            }
        }

        /// <summary>
        /// Gets or sets the uplift criterion stability.
        /// </summary>
        /// <value>
        /// The uplift criterion stability.
        /// </value>
        public virtual double? UpliftCriterionStability
        {
            get
            {
                return ModelFactors.UpliftCriterionStability;
            }
            set
            {
                ModelFactors.UpliftCriterionStability = value;
            }
        }

        /// <summary>
        /// Gets or sets the uplift criterion piping.
        /// </summary>
        /// <value>
        /// The uplift criterion piping.
        /// </value>
        public virtual double? UpliftCriterionPiping
        {
            get
            {
                return ModelFactors.UpliftCriterionPiping;
            }
            set
            {
                ModelFactors.UpliftCriterionPiping = value;
            }
        }

        /// <summary>
        /// Gets or sets the slope damping piezometric height polder side.
        /// </summary>
        /// <value>
        /// The slope damping piezometric height polder side.
        /// </value>
        public virtual double SlopeDampingPiezometricHeightPolderSide
        {
            get
            {
                return slopeDampingPiezometricHeightPolderSide;
            }
            set
            {
                slopeDampingPiezometricHeightPolderSide = value;                
            }
        }

        /// <summary>
        /// Gets or sets the height of the dike table.
        /// </summary>
        /// <value>
        /// The height of the dike table.
        /// </value>
        public virtual double DikeTableHeight
        {
            get
            {
                return dikeTableHeight;
            }
            set
            {
                dikeTableHeight = value;                
            }
        }

        /// <summary>
        /// Gets or sets the soil list.
        /// </summary>
        /// <value>
        /// The soil list.
        /// </value>
        public SoilList SoilList { get; set; }

        /// <summary>
        /// Gets or sets the gauges.
        /// </summary>
        /// <value>
        /// The gauges.
        /// </value>
        public virtual IList<Gauge> Gauges
        {
            get
            {
                return gauges;
            }
            set
            {
                gauges = value;
            }
        }

        /// <summary>
        /// Gets or sets the gauge pl lines.
        /// </summary>
        /// <value>
        /// The gauge pl lines.
        /// </value>
        public virtual IList<GaugePlLine> GaugePlLines
        {
            get
            {
                return gaugePlLines;
            }
            set
            {
                gaugePlLines = value;
            }
        }

        /// <summary>
        /// Gets or sets a value indicating whether [redesign dike height].
        /// </summary>
        /// <value>
        ///   <c>true</c> if [redesign dike height]; otherwise, <c>false</c>.
        /// </value>
        public bool RedesignDikeHeight
        {
            get
            {
                return redesignDikeHeight;
            }
            set
            {
                redesignDikeHeight = value;                
            }
        }

        /// <summary>
        /// Gets or sets a value indicating whether [redesign dike shoulder].
        /// </summary>
        /// <value>
        ///   <c>true</c> if [redesign dike shoulder]; otherwise, <c>false</c>.
        /// </value>
        public bool RedesignDikeShoulder
        {
            get
            {
                return redesignDikeShoulder;
            }
            set
            {
                redesignDikeShoulder = value;                
            }
        }

        /// <summary>
        /// Gets or sets the stability design method.
        /// </summary>
        /// <value>
        /// The stability design method.
        /// </value>
        public StabilityDesignMethod StabilityDesignMethod
        {
            get
            {
                return stabilityDesignMethod;
            }
            set
            {
                stabilityDesignMethod = value;                
            }
        }

        /// <summary>
        /// Gets or sets the slope adaption start cotangent.
        /// </summary>
        /// <value>
        /// The slope adaption start cotangent.
        /// </value>
        public double SlopeAdaptionStartCotangent
        {
            get
            {
                return slopeAdaptionStartCotangent;
            }
            set
            {
                slopeAdaptionStartCotangent = value;                
            }
        }

        /// <summary>
        /// Gets or sets the slope adaption end cotangent.
        /// </summary>
        /// <value>
        /// The slope adaption end cotangent.
        /// </value>
        public double SlopeAdaptionEndCotangent
        {
            get
            {
                return slopeAdaptionEndCotangent;
            }
            set
            {
                slopeAdaptionEndCotangent = value;                
            }
        }

        /// <summary>
        /// Gets or sets the slope adaption step cotangent.
        /// </summary>
        /// <value>
        /// The slope adaption step cotangent.
        /// </value>
        public double SlopeAdaptionStepCotangent
        {
            get
            {
                return slopeAdaptionStepCotangent;
            }
            set
            {
                slopeAdaptionStepCotangent = value;                
            }
        }

        /// <summary>
        /// Gets or sets a value indicating whether [use new dike top width].
        /// </summary>
        /// <value>
        ///   <c>true</c> if [use new dike top width]; otherwise, <c>false</c>.
        /// </value>
        public bool UseNewDikeTopWidth
        {
            get
            {
                return useNewDikeTopWidth;
            }
            set
            {
                useNewDikeTopWidth = value;                
            }
        }

        /// <summary>
        /// Gets or sets the new width of the dike top.
        /// </summary>
        /// <value>
        /// The new width of the dike top.
        /// </value>
        public double NewDikeTopWidth
        {
            get
            {
                return newDikeTopWidth;
            }
            set
            {
                newDikeTopWidth = value;                
            }
        }

        /// <summary>
        /// Gets or sets a value indicating whether [use new dike slope inside].
        /// </summary>
        /// <value>
        ///   <c>true</c> if [use new dike slope inside]; otherwise, <c>false</c>.
        /// </value>
        public bool UseNewDikeSlopeInside
        {
            get
            {
                return useNewDikeSlopeInside;
            }
            set
            {
                useNewDikeSlopeInside = value;                
            }
        }

        /// <summary>
        /// Gets or sets the new dike slope inside.
        /// </summary>
        /// <value>
        /// The new dike slope inside.
        /// </value>
        public double NewDikeSlopeInside
        {
            get
            {
                return newDikeSlopeInside;
            }
            set
            {
                newDikeSlopeInside = value;                
            }
        }

        /// <summary>
        /// Gets or sets a value indicating whether [use new dike slope outside].
        /// </summary>
        /// <value>
        ///   <c>true</c> if [use new dike slope outside]; otherwise, <c>false</c>.
        /// </value>
        public bool UseNewDikeSlopeOutside
        {
            get
            {
                return useNewDikeSlopeOutside;
            }
            set
            {
                useNewDikeSlopeOutside = value;                
            }
        }

        /// <summary>
        /// Gets or sets the new dike slope outside.
        /// </summary>
        /// <value>
        /// The new dike slope outside.
        /// </value>
        public double NewDikeSlopeOutside
        {
            get
            {
                return newDikeSlopeOutside;
            }
            set
            {
                newDikeSlopeOutside = value;                
            }
        }

        /// <summary>
        /// Gets or sets a value indicating whether [use new shoulder top slope].
        /// </summary>
        /// <value>
        ///   <c>true</c> if [use new shoulder top slope]; otherwise, <c>false</c>.
        /// </value>
        public bool UseNewShoulderTopSlope
        {
            get
            {
                return useNewShoulderTopSlope;
            }
            set
            {
                useNewShoulderTopSlope = value;                
            }
        }

        /// <summary>
        /// Gets or sets the new shoulder top slope.
        /// </summary>
        /// <value>
        /// The new shoulder top slope.
        /// </value>
        public double NewShoulderTopSlope
        {
            get
            {
                return newShoulderTopSlope;
            }
            set
            {
                newShoulderTopSlope = value;                
            }
        }

        /// <summary>
        /// Gets or sets a value indicating whether [use new shoulder base slope].
        /// </summary>
        /// <value>
        ///   <c>true</c> if [use new shoulder base slope]; otherwise, <c>false</c>.
        /// </value>
        public bool UseNewShoulderBaseSlope
        {
            get
            {
                return useNewShoulderBaseSlope;
            }
            set
            {
                useNewShoulderBaseSlope = value;                
            }
        }

        /// <summary>
        /// Gets or sets the new shoulder base slope.
        /// </summary>
        /// <value>
        /// The new shoulder base slope.
        /// </value>
        public double NewShoulderBaseSlope
        {
            get
            {
                return newShoulderBaseSlope;
            }
            set
            {
                newShoulderBaseSlope = value;                
            }
        }

        /// <summary>
        /// Gets or sets a value indicating whether [use new maximum height shoulder as fraction].
        /// </summary>
        /// <value>
        ///   <c>true</c> if [use new maximum height shoulder as fraction]; otherwise, <c>false</c>.
        /// </value>
        public bool UseNewMaxHeightShoulderAsFraction
        {
            get
            {
                return useNewMaxHeightShoulderAsFraction;
            }
            set
            {
                useNewMaxHeightShoulderAsFraction = value;                
            }
        }

        /// <summary>
        /// Gets or sets the new maximum height shoulder as fraction.
        /// </summary>
        /// <value>
        /// The new maximum height shoulder as fraction.
        /// </value>
        public double NewMaxHeightShoulderAsFraction
        {
            get
            {
                return newMaxHeightShoulderAsFraction;
            }
            set
            {
                newMaxHeightShoulderAsFraction = value;                
            }
        }

        /// <summary>
        /// Gets or sets a value indicating whether [use new minimum distance dike toe start ditch].
        /// </summary>
        /// <value>
        ///   <c>true</c> if [use new minimum distance dike toe start ditch]; otherwise, <c>false</c>.
        /// </value>
        public bool UseNewMinDistanceDikeToeStartDitch
        {
            get
            {
                return useNewMinDistanceDikeToeStartDitch;
            }
            set
            {
                useNewMinDistanceDikeToeStartDitch = value;
            }
        }

        /// <summary>
        /// Gets or sets the new minimum distance dike toe start ditch.
        /// </summary>
        /// <value>
        /// The new minimum distance dike toe start ditch.
        /// </value>
        public double NewMinDistanceDikeToeStartDitch
        {
            get
            {
                return newMinDistanceDikeToeStartDitch;
            }
            set
            {
                newMinDistanceDikeToeStartDitch = value;                
            }
        }

        /// <summary>
        /// Gets or sets a value indicating whether [use new ditch definition].
        /// </summary>
        /// <value>
        ///   <c>true</c> if [use new ditch definition]; otherwise, <c>false</c>.
        /// </value>
        public bool UseNewDitchDefinition
        {
            get
            {
                return useNewDitchDefinition;
            }
            set
            {
                useNewDitchDefinition = value;                
            }
        }

        /// <summary>
        /// Gets or sets the new width ditch bottom.
        /// </summary>
        /// <value>
        /// The new width ditch bottom.
        /// </value>
        public double NewWidthDitchBottom
        {
            get
            {
                return newWidthDitchBottom;
            }
            set
            {
                newWidthDitchBottom = value;                
            }
        }

        /// <summary>
        /// Gets or sets the new slope angle ditch.
        /// </summary>
        /// <value>
        /// The new slope angle ditch.
        /// </value>
        public double NewSlopeAngleDitch
        {
            get
            {
                return newSlopeAngleDitch;
            }
            set
            {
                newSlopeAngleDitch = value;
                
            }
        }

        /// <summary>
        /// Gets or sets the new depth ditch.
        /// </summary>
        /// <value>
        /// The new depth ditch.
        /// </value>
        public double NewDepthDitch
        {
            get
            {
                return newDepthDitch;
            }
            set
            {
                newDepthDitch = value;                
            }
        }

        /// <summary>
        /// Gets the scenarios.
        /// </summary>
        /// <value>
        /// The scenarios.
        /// </value>
        [Validate]
        public List<DesignScenario> Scenarios
        {
            get
            {
                return scenarios;
            }
        }

        /// <summary>
        /// Gets or sets the type of the dam project.
        /// </summary>
        /// <value>
        /// The type of the dam project.
        /// </value>
        public static DamProjectType DamProjectType
        {
            get
            {
                return damProjectType;
            }
            set
            {
                damProjectType = value;
            }
        }

        /// <summary>
        /// Gets or sets the stability options.
        /// </summary>
        /// <value>
        /// The stability options.
        /// </value>
        public StabilityOptions StabilityOptions
        {
            get
            {
                return stabilityOptions;
            }
            set
            {
                stabilityOptions = value;
            }
        }

        #region Design parameters

        /// <summary>
        /// Gets or sets the dike embankment material.
        /// </summary>
        /// <value>
        /// The dike embankment material.
        /// </value>
        public virtual string DikeEmbankmentMaterial
        {
            get
            {
                return dikeEmbankmentMaterial;
            }
            set
            {
                dikeEmbankmentMaterial = value;                
            }
        }

        /// <summary>
        /// Gets or sets the shoulder embankment material.
        /// </summary>
        /// <value>
        /// The shoulder embankment material.
        /// </value>
        public virtual string ShoulderEmbankmentMaterial
        {
            get
            {
                return shoulderEmbankmentMaterial;
            }
            set
            {
                shoulderEmbankmentMaterial = value;                
            }
        }

        /// <summary>
        /// Gets or sets the stability shoulder grow slope.
        /// </summary>
        /// <value>
        /// The stability shoulder grow slope.
        /// </value>
        public virtual double StabilityShoulderGrowSlope
        {
            get
            {
                return stabilityShoulderGrowSlope;
            }
            set
            {
                stabilityShoulderGrowSlope = value;                
            }
        }

        /// <summary>
        /// Gets or sets the stability shoulder grow delta x.
        /// </summary>
        /// <value>
        /// The stability shoulder grow delta x.
        /// </value>
        public virtual double StabilityShoulderGrowDeltaX
        {
            get
            {
                return stabilityShoulderGrowDeltaX;
            }
            set
            {
                stabilityShoulderGrowDeltaX = value;                
            }
        }

        /// <summary>
        /// Gets or sets the stability slope adaption delta x.
        /// </summary>
        /// <value>
        /// The stability slope adaption delta x.
        /// </value>
        public virtual double StabilitySlopeAdaptionDeltaX
        {
            get
            {
                return stabilitySlopeAdaptionDeltaX;
            }
            set
            {
                stabilitySlopeAdaptionDeltaX = value;                
            }
        }

        #endregion

        #region PlLine creation parameters

        /// <summary>
        /// Gets or sets the dike soil scenario.
        /// </summary>
        /// <value>
        /// The dike soil scenario.
        /// </value>
        public DikeSoilScenario DikeSoilScenario { get; set; }

        /// <summary>
        /// Gets or sets the head pl 2.
        /// </summary>
        /// <value>
        /// The head pl 2.
        /// </value>
        public virtual double? HeadPl2
        {
            get
            {
                return headPl2;
            }
            set
            {
                headPl2 = value;                
            }
        }

        /// <summary>
        /// Gets or sets the head PL3.
        /// </summary>
        /// <value>
        /// The head PL3.
        /// </value>
        public virtual double? HeadPl3
        {
            get
            {
                return headPl3;
            }
            set
            {
                headPl3 = value;                
            }
        }

        /// <summary>
        /// Gets or sets the head PL4.
        /// </summary>
        /// <value>
        /// The head PL4.
        /// </value>
        public virtual double? HeadPl4
        {
            get
            {
                return headPl4;
            }
            set
            {
                headPl4 = value;                
            }
        }

        /// <summary>
        /// Gets or sets the pl line offset below dike top at river.
        /// </summary>
        /// <value>
        /// The pl line offset below dike top at river.
        /// </value>
        public virtual double PlLineOffsetBelowDikeTopAtRiver
        {
            get
            {
                return pLLineOffsetBelowDikeTopAtRiver;
            }
            set
            {
                pLLineOffsetBelowDikeTopAtRiver = value;                
            }
        }

        /// <summary>
        /// Gets or sets the pl line offset below dike top at polder.
        /// </summary>
        /// <value>
        /// The pl line offset below dike top at polder.
        /// </value>
        public virtual double PlLineOffsetBelowDikeTopAtPolder
        {
            get
            {
                return pLLineOffsetBelowDikeTopAtPolder;
            }
            set
            {
                pLLineOffsetBelowDikeTopAtPolder = value;                
            }
        }

        /// <summary>
        /// Gets or sets the pl line offset below shoulder base inside.
        /// </summary>
        /// <value>
        /// The pl line offset below shoulder base inside.
        /// </value>
        public virtual double PlLineOffsetBelowShoulderBaseInside
        {
            get
            {
                return pLLineOffsetBelowShoulderBaseInside;
            }
            set
            {
                pLLineOffsetBelowShoulderBaseInside = value;                
            }
        }

        /// <summary>
        /// Gets or sets the pl line offset below dike toe at polder.
        /// </summary>
        /// <value>
        /// The pl line offset below dike toe at polder.
        /// </value>
        public virtual double PlLineOffsetBelowDikeToeAtPolder
        {
            get
            {
                return pLLineOffsetBelowDikeToeAtPolder;
            }
            set
            {
                pLLineOffsetBelowDikeToeAtPolder = value;                
            }
        }

        /// <summary>
        /// Gets or sets the use pl line offset below dike crest middle.
        /// </summary>
        /// <value>
        /// The use pl line offset below dike crest middle.
        /// </value>
        public bool? UsePlLineOffsetBelowDikeCrestMiddle { get; set; }

        /// <summary>
        /// Gets or sets the pl line offset below dike crest middle.
        /// </summary>
        /// <value>
        /// The pl line offset below dike crest middle.
        /// </value>
        public double? PlLineOffsetBelowDikeCrestMiddle
        {
            get { return plLineOffsetBelowDikeCrestMiddle; }
            set
            {
                plLineOffsetBelowDikeCrestMiddle = value;                
            }
        }

        /// <summary>
        /// Gets or sets the use pl line offset factor below shoulder crest.
        /// </summary>
        /// <value>
        /// The use pl line offset factor below shoulder crest.
        /// </value>
        public bool? UsePlLineOffsetFactorBelowShoulderCrest { get; set; }

        /// <summary>
        /// Gets or sets the pl line offset factor below shoulder crest.
        /// </summary>
        /// <value>
        /// The pl line offset factor below shoulder crest.
        /// </value>
        public double? PlLineOffsetFactorBelowShoulderCrest 
        {
            get { return plLineOffsetFactorBelowShoulderCrest; }
            set
            {
                plLineOffsetFactorBelowShoulderCrest = value;                
            } 
        }

        /// <summary>
        /// Gets or sets the intrusion vertical water pressure.
        /// </summary>
        /// <value>
        /// The intrusion vertical water pressure.
        /// </value>
        public IntrusionVerticalWaterPressureType? IntrusionVerticalWaterPressure
        {
            get { return intrusionVerticalWaterPressure; }
            set
            {
                intrusionVerticalWaterPressure = value;                
            }
        }
        #endregion

        #region Waterlevels

        /// <summary>
        /// Gets or sets the polder level.
        /// </summary>
        /// <value>
        /// The polder level.
        /// </value>
        public virtual double PolderLevel
        {
            get
            {
                return polderLevel;
            }
            set
            {
                polderLevel = value;                
            }
        }

        /// <summary>
        /// Gets or sets the river level.
        /// </summary>
        /// <value>
        /// The river level.
        /// </value>
        public virtual double RiverLevel
        {
            get
            {
                return scenarioRiverLevel;
            }
            set
            {
                scenarioRiverLevel = value;                
            }
        }

        #endregion

        /// <summary>
        /// Gets the dike embankment soil.
        /// </summary>
        /// <returns></returns>
        public Soil GetDikeEmbankmentSoil()
        {
            if ((stabilityOptions != null && String.IsNullOrEmpty(stabilityOptions.SoilDatabaseName)) || String.IsNullOrEmpty(DikeEmbankmentMaterial))
            {
                return null;
            }
            return SoilList.GetSoilByName(DikeEmbankmentMaterial);            
        }

        /// <summary>
        /// Aligns the boundary points of PL1 line with adapted surface line.
        /// </summary>
        /// <param name="adaptedSurfaceLine">The adapted surface line.</param>
        public void AlignBoundaryPointsOfPl1LineWithAdaptedSurfaceLine(SurfaceLine2 adaptedSurfaceLine)
        {
            if ((LocalXzpl1Line != null) && (LocalXzpl1Line.Points.Count > 1))
            {
                GeometryPoint lastPointPl1Line = LocalXzpl1Line.Points.Last();
                GeometryPoint lastPointSurfaceLine = adaptedSurfaceLine.Geometry.Points.Last();
                lastPointPl1Line.X = lastPointSurfaceLine.X;
                GeometryPoint firstPointPl1Line = LocalXzpl1Line.Points.First();
                GeometryPoint firstPointSurfaceLine = adaptedSurfaceLine.Geometry.Points.First();
                firstPointPl1Line.X = firstPointSurfaceLine.X;
            }
        }

        /// <summary>
        /// Gets or sets the model parameters for pl lines.
        /// </summary>
        /// <value>
        /// The model parameters for pl lines.
        /// </value>
        public ModelParametersForPlLines ModelParametersForPlLines
        {
            get
            {
                return modelParametersForPlLines;
            }
            set
            {
                modelParametersForPlLines = value;
            }
        }

        /// <summary>
        /// Returns a <see cref="System.String" /> that represents this instance.
        /// </summary>
        /// <returns>
        /// A <see cref="System.String" /> that represents this instance.
        /// </returns>
        public override string ToString()
        {
            return Name;            
        }

        /// <summary>
        /// Adds a new sensor location.
        /// </summary>
        public void AddSensorLocation()
        {
            var factory = new SensorFactory();
            SensorLocation = factory.CreateSensorLocation(this);
        }        
    }
}