// Copyright (C) Stichting Deltares 2018. All rights reserved.
//
// This file is part of the Dam Engine.
//
// The Dam Engine is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// All names, logos, and references to "Deltares" are registered trademarks of
// Stichting Deltares and remain full property of Stichting Deltares at all times.
// All rights reserved.

using System;
using System.Collections.Generic;
using System.Linq;
using Deltares.DamEngine.Calculators.PlLinesCreator;
using Deltares.DamEngine.Data.General;
using Deltares.DamEngine.Data.General.PlLines;
using Deltares.DamEngine.Data.General.Sensors;
using Deltares.DamEngine.Data.Geometry;
using Deltares.DamEngine.Data.Geotechnics;
using NUnit.Framework;

namespace Deltares.DamEngine.Calculators.Tests.Sensors
{
    [TestFixture]
    public class SensorPlLineCreatorTest
    {
        #region Setup

        [TestFixtureSetUp]
        public void FixtureSetup()
        {
        }

        [TestFixtureTearDown]
        public void FixtureTearDown()
        {
        }

        [SetUp]
        public void TestSetup()
        {

        }

        [TearDown]
        public void TestTearDown()
        {

        }

        #endregion

        [Test]
        [ExpectedException(typeof(PlLinesCreatorException))]
        public void CreatePlLine_Pl1NoSensorData_Throws()
        {
            // setup
            var location = new Location("test");
            SensorLocation sensorLocation = new SensorFactory().CreateSensorLocation(location);
            var creator = SensorPlLineCreator.CreateInstance(sensorLocation, new Dictionary<Sensor, double>());

            // call
            creator.CreatePlLine(PlLineType.Pl1);
        }

        [Test] // Pl2 is not yet supported
        [ExpectedException(typeof(NotSupportedException))]
        public void CreatePlLine_Pl2_ThrowsNotSupported()
        {
            // setup
            var location = new Location("test");
            SensorLocation sensorLocation = new SensorFactory().CreateSensorLocation(location);
            var creator = SensorPlLineCreator.CreateInstance(sensorLocation, new Dictionary<Sensor, double>());

            // call
            creator.CreatePlLine(PlLineType.Pl2);
        }

        [Test]
        [ExpectedException(typeof(PlLinesCreatorException))]
        public void CreatePlLine_Pl3NoSensorData_Throws()
        {
            // setup
            var location = new Location("test");
            SensorLocation sensorLocation = new SensorFactory().CreateSensorLocation(location);
            var creator = SensorPlLineCreator.CreateInstance(sensorLocation, new Dictionary<Sensor, double>());

            // call
            creator.CreatePlLine(PlLineType.Pl3);
        }

        [Test]
        [ExpectedException(typeof(PlLinesCreatorException))]
        public void CreatePlLine_Pl4NoSensorData_Throws()
        {
            // setup
            var location = new Location("test");
            SensorLocation sensorLocation = new SensorFactory().CreateSensorLocation(location);
            var creator = SensorPlLineCreator.CreateInstance(sensorLocation, new Dictionary<Sensor, double>());

            // call
            creator.CreatePlLine(PlLineType.Pl4);
        }

        [Test]
        public void CreatePlLine_AllPlLinesDummyTest_ResultsAreAsExpected()
        {
            // setup
            var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints = { GeometryMustContainPoint = true },
                Geometry = new GeometryPointString()
            };
            var location = new Location("test")
            {
                RiverLevel = 1,
                PolderLevel = 1
            };
            location.AddNewSensorData();
            location.SensorData.Pl1PlLineOffsetBelowDikeToeAtPolder = DataSourceTypeSensors.LocationData;
            location.SensorData.Pl1PlLineOffsetBelowDikeTopAtPolder = DataSourceTypeSensors.LocationData;
            location.SensorData.Pl1PlLineOffsetBelowDikeTopAtRiver = DataSourceTypeSensors.LocationData;
            location.SensorData.Pl1PlLineOffsetBelowShoulderBaseInside = DataSourceTypeSensors.LocationData;

            // create dike with ditch


            surfaceLine.EnsurePointOfType(0.0, 0.0, CharacteristicPointType.SurfaceLevelOutside);
            surfaceLine.EnsurePointOfType(50.0, 0.0, CharacteristicPointType.DikeToeAtRiver);
            surfaceLine.EnsurePointOfType(85.0, 8.0, CharacteristicPointType.DikeTopAtRiver);
            surfaceLine.EnsurePointOfType(95.0, 8.0, CharacteristicPointType.DikeTopAtPolder);
            surfaceLine.EnsurePointOfType(108.0, 4.0, CharacteristicPointType.ShoulderBaseInside);
            surfaceLine.EnsurePointOfType(116.0, 3.0, CharacteristicPointType.ShoulderTopInside);
            surfaceLine.EnsurePointOfType(121.0, 0.0, CharacteristicPointType.DikeToeAtPolder);
            surfaceLine.EnsurePointOfType(190.0, 0.0, CharacteristicPointType.SurfaceLevelInside);

            location.SurfaceLine = surfaceLine;

            var sensor1 = new Sensor { ID = 1, Name = "Test1", Depth = 2, RelativeLocation = 50, PlLineMappings = new[] { PlLineType.Pl1 }, Type = SensorType.WaterLevel };
            var sensor2 = new Sensor { ID = 2, Name = "Test2", Depth = 2, RelativeLocation = 90, PlLineMappings = new[] { PlLineType.Pl1 } };
            var sensor3 = new Sensor { ID = 3, Name = "Test3", Depth = 2, RelativeLocation = 104, PlLineMappings = new[] { PlLineType.Pl1 } };
            var sensor4 = new Sensor { ID = 4, Name = "Test4", Depth = 2, RelativeLocation = 123.3, PlLineMappings = new[] { PlLineType.Pl1 } };
            var sensor5 = new Sensor { ID = 5, Name = "Test5", Depth = 2, RelativeLocation = 90, PlLineMappings = new[] { PlLineType.Pl3, PlLineType.Pl4 } };
            var sensor6 = new Sensor { ID = 6, Name = "Test6", Depth = 2, RelativeLocation = 123.3, PlLineMappings = new[] { PlLineType.Pl3, PlLineType.Pl4 } };
            var sensor7 = new Sensor { ID = 7, Name = "Test7", Depth = 2, RelativeLocation = 180, PlLineMappings = new[] { PlLineType.Pl3, PlLineType.Pl4 } };

            var repository = new SensorRepository(location);

            repository.Add(sensor1);
            repository.Add(sensor2);
            repository.Add(sensor3);
            repository.Add(sensor4);
            repository.Add(sensor5);
            repository.Add(sensor6);
            repository.Add(sensor7);

            IDictionary<Sensor, double> sensorValues = new Dictionary<Sensor, double>()
                                                      {
                                                          {sensor1, 1},
                                                          {sensor2, 1},
                                                          {sensor3, 1},
                                                          {sensor4, 1},
                                                          {sensor5, 1},
                                                          {sensor6, 1},
                                                          {sensor7, 1},
                                                      };

            var sensorLocation = location.SensorData;

            var creator = new SensorPlLine1Creator(sensorLocation, sensorValues);

            // call
            PlLine actual = creator.CreatePlLine();

            // asserts

            // Number of expected points in line
            var expectedCount = repository.Sensors.Count(s => s.PlLineMappings.Contains(PlLineType.Pl1)) + 2 + 4; // interection + end + 4 configured characteristic points
            Assert.AreEqual(expectedCount, actual.Points.Count);

            // P1
            var p1 = actual.Points.First();
            Assert.IsNotNull(p1);
            var expectedZValueP1 = sensorValues[sensor1];
            Assert.AreEqual(expectedZValueP1, p1.Z);

            // P2
            var p2 = actual.Points.FirstOrDefault(p => p.Name == sensor2.Name);
            Assert.IsNotNull(p2);
            Assert.AreEqual(sensor2.RelativeLocation, p2.X);
            var expectedZValueP2 = sensorValues[sensor2];
            Assert.AreEqual(expectedZValueP2, p2.Z);

            // P3
            var p3 = actual.Points.FirstOrDefault(p => p.Name == sensor3.Name);
            Assert.IsNotNull(p3);
            Assert.AreEqual(sensor3.RelativeLocation, p3.X);
            var expectedZValueP3 = sensorValues[sensor3];
            Assert.AreEqual(expectedZValueP3, p3.Z);

            // P4
            var p4 = actual.Points.FirstOrDefault(p => p.Name == sensor4.Name);
            Assert.IsNotNull(p4);
            Assert.AreEqual(sensor4.RelativeLocation, p4.X);
            var expectedZValueP4 = sensorValues[sensor4];
            Assert.AreEqual(expectedZValueP4, p4.Z);
        }

        [Test]
        public void CreatePlLine_Pl1DikeToeAtPolderToSurfaceLevelInside_ZValueShouldBePolderLevel()
        {
            // setup
            const double polderLevel = -0.5;
            const double expectedEndPoint = -0.1; // Is not polderlevel, but level under toe of dike inward
            var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints =
                {
                    GeometryMustContainPoint = true
                },
                Geometry = new GeometryPointString()
            };
            var location = new Location("test")
            {
                RiverLevel = 5,
                PolderLevel = polderLevel
            };
            location.AddNewSensorData();
            location.SensorData.Pl1PlLineOffsetBelowDikeToeAtPolder = DataSourceTypeSensors.LocationData;
            location.SensorData.Pl1PlLineOffsetBelowDikeTopAtPolder = DataSourceTypeSensors.LocationData;
            location.SensorData.Pl1PlLineOffsetBelowDikeTopAtRiver = DataSourceTypeSensors.LocationData;
            location.SensorData.Pl1PlLineOffsetBelowShoulderBaseInside = DataSourceTypeSensors.LocationData;

            // create dike with ditch

            surfaceLine.EnsurePointOfType(0.0, 0.0, CharacteristicPointType.SurfaceLevelOutside);
            surfaceLine.EnsurePointOfType(50.0, 0.0, CharacteristicPointType.DikeToeAtRiver);
            surfaceLine.EnsurePointOfType(85.0, 8.0, CharacteristicPointType.DikeTopAtRiver);
            surfaceLine.EnsurePointOfType(95.0, 8.0, CharacteristicPointType.DikeTopAtPolder);
            surfaceLine.EnsurePointOfType(108.0, 4.0, CharacteristicPointType.ShoulderBaseInside);
            surfaceLine.EnsurePointOfType(116.0, 3.0, CharacteristicPointType.ShoulderTopInside);
            surfaceLine.EnsurePointOfType(121.0, 0.0, CharacteristicPointType.DikeToeAtPolder);
            surfaceLine.EnsurePointOfType(190.0, 0.0, CharacteristicPointType.SurfaceLevelInside);

            location.SurfaceLine = surfaceLine;

            var sensor1 = new Sensor { ID = 1, Name = "Test1", Depth = 2, RelativeLocation = 50, PlLineMappings = new[] { PlLineType.Pl1 }, Type = SensorType.WaterLevel };
            var sensor2 = new Sensor { ID = 2, Name = "Test2", Depth = 2, RelativeLocation = 90, PlLineMappings = new[] { PlLineType.Pl1 } };
            var sensor3 = new Sensor { ID = 3, Name = "Test3", Depth = 2, RelativeLocation = 104, PlLineMappings = new[] { PlLineType.Pl1 } };
            var sensor4 = new Sensor { ID = 4, Name = "Test4", Depth = 2, RelativeLocation = 123.3, PlLineMappings = new[] { PlLineType.Pl1 } };

            var repository = new SensorRepository(location);

            repository.Add(sensor1);
            repository.Add(sensor2);
            repository.Add(sensor3);
            repository.Add(sensor4);

            IDictionary<Sensor, double> sensorValues = new Dictionary<Sensor, double>()
                                                      {
                                                          {sensor1, 1},
                                                          {sensor2, 1},
                                                          {sensor3, 1},
                                                          {sensor4, 1},
                                                      };

            var sensorLocation = location.SensorData;

            var creator = new SensorPlLine1Creator(sensorLocation, sensorValues);

            // call
            PlLine actual = creator.CreatePlLine();

            // asserts
            var lastPoint = actual.Points.Last();
            Assert.AreEqual(expectedEndPoint, lastPoint.Z);
        }

        [Test, Ignore("Test must be reviewed.")]
        public void CreatePlLine_Pl1DikeToeAtPolderToSurfaceLevelInsideAndNoLocationData_ZValueShouldBeSurfaceLevel()
        {
            // setup
            const int expectedValue = 1;
            var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints = { GeometryMustContainPoint = true },
                Geometry = new GeometryPointString()
            };
            var location = new Location("test")
            {
                RiverLevel = 5,
                PolderLevel = -1
            };
            location.AddNewSensorData();
            location.SensorData.Pl1PlLineOffsetBelowDikeTopAtRiver = DataSourceTypeSensors.LocationData;
            location.SensorData.Pl1PlLineOffsetBelowDikeTopAtPolder = DataSourceTypeSensors.LocationData;
            location.SensorData.Pl1PlLineOffsetBelowShoulderBaseInside = DataSourceTypeSensors.LocationData;
            location.SensorData.Pl1PlLineOffsetBelowDikeToeAtPolder = DataSourceTypeSensors.Sensor;

            surfaceLine.EnsurePointOfType(0.0, 0.0, CharacteristicPointType.SurfaceLevelOutside);
            surfaceLine.EnsurePointOfType(50.0, 0.0, CharacteristicPointType.DikeToeAtRiver);
            surfaceLine.EnsurePointOfType(85.0, 8.0, CharacteristicPointType.DikeTopAtRiver);
            surfaceLine.EnsurePointOfType(95.0, 8.0, CharacteristicPointType.DikeTopAtPolder);
            surfaceLine.EnsurePointOfType(108.0, 4.0, CharacteristicPointType.ShoulderBaseInside);
            surfaceLine.EnsurePointOfType(116.0, 3.0, CharacteristicPointType.ShoulderTopInside);
            surfaceLine.EnsurePointOfType(121.0, 0.0, CharacteristicPointType.DikeToeAtPolder);
            surfaceLine.EnsurePointOfType(190.0, expectedValue, CharacteristicPointType.SurfaceLevelInside);

            location.SurfaceLine = surfaceLine;

            var sensor1 = new Sensor { ID = 1, Name = "Test1", Depth = 2, RelativeLocation = 50, PlLineMappings = new[] { PlLineType.Pl1 }, Type = SensorType.WaterLevel };
            var sensor2 = new Sensor { ID = 2, Name = "Test2", Depth = 2, RelativeLocation = 90, PlLineMappings = new[] { PlLineType.Pl1 } };
            var sensor3 = new Sensor { ID = 3, Name = "Test3", Depth = 2, RelativeLocation = 104, PlLineMappings = new[] { PlLineType.Pl1 } };
            var sensor4 = new Sensor { ID = 4, Name = "Test4", Depth = 2, RelativeLocation = 123.3, PlLineMappings = new[] { PlLineType.Pl1 } };

            var repository = new SensorRepository(location);

            repository.Add(sensor1);
            repository.Add(sensor2);
            repository.Add(sensor3);
            repository.Add(sensor4);

            IDictionary<Sensor, double> sensorValues = new Dictionary<Sensor, double>()
                                                      {
                                                          {sensor1, 1},
                                                          {sensor2, 1},
                                                          {sensor3, 1},
                                                          {sensor4, 1},
                                                      };

            var sensorLocation = location.SensorData;

            var creator = new SensorPlLine1Creator(sensorLocation, sensorValues);

            // call
            PlLine actual = creator.CreatePlLine();

            // asserts
            var lastPoint = actual.Points.Last();
            Assert.AreEqual(expectedValue, lastPoint.Z);
        }

        [Test]
        public void GetDitchWaterLevelIntersectionAtXDikeSide_PolderLevelIntersectsInDitch_ShouldReturnIntersectionValue()
        {
            // setup
            var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints =
                {
                    GeometryMustContainPoint = true
                },
                Geometry = new GeometryPointString()
            };
            var location = new Location();
            surfaceLine.EnsurePointOfType(0.0, 0.0, CharacteristicPointType.SurfaceLevelOutside);
            surfaceLine.EnsurePointOfType(10, 0.0, CharacteristicPointType.DitchDikeSide);
            surfaceLine.EnsurePointOfType(15, -5, CharacteristicPointType.BottomDitchDikeSide);
            surfaceLine.EnsurePointOfType(17, -5, CharacteristicPointType.BottomDitchPolderSide);
            surfaceLine.EnsurePointOfType(20, 0.0, CharacteristicPointType.DitchPolderSide);
            surfaceLine.EnsurePointOfType(25, 0.0, CharacteristicPointType.SurfaceLevelInside);

            location.AddNewSensorData();
            location.SurfaceLine = surfaceLine;

            var creator = new SensorPlLine1Creator(location.SensorData, new Dictionary<Sensor, double>());
            var actual = creator.GetDitchWaterLevelIntersectionAtXDikeSide(-2.5);
            const double expected = 12.5;
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void CreatePlLine_Pl1IgnorAllSensors_ResultsAreAsExpected()
        {
            // setup
            var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints =
                {
                    GeometryMustContainPoint = true
                },
                Geometry = new GeometryPointString()
            };
            var location = new Location("test")
            {
                RiverLevel = 1,
                PolderLevel = 1
            };
            location.AddNewSensorData();
            location.SensorData.Pl1PlLineOffsetBelowDikeToeAtPolder = DataSourceTypeSensors.Ignore;
            location.SensorData.Pl1PlLineOffsetBelowDikeTopAtPolder = DataSourceTypeSensors.Ignore;
            location.SensorData.Pl1PlLineOffsetBelowDikeTopAtRiver = DataSourceTypeSensors.Ignore;
            location.SensorData.Pl1PlLineOffsetBelowShoulderBaseInside = DataSourceTypeSensors.Ignore;
            location.SensorData.Pl1WaterLevelAtRiver = DataSourceTypeSensors.LocationData;
            location.SensorData.Pl1WaterLevelAtPolder = DataSourceTypeSensors.LocationData;

            // Assert.IsTrue(location.SensorData.IsValid());

            surfaceLine.EnsurePointOfType(0.0, 0.0, CharacteristicPointType.SurfaceLevelOutside);
            surfaceLine.EnsurePointOfType(50.0, 0.0, CharacteristicPointType.DikeToeAtRiver);
            surfaceLine.EnsurePointOfType(80.0, 5.0, CharacteristicPointType.DikeTopAtRiver);
            surfaceLine.EnsurePointOfType(125, 5.0, CharacteristicPointType.DikeTopAtPolder);
            surfaceLine.EnsurePointOfType(140.0, 0.0, CharacteristicPointType.DikeToeAtPolder);
            surfaceLine.EnsurePointOfType(145.0, 0.0, CharacteristicPointType.ShoulderBaseInside);
            surfaceLine.EnsurePointOfType(190.0, 0.0, CharacteristicPointType.SurfaceLevelInside);

            location.SurfaceLine = surfaceLine;

            var sensor1 = new Sensor { ID = 1, Name = "Test1", Depth = 2, RelativeLocation = 50, PlLineMappings = new[] { PlLineType.Pl1 }, Type = SensorType.WaterLevel };
            var sensor2 = new Sensor { ID = 2, Name = "Test2", Depth = 2, RelativeLocation = 90, PlLineMappings = new[] { PlLineType.Pl1 } };
            var sensor3 = new Sensor { ID = 3, Name = "Test3", Depth = 2, RelativeLocation = 104, PlLineMappings = new[] { PlLineType.Pl1 } };
            var sensor4 = new Sensor { ID = 4, Name = "Test4", Depth = 2, RelativeLocation = 123.3, PlLineMappings = new[] { PlLineType.Pl1 } };
            var sensor5 = new Sensor { ID = 5, Name = "Test5", Depth = 2, RelativeLocation = 90, PlLineMappings = new[] { PlLineType.Pl3, PlLineType.Pl4 } };
            var sensor6 = new Sensor { ID = 6, Name = "Test6", Depth = 2, RelativeLocation = 123.3, PlLineMappings = new[] { PlLineType.Pl3, PlLineType.Pl4 } };
            var sensor7 = new Sensor { ID = 7, Name = "Test7", Depth = 2, RelativeLocation = 180, PlLineMappings = new[] { PlLineType.Pl3, PlLineType.Pl4 } };

            var repository = new SensorRepository(location);

            repository.Add(sensor1);
            repository.Add(sensor2);
            repository.Add(sensor3);
            repository.Add(sensor4);
            repository.Add(sensor5);
            repository.Add(sensor6);
            repository.Add(sensor7);

            IDictionary<Sensor, double> sensorValues = new Dictionary<Sensor, double>()
                                                      {
                                                          {sensor1, 1},
                                                          {sensor2, 1},
                                                          {sensor3, 1},
                                                          {sensor4, 1},
                                                          {sensor5, 1},
                                                          {sensor6, 1},
                                                          {sensor7, 1},
                                                      };

            var sensorLocation = location.SensorData;
            var creator = new SensorPlLine1Creator(sensorLocation, sensorValues);

            // call
            PlLine actual = creator.CreatePlLine();

            // asserts

            // Number of expected points in line
            const int expectedNumberOfCharacteristicPoints = 2;
            var pl1SensorCount = repository.Sensors.Count(s => s.PlLineMappings.Contains(PlLineType.Pl1)) +
                expectedNumberOfCharacteristicPoints + 1; // plus one for the intersection point + one for point below toe of dike
            Assert.AreEqual(pl1SensorCount, actual.Points.Count);

            // P2
            var p2 = actual.Points.FirstOrDefault(p => p.Name == sensor2.Name);
            Assert.IsNotNull(p2);
            Assert.AreEqual(sensor2.RelativeLocation, p2.X);
            var expectedZValueP2 = sensorValues[sensor2];
            Assert.AreEqual(expectedZValueP2, p2.Z);

            // P3
            var p3 = actual.Points.FirstOrDefault(p => p.Name == sensor3.Name);
            Assert.IsNotNull(p3);
            Assert.AreEqual(sensor3.RelativeLocation, p3.X);
            var expectedZValueP3 = sensorValues[sensor3];
            Assert.AreEqual(expectedZValueP3, p3.Z);

            // P4
            var p4 = actual.Points.FirstOrDefault(p => p.Name == sensor4.Name);
            Assert.IsNotNull(p4);
            Assert.AreEqual(sensor4.RelativeLocation, p4.X);
            var expectedZValueP4 = sensorValues[sensor4];
            Assert.AreEqual(expectedZValueP4, p4.Z);
        }

        [Test]
        public void CreatePlLinePl1_DikeHasDitch_ResultsAreAsExpected()
        {
            var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints =
                {
                    GeometryMustContainPoint = true
                },
                Geometry = new GeometryPointString()
            };
            var location = new Location("test")
            {
                RiverLevel = 1, PolderLevel = 1
            };
                #region Setup

                location.AddNewSensorData();
                location.SensorData.Pl1PlLineOffsetBelowDikeToeAtPolder = DataSourceTypeSensors.Ignore;
                location.SensorData.Pl1PlLineOffsetBelowDikeTopAtPolder = DataSourceTypeSensors.Ignore;
                location.SensorData.Pl1PlLineOffsetBelowDikeTopAtRiver = DataSourceTypeSensors.Ignore;
                location.SensorData.Pl1PlLineOffsetBelowShoulderBaseInside = DataSourceTypeSensors.Ignore;
                location.SensorData.Pl1WaterLevelAtRiver = DataSourceTypeSensors.LocationData;
                location.SensorData.Pl1WaterLevelAtPolder = DataSourceTypeSensors.LocationData;

                // Assert.IsTrue(location.SensorData.IsValid());

                surfaceLine.EnsurePointOfType(0.0, 0.0, CharacteristicPointType.SurfaceLevelOutside);
                surfaceLine.EnsurePointOfType(50.0, 0.0, CharacteristicPointType.DikeToeAtRiver);
                surfaceLine.EnsurePointOfType(80.0, 5.0, CharacteristicPointType.DikeTopAtRiver);
                surfaceLine.EnsurePointOfType(125, 5.0, CharacteristicPointType.DikeTopAtPolder);
                surfaceLine.EnsurePointOfType(140.0, 0.0, CharacteristicPointType.DikeToeAtPolder);
                surfaceLine.EnsurePointOfType(148.0, 0.5, CharacteristicPointType.DitchDikeSide);
                surfaceLine.EnsurePointOfType(150.0, -4.0, CharacteristicPointType.BottomDitchDikeSide);
                surfaceLine.EnsurePointOfType(154.0, -4.0, CharacteristicPointType.BottomDitchPolderSide);
                surfaceLine.EnsurePointOfType(158.0, 0.0, CharacteristicPointType.DitchPolderSide);
                surfaceLine.EnsurePointOfType(190.0, 0.0, CharacteristicPointType.SurfaceLevelInside);

                location.SurfaceLine = surfaceLine;

                var sensor1 = new Sensor { ID = 1, Name = "Test1", Depth = 2, RelativeLocation = 50, PlLineMappings = new[] { PlLineType.Pl1 }, Type = SensorType.WaterLevel };
                var sensor2 = new Sensor { ID = 2, Name = "Test2", Depth = 2, RelativeLocation = 90, PlLineMappings = new[] { PlLineType.Pl1 } };
                var sensor3 = new Sensor { ID = 3, Name = "Test3", Depth = 2, RelativeLocation = 104, PlLineMappings = new[] { PlLineType.Pl1 } };
                var sensor4 = new Sensor { ID = 4, Name = "Test4", Depth = 2, RelativeLocation = 128, PlLineMappings = new[] { PlLineType.Pl1 } };

                var repository = new SensorRepository(location);

                repository.Add(sensor1);
                repository.Add(sensor2);
                repository.Add(sensor3);
                repository.Add(sensor4);

                IDictionary<Sensor, double> sensorValues = new Dictionary<Sensor, double>()
                                                      {
                                                          {sensor1, 3},
                                                          {sensor2, 3},
                                                          {sensor3, 3},
                                                          {sensor4, 3},
                                                      };

                var sensorLocation = location.SensorData;
                var creator = new SensorPlLine1Creator(sensorLocation, sensorValues);

                #endregion

                // call
                PlLine actual = creator.CreatePlLine();

                // asserts

                // Number of expected points in line
                var pl1SensorCount = repository.Sensors.Count(s => s.PlLineMappings.Contains(PlLineType.Pl1));
                Assert.AreEqual(pl1SensorCount + 2 /* intersection points */, actual.Points.Count);

                // P2
                var p2 = actual.Points.FirstOrDefault(p => p.Name == sensor2.Name);
                Assert.IsNotNull(p2);
                Assert.AreEqual(sensor2.RelativeLocation, p2.X);
                var expectedZValueP2 = sensorValues[sensor2];
                Assert.AreEqual(expectedZValueP2, p2.Z);

                // P3
                var p3 = actual.Points.FirstOrDefault(p => p.Name == sensor3.Name);
                Assert.IsNotNull(p3);
                Assert.AreEqual(sensor3.RelativeLocation, p3.X);
                var expectedZValueP3 = sensorValues[sensor3];
                Assert.AreEqual(expectedZValueP3, p3.Z);

                // P4
                var p4 = actual.Points.FirstOrDefault(p => p.Name == sensor4.Name);
                Assert.IsNotNull(p4);
                Assert.AreEqual(sensor4.RelativeLocation, p4.X);
                var expectedZValueP4 = sensorValues[sensor4];
                Assert.AreEqual(expectedZValueP4, p4.Z);
        }

        [Test]
        public void CreatePlLine_DikeHasDitchAndSensor_DichLevelIsHorizontal()
        {
            const int polderLevel = 0;
            const int waterLevel = 1;
            var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints =
                {
                    GeometryMustContainPoint = true
                },
                Geometry = new GeometryPointString()
            };
            var location = new Location("test")
            {
                RiverLevel = waterLevel, PolderLevel = polderLevel
            };
                #region Setup

                location.AddNewSensorData();
                location.SensorData.Pl1PlLineOffsetBelowDikeToeAtPolder = DataSourceTypeSensors.Ignore;
                location.SensorData.Pl1PlLineOffsetBelowDikeTopAtPolder = DataSourceTypeSensors.Ignore;
                location.SensorData.Pl1PlLineOffsetBelowDikeTopAtRiver = DataSourceTypeSensors.Ignore;
                location.SensorData.Pl1PlLineOffsetBelowShoulderBaseInside = DataSourceTypeSensors.Ignore;

                location.SensorData.Pl1WaterLevelAtRiver = DataSourceTypeSensors.Sensor;
                location.SensorData.Pl1WaterLevelAtPolder = DataSourceTypeSensors.Sensor;

                // Assert.IsTrue(location.SensorData.IsValid());

                surfaceLine.EnsurePointOfType(0.0, 0.0, CharacteristicPointType.SurfaceLevelOutside);
                surfaceLine.EnsurePointOfType(50.0, 0.0, CharacteristicPointType.DikeToeAtRiver);
                surfaceLine.EnsurePointOfType(80.0, 5.0, CharacteristicPointType.DikeTopAtRiver);
                surfaceLine.EnsurePointOfType(125, 5.0, CharacteristicPointType.DikeTopAtPolder);
                surfaceLine.EnsurePointOfType(140.0, 0.0, CharacteristicPointType.DikeToeAtPolder);
                surfaceLine.EnsurePointOfType(148.0, 0.5, CharacteristicPointType.DitchDikeSide);
                surfaceLine.EnsurePointOfType(150.0, -4.0, CharacteristicPointType.BottomDitchDikeSide);
                surfaceLine.EnsurePointOfType(154.0, -4.0, CharacteristicPointType.BottomDitchPolderSide);
                surfaceLine.EnsurePointOfType(158.0, 0.0, CharacteristicPointType.DitchPolderSide);
                surfaceLine.EnsurePointOfType(190.0, 0.0, CharacteristicPointType.SurfaceLevelInside);

                location.SurfaceLine = surfaceLine;

                var sensor1 = new Sensor { ID = 1, Name = "Test1", Depth = 2, RelativeLocation = 50, PlLineMappings = new[] { PlLineType.Pl1 }, Type = SensorType.WaterLevel };
                var sensor2 = new Sensor { ID = 2, Name = "Test2", Depth = 2, RelativeLocation = 90, PlLineMappings = new[] { PlLineType.Pl1 } };
                var sensor3 = new Sensor { ID = 3, Name = "Test3", Depth = 2, RelativeLocation = 104, PlLineMappings = new[] { PlLineType.Pl1 } };
                var sensor4 = new Sensor { ID = 4, Name = "Test4", Depth = 2, RelativeLocation = 128, PlLineMappings = new[] { PlLineType.Pl1 } };
                var sensor5 = new Sensor { ID = 5, Name = "Test5", Depth = 2, RelativeLocation = 152, PlLineMappings = new[] { PlLineType.Pl1 }, Type = SensorType.PolderLevel };

                var repository = new SensorRepository(location);

                repository.Add(sensor1);
                repository.Add(sensor2);
                repository.Add(sensor3);
                repository.Add(sensor4);
                repository.Add(sensor5);

                IDictionary<Sensor, double> sensorValues = new Dictionary<Sensor, double>()
                                                      {
                                                          {sensor1, waterLevel},
                                                          {sensor2, -1},
                                                          {sensor3, -1},
                                                          {sensor4, -1},
                                                          {sensor5, -1.5}
                                                      };

                var sensorLocation = location.SensorData;

                #endregion

                // call
                var creator = new SensorPlLine1Creator(sensorLocation, sensorValues);
                PlLine actual = creator.CreatePlLine();

                // checks
                var xDitchDikeSide = creator.GetDitchWaterLevelIntersectionAtXDikeSide(sensorValues[sensor5]);
                var xDitchPolderSide = creator.GetDitchWaterLevelIntersectionAtXPolderSide(sensorValues[sensor5]);
                Assert.IsTrue(actual.Points.Any(p => p.X == xDitchDikeSide));

                var zDitchDikeSide = actual.Points.Single(p => p.X == xDitchDikeSide).Z;
                var zDitchPolderSide = actual.Points.Single(p => p.X == xDitchPolderSide).Z;

                Assert.IsTrue(actual.Points.Any(p => p.X == xDitchPolderSide));
                Assert.AreEqual(zDitchDikeSide, zDitchPolderSide);

                var endPoint = actual.Points.Last();

                // End point should be z of x intersection at dike side in ditch (horizontal)        
                Assert.AreEqual(endPoint.Z, zDitchDikeSide);
        }

        [Test]
        public void CreatePlLine_Pl3and4_FirstSegmentShouldBeHorizontalEqualToLocationData()
        {
            // setup
            const double xDikeToeAtRiver = 50.0;
            const double waterLevel = 1.0;

            var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints =
                {
                    GeometryMustContainPoint = true
                },
                Geometry = new GeometryPointString()
            };
            var location = new Location("test")
            {
                RiverLevel = waterLevel, PolderLevel = waterLevel
            };
            {
                location.AddNewSensorData();
                location.SensorData.Pl3 = DataSourceTypeSensors.Sensor;
                location.SensorData.Pl1WaterLevelAtRiver = DataSourceTypeSensors.LocationData;
                location.SensorData.Pl1WaterLevelAtPolder = DataSourceTypeSensors.LocationData;

                // Assert.IsTrue(location.SensorData.IsValid());

                surfaceLine.EnsurePointOfType(0.0, 0.0, CharacteristicPointType.SurfaceLevelOutside);
                surfaceLine.EnsurePointOfType(xDikeToeAtRiver, 0.0, CharacteristicPointType.DikeToeAtRiver);
                surfaceLine.EnsurePointOfType(80.0, 5.0, CharacteristicPointType.DikeTopAtRiver);
                surfaceLine.EnsurePointOfType(125, 5.0, CharacteristicPointType.DikeTopAtPolder);
                surfaceLine.EnsurePointOfType(140.0, 0.0, CharacteristicPointType.DikeToeAtPolder);
                surfaceLine.EnsurePointOfType(145.0, 0.0, CharacteristicPointType.ShoulderBaseInside);
                surfaceLine.EnsurePointOfType(190.0, 0.0, CharacteristicPointType.SurfaceLevelInside);

                location.SurfaceLine = surfaceLine;


                var sensor1 = new Sensor { ID = 1, Name = "Test1", Depth = waterLevel, RelativeLocation = 50, PlLineMappings = new[] { PlLineType.Pl1 }, Type = SensorType.WaterLevel };
                var sensor5 = new Sensor { ID = 5, Name = "Test5", Depth = -8, RelativeLocation = 90, PlLineMappings = new[] { PlLineType.Pl3 } };
                var sensor6 = new Sensor { ID = 6, Name = "Test6", Depth = -8, RelativeLocation = 123.3, PlLineMappings = new[] { PlLineType.Pl3 } };
                var sensor7 = new Sensor { ID = 7, Name = "Test7", Depth = -8, RelativeLocation = 180, PlLineMappings = new[] { PlLineType.Pl3 } };

                var repository = new SensorRepository(location);

                repository.Add(sensor1);
                repository.Add(sensor5);
                repository.Add(sensor6);
                repository.Add(sensor7);

                IDictionary<Sensor, double> sensorValues = new Dictionary<Sensor, double>()
                                                      {
                                                          {sensor1, waterLevel},
                                                          {sensor5, waterLevel},
                                                          {sensor6, waterLevel},
                                                          {sensor7, waterLevel},
                                                      };

                var sensorLocation = location.SensorData;
                var creator = new SensorPlLine3Creator(sensorLocation, sensorValues);

                // call
                PlLine actual = creator.CreatePlLine();

                //checks

                // start first segment
                Assert.AreEqual(-0.0, actual.Points[0].X);
                Assert.AreEqual(waterLevel, actual.Points[0].Z);

                // end of first segment (ends at DikeToeAtRiver)
                Assert.AreEqual(xDikeToeAtRiver, actual.Points[1].X);
                Assert.AreEqual(waterLevel, actual.Points[1].Z);
            }
        }

        [Test]
        public void CreatePlLine_Pl3and4_FirstSegmentShouldBeHorizontalEqualToWaterLevelSensor()
        {
            // setup
            const double xDikeToeAtRiver = 50.0;
            const double waterLevel = -0.25;

            var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints =
                {
                    GeometryMustContainPoint = true
                },
                Geometry = new GeometryPointString()
            };
            var location = new Location("test")
            {
                RiverLevel = 1.0, PolderLevel = 1.0
            };
            {
                location.AddNewSensorData();
                location.SensorData.Pl3 = DataSourceTypeSensors.Sensor;
                location.SensorData.Pl1WaterLevelAtRiver = DataSourceTypeSensors.Sensor;
                location.SensorData.Pl1WaterLevelAtPolder = DataSourceTypeSensors.Sensor;

                // Assert.IsTrue(location.SensorData.IsValid());

                surfaceLine.EnsurePointOfType(0.0, 0.0, CharacteristicPointType.SurfaceLevelOutside);
                surfaceLine.EnsurePointOfType(xDikeToeAtRiver, 0.0, CharacteristicPointType.DikeToeAtRiver);
                surfaceLine.EnsurePointOfType(80.0, 5.0, CharacteristicPointType.DikeTopAtRiver);
                surfaceLine.EnsurePointOfType(125, 5.0, CharacteristicPointType.DikeTopAtPolder);
                surfaceLine.EnsurePointOfType(140.0, 0.0, CharacteristicPointType.DikeToeAtPolder);
                surfaceLine.EnsurePointOfType(145.0, 0.0, CharacteristicPointType.ShoulderBaseInside);
                surfaceLine.EnsurePointOfType(190.0, 0.0, CharacteristicPointType.SurfaceLevelInside);

                location.SurfaceLine = surfaceLine;


                var sensor1 = new Sensor { ID = 1, Name = "Test1", Depth = -0.25, RelativeLocation = 50, PlLineMappings = new[] { PlLineType.Pl1 }, Type = SensorType.WaterLevel };
                var sensor5 = new Sensor { ID = 5, Name = "Test5", Depth = -8, RelativeLocation = 90, PlLineMappings = new[] { PlLineType.Pl3 } };
                var sensor6 = new Sensor { ID = 6, Name = "Test6", Depth = -8, RelativeLocation = 123.3, PlLineMappings = new[] { PlLineType.Pl3 } };
                var sensor7 = new Sensor { ID = 7, Name = "Test7", Depth = -8, RelativeLocation = 180, PlLineMappings = new[] { PlLineType.Pl3 } };

                var repository = new SensorRepository(location);

                repository.Add(sensor1);
                repository.Add(sensor5);
                repository.Add(sensor6);
                repository.Add(sensor7);

                IDictionary<Sensor, double> sensorValues = new Dictionary<Sensor, double>()
                                                      {
                                                          {sensor1, waterLevel},
                                                          {sensor5, 1},
                                                          {sensor6, 1},
                                                          {sensor7, 1},
                                                      };

                var sensorLocation = location.SensorData;
                var creator = new SensorPlLine3Creator(sensorLocation, sensorValues);

                // call
                PlLine actual = creator.CreatePlLine();

                //checks

                // start first segment
                Assert.AreEqual(-0.0, actual.Points[0].X);
                Assert.AreEqual(waterLevel, actual.Points[0].Z);

                // end of first segment (ends at DikeToeAtRiver)
                Assert.AreEqual(xDikeToeAtRiver, actual.Points[1].X);
                Assert.AreEqual(waterLevel, actual.Points[1].Z);
            }
        }
    }
}