// 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 Deltares.DamEngine.Data.Standard;
using Deltares.DamEngine.Data.Standard.Validation;

namespace Deltares.DamEngine.Data.General
{
    
    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 : 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;

        public double XCoordinateLastUpliftPoint
        {
            get
            {
                return xCoordinateLastUpliftPoint;
            }
            set
            {
                xCoordinateLastUpliftPoint = value;                
            }
        }
        public TangentLinesDefinition UpliftVanTangentLinesDefinition { get; set; }
        
        public double UpliftVanTangentLinesDistance
        {
            get
            {
                return upliftVanTangentLinesDistance;
            }
            set
            {
                upliftVanTangentLinesDistance = value;                
            }
        }
        public TangentLinesDefinition BishopTangentLinesDefinition { get; set; }
        
        public double BishopTangentLinesDistance
        {
            get
            {
                return bishopTangentLinesDistance;
            }
            set
            {
                bishopTangentLinesDistance = value;                
            }
        }
        public GridSizeDetermination GridSizeDetermination { get; set; }
        
        public int UpliftVanLeftGridVerticalPointCount
        {
            get
            {
                return upliftVanLeftGridVerticalPointCount;
            }
            set
            {
                upliftVanLeftGridVerticalPointCount = value;                
            }
        }
        
        public double UpliftVanLeftGridVerticalPointDistance
        {
            get
            {
                return upliftVanLeftGridVerticalPointDistance;
            }
            set
            {
                upliftVanLeftGridVerticalPointDistance = value;                
            }
        }
        
        public int UpliftVanLeftGridHorizontalPointCount
        {
            get
            {
                return upliftVanLeftGridHorizontalPointCount;
            }
            set
            {
                upliftVanLeftGridHorizontalPointCount = value;                
            }
        }
        
        public double UpliftVanLeftGridHorizontalPointDistance
        {
            get
            {
                return upliftVanLeftGridHorizontalPointDistance;
            }
            set
            {
                upliftVanLeftGridHorizontalPointDistance = value;
            }
        }
        
        public int UpliftVanRightGridVerticalPointCount
        {
            get
            {
                return upliftVanRightGridVerticalPointCount;
            }
            set
            {
                upliftVanRightGridVerticalPointCount = value;                
            }
        }
        
        public double UpliftVanRightGridVerticalPointDistance
        {
            get
            {
                return upliftVanRightGridVerticalPointDistance;
            }
            set
            {
                upliftVanRightGridVerticalPointDistance = value;                
            }
        }
        
        public int UpliftVanRightGridHorizontalPointCount
        {
            get
            {
                return upliftVanRightGridHorizontalPointCount;
            }
            set
            {
                upliftVanRightGridHorizontalPointCount = value;                
            }
        }
        
        public double UpliftVanRightGridHorizontalPointDistance
        {
            get
            {
                return upliftVanRightGridHorizontalPointDistance;
            }
            set
            {
                upliftVanRightGridHorizontalPointDistance = value;                
            }
        }
        
        public int BishopGridVerticalPointCount
        {
            get
            {
                return bishopGridVerticalPointCount;
            }
            set
            {
                bishopGridVerticalPointCount = value;                
            }
        }
        
        public double BishopGridVerticalPointDistance
        {
            get
            {
                return bishopGridVerticalPointDistance;
            }
            set
            {
                bishopGridVerticalPointDistance = value;                
            }
        }
        
        public int BishopGridHorizontalPointCount
        {
            get
            {
                return bishopGridHorizontalPointCount;
            }
            set
            {
                bishopGridHorizontalPointCount = value;                
            }
        }
        
        public double BishopGridHorizontalPointDistance
        {
            get
            {
                return bishopGridHorizontalPointDistance;
            }
            set
            {
                bishopGridHorizontalPointDistance = value;                
            }
        }

        public DamFailureMechanismeCalculationSpecification Specification { get; set; }
        
        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 MStabGeometryCreationOptions : IAssignable<MStabGeometryCreationOptions>, ICloneable<MStabGeometryCreationOptions>
    {
        public MStabGeometryCreationOptions()
        {
            SoilProfileType = SoilProfileType.ProfileType1D;
            SoilGeometry2DFilename = "";
            XOffsetSoilGeometry2DOrigin = 0.0;
            MaterialForDike = "";
            MaterialForShoulder = "";
            IsUseOriginalPlLineAssignments = false;
            IsUseOriginalCalculationOptions = false;
            PlLineAssignment = PlLineAssignment.ExpertKnowledge;
            IntrusionVerticalWaterPressureType = IntrusionVerticalWaterPressureType.Standard;
            PenetrationLength = 0.0;
            IsDesign = false;
        }
        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 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.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; }

        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>
    {
        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; }
        
        public MStabModelType Model { get; set; }
        
        public MStabShearStrength ShearStrength { get; set; }
        
        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
            {
                gridPosition = value;                
            }
        }

        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;
            }
        }

        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;
        }        
    }
}