// 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.ComponentModel;
using System.Xml.Serialization;
using Deltares.Standard.Attributes;
using Deltares.Standard.EventPublisher;
using Deltares.Standard.Validation;

namespace Deltares.Dam.Data
{
    using Deltares.Standard;

    public enum TangentLinesDefinition
    {
        OnBoundaryLines = 0,
        Specified = 1
    }

    public enum GridSizeDetermination
    {
        Automatic = 0,
        Specified = 1
    }

    public class SheetPiling : IAssignable<SheetPiling>, ICloneable<SheetPiling>
    {
        public double XCoordinate { get; set; }
        public double YCoordinate { get; set; }
        public double ZCoordinate { get; set; }
        public double Length { get; set; }

        public void Assign(SheetPiling sheetPiling)
        {
            this.XCoordinate = sheetPiling.XCoordinate;
            this.YCoordinate = sheetPiling.YCoordinate;
            this.ZCoordinate = sheetPiling.ZCoordinate;
            this.Length = sheetPiling.Length;
        }

        public SheetPiling Clone()
        {
            var sheetPiling = new SheetPiling();
            sheetPiling.Assign(this);
            return sheetPiling;
        }
    }

    public class HorizontalBalanceArea : IAssignable<HorizontalBalanceArea>, ICloneable<HorizontalBalanceArea>
    {
        public double XLeft { get; set; }
        public double XRight { get; set; }
        public double YTop { get; set; }
        public double YBottom { get; set; }
        public int PlaneCount { get; set; }
        public void Assign(HorizontalBalanceArea horizontalBalanceArea)
        {
            this.XLeft = horizontalBalanceArea.XLeft;
            this.XRight = horizontalBalanceArea.XRight;
            this.YTop = horizontalBalanceArea.YTop;
            this.YBottom = horizontalBalanceArea.YBottom;
            this.PlaneCount = horizontalBalanceArea.PlaneCount;
        }

        public HorizontalBalanceArea Clone()
        {
            var horizontalBalanceArea = new HorizontalBalanceArea();
            horizontalBalanceArea.Assign(this);
            return horizontalBalanceArea;
        }
    }

    public class SlipCircleDefinition : IVisibleEnabled, IAssignable<SlipCircleDefinition>, ICloneable<SlipCircleDefinition>
    {
        private double xCoordinateLastUpliftPoint;
        private int upliftVanLeftGridVerticalPointCount;
        private double upliftVanTangentLinesDistance;
        private double bishopTangentLinesDistance;
        private double upliftVanLeftGridVerticalPointDistance;
        private int upliftVanLeftGridHorizontalPointCount;
        private double upliftVanLeftGridHorizontalPointDistance;
        private int upliftVanRightGridVerticalPointCount;
        private double upliftVanRightGridVerticalPointDistance;
        private int upliftVanRightGridHorizontalPointCount;
        private double upliftVanRightGridHorizontalPointDistance;
        private int bishopGridHorizontalPointCount;
        private double bishopGridHorizontalPointDistance;
        private int bishopGridVerticalPointCount;
        private double bishopGridVerticalPointDistance;

        [Format("F2")]
        public double XCoordinateLastUpliftPoint
        {
            get
            {
                return xCoordinateLastUpliftPoint;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, "XCoordinateLastUpliftPoint");
                xCoordinateLastUpliftPoint = value;
                DataEventPublisher.AfterChange(this, "XCoordinateLastUpliftPoint");
            }
        }
        public TangentLinesDefinition UpliftVanTangentLinesDefinition { get; set; }
        [Format("F2")]
        [Minimum(0.01)]
        [Maximum(1000.0)]
        public double UpliftVanTangentLinesDistance
        {
            get
            {
                return upliftVanTangentLinesDistance;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, "UpliftVanTangentLinesDistance");
                upliftVanTangentLinesDistance = value;
                DataEventPublisher.AfterChange(this, "UpliftVanTangentLinesDistance");
            }
        }
        public TangentLinesDefinition BishopTangentLinesDefinition { get; set; }
        [Format("F2")]
        [Minimum(0.01)]
        [Maximum(1000.0)]
        public double BishopTangentLinesDistance
        {
            get
            {
                return bishopTangentLinesDistance;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, "BishopTangentLinesDistance");
                bishopTangentLinesDistance = value;
                DataEventPublisher.AfterChange(this, "BishopTangentLinesDistance");
            }
        }
        public GridSizeDetermination GridSizeDetermination { get; set; }
        [Minimum(1)]
        [Maximum(100)]
        public int UpliftVanLeftGridVerticalPointCount
        {
            get
            {
                return upliftVanLeftGridVerticalPointCount;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, "UpliftVanLeftGridVerticalPointCount");
                upliftVanLeftGridVerticalPointCount = value;
                DataEventPublisher.AfterChange(this, "UpliftVanLeftGridVerticalPointCount");
            }
        }
        [Format("F2")]
        [Minimum(0.01)]
        [Maximum(1000.0)]
        public double UpliftVanLeftGridVerticalPointDistance
        {
            get
            {
                return upliftVanLeftGridVerticalPointDistance;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, "UpliftVanLeftGridVerticalPointDistance");
                upliftVanLeftGridVerticalPointDistance = value;
                DataEventPublisher.AfterChange(this, "UpliftVanLeftGridVerticalPointDistance");
            }
        }
        [Minimum(1)]
        [Maximum(100)]
        public int UpliftVanLeftGridHorizontalPointCount
        {
            get
            {
                return upliftVanLeftGridHorizontalPointCount;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, "UpliftVanLeftGridHorizontalPointCount");
                upliftVanLeftGridHorizontalPointCount = value;
                DataEventPublisher.AfterChange(this, "UpliftVanLeftGridHorizontalPointCount");
            }
        }
        [Format("F2")]
        [Minimum(0.01)]
        [Maximum(1000.0)]
        public double UpliftVanLeftGridHorizontalPointDistance
        {
            get
            {
                return upliftVanLeftGridHorizontalPointDistance;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, "UpliftVanLeftGridHorizontalPointDistance");
                upliftVanLeftGridHorizontalPointDistance = value;
                DataEventPublisher.AfterChange(this, "UpliftVanLeftGridHorizontalPointDistance");
            }
        }
        [Minimum(1)]
        [Maximum(100)]
        public int UpliftVanRightGridVerticalPointCount
        {
            get
            {
                return upliftVanRightGridVerticalPointCount;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, "UpliftVanRightGridVerticalPointCount");
                upliftVanRightGridVerticalPointCount = value;
                DataEventPublisher.AfterChange(this, "UpliftVanRightGridVerticalPointCount");
            }
        }
        [Format("F2")]
        [Minimum(0.01)]
        [Maximum(1000.0)]
        public double UpliftVanRightGridVerticalPointDistance
        {
            get
            {
                return upliftVanRightGridVerticalPointDistance;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, "UpliftVanRightGridVerticalPointDistance");
                upliftVanRightGridVerticalPointDistance = value;
                DataEventPublisher.AfterChange(this, "UpliftVanRightGridVerticalPointDistance");
            }
        }
        [Minimum(1)]
        [Maximum(100)]
        public int UpliftVanRightGridHorizontalPointCount
        {
            get
            {
                return upliftVanRightGridHorizontalPointCount;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, "UpliftVanRightGridHorizontalPointCount");
                upliftVanRightGridHorizontalPointCount = value;
                DataEventPublisher.AfterChange(this, "UpliftVanRightGridHorizontalPointCount");
            }
        }
        [Format("F2")]
        [Minimum(0.01)]
        [Maximum(1000.0)]
        public double UpliftVanRightGridHorizontalPointDistance
        {
            get
            {
                return upliftVanRightGridHorizontalPointDistance;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, "UpliftVanRightGridHorizontalPointDistance");
                upliftVanRightGridHorizontalPointDistance = value;
                DataEventPublisher.AfterChange(this, "UpliftVanRightGridHorizontalPointDistance");
            }
        }
        [Minimum(1)]
        [Maximum(100)]
        public int BishopGridVerticalPointCount
        {
            get
            {
                return bishopGridVerticalPointCount;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, "BishopGridVerticalPointCount");
                bishopGridVerticalPointCount = value;
                DataEventPublisher.AfterChange(this, "BishopGridVerticalPointCount");
            }
        }
        [Format("F2")]
        [Minimum(0.01)]
        [Maximum(1000.0)]
        public double BishopGridVerticalPointDistance
        {
            get
            {
                return bishopGridVerticalPointDistance;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, "BishopGridVerticalPointDistance");
                bishopGridVerticalPointDistance = value;
                DataEventPublisher.AfterChange(this, "BishopGridVerticalPointDistance");
            }
        }
        [Minimum(1)]
        [Maximum(100)]
        public int BishopGridHorizontalPointCount
        {
            get
            {
                return bishopGridHorizontalPointCount;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, "BishopGridHorizontalPointCount");
                bishopGridHorizontalPointCount = value;
                DataEventPublisher.AfterChange(this, "BishopGridHorizontalPointCount");
            }
        }
        [Format("F2")]
        [Minimum(0.01)]
        [Maximum(1000.0)]
        public double BishopGridHorizontalPointDistance
        {
            get
            {
                return bishopGridHorizontalPointDistance;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, "BishopGridHorizontalPointDistance");
                bishopGridHorizontalPointDistance = value;
                DataEventPublisher.AfterChange(this, "BishopGridHorizontalPointDistance");
            }
        }

        public DamFailureMechanismeCalculationSpecification Specification { get; set; }

        public bool IsVisible(string property)
        {
            if (Specification == null)
                return true;

            switch (property)
            {
                case "GridSizeDetermination": return IsStabiltyUpliftVan() || IsStabiltyBishopUpliftVan() || IsStabiltyBishop();
                // Uplift Van
                case "UpliftVanTangentLinesDefinition":
                    return IsStabiltyUpliftVan() || IsStabiltyBishopUpliftVan();
                case "UpliftVanTangentLinesDistance":
                    return IsStabiltyUpliftVan() || IsStabiltyBishopUpliftVan();
                case "UpliftVanLeftGridVerticalPointCount":
                    return IsStabiltyUpliftVan() || IsStabiltyBishopUpliftVan();
                case "UpliftVanLeftGridVerticalPointDistance":
                    return IsStabiltyUpliftVan() || IsStabiltyBishopUpliftVan();
                case "UpliftVanLeftGridHorizontalPointCount":
                    return IsStabiltyUpliftVan() || IsStabiltyBishopUpliftVan();
                case "UpliftVanLeftGridHorizontalPointDistance":
                    return IsStabiltyUpliftVan() || IsStabiltyBishopUpliftVan();
                case "UpliftVanRightGridVerticalPointCount":
                    return IsStabiltyUpliftVan() || IsStabiltyBishopUpliftVan();
                case "UpliftVanRightGridVerticalPointDistance":
                    return IsStabiltyUpliftVan() || IsStabiltyBishopUpliftVan();
                case "UpliftVanRightGridHorizontalPointCount":
                    return IsStabiltyUpliftVan() || IsStabiltyBishopUpliftVan();
                case "UpliftVanRightGridHorizontalPointDistance":
                    return IsStabiltyUpliftVan() || IsStabiltyBishopUpliftVan();

                // Bishop
                case "BishopTangentLinesDefinition":
                    return false; //IsStabiltyBishop() || IsStabiltyBishopUpliftVan(); False for now. See MWDAM-640. 
                case "BishopTangentLinesDistance":
                    return false; //IsStabiltyBishop() || IsStabiltyBishopUpliftVan(); False for now. See MWDAM-640. 
                case "BishopGridVerticalPointCount":
                    return IsStabiltyBishop() || IsStabiltyBishopUpliftVan();
                case "BishopGridVerticalPointDistance":
                    return IsStabiltyBishop() || IsStabiltyBishopUpliftVan();
                case "BishopGridHorizontalPointCount":
                    return IsStabiltyBishop() || IsStabiltyBishopUpliftVan();
                case "BishopGridHorizontalPointDistance":
                    return IsStabiltyBishop() || IsStabiltyBishopUpliftVan();
                default: return true;
            }
        }

        private bool IsStabiltyBishop()
        {
            return ((Specification.FailureMechanismSystemType == FailureMechanismSystemType.StabilityInside ||
                     Specification.FailureMechanismSystemType == FailureMechanismSystemType.StabilityOutside) &&
                    (MStabModelType)Specification.CalculationModel == MStabModelType.Bishop);
        }

        private bool IsStabiltyUpliftVan()
        {
            return ((Specification.FailureMechanismSystemType == FailureMechanismSystemType.StabilityInside ||
                     Specification.FailureMechanismSystemType == FailureMechanismSystemType.StabilityOutside) &&
                    (MStabModelType)Specification.CalculationModel == MStabModelType.UpliftVan);
        }

        private bool IsStabiltyBishopUpliftVan()
        {
            return ((Specification.FailureMechanismSystemType == FailureMechanismSystemType.StabilityInside ||
                     Specification.FailureMechanismSystemType == FailureMechanismSystemType.StabilityOutside) &&
                    (MStabModelType)Specification.CalculationModel == MStabModelType.BishopUpliftVan);
        }

        public bool IsEnabled(string property)
        {
            if (Specification == null)
                return true;

            switch (property)
            {
                // Uplift Van
                case "UpliftVanTangentLinesDefinition":
                    return true;
                case "UpliftVanTangentLinesDistance":
                    return UpliftVanTangentLinesDefinition == TangentLinesDefinition.Specified;
                case "UpliftVanLeftGridVerticalPointCount":
                    return GridSizeDetermination == GridSizeDetermination.Specified;
                case "UpliftVanLeftGridVerticalPointDistance":
                    return GridSizeDetermination == GridSizeDetermination.Specified;
                case "UpliftVanLeftGridHorizontalPointCount":
                    return GridSizeDetermination == GridSizeDetermination.Specified;
                case "UpliftVanLeftGridHorizontalPointDistance":
                    return GridSizeDetermination == GridSizeDetermination.Specified;
                case "UpliftVanRightGridVerticalPointCount":
                    return GridSizeDetermination == GridSizeDetermination.Specified;
                case "UpliftVanRightGridVerticalPointDistance":
                    return GridSizeDetermination == GridSizeDetermination.Specified;
                case "UpliftVanRightGridHorizontalPointCount":
                    return GridSizeDetermination == GridSizeDetermination.Specified;
                case "UpliftVanRightGridHorizontalPointDistance":
                    return GridSizeDetermination == GridSizeDetermination.Specified;

                // Bishop
                case "BishopTangentLinesDefinition":
                    return true;
                case "BishopTangentLinesDistance":
                    return BishopTangentLinesDefinition == TangentLinesDefinition.Specified;
                case "BishopGridVerticalPointCount":
                    return GridSizeDetermination == GridSizeDetermination.Specified;
                case "BishopGridVerticalPointDistance":
                    return GridSizeDetermination == GridSizeDetermination.Specified;
                case "BishopGridHorizontalPointCount":
                    return GridSizeDetermination == GridSizeDetermination.Specified;
                case "BishopGridHorizontalPointDistance":
                    return GridSizeDetermination == GridSizeDetermination.Specified;
                default: return true;
            }
        }

        public void Assign(SlipCircleDefinition slipCircleDefinition)
        {
            this.XCoordinateLastUpliftPoint = slipCircleDefinition.XCoordinateLastUpliftPoint;
            this.UpliftVanTangentLinesDefinition = slipCircleDefinition.UpliftVanTangentLinesDefinition;
            this.UpliftVanTangentLinesDistance = slipCircleDefinition.UpliftVanTangentLinesDistance;
            this.BishopTangentLinesDefinition = slipCircleDefinition.BishopTangentLinesDefinition;
            this.BishopTangentLinesDistance = slipCircleDefinition.BishopTangentLinesDistance;
            this.GridSizeDetermination = slipCircleDefinition.GridSizeDetermination;
            this.UpliftVanLeftGridVerticalPointCount = slipCircleDefinition.UpliftVanLeftGridVerticalPointCount;
            this.UpliftVanLeftGridVerticalPointDistance = slipCircleDefinition.UpliftVanLeftGridVerticalPointDistance;
            this.UpliftVanLeftGridHorizontalPointCount = slipCircleDefinition.UpliftVanLeftGridHorizontalPointCount;
            this.UpliftVanLeftGridHorizontalPointDistance = slipCircleDefinition.UpliftVanLeftGridHorizontalPointDistance;
            this.UpliftVanRightGridVerticalPointCount = slipCircleDefinition.UpliftVanRightGridVerticalPointCount;
            this.UpliftVanRightGridVerticalPointDistance = slipCircleDefinition.UpliftVanRightGridVerticalPointDistance;
            this.UpliftVanRightGridHorizontalPointCount = slipCircleDefinition.UpliftVanRightGridHorizontalPointCount;
            this.UpliftVanRightGridHorizontalPointDistance = slipCircleDefinition.UpliftVanRightGridHorizontalPointDistance;
            this.BishopGridVerticalPointCount = slipCircleDefinition.BishopGridVerticalPointCount;
            this.BishopGridVerticalPointDistance = slipCircleDefinition.BishopGridVerticalPointDistance;
            this.BishopGridHorizontalPointCount = slipCircleDefinition.BishopGridHorizontalPointCount;
            this.BishopGridHorizontalPointDistance = slipCircleDefinition.BishopGridHorizontalPointDistance;
        }

        public SlipCircleDefinition Clone()
        {
            var slipCircleDefinition = new SlipCircleDefinition();
            slipCircleDefinition.Assign(this);
            return slipCircleDefinition;
        }
    }

    public class MStabZoneAreas : IAssignable<MStabZoneAreas>, ICloneable<MStabZoneAreas>
    {
        public double DikeTableHeight { get; set; }
        public double DikeTableWidth { get; set; }
        public double XCoordinateDikeTopAtRiver { get; set; }
        public double XCoordinateDikeTopAtPolder { get; set; }
        public double XCoordinateStartRestProfile { get; set; }
        public double SafetyFactorZone1A { get; set; }
        public double SafetyFactorZone1B { get; set; }
        public void Assign(MStabZoneAreas mstabZoneAreas)
        {
            this.DikeTableHeight = mstabZoneAreas.DikeTableHeight;
            this.DikeTableWidth = mstabZoneAreas.DikeTableWidth;
            this.XCoordinateDikeTopAtRiver = mstabZoneAreas.XCoordinateDikeTopAtRiver;
            this.XCoordinateDikeTopAtPolder = mstabZoneAreas.XCoordinateDikeTopAtPolder;
            this.XCoordinateStartRestProfile = mstabZoneAreas.XCoordinateStartRestProfile;
            this.SafetyFactorZone1A = mstabZoneAreas.SafetyFactorZone1A;
            this.SafetyFactorZone1B = mstabZoneAreas.SafetyFactorZone1B;
        }

        public MStabZoneAreas Clone()
        {
            var mstabZoneAreas = new MStabZoneAreas();
            mstabZoneAreas.Assign(this);
            return mstabZoneAreas;
        }
    }

    public class MStabForbiddenZone : IAssignable<MStabForbiddenZone>, ICloneable<MStabForbiddenZone>
    {
        public bool IsXEntryMinUsed { get; set; }
        public bool IsXEntryMaxUsed { get; set; }
        public double XEntryMin { get; set; }
        public double XEntryMax { get; set; }
        public void Assign(MStabForbiddenZone mstabForbiddenZone)
        {
            this.IsXEntryMinUsed = mstabForbiddenZone.IsXEntryMinUsed;
            this.IsXEntryMaxUsed = mstabForbiddenZone.IsXEntryMaxUsed;
            this.XEntryMin = mstabForbiddenZone.XEntryMin;
            this.XEntryMax = mstabForbiddenZone.XEntryMax;
        }

        public MStabForbiddenZone Clone()
        {
            var mstabForbiddenZone = new MStabForbiddenZone();
            mstabForbiddenZone.Assign(this);
            return mstabForbiddenZone;
        }
    }

    public class MStabDesignEmbankment : IAssignable<MStabDesignEmbankment>, ICloneable<MStabDesignEmbankment>
    {
        public string EmbankmentMaterialname { get; set; }
        public string PreviousGeometry2DFilename { get; set; }
        public void Assign(MStabDesignEmbankment mstabDesignEmbankment)
        {
            this.EmbankmentMaterialname = mstabDesignEmbankment.EmbankmentMaterialname;
            this.PreviousGeometry2DFilename = mstabDesignEmbankment.PreviousGeometry2DFilename;
        }

        public MStabDesignEmbankment Clone()
        {
            var mstabDesignEmbankment = new MStabDesignEmbankment();
            mstabDesignEmbankment.Assign(this);
            return mstabDesignEmbankment;
        }
    }

    public class MStabGeometryCreationOptions : IAssignable<MStabGeometryCreationOptions>, ICloneable<MStabGeometryCreationOptions>
    {
        public MStabGeometryCreationOptions()
        {
            SoilProfileType = SoilProfileType.SoilProfile1D;
            SoilGeometry2DFilename = "";
            XOffsetSoilGeometry2DOrigin = 0.0;
            MaterialForDike = "";
            MaterialForShoulder = "";
            IsUseOriginalPLLineAssignments = false;
            IsUseOriginalCalculationOptions = false;
            IsDrySituation = false;
            PLLineAssignment = PLLineAssignment.ExpertKnowledge;
            IntrusionVerticalWaterPressureType = IntrusionVerticalWaterPressureType.Standard;
            PenetrationLength = 0.0;
            IsDesign = false;
        }
        [XmlOldName("SoilGeometryType")]
        public SoilProfileType SoilProfileType { get; set; }
        public string SoilGeometry2DFilename { get; set; }
        public double XOffsetSoilGeometry2DOrigin { get; set; }
        public string MaterialForDike { get; set; }
        public string MaterialForShoulder { get; set; }
        public bool IsUseOriginalPLLineAssignments { get; set; }
        public bool IsUseOriginalCalculationOptions { get; set; }
        public bool IsDrySituation { get; set; }
        public PLLineAssignment PLLineAssignment { get; set; }
        public IntrusionVerticalWaterPressureType IntrusionVerticalWaterPressureType { get; set; }
        public double PenetrationLength { get; set; }
        public bool IsDesign { get; set; }

        public void Assign(MStabGeometryCreationOptions mstabGeometryCreationOptions)
        {
            this.SoilProfileType = mstabGeometryCreationOptions.SoilProfileType;
            this.SoilGeometry2DFilename = mstabGeometryCreationOptions.SoilGeometry2DFilename;
            this.XOffsetSoilGeometry2DOrigin = mstabGeometryCreationOptions.XOffsetSoilGeometry2DOrigin;
            this.MaterialForDike = mstabGeometryCreationOptions.MaterialForDike;
            this.MaterialForShoulder = mstabGeometryCreationOptions.MaterialForShoulder;
            this.IsUseOriginalPLLineAssignments = mstabGeometryCreationOptions.IsUseOriginalPLLineAssignments;
            this.IsUseOriginalCalculationOptions = mstabGeometryCreationOptions.IsUseOriginalCalculationOptions;
            this.IsDrySituation = mstabGeometryCreationOptions.IsDrySituation;
            this.PLLineAssignment = mstabGeometryCreationOptions.PLLineAssignment;
            this.IntrusionVerticalWaterPressureType = mstabGeometryCreationOptions.IntrusionVerticalWaterPressureType;
            this.PenetrationLength = mstabGeometryCreationOptions.PenetrationLength;
            this.IsDesign = mstabGeometryCreationOptions.IsDesign;
        }

        public MStabGeometryCreationOptions Clone()
        {
            var mstabGeometryCreationOptions = new MStabGeometryCreationOptions();
            mstabGeometryCreationOptions.Assign(this);
            return mstabGeometryCreationOptions;
        }
    }

    public class MStabCalculationOptions : IAssignable<MStabCalculationOptions>, ICloneable<MStabCalculationOptions>
    {
        public double MinimalCircleDepth { get; set; }
        [Label("MStab Zone Types")]
        [ReadOnly(true)]
        public MStabZonesType ZonesType { get; set; }

        public void Assign(MStabCalculationOptions mstabCalculationOptions)
        {
            this.MinimalCircleDepth = mstabCalculationOptions.MinimalCircleDepth;
            this.ZonesType = mstabCalculationOptions.ZonesType;
        }

        public MStabCalculationOptions Clone()
        {
            var mstabCalculationOptions = new MStabCalculationOptions();
            mstabCalculationOptions.Assign(this);
            return mstabCalculationOptions;
        }
    }

    public class MStabParameters : ICloneable<MStabParameters>, IVisibleEnabled
    {
        private MStabGridPosition gridPosition;

        public MStabParameters()
        {
            this.IsCalculateAllStabilityProjectsAtOnce = true;
            this.IsOverrulePLLineCreationMethod = false;
            this.PLLineCreationMethod = PLLineCreationMethod.ExpertKnowledgeRRD;
            this.Model = MStabModelType.Bishop;
            this.SearchMethod = MStabSearchMethod.Grid;
            this.ZoneAreas = null;
            this.gridPosition = MStabGridPosition.Right;
            this.CalculationOptions = new MStabCalculationOptions();
            this.GeometryCreationOptions = new MStabGeometryCreationOptions();
            this.SheetPiling = null;
            this.HorizontalBalanceArea = new HorizontalBalanceArea();
            this.SlipCircleDefinition = new SlipCircleDefinition();
        }

        public bool IsCombinedBishopUpliftVanCalculation { get { return (Model == MStabModelType.BishopUpliftVan); } }
        // IsCombinedBishopUpliftVanCalculation (formerly IsAutoSelectCalculation) is the same as Model == MStabModel.BishopUpliftVan
        // This property was first implemented for FewsDam and later MStabModel.BishopUpliftVan was implemented for normal DAM operation
        // Now we will use Model == MStabModel.BishopUpliftVan for  both FewsDam and DAM
        // This readonly property is implemented for backward compatibiity

        public bool IsCalculateAllStabilityProjectsAtOnce { get; set; }
        // Normally PLLine creation is specified per location.
        // If IsOverrulePLLineCreationMethod is set to true the settings in the locations will be 
        // overruled with the value in PLLineCreationMethod
        public bool IsOverrulePLLineCreationMethod { get; set; }
        public PLLineCreationMethod PLLineCreationMethod { get; set; }
        [Label("Model")]
        public MStabModelType Model { get; set; }
        [Label("Shear Strength")]
        public MStabShearStrength ShearStrength { get; set; }
        [Label("Search Method")]
        public MStabSearchMethod SearchMethod { get; set; }
        public bool IsProbabilistic { get; set; }
        public string ProjectFileName { get; set; }
        public string SoilDatabaseName { get; set; }
        public MStabZoneAreas ZoneAreas { get; set; }
        public MStabForbiddenZone ForbiddenZone { get; set; }
        public MStabGeometryCreationOptions GeometryCreationOptions { get; set; }
        public SheetPiling SheetPiling { get; set; }
        public HorizontalBalanceArea HorizontalBalanceArea { get; set; }
        [Validate]
        public SlipCircleDefinition SlipCircleDefinition { get; set; }
        public MStabCalculationOptions CalculationOptions { get; set; }

        public MStabGridPosition GridPosition
        {
            get { return gridPosition; }
            set
            {
                DataEventPublisher.BeforeChange(this, "GridPosition");
                gridPosition = value;
                DataEventPublisher.AfterChange(this, "GridPosition");
            }
        }

        public void Assign(MStabParameters mstabParameters)
        {
            this.Model = mstabParameters.Model;
            this.ShearStrength = mstabParameters.ShearStrength;
            this.SearchMethod = mstabParameters.SearchMethod;
            this.IsProbabilistic = mstabParameters.IsProbabilistic;
            this.GridPosition = mstabParameters.GridPosition;
            this.ProjectFileName = mstabParameters.ProjectFileName;
            this.SoilDatabaseName = mstabParameters.SoilDatabaseName;
            if (this.ZoneAreas != null)
            {
                this.ZoneAreas.Assign(mstabParameters.ZoneAreas);
            }
            else
            {
                this.ZoneAreas = null;
            }
            if (this.ForbiddenZone != null)
            {
                this.ForbiddenZone.Assign(mstabParameters.ForbiddenZone);
            }
            else
            {
                this.ForbiddenZone = null;
            }
            if (this.CalculationOptions != null)
            {
                this.CalculationOptions.Assign(mstabParameters.CalculationOptions);
            }
            else
            {
                this.CalculationOptions = null;
            }
            if (this.GeometryCreationOptions != null)
            {
                this.GeometryCreationOptions.Assign(mstabParameters.GeometryCreationOptions);
            }
            else
            {
                this.GeometryCreationOptions = null;
            }
            if (this.SheetPiling != null)
            {
                this.SheetPiling.Assign(mstabParameters.SheetPiling);
            }
            else
            {
                this.SheetPiling = null;
            }
            if (this.HorizontalBalanceArea != null)
            {
                this.HorizontalBalanceArea.Assign(mstabParameters.HorizontalBalanceArea);
            }
            else
            {
                this.HorizontalBalanceArea = null;
            }
            this.SoilDatabaseName = mstabParameters.SoilDatabaseName;
            if (this.SlipCircleDefinition != null)
            {
                this.SlipCircleDefinition.Assign(mstabParameters.SlipCircleDefinition);
            }
            else
            {
                this.SlipCircleDefinition = null;
            }
        }

        [Label("MStab Zone Types")]
        [ReadOnly(true)]
        [XmlIgnore]
        public MStabZonesType ZonesType
        {
            get { return this.CalculationOptions.ZonesType; }
            set { this.CalculationOptions.ZonesType = value; }
        }

        public MStabParameters Clone()
        {
            var mstabParameters = new MStabParameters();
            if (this.ZoneAreas != null)
                mstabParameters.ZoneAreas = this.ZoneAreas.Clone();
            if (this.ForbiddenZone != null)
                mstabParameters.ForbiddenZone = this.ForbiddenZone.Clone();
            if (this.GeometryCreationOptions != null)
                mstabParameters.GeometryCreationOptions = this.GeometryCreationOptions.Clone();
            if (this.SheetPiling != null)
                mstabParameters.SheetPiling = this.SheetPiling.Clone();
            if (this.HorizontalBalanceArea != null)
                mstabParameters.HorizontalBalanceArea = this.HorizontalBalanceArea.Clone();
            if (this.SlipCircleDefinition != null)
                mstabParameters.SlipCircleDefinition = this.SlipCircleDefinition.Clone();
            if (this.CalculationOptions != null)
                mstabParameters.CalculationOptions = this.CalculationOptions.Clone();

            mstabParameters.Assign(this);

            return mstabParameters;
        }

        #region IVisibleEnabled Members

        public bool IsEnabled(string property)
        {
            switch (property)
            {
                case "SearchMethod": return Location.DamProjectType == DamProjectType.Design || Location.DamProjectType == DamProjectType.Assessment;
                case "GridPosition": return false; // position depends on failuremechanisme type (inside or outside)
                case "ZonesType": return false; // Is set per location!
                default: return true;
            }
        }

        public bool IsVisible(string property)
        {
            switch (property)
            {
                case "Model": return Location.DamProjectType != DamProjectType.Assessment;
                case "SearchMethod": return
                   (SlipCircleDefinition.Specification.FailureMechanismSystemType == FailureMechanismSystemType.StabilityInside ||
                   SlipCircleDefinition.Specification.FailureMechanismSystemType == FailureMechanismSystemType.StabilityOutside) &&
                    (Model == MStabModelType.Bishop ||
                    Model == MStabModelType.BishopUpliftVan || Model == MStabModelType.UpliftVan);
                case "ZonesType": return false; // Is set per location!
                case "GridPosition": return false; // position depends on failuremechanisme type (inside or outside)
                default: return true;
            }
        }

        #endregion

    }
}