//-----------------------------------------------------------------------
// <copyright file="PLLinesCreatorDupuitTests.cs" company="Deltares">
//  Copyright (c) 2011 Deltares. All rights reserved.
// </copyright>
// <author>B.S.T.I.M. The</author>
// <email>tom.the@deltares.nl</email>
// <date>12-05-2011</date>
// <summary>Create objects to test Dupuit calcualtion (DikeFlow.exe)</summary>
//-----------------------------------------------------------------------

using Deltares.Geometry;
using Deltares.Dam.Data;
using Deltares.Geotechnics;
using Deltares.Geotechnics.GeotechnicalGeometry;
using Deltares.Geotechnics.Soils;
using Deltares.Geotechnics.SurfaceLines;

namespace Deltares.Dam.TestHelper
{
    public class FactoryForDupuitCalculatorTest
    {

        const double tolerance = 0.01;
        const double limitLeft = 0.0;
        const double limitRight = 170.8333;
        const double dikeHeight = 10.0;
        const double bermHeight = 3.0;
        const double bermWidth = 10.0;
        const double crestWidth = 5.0;
        const double lForeland = 10.0;
        const double distanceToDitch = 20.0;
        const double lHinterland = 40.0;
        const double atanaOuterSlope = 0.3;
        const double atanaInnerSlope = 0.20;
        const double atanaDitchSlope = 1.0;
        const double ditchHeight = 1.0;
        const double ditchWidth = 0.5;

        public static SoilList CreateSoilListBm3_4()
        {
            var soilList = new SoilList();
            soilList.Soils.Add(new Soil()
            {
                Name = "Sand",
                AbovePhreaticLevel = 26.5,
                BelowPhreaticLevel = 26.5,
                FrictionAngle = 20.0,
                Cohesion = 8.0,
                PermeabKx = 10.0 * DupuitCalculatorFileIO.cFactor_mPerDay_2_mPerSec
            });
            soilList.Soils.Add(new Soil()
            {
                Name = "Clay",
                AbovePhreaticLevel = 26.5,
                BelowPhreaticLevel = 26.5,
                FrictionAngle = 20.0,
                Cohesion = 8.0,
                PermeabKx = 0.003 * DupuitCalculatorFileIO.cFactor_mPerDay_2_mPerSec
            });
            soilList.Soils.Add(new Soil()
            {
                Name = "Surchage",
                AbovePhreaticLevel = 65.0,
                BelowPhreaticLevel = 65.0,
                FrictionAngle = 20.0,
                Cohesion = 8.0,
                PermeabKx = 0.003 * DupuitCalculatorFileIO.cFactor_mPerDay_2_mPerSec
            });
            soilList.Soils.Add(new Soil()
            {
                Name = "Holland peat ond",
                AbovePhreaticLevel = 11.5,
                BelowPhreaticLevel = 11.5,
                FrictionAngle = 20.0,
                Cohesion = 8.0,
                PermeabKx = 0.003 * DupuitCalculatorFileIO.cFactor_mPerDay_2_mPerSec
            });
            soilList.Soils.Add(new Soil()
            {
                Name = "Holland peat nst",
                AbovePhreaticLevel = 11.5,
                BelowPhreaticLevel = 11.5,
                FrictionAngle = 20.0,
                Cohesion = 8.0,
                PermeabKx = 0.003 * DupuitCalculatorFileIO.cFactor_mPerDay_2_mPerSec
            });
            soilList.Soils.Add(new Soil()
            {
                Name = "tiel nst",
                AbovePhreaticLevel = 15.0,
                BelowPhreaticLevel = 15.0,
                FrictionAngle = 20.0,
                Cohesion = 8.0,
                PermeabKx = 0.03 * DupuitCalculatorFileIO.cFactor_mPerDay_2_mPerSec
            });

            return soilList;
            
        }
        public static SoilList CreateSoilList()
        {
            var soilList = new SoilList();
            soilList.Soils.Add(new Soil()
            {
                Name = "aquifermaterial",
                AbovePhreaticLevel = 26.5,
                BelowPhreaticLevel = 26.5,
                FrictionAngle = 20.0,
                Cohesion = 8.0,
                PermeabKx = 100.0 * DupuitCalculatorFileIO.cFactor_mPerDay_2_mPerSec
            });
            soilList.Soils.Add(new Soil()
            {
                Name = "covermaterial",
                AbovePhreaticLevel = 26.5,
                BelowPhreaticLevel = 26.5,
                FrictionAngle = 20.0,
                Cohesion = 8.0,
                PermeabKx = 0.03 * DupuitCalculatorFileIO.cFactor_mPerDay_2_mPerSec
            });
            soilList.Soils.Add(new Soil()
            {
                Name = "dikematerial",
                AbovePhreaticLevel = 26.5,
                BelowPhreaticLevel = 26.5,
                FrictionAngle = 20.0,
                Cohesion = 8.0,
                PermeabKx = 1.0 * DupuitCalculatorFileIO.cFactor_mPerDay_2_mPerSec
            });
            return soilList;
        }

        /// <summary>
        /// Create time serie waterlevels for test
        /// </summary>
        /// <returns></returns>
        public static TimeSerie CreateWaterLevelTimeSerie()
        {
            var waterLevelTimeserie = new TimeSerie();
            waterLevelTimeserie.StartDateTime = System.DateTime.Now;
            waterLevelTimeserie.Entries.Add(new TimeSerieEntry(waterLevelTimeserie.StartDateTime, 4.0));
            waterLevelTimeserie.Entries.Add(new TimeSerieEntry(waterLevelTimeserie.StartDateTime.AddDays(1.0), 5.0));
            waterLevelTimeserie.Entries.Add(new TimeSerieEntry(waterLevelTimeserie.StartDateTime.AddDays(2.0), 6.0));
            waterLevelTimeserie.EndDateTime = waterLevelTimeserie.Entries[waterLevelTimeserie.Entries.Count - 1].DateTime;
            return waterLevelTimeserie;
        }

        /// <summary>
        /// Create time serie waterlevels for test
        /// </summary>
        /// <returns></returns>
        public static TimeSerie CreateSafetyFactorTimeSerie()
        {
            var safetyFactorTimeserie = new TimeSerie();
            safetyFactorTimeserie.StartDateTime = System.DateTime.Now;
            safetyFactorTimeserie.Entries.Add(new TimeSerieEntry(safetyFactorTimeserie.StartDateTime, 1.12));
            safetyFactorTimeserie.Entries.Add(new TimeSerieEntry(safetyFactorTimeserie.StartDateTime.AddDays(1.0), 1.45));
            safetyFactorTimeserie.Entries.Add(new TimeSerieEntry(safetyFactorTimeserie.StartDateTime.AddDays(2.0), 0.95));
            safetyFactorTimeserie.EndDateTime = safetyFactorTimeserie.Entries[safetyFactorTimeserie.Entries.Count - 1].DateTime;
            return safetyFactorTimeserie;
        }

        /// <summary>
        /// Create time serie waterlevels for test
        /// </summary>
        /// <returns></returns>
        public static TimeSerie CreatePolderLevelTimeSerie()
        {
            var polderLevelTimeserie = new TimeSerie();
            polderLevelTimeserie.StartDateTime = System.DateTime.Now;
            polderLevelTimeserie.Entries.Add(new TimeSerieEntry(polderLevelTimeserie.StartDateTime, 2.0));
            polderLevelTimeserie.Entries.Add(new TimeSerieEntry(polderLevelTimeserie.StartDateTime.AddDays(1.0), 3.0));
            polderLevelTimeserie.Entries.Add(new TimeSerieEntry(polderLevelTimeserie.StartDateTime.AddDays(2.0), 4.0));
            polderLevelTimeserie.EndDateTime = polderLevelTimeserie.Entries[polderLevelTimeserie.Entries.Count - 1].DateTime;
            return polderLevelTimeserie;
        }

        /// <summary>
        /// Create time serie pllines for test
        /// </summary>
        /// <returns></returns>
        public static DupuitPLLinesTimeSerie CreateDupuitPLLinesTimeSerie()
        {
            var dupuitPPLinesTimeSerie = new DupuitPLLinesTimeSerie();
            DupuitTimeSerieEntry dupuitTimeSerieEntry;
            var dupuitPlLines = new DupuitPLLines();
            double head = 0.0;
            for (int lineIndex = 0; lineIndex < 6; lineIndex++)
            {
                var plLine = new PLLine();
                plLine.Points.Add(new PLLinePoint() { X = limitLeft, Z = head });
                plLine.Points.Add(new PLLinePoint() { X = (limitLeft + limitRight) / 2, Z = head + 1.0 });
                plLine.Points.Add(new PLLinePoint() { X = limitRight, Z = head });
                dupuitPlLines.PLLines.Add(plLine);
                head += 1.0;
            }
            dupuitTimeSerieEntry = new DupuitTimeSerieEntry();
            dupuitTimeSerieEntry.DupuitPlLines = dupuitPlLines;
            dupuitTimeSerieEntry.TimeInSeconds = 0.0;
            dupuitPPLinesTimeSerie.Entries.Add(dupuitTimeSerieEntry);
            dupuitTimeSerieEntry = new DupuitTimeSerieEntry();
            dupuitTimeSerieEntry.DupuitPlLines = dupuitPlLines;
            dupuitTimeSerieEntry.TimeInSeconds = 1.0;
            dupuitPPLinesTimeSerie.Entries.Add(dupuitTimeSerieEntry);
            dupuitTimeSerieEntry = new DupuitTimeSerieEntry();
            dupuitTimeSerieEntry.DupuitPlLines = dupuitPlLines;
            dupuitTimeSerieEntry.TimeInSeconds = 2.0;
            dupuitPPLinesTimeSerie.Entries.Add(dupuitTimeSerieEntry);
            return dupuitPPLinesTimeSerie;
        }

        public static SurfaceLine2 CreateBm3_4SurfaceLine()
        {
            var surfaceLine = new SurfaceLine2
            {
                Geometry = new LocalizedGeometryPointString(),
                CharacteristicPoints = { GeometryMustContainPoint = true }
            };

            surfaceLine.EnsurePointOfType(-50.000, -5.970, CharacteristicPointType.SurfaceLevelOutside);
            surfaceLine.EnsurePoint(-38.430, -5.860);
            surfaceLine.EnsurePoint(-35.900, -5.000);
            surfaceLine.EnsurePointOfType(-31.900, -5.000, CharacteristicPointType.DikeToeAtRiver);
            surfaceLine.EnsurePointOfType(-13.300, 1.200, CharacteristicPointType.ShoulderTopOutside);
            surfaceLine.EnsurePointOfType(-9.300, 1.200, CharacteristicPointType.ShoulderBaseOutside);
            surfaceLine.EnsurePoint(-2.800, 4.450);
            surfaceLine.EnsurePointOfType(2.800, 6.050, CharacteristicPointType.DikeTopAtRiver);
            surfaceLine.EnsurePoint(7.300, 6.180);
            surfaceLine.EnsurePoint(8.300, 6.150);
            surfaceLine.EnsurePoint(8.300, 6.350);
            surfaceLine.EnsurePoint(10.800, 6.279);
            surfaceLine.EnsurePoint(10.800, 6.079);
            surfaceLine.EnsurePointOfType(11.800, 6.050, CharacteristicPointType.DikeTopAtPolder);
            surfaceLine.EnsurePointOfType(26.350, 1.200, CharacteristicPointType.ShoulderBaseInside);
            surfaceLine.EnsurePointOfType(43.350, 1.200, CharacteristicPointType.ShoulderTopInside);
            surfaceLine.EnsurePointOfType(49.350, -0.800, CharacteristicPointType.DikeToeAtPolder);
            surfaceLine.EnsurePoint(50.000, -0.860);
            surfaceLine.EnsurePointOfType(100.000, -0.860, CharacteristicPointType.SurfaceLevelInside);

            return surfaceLine;
        }
        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public static SurfaceLine2 CreateExampleSurfaceLine()
        {
            var surfaceLine = new SurfaceLine2
            {
                Geometry = new LocalizedGeometryPointString(),
                CharacteristicPoints = { GeometryMustContainPoint = true }
            };

            // surfaceline
            double currentX = limitLeft;
            surfaceLine.EnsurePointOfType(currentX, 0.0, CharacteristicPointType.SurfaceLevelOutside);
            currentX += lForeland;
            surfaceLine.EnsurePointOfType(currentX, 0.0, CharacteristicPointType.DikeToeAtRiver);
            currentX += dikeHeight / atanaOuterSlope;
            surfaceLine.EnsurePointOfType(currentX, dikeHeight, CharacteristicPointType.DikeTopAtRiver);
            currentX += crestWidth;
            surfaceLine.EnsurePointOfType(currentX, dikeHeight, CharacteristicPointType.DikeTopAtPolder);
            currentX += (dikeHeight - bermHeight) / atanaInnerSlope;
            surfaceLine.EnsurePointOfType(currentX, bermHeight, CharacteristicPointType.ShoulderBaseInside);
            currentX += bermWidth;
            surfaceLine.EnsurePointOfType(currentX, bermHeight, CharacteristicPointType.ShoulderTopInside);
            currentX += bermHeight / atanaInnerSlope;
            surfaceLine.EnsurePointOfType(currentX, 0.0, CharacteristicPointType.DikeToeAtPolder);
            currentX += distanceToDitch;
            var ditch1Point = new Geometry2DPoint(currentX, 0.0);
            surfaceLine.EnsurePointOfType(ditch1Point.X, ditch1Point.Z, CharacteristicPointType.DitchDikeSide);
            currentX += ditchHeight / atanaDitchSlope;
            var ditch2Point = new Geometry2DPoint(currentX, -ditchHeight);
            surfaceLine.EnsurePointOfType(ditch2Point.X, ditch2Point.Z, CharacteristicPointType.BottomDitchDikeSide);
            currentX += ditchWidth;
            var ditch3Point = new Geometry2DPoint(currentX, -ditchHeight);
            surfaceLine.EnsurePointOfType(ditch3Point.X, ditch3Point.Z, CharacteristicPointType.BottomDitchPolderSide);
            currentX += ditchHeight / atanaDitchSlope;
            var ditch4Point = new Geometry2DPoint(currentX, 0.0);
            surfaceLine.EnsurePointOfType(ditch4Point.X, ditch4Point.Z, CharacteristicPointType.DitchPolderSide);
            currentX += lHinterland;
            surfaceLine.EnsurePointOfType(currentX, 0.0, CharacteristicPointType.SurfaceLevelInside);
            return surfaceLine;
        }
        /// <summary>
        /// Create geoemtry 2D for test
        /// </summary>
        /// <returns></returns>
        public static Geometry2DData CreateExampleGeometry2D()
        {
            using (SurfaceLine2 surfaceLine = CreateExampleSurfaceLine())
            {
                var geometry2D = new Geometry2DData();
                var boundaryLine = new Geometry2DBoundaryLine();
                boundaryLine.Points.Add(new Geometry2DPoint(surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelOutside).X, -18.0));
                boundaryLine.Points.Add(new Geometry2DPoint(surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelInside).X, -18.0));
                geometry2D.AddLayer(new Geometry2DLayer()
                {
                    boundaryLine = boundaryLine,
                    soilName = "aquifermaterial"
                });

                boundaryLine = new Geometry2DBoundaryLine();
                boundaryLine.Points.Add(new Geometry2DPoint(surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelOutside).X, -8.0));
                boundaryLine.Points.Add(new Geometry2DPoint(surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelInside).X, -8.0));
                geometry2D.AddLayer(new Geometry2DLayer()
                {
                    boundaryLine = boundaryLine,
                    soilName = "aquifermaterial"
                });

                boundaryLine = new Geometry2DBoundaryLine();
                boundaryLine.Points.Add(new Geometry2DPoint(surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelOutside).X, -7.0));
                boundaryLine.Points.Add(new Geometry2DPoint(surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelInside).X, -7.0));
                geometry2D.AddLayer(new Geometry2DLayer()
                {
                    boundaryLine = boundaryLine,
                    soilName = "covermaterial"
                });

                boundaryLine = new Geometry2DBoundaryLine();
                boundaryLine.Points.Add(new Geometry2DPoint(surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelOutside).X, -2.0));
                boundaryLine.Points.Add(new Geometry2DPoint(surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelInside).X, -2.0));
                geometry2D.AddLayer(new Geometry2DLayer()
                {
                    boundaryLine = boundaryLine,
                    soilName = "covermaterial"
                });

                var ditchBoundaryLine = new Geometry2DBoundaryLine();
                GeometryPoint point = surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelOutside);
                ditchBoundaryLine.Points.Add(new Geometry2DPoint(point.X, point.Z));
                point = surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide);
                ditchBoundaryLine.Points.Add(new Geometry2DPoint(point.X, point.Z));
                point = surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide);
                ditchBoundaryLine.Points.Add(new Geometry2DPoint(point.X, point.Z));
                point = surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide);
                ditchBoundaryLine.Points.Add(new Geometry2DPoint(point.X, point.Z));
                point = surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide);
                ditchBoundaryLine.Points.Add(new Geometry2DPoint(point.X, point.Z));
                point = surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelInside);
                ditchBoundaryLine.Points.Add(new Geometry2DPoint(point.X, point.Z));
                geometry2D.AddLayer(new Geometry2DLayer()
                {
                    boundaryLine = ditchBoundaryLine,
                    soilName = "covermaterial"
                });

                var surfaceBoundaryLine = new Geometry2DBoundaryLine();
                foreach (var surfaceLinePoint in surfaceLine.Geometry.Points)
                {
                    surfaceBoundaryLine.Points.Add(new Geometry2DPoint(surfaceLinePoint.X, surfaceLinePoint.Z));
                }
                geometry2D.AddLayer(new Geometry2DLayer()
                {
                    boundaryLine = surfaceBoundaryLine,
                    soilName = "dikematerial"
                });

                return geometry2D;
            }
        }
    }
}