using System.Linq;

using Deltares.Dam.Data;
using Deltares.Geometry;
using Deltares.Geotechnics;
using Deltares.Geotechnics.GeotechnicalGeometry;
using Deltares.Geotechnics.SurfaceLines;
using Deltares.Standard;
using Deltares.Standard.Validation;
using NUnit.Framework;

namespace Deltares.Dam.Tests
{
    [TestFixture]
    public class NonWaterRetainingObjectInSurfaceLineTest
    {
        private NonWaterRetainingObjectInSurfaceLine nwoSurf;
        private NonWaterRetainingObject nonWaterRetainingObject;
        private SurfaceLine2 surfaceLine;

        [SetUp]
        public void TestSetup()
        {
            nonWaterRetainingObject = new NonWaterRetainingObject();
            nonWaterRetainingObject.Category = NonWaterRetainingObjectCategory.Tree;
            nonWaterRetainingObject.Type = NonWaterRetainingObjectType.Oak;
            nonWaterRetainingObject.PhreaticAdaption = PhreaticAdaptionType.MakeEmpty;
            nonWaterRetainingObject.MaxDistanceFromToe = 1000;
            nonWaterRetainingObject.GetDefaultValuesPerCategoryAndType(NonWaterRetainingObjectCategory.Tree, NonWaterRetainingObjectType.Oak);
            surfaceLine = new SurfaceLine2
            {
                Geometry = new LocalizedGeometryPointString(),
                CharacteristicPoints = { GeometryMustContainPoint = true }
            };
            surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.SurfaceLevelOutside);
            surfaceLine.EnsurePoint(10, 0); // MK: Removed characteristic point DikeTableHeigt. Is moved to scenario's now,
                                            // but this test still needs a point in this place.
            surfaceLine.EnsurePointOfType(40, 0, CharacteristicPointType.DikeToeAtRiver);
            surfaceLine.EnsurePointOfType(56, 8, CharacteristicPointType.DikeTopAtRiver);
            surfaceLine.EnsurePointOfType(60, 8, CharacteristicPointType.TrafficLoadOutside);
            surfaceLine.EnsurePointOfType(68, 8, CharacteristicPointType.TrafficLoadInside);
            surfaceLine.EnsurePointOfType(70, 8, CharacteristicPointType.DikeTopAtPolder);
            surfaceLine.EnsurePointOfType(86, 0, CharacteristicPointType.DikeToeAtPolder);
            surfaceLine.EnsurePointOfType(100, 0, CharacteristicPointType.DitchDikeSide);
            surfaceLine.EnsurePointOfType(101, -1.5, CharacteristicPointType.BottomDitchDikeSide);
            surfaceLine.EnsurePointOfType(103, -1.5, CharacteristicPointType.BottomDitchPolderSide);
            surfaceLine.EnsurePointOfType(104, 0, CharacteristicPointType.DitchPolderSide);
            surfaceLine.EnsurePointOfType(120, 0, CharacteristicPointType.SurfaceLevelInside);

            nwoSurf = new NonWaterRetainingObjectInSurfaceLine();
            nwoSurf.NonWaterRetainingObject = nonWaterRetainingObject;
            nwoSurf.GridPosition = MStabGridPosition.Right;
            nwoSurf.SurfaceLine = surfaceLine;
            nwoSurf.StepSizeX = 0.5;
        }

        [TearDown]
        public void TearDown()
        {
            surfaceLine.Dispose();
        }

        [Test]
        public void TestDetermineStartLocationForNonWaterRetainingObjectAtPolderSide()
        {
            nwoSurf.GridPosition = MStabGridPosition.Right;
            Assert.AreEqual(109, nwoSurf.DetermineStartLocationForNonWaterRetainingObject(false));            
        }

        [Test]
        public void TestDetermineStartLocationForNonWaterRetainingObjectAtRiverSide()
        {
            nwoSurf.GridPosition = MStabGridPosition.Left;
            Assert.AreEqual(1, nwoSurf.DetermineStartLocationForNonWaterRetainingObject(false));
        }

        [Test]
        public void TestDetermineStartLocationForNonWaterRetainingObjectAtPolderSideWithMaxDistance()
        {
            nwoSurf.GridPosition = MStabGridPosition.Right;
            nonWaterRetainingObject.MaxDistanceFromToe = 30;
            Assert.AreEqual(106, nwoSurf.DetermineStartLocationForNonWaterRetainingObject(false));
        }

        [Test]
        public void TestDetermineStartLocationForNonWaterRetainingObjectAtPolderSideWithMaxDistance2()
        {
            nwoSurf.GridPosition = MStabGridPosition.Right;
            nonWaterRetainingObject.MaxDistanceFromToe = 5;
            Assert.AreEqual(81, nwoSurf.DetermineStartLocationForNonWaterRetainingObject(false));
        }

        [Test]
        public void TestDetermineStartLocationForNonWaterRetainingObjectAtRiverSideWithMaxDistance()
        {
            nwoSurf.GridPosition = MStabGridPosition.Left;
            nonWaterRetainingObject.MaxDistanceFromToe = 30;
            Assert.AreEqual(10, nwoSurf.DetermineStartLocationForNonWaterRetainingObject(false));
        }

        [Test]
        public void TestDetermineStartLocationForNonWaterRetainingObjectAtPolderSideWithMaxDistanceSkipingDitch()
        {
            nwoSurf.GridPosition = MStabGridPosition.Right;
            nonWaterRetainingObject.MaxDistanceFromToe = 28;
            Assert.AreEqual(89.9, nwoSurf.DetermineStartLocationForNonWaterRetainingObject(true), GeometryPoint.Precision);
        }

        [Test]
        public void TestDetermineStartLocationForNonWaterRetainingObjectSkippingDitch()
        {
            nwoSurf.GridPosition = MStabGridPosition.Right;
            SurfaceLine2 oldSurfaceLine = nwoSurf.SurfaceLine;
            oldSurfaceLine.Geometry.Points[oldSurfaceLine.Geometry.Count - 1].X = 115;
            nwoSurf.SurfaceLine = oldSurfaceLine;
            Assert.AreEqual(89.9, nwoSurf.DetermineStartLocationForNonWaterRetainingObject(true), GeometryPoint.Precision);
        }                       

        [Test]
        public void TestDetermineNewFitPostionX()
        {
            nwoSurf.GridPosition = MStabGridPosition.Right;
            nwoSurf.StepSizeX = 0.5;
            Assert.AreEqual(0.5, nwoSurf.DetermineNewFitPostionX(1, false));
            nwoSurf.GridPosition = MStabGridPosition.Left;
            nwoSurf.StepSizeX = 1.5;
            Assert.AreEqual(2.5, nwoSurf.DetermineNewFitPostionX(1, false));            
        }

        [Test]
        public void TestDetermineNewFitPostionXSkippingDitch()
        {
            nwoSurf.GridPosition = MStabGridPosition.Right;
            nwoSurf.StepSizeX = 0.5;
            // right of ditch, no extra move
            Assert.AreEqual(104.5, nwoSurf.DetermineNewFitPostionX(105, true));
            // on polderside ditch, so extra move
            Assert.AreEqual(89.9, nwoSurf.DetermineNewFitPostionX(104.5, true));
            // in ditch, so extra move
            Assert.AreEqual(89.9, nwoSurf.DetermineNewFitPostionX(103, true));
            // on dikeside ditch, so extra move
            Assert.AreEqual(89.9, nwoSurf.DetermineNewFitPostionX(90.5, true));
            // left off ditch, no extra move
            Assert.AreEqual(89.5, nwoSurf.DetermineNewFitPostionX(90, true));
            nwoSurf.GridPosition = MStabGridPosition.Left;
            nwoSurf.StepSizeX = 1.5;
            Assert.AreEqual(2.5, nwoSurf.DetermineNewFitPostionX(1, true));
        }

        [Test]
        public void TestFitNonWaterRetainingObjectInSurfaceLineSimplePolderSide()
        {
            nwoSurf.GridPosition = MStabGridPosition.Right;
            using (SurfaceLine2 surfaceLine = nwoSurf.FitNonWaterRetainingObjectInSurfaceLine(109))
            {
                Assert.AreEqual(119, surfaceLine.Geometry.Points[surfaceLine.Geometry.Count - 2].X);
                Assert.AreEqual(115, surfaceLine.Geometry.Points[surfaceLine.Geometry.Count - 3].X);
                Assert.AreEqual(-2, surfaceLine.Geometry.Points[surfaceLine.Geometry.Count - 3].Z);
            }
        }

        [Test]
        public void AreCharacteristicsPointsAddedCorrect()
        {
            nwoSurf.GridPosition = MStabGridPosition.Right;
            using (SurfaceLine2 surfaceLine = nwoSurf.FitNonWaterRetainingObjectInSurfaceLine(109))
            {
                Assert.IsTrue(surfaceLine.IsCharacteristicPoint(surfaceLine.Geometry.Points[surfaceLine.Geometry.Count - 2]));
                Assert.AreEqual(true, surfaceLine.IsCharacteristicPoint(surfaceLine.Geometry.Points[surfaceLine.Geometry.Count - 3]));
                Assert.AreEqual(true, surfaceLine.IsCharacteristicPoint(surfaceLine.Geometry.Points[surfaceLine.Geometry.Count - 4]));
                Assert.AreEqual(true, surfaceLine.IsCharacteristicPoint(surfaceLine.Geometry.Points[surfaceLine.Geometry.Count - 5]));
            }
        }

        [Test]
        public void TestFitNonWaterRetainingObjectInSurfaceLineSimplePolderSideFail()
        {
            nwoSurf.GridPosition = MStabGridPosition.Right;
            using (SurfaceLine2 surfaceLine = nwoSurf.FitNonWaterRetainingObjectInSurfaceLine(85.9))
            {
                Assert.AreEqual(null, surfaceLine);            
            }
        }

        [Test]
        public void TestFitNonWaterRetainingObjectInSurfaceLineRotateAntiClockwisePolderSide()
        {
            nwoSurf.GridPosition = MStabGridPosition.Right;
            SurfaceLine2 oldSurfaceLine = nwoSurf.SurfaceLine;
            oldSurfaceLine.Geometry.Points[oldSurfaceLine.Geometry.Count - 1].Z = 2.1064399613983336555444233185555;
            var validationError = oldSurfaceLine.Validate().FirstOrDefault(vr => vr.MessageType == ValidationResultType.Error);
            if (validationError != null)
            {
                throw new SurfaceLineException(validationError.Text);
            }
            using (SurfaceLine2 surfaceLine = nwoSurf.FitNonWaterRetainingObjectInSurfaceLine(109))
            {
                Assert.AreEqual(118.914, surfaceLine.Geometry.Points[surfaceLine.Geometry.Count - 2].X, GeometryPoint.Precision);
                Assert.AreEqual(1.964, surfaceLine.Geometry.Points[surfaceLine.Geometry.Count - 2].Z, GeometryPoint.Precision);
                Assert.AreEqual(115.210, surfaceLine.Geometry.Points[surfaceLine.Geometry.Count - 3].X, GeometryPoint.Precision);
                Assert.AreEqual(-0.541, surfaceLine.Geometry.Points[surfaceLine.Geometry.Count - 3].Z, GeometryPoint.Precision);
                Assert.AreEqual(113.227, surfaceLine.Geometry.Points[surfaceLine.Geometry.Count - 4].X, GeometryPoint.Precision);
                Assert.AreEqual(-0.803, surfaceLine.Geometry.Points[surfaceLine.Geometry.Count - 4].Z, GeometryPoint.Precision);
                Assert.AreEqual(109, surfaceLine.Geometry.Points[surfaceLine.Geometry.Count - 5].X, GeometryPoint.Precision);
                Assert.AreEqual(0.658, surfaceLine.Geometry.Points[surfaceLine.Geometry.Count - 5].Z, GeometryPoint.Precision);
            }
        }

        [Test]
        public void TestFitNonWaterRetainingObjectInSurfaceLineRotateClockwisePolderSide()
        {
            nwoSurf.GridPosition = MStabGridPosition.Right;
            SurfaceLine2 oldSurfaceLine = nwoSurf.SurfaceLine;
            oldSurfaceLine.Geometry.Points[oldSurfaceLine.Geometry.Count - 1].Z = -2.1064399613983336555444233185555;
            var validationError = oldSurfaceLine.Validate().FirstOrDefault(vr => vr.MessageType == ValidationResultType.Error);
            if (validationError != null)
            {
                throw new SurfaceLineException(validationError.Text);
            }
            using (SurfaceLine2 surfaceLine = nwoSurf.FitNonWaterRetainingObjectInSurfaceLine(109))
            {
                Assert.AreEqual(118.914, surfaceLine.Geometry.Points[surfaceLine.Geometry.Count - 2].X, GeometryPoint.Precision);
                Assert.AreEqual(-1.964, surfaceLine.Geometry.Points[surfaceLine.Geometry.Count - 2].Z, GeometryPoint.Precision);
                Assert.AreEqual(114.688, surfaceLine.Geometry.Points[surfaceLine.Geometry.Count - 3].X, GeometryPoint.Precision);
                Assert.AreEqual(-3.424, surfaceLine.Geometry.Points[surfaceLine.Geometry.Count - 3].Z, GeometryPoint.Precision);
                Assert.AreEqual(112.705, surfaceLine.Geometry.Points[surfaceLine.Geometry.Count - 4].X, GeometryPoint.Precision);
                Assert.AreEqual(-3.163, surfaceLine.Geometry.Points[surfaceLine.Geometry.Count - 4].Z, GeometryPoint.Precision);
                Assert.AreEqual(109, surfaceLine.Geometry.Points[surfaceLine.Geometry.Count - 5].X, GeometryPoint.Precision);
                Assert.AreEqual(-0.658, surfaceLine.Geometry.Points[surfaceLine.Geometry.Count - 5].Z, GeometryPoint.Precision);
            }
        }

        [Test]
        public void TestFitNonWaterRetainingObjectInSurfaceLineOnBottomDitchPolderPoint()
        {
            nwoSurf.GridPosition = MStabGridPosition.Right;
            using (SurfaceLine2 surfaceLine = nwoSurf.FitNonWaterRetainingObjectInSurfaceLine(103))
            {
                Assert.AreEqual(112.887, surfaceLine.Geometry.Points[surfaceLine.Geometry.Count - 2].X, GeometryPoint.Precision);
                Assert.AreEqual(0, surfaceLine.Geometry.Points[surfaceLine.Geometry.Count - 2].Z, GeometryPoint.Precision);
                Assert.AreEqual(109.232, surfaceLine.Geometry.Points[surfaceLine.Geometry.Count - 3].X, GeometryPoint.Precision);
                Assert.AreEqual(-2.578, surfaceLine.Geometry.Points[surfaceLine.Geometry.Count - 3].Z, GeometryPoint.Precision);
                Assert.AreEqual(107.255, surfaceLine.Geometry.Points[surfaceLine.Geometry.Count - 4].X, GeometryPoint.Precision);
                Assert.AreEqual(-2.878, surfaceLine.Geometry.Points[surfaceLine.Geometry.Count - 4].Z, GeometryPoint.Precision);
                Assert.AreEqual(103, surfaceLine.Geometry.Points[surfaceLine.Geometry.Count - 5].X, GeometryPoint.Precision);
                Assert.AreEqual(-1.5, surfaceLine.Geometry.Points[surfaceLine.Geometry.Count - 5].Z, GeometryPoint.Precision);
            }
        }

        [Test]
        public void TestFitNonWaterRetainingObjectInSurfaceLineSimpleRiverSide()
        {
            nwoSurf.GridPosition = MStabGridPosition.Left;
            using (SurfaceLine2 surfaceLine = nwoSurf.FitNonWaterRetainingObjectInSurfaceLine(1))
            {
                Assert.AreEqual(11, surfaceLine.Geometry.Points[4].X);
                Assert.AreEqual(7, surfaceLine.Geometry.Points[3].X);
                Assert.AreEqual(-2, surfaceLine.Geometry.Points[3].Z);
            }
        }

        [Test]
        public void TestFitNonWaterRetainingObjectInSurfaceLineSimpleRiverSideFail()
        {
            nwoSurf.GridPosition = MStabGridPosition.Left;
            using (SurfaceLine2 surfaceLine = nwoSurf.FitNonWaterRetainingObjectInSurfaceLine(40.1))
            {
                Assert.AreEqual(null, surfaceLine);
            }
        }

        [Test]
        public void TestFitNonWaterRetainingObjectInSurfaceLineRotateAntiClockwiseRiverSide()
        {
            nwoSurf.GridPosition = MStabGridPosition.Left;
            SurfaceLine2 oldSurfaceLine = nwoSurf.SurfaceLine;
            oldSurfaceLine.Geometry.Points[0].Z = -2.1064399613983336555444233185555;
            var validationError = oldSurfaceLine.Validate().FirstOrDefault(vr => vr.MessageType == ValidationResultType.Error);
            if (validationError != null)
            {
                throw new SurfaceLineException(validationError.Text);
            }
            using (SurfaceLine2 surfaceLine = nwoSurf.FitNonWaterRetainingObjectInSurfaceLine(1))
            {
                Assert.AreEqual(1, surfaceLine.Geometry.Points[1].X, GeometryPoint.Precision);
                Assert.AreEqual(-1.896, surfaceLine.Geometry.Points[1].Z, GeometryPoint.Precision);
                Assert.AreEqual(5.307, surfaceLine.Geometry.Points[2].X, GeometryPoint.Precision);
                Assert.AreEqual(-3.101, surfaceLine.Geometry.Points[2].Z, GeometryPoint.Precision);
                Assert.AreEqual(7.270, surfaceLine.Geometry.Points[3].X, GeometryPoint.Precision);
                Assert.AreEqual(-2.722, surfaceLine.Geometry.Points[3].Z, GeometryPoint.Precision);
                Assert.AreEqual(10.819, surfaceLine.Geometry.Points[4].X, GeometryPoint.Precision);
                Assert.AreEqual(0, surfaceLine.Geometry.Points[4].Z, GeometryPoint.Precision);
            }
        }

        [Test]
        public void TestFitNonWaterRetainingObjectInSurfaceLineRotateClockwiseRiverSide()
        {
            nwoSurf.GridPosition = MStabGridPosition.Left;
            SurfaceLine2 oldSurfaceLine = nwoSurf.SurfaceLine;
            oldSurfaceLine.Geometry.Points[0].Z = 2.1064399613983336555444233185555;
            var validationError = oldSurfaceLine.Validate().FirstOrDefault(vr => vr.MessageType == ValidationResultType.Error);
            if (validationError != null)
            {
                throw new SurfaceLineException(validationError.Text);
            }
            using (SurfaceLine2 surfaceLine = nwoSurf.FitNonWaterRetainingObjectInSurfaceLine(1))
            {
                Assert.AreEqual(1, surfaceLine.Geometry.Points[1].X, GeometryPoint.Precision);
                Assert.AreEqual(1.896, surfaceLine.Geometry.Points[1].Z, GeometryPoint.Precision);
                Assert.AreEqual(4.548, surfaceLine.Geometry.Points[2].X, GeometryPoint.Precision);
                Assert.AreEqual(-0.826, surfaceLine.Geometry.Points[2].Z, GeometryPoint.Precision);
                Assert.AreEqual(6.512, surfaceLine.Geometry.Points[3].X, GeometryPoint.Precision);
                Assert.AreEqual(-1.205, surfaceLine.Geometry.Points[3].Z, GeometryPoint.Precision);
                Assert.AreEqual(10.819, surfaceLine.Geometry.Points[4].X, GeometryPoint.Precision);
                Assert.AreEqual(0, surfaceLine.Geometry.Points[4].Z, GeometryPoint.Precision);
            }
        }
    }
}