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

using System;
using System.Collections.Generic;
using System.Linq;
using Deltares.Dam.Data;
using Deltares.Dam.Data.Sensors;
using Deltares.Geotechnics.GeotechnicalGeometry;
using Deltares.Geotechnics.SurfaceLines;
using NUnit.Framework;

namespace Deltares.Dam.Tests.Sensors
{
    [TestFixture]
    public class SensorLocationTest
    {
        private Location location;

        #region Serialization Tests

        [Test]
        public void SerializeDeserialize_ValidSensorLocation_ShouldBePersitable()
        {
            // setup
            SensorLocation left = CreateValidSensorLocation();

            // call
            string xml = left.Serialize();
            SensorLocation right = SensorLocation.Deserialize(xml);

            // assert
            Assert.That(right.GroupID, Is.EqualTo(left.GroupID));
        }

        #endregion

        #region Helper methods

        /// <summary>
        /// Creates and initializes a valid sensor location for testing.
        /// </summary>
        /// <returns></returns>
        private SensorLocation CreateValidSensorLocation()
        {
            var factory = new SensorFactory();
            SensorLocation sensorLocation = factory.CreateSensorLocation(location);
            Assert.That(sensorLocation.IsValid(), Is.True, "The initialized test sensor location is not valid");
            return sensorLocation;
        }

        #endregion

        #region Setup

        [SetUp]
        public void FixtureSetup() {}

        [TearDown]
        public void FixtureTearDown() {}

        [SetUp]
        public void TestSetup()
        {
            location = new Location();

            location.Scenarios.Add(new Scenario());
        }

        [TearDown]
        public void TestTearDown()
        {
            location.Scenarios.Clear();
            location.Dispose();
        }

        #endregion

        #region Validation Tests

        [Test]
        public void IsValid_InputOuterWaterLevelIsSetToIgnore_ShouldReturnFalse()
        {
            // setup
            SensorLocation sensorLocation = CreateValidSensorLocation();
            sensorLocation.SourceTypePl1WaterLevelAtRiver = DataSourceTypeSensors.Ignore;

            // call
            bool actual = sensorLocation.IsValid();

            // assert
            Assert.That(actual, Is.False);
        }

        [Test]
        public void IsValid_InputOuterWaterLevelIsSetToLocationData_ShouldReturnTrue()
        {
            // setup
            SensorLocation sensorLocation = CreateValidSensorLocation();
            sensorLocation.SourceTypePl1WaterLevelAtRiver = DataSourceTypeSensors.LocationData;

            // call
            bool actual = sensorLocation.IsValid();

            // assert
            Assert.That(actual, Is.True);
        }

        [Test]
        public void IsValid_InputOuterWaterLevelIsSetToSensor_ShouldReturnTrue()
        {
            // setup
            SensorLocation sensorLocation = CreateValidSensorLocation();
            sensorLocation.SourceTypePl1WaterLevelAtRiver = DataSourceTypeSensors.Sensor;

            // call
            bool actual = sensorLocation.IsValid();

            // assert
            Assert.That(actual, Is.True);
        }

        [Test]
        public void IsValid_InputPL1PolderLevelIsSetToIgnore_ShouldReturnFalse()
        {
            // setup
            SensorLocation sensorLocation = CreateValidSensorLocation();
            sensorLocation.SourceTypePl1WaterLevelAtPolder = DataSourceTypeSensors.Ignore;

            // call
            bool actual = sensorLocation.IsValid();

            // assert
            Assert.That(actual, Is.False);
        }

        [Test]
        public void IsValid_InputPL1PolderLevelIsSetToLocationData_ShouldReturnTrue()
        {
            // setup
            SensorLocation sensorLocation = CreateValidSensorLocation();
            sensorLocation.SourceTypePl1WaterLevelAtPolder = DataSourceTypeSensors.LocationData;

            // call
            bool actual = sensorLocation.IsValid();

            // assert
            Assert.That(actual, Is.True);
        }

        [Test]
        public void IsValid_InputPL1PolderLevelIsSetToSensor_ShouldReturnTrue()
        {
            // setup
            SensorLocation sensorLocation = CreateValidSensorLocation();
            sensorLocation.SourceTypePl1WaterLevelAtPolder = DataSourceTypeSensors.Sensor;

            // call
            bool actual = sensorLocation.IsValid();

            // assert
            Assert.That(actual, Is.True);
        }

        [Test]
        public void IsValid_InputPL3IsSetToIgnore_ShouldReturnFalse()
        {
            // setup
            SensorLocation sensorLocation = CreateValidSensorLocation();
            sensorLocation.SourceTypePl3 = DataSourceTypeSensors.Ignore;

            // call
            bool actual = sensorLocation.IsValid();

            // assert
            Assert.That(actual, Is.False);
        }

        [Test]
        public void IsValid_InputPL3IsSetToLocationData_ShouldReturnTrue()
        {
            // setup
            SensorLocation sensorLocation = CreateValidSensorLocation();
            sensorLocation.SourceTypePl3 = DataSourceTypeSensors.LocationData;

            // call
            bool actual = sensorLocation.IsValid();

            // assert
            Assert.That(actual, Is.True);
        }

        [Test]
        public void IsValid_InputPL3IsSetToSensor_ShouldReturnTrue()
        {
            // setup
            SensorLocation sensorLocation = CreateValidSensorLocation();
            sensorLocation.SourceTypePl1WaterLevelAtPolder = DataSourceTypeSensors.Sensor;

            // call
            bool actual = sensorLocation.IsValid();

            // assert
            Assert.That(actual, Is.True);
        }

        [Test]
        public void IsValid_InputPL4IsSetToIgnore_ShouldReturnFalse()
        {
            // setup
            SensorLocation sensorLocation = CreateValidSensorLocation();
            sensorLocation.SourceTypePl4 = DataSourceTypeSensors.Ignore;

            // call
            bool actual = sensorLocation.IsValid();

            // assert
            Assert.That(actual, Is.False);
        }

        [Test]
        public void IsValid_InputPL4IsSetToLocationData_ShouldReturnTrue()
        {
            // setup
            SensorLocation sensorLocation = CreateValidSensorLocation();
            sensorLocation.SourceTypePl4 = DataSourceTypeSensors.LocationData;

            // call
            bool actual = sensorLocation.IsValid();

            // assert
            Assert.That(actual, Is.True);
        }

        [Test]
        public void IsValid_InputPL4IsSetToSensor_ShouldReturnTrue()
        {
            // setup
            SensorLocation sensorLocation = CreateValidSensorLocation();
            sensorLocation.SourceTypePl4 = DataSourceTypeSensors.Sensor;

            // call
            bool actual = sensorLocation.IsValid();

            // assert
            Assert.That(actual, Is.True);
        }

        [Test]
        public void IsValid_InputPL1PLLineOffsetBelowDikeToeAtPolderIsSetToIgnore_ShouldReturnTrue()
        {
            // setup
            SensorLocation sensorLocation = CreateValidSensorLocation();
            sensorLocation.SourceTypePl1PlLineOffsetBelowDikeToeAtPolder = DataSourceTypeSensors.Ignore;

            // call
            bool actual = sensorLocation.IsValid();

            // assert
            Assert.That(actual, Is.True);
        }

        [Test]
        public void IsValid_InputPL1PLLineOffsetBelowDikeToeAtPolderIsSetToLocationData_ShouldReturnTrue()
        {
            // setup
            SensorLocation sensorLocation = CreateValidSensorLocation();
            sensorLocation.SourceTypePl1PlLineOffsetBelowDikeToeAtPolder = DataSourceTypeSensors.LocationData;

            // call
            bool actual = sensorLocation.IsValid();

            // assert
            Assert.That(actual, Is.True);
        }

        [Test]
        public void IsValid_InputPL1PLLineOffsetBelowDikeToeAtPolderIsSetToSensor_ShouldReturnFalse()
        {
            // setup
            SensorLocation sensorLocation = CreateValidSensorLocation();
            sensorLocation.SourceTypePl1PlLineOffsetBelowDikeToeAtPolder = DataSourceTypeSensors.Sensor;

            // call
            bool actual = sensorLocation.IsValid();

            // assert
            Assert.That(actual, Is.False);
        }

        [Test]
        public void IsValid_InputPL1PLLineOffsetBelowDikeTopAtPolderIsSetToIgnore_ShouldReturnTrue()
        {
            // setup
            SensorLocation sensorLocation = CreateValidSensorLocation();
            sensorLocation.SourceTypePl1PlLineOffsetBelowDikeTopAtPolder = DataSourceTypeSensors.Ignore;

            // call
            bool actual = sensorLocation.IsValid();

            // assert
            Assert.That(actual, Is.True);
        }

        [Test]
        public void IsValid_InputPL1PLLineOffsetBelowDikeTopAtPolderIsSetToLocationData_ShouldReturnTrue()
        {
            // setup
            SensorLocation sensorLocation = CreateValidSensorLocation();
            sensorLocation.SourceTypePl1PlLineOffsetBelowDikeTopAtPolder = DataSourceTypeSensors.LocationData;

            // call
            bool actual = sensorLocation.IsValid();

            // assert
            Assert.That(actual, Is.True);
        }

        [Test]
        public void IsValid_InputPL1PLLineOffsetBelowDikeTopAtPolderIsSetToSensor_ShouldReturnFalse()
        {
            // setup
            SensorLocation sensorLocation = CreateValidSensorLocation();
            sensorLocation.SourceTypePl1PlLineOffsetBelowDikeTopAtPolder = DataSourceTypeSensors.Sensor;

            // call
            bool actual = sensorLocation.IsValid();

            // assert
            Assert.That(actual, Is.False);
        }

        [Test]
        public void IsValid_InputPL1PLLineOffsetBelowDikeTopAtRiverIsSetToIgnore_ShouldReturnTrue()
        {
            // setup
            SensorLocation sensorLocation = CreateValidSensorLocation();
            sensorLocation.SourceTypePl1PlLineOffsetBelowDikeTopAtRiver = DataSourceTypeSensors.Ignore;

            // call
            bool actual = sensorLocation.IsValid();

            // assert
            Assert.That(actual, Is.True);
        }

        [Test]
        public void IsValid_InputPL1PLLineOffsetBelowDikeTopAtRiverIsSetToLocationData_ShouldReturnTrue()
        {
            // setup
            SensorLocation sensorLocation = CreateValidSensorLocation();
            sensorLocation.SourceTypePl1PlLineOffsetBelowDikeTopAtRiver = DataSourceTypeSensors.LocationData;

            // call
            bool actual = sensorLocation.IsValid();

            // assert
            Assert.That(actual, Is.True);
        }

        [Test]
        public void IsValid_InputPL1PLLineOffsetBelowDikeTopAtRiverIsSetToSensor_ShouldReturnFalse()
        {
            // setup
            SensorLocation sensorLocation = CreateValidSensorLocation();
            sensorLocation.SourceTypePl1PlLineOffsetBelowDikeTopAtRiver = DataSourceTypeSensors.Sensor;

            // call
            bool actual = sensorLocation.IsValid();

            // assert
            Assert.That(actual, Is.False);
        }

        [Test]
        public void IsValid_InputPL1PLLineOffsetBelowShoulderBaseInsideIsSetToIgnore_ShouldReturnTrue()
        {
            // setup
            SensorLocation sensorLocation = CreateValidSensorLocation();
            sensorLocation.SourceTypePl1PlLineOffsetBelowShoulderBaseInside = DataSourceTypeSensors.Ignore;

            // call
            bool actual = sensorLocation.IsValid();

            // assert
            Assert.That(actual, Is.True);
        }

        [Test]
        public void IsValid_InputPL1PLLineOffsetBelowShoulderBaseInsideIsSetToLocationData_ShouldReturnTrue()
        {
            // setup
            SensorLocation sensorLocation = CreateValidSensorLocation();
            sensorLocation.SourceTypePl1PlLineOffsetBelowShoulderBaseInside = DataSourceTypeSensors.LocationData;

            // call
            bool actual = sensorLocation.IsValid();

            // assert
            Assert.That(actual, Is.True);
        }

        [Test]
        public void IsValid_InputPL1PLLineOffsetBelowShoulderBaseInsideIsSetToSensor_ShouldReturnFalse()
        {
            // setup
            SensorLocation sensorLocation = CreateValidSensorLocation();
            sensorLocation.SourceTypePl1PlLineOffsetBelowShoulderBaseInside = DataSourceTypeSensors.Sensor;

            // call
            bool actual = sensorLocation.IsValid();

            // assert
            Assert.That(actual, Is.False);
        }

        [Test]
        public void IsValid_GroupIsSetToNull_ShouldReturnFalse()
        {
            // setup
            using (var location1 = new Location())
            {
                var sensorLocation = new SensorLocation
                {
                    Group = null,
                    Location = location1,
                    SourceTypePl1WaterLevelAtRiver = DataSourceTypeSensors.LocationData,
                    SourceTypePl1PlLineOffsetBelowDikeToeAtPolder = DataSourceTypeSensors.LocationData,
                    SourceTypePl1PlLineOffsetBelowDikeTopAtPolder = DataSourceTypeSensors.LocationData,
                    SourceTypePl1PlLineOffsetBelowDikeTopAtRiver = DataSourceTypeSensors.LocationData,
                    SourceTypePl1PlLineOffsetBelowShoulderBaseInside = DataSourceTypeSensors.LocationData,
                    SourceTypePl1WaterLevelAtPolder = DataSourceTypeSensors.LocationData,
                    SourceTypePl3 = DataSourceTypeSensors.LocationData,
                    SourceTypePl4 = DataSourceTypeSensors.LocationData
                };

                // call
                bool actual = sensorLocation.IsValid();

                // assert
                Assert.That(actual, Is.False);
            }
        }

        [Test]
        public void IsValid_LocationIsSetToNull_ShouldReturnFalse()
        {
            // setup
            SensorLocation sensorLocation = CreateValidSensorLocation();
            sensorLocation.Location = null;

            // call
            bool actual = sensorLocation.IsValid();

            // assert
            Assert.That(actual, Is.False);
        }

        #endregion

        #region Sensor Or Location Data Value Tests

        [Test]
        public void GetSensorsSortedByRelativeLocationAlongProfile_3SensorsForPL1_PointsAreSortedAsExpected()
        {
            var sensor1 = new Sensor
            {
                RelativeLocation = 10,
                ID = 1,
                Name = "1",
                PLLineMappings = new[]
                {
                    PLLineType.PL1
                }
            };
            var sensor2 = new Sensor
            {
                RelativeLocation = 5,
                ID = 2,
                Name = "2",
                PLLineMappings = new[]
                {
                    PLLineType.PL1
                }
            };
            var sensor3 = new Sensor
            {
                RelativeLocation = 12,
                ID = 3,
                Name = "3",
                PLLineMappings = new[]
                {
                    PLLineType.PL1
                }
            };

            using (var surfaceLine = new SurfaceLine2
                   {
                       CharacteristicPoints =
                       {
                           GeometryMustContainPoint = true
                       },
                       Geometry = new LocalizedGeometryPointString()
                   })
            using (var testLocation = new Location("testLocation")
                   {
                       SurfaceLine2 = surfaceLine
                   })
            {
                testLocation.AddNewSensorData();
                var repository = new SensorRepository(testLocation);
                repository.Add(new[]
                {
                    sensor1,
                    sensor2,
                    sensor3
                });

                testLocation.SensorLocation.SurfaceLine.EnsurePointOfType(0, 0, 0, CharacteristicPointType.SurfaceLevelOutside);

                List<KeyValuePair<double, Sensor>> table = testLocation.SensorLocation.GetSensorsSortedByRelativeLocationAlongProfile(PLLineType.PL1).ToList();

                Assert.That(table.ElementAt(0).Key, Is.EqualTo(5));
                Assert.That(table.ElementAt(1).Key, Is.EqualTo(10));
                Assert.That(table.ElementAt(2).Key, Is.EqualTo(12));

                Assert.That(table[0].Key, Is.EqualTo(5));
                Assert.That(table[1].Key, Is.EqualTo(10));
                Assert.That(table[2].Key, Is.EqualTo(12));

                List<Sensor> sortedSensors =
                    testLocation.SensorLocation.GetSensorsSortedByRelativeLocationAlongProfile(PLLineType.PL1).Select(s => s.Value).ToList();

                Assert.That(sortedSensors[0].RelativeLocation, Is.EqualTo(5));
                Assert.That(sortedSensors[1].RelativeLocation, Is.EqualTo(10));
                Assert.That(sortedSensors[2].RelativeLocation, Is.EqualTo(12));
            }
        }

        [Test]
        public void GetValue_PL1PLLineOffsetBelowDikeToeAtPolderAndDataSourceTypeIgnore_ShouldReturnNull()
        {
            // setup
            var sensor = new Sensor();
            const double sensorValue = 1.1;
            var sensorValues = new Dictionary<Sensor, double>
            {
                {
                    sensor, sensorValue
                }
            };
            SensorLocation sensorLocation = CreateValidSensorLocation();

            sensorLocation.SourceTypePl1PlLineOffsetBelowDikeToeAtPolder = DataSourceTypeSensors.Ignore;

            // call
            double? actualValue = sensorLocation.GetValue(x => x.SourceTypePl1PlLineOffsetBelowDikeToeAtPolder, sensorValues, sensor);

            // assert            
            Assert.That(actualValue, Is.Null);
        }

        [Test]
        public void GetValue_PL1PLLineOffsetBelowDikeToeAtPolderAndDataSourceTypeLocationData_ShouldReturnValue()
        {
            // setup
            var sensor = new Sensor();
            const double testValue = 1.1;
            var sensorValues = new Dictionary<Sensor, double>
            {
                {
                    sensor, testValue
                }
            };
            SensorLocation sensorLocation = CreateValidSensorLocation();

            location.Scenarios[0].PlLineOffsetBelowDikeToeAtPolder = testValue;

            sensorLocation.SourceTypePl1PlLineOffsetBelowDikeToeAtPolder = DataSourceTypeSensors.LocationData;

            // call
            double? actualValue = sensorLocation.GetValue(x => x.SourceTypePl1PlLineOffsetBelowDikeToeAtPolder, sensorValues, sensor);

            // assert            
            Assert.That(actualValue, Is.EqualTo(testValue));
        }

        [Test]
        public void GetValue_PL1PLLineOffsetBelowDikeToeAtPolderAndDataSourceTypeSensor_ShouldReturnNull()
        {
            // setup
            var sensor = new Sensor();
            const double sensorValue = 1.1;
            var sensorValues = new Dictionary<Sensor, double>
            {
                {
                    sensor, sensorValue
                }
            };
            SensorLocation sensorLocation = CreateValidSensorLocation();

            sensorLocation.SourceTypePl1PlLineOffsetBelowDikeToeAtPolder = DataSourceTypeSensors.Sensor;

            // call
            double? actualValue = sensorLocation.GetValue(x => x.SourceTypePl1PlLineOffsetBelowDikeToeAtPolder, sensorValues, sensor);

            // assert            
            Assert.That(actualValue, Is.Null);
        }

        [Test]
        public void GetValue_PL1PLLineOffsetBelowDikeTopAtPolderAndDataSourceTypeIgnore_ShouldReturnNull()
        {
            // setup
            var sensor = new Sensor();
            const double sensorValue = 1.1;
            var sensorValues = new Dictionary<Sensor, double>
            {
                {
                    sensor, sensorValue
                }
            };
            SensorLocation sensorLocation = CreateValidSensorLocation();

            sensorLocation.SourceTypePl1PlLineOffsetBelowDikeTopAtPolder = DataSourceTypeSensors.Ignore;

            // call
            double? actualValue = sensorLocation.GetValue(x => x.SourceTypePl1PlLineOffsetBelowDikeTopAtPolder, sensorValues, sensor);

            // assert            
            Assert.That(actualValue, Is.Null);
        }

        [Test]
        public void GetValue_PL1PLLineOffsetBelowDikeTopAtPolderAndDataSourceTypeLocationData_ShouldReturnValue()
        {
            // setup
            var sensor = new Sensor();
            const double testValue = 1.1;
            var sensorValues = new Dictionary<Sensor, double>
            {
                {
                    sensor, testValue
                }
            };
            SensorLocation sensorLocation = CreateValidSensorLocation();
            location.Scenarios[0].PlLineOffsetBelowDikeTopAtPolder = testValue;

            sensorLocation.SourceTypePl1PlLineOffsetBelowDikeTopAtPolder = DataSourceTypeSensors.LocationData;

            // call
            double? actualValue = sensorLocation.GetValue(x => x.SourceTypePl1PlLineOffsetBelowDikeTopAtPolder, sensorValues, sensor);

            // assert            
            Assert.That(actualValue, Is.EqualTo(testValue));
        }

        [Test]
        public void GetValue_PL1PLLineOffsetBelowDikeTopAtPolderAndDataSourceTypeSensor_ShouldReturnNull()
        {
            // setup
            var sensor = new Sensor();
            const double sensorValue = 1.1;
            var sensorValues = new Dictionary<Sensor, double>
            {
                {
                    sensor, sensorValue
                }
            };
            SensorLocation sensorLocation = CreateValidSensorLocation();

            sensorLocation.SourceTypePl1PlLineOffsetBelowDikeTopAtPolder = DataSourceTypeSensors.Sensor;

            // call
            double? actualValue = sensorLocation.GetValue(x => x.SourceTypePl1PlLineOffsetBelowDikeTopAtPolder, sensorValues, sensor);

            // assert            
            Assert.That(actualValue, Is.Null);
        }

        [Test]
        public void GetValue_PL1PLLineOffsetBelowDikeTopAtRiverAndDataSourceTypeIgnore_ShouldReturnNull()
        {
            // setup
            var sensor = new Sensor();
            const double sensorValue = 1.1;
            var sensorValues = new Dictionary<Sensor, double>
            {
                {
                    sensor, sensorValue
                }
            };
            SensorLocation sensorLocation = CreateValidSensorLocation();

            sensorLocation.SourceTypePl1PlLineOffsetBelowDikeTopAtRiver = DataSourceTypeSensors.Ignore;

            // call
            double? actualValue = sensorLocation.GetValue(x => x.SourceTypePl1PlLineOffsetBelowDikeTopAtRiver, sensorValues, sensor);

            // assert            
            Assert.That(actualValue, Is.Null);
        }

        [Test]
        public void GetValue_PL1PLLineOffsetBelowDikeTopAtRiverAndDataSourceTypeLocationData_ShouldReturnValue()
        {
            // setup
            var sensor = new Sensor();
            const double testValue = 1.1;
            var sensorValues = new Dictionary<Sensor, double>
            {
                {
                    sensor, testValue
                }
            };
            SensorLocation sensorLocation = CreateValidSensorLocation();
            location.Scenarios[0].PlLineOffsetBelowDikeTopAtRiver = testValue;

            sensorLocation.SourceTypePl1PlLineOffsetBelowDikeTopAtRiver = DataSourceTypeSensors.LocationData;

            // call
            double? actualValue = sensorLocation.GetValue(x => x.SourceTypePl1PlLineOffsetBelowDikeTopAtRiver, sensorValues, sensor);

            // assert            
            Assert.That(actualValue, Is.EqualTo(testValue));
        }

        [Test]
        public void GetValue_PL1PLLineOffsetBelowDikeTopAtRiverAndDataSourceTypeSensor_ShouldReturnNull()
        {
            // setup
            var sensor = new Sensor();
            const double sensorValue = 1.1;
            var sensorValues = new Dictionary<Sensor, double>
            {
                {
                    sensor, sensorValue
                }
            };
            SensorLocation sensorLocation = CreateValidSensorLocation();

            sensorLocation.SourceTypePl1PlLineOffsetBelowDikeTopAtRiver = DataSourceTypeSensors.Sensor;

            // call
            double? actualValue = sensorLocation.GetValue(x => x.SourceTypePl1PlLineOffsetBelowDikeTopAtRiver, sensorValues, sensor);

            // assert            
            Assert.That(actualValue, Is.Null);
        }

        [Test]
        public void GetValue_PL1PLLineOffsetBelowShoulderBaseInsideAndDataSourceTypeIgnore_ShouldReturnNull()
        {
            // setup
            var sensor = new Sensor();
            const double sensorValue = 1.1;
            var sensorValues = new Dictionary<Sensor, double>
            {
                {
                    sensor, sensorValue
                }
            };
            SensorLocation sensorLocation = CreateValidSensorLocation();

            sensorLocation.SourceTypePl1PlLineOffsetBelowShoulderBaseInside = DataSourceTypeSensors.Ignore;

            // call
            double? actualValue = sensorLocation.GetValue(x => x.SourceTypePl1PlLineOffsetBelowShoulderBaseInside, sensorValues, sensor);

            // assert            
            Assert.That(actualValue, Is.Null);
        }

        [Test]
        public void GetValue_PL1PLLineOffsetBelowShoulderBaseInsideAndDataSourceTypeLocationData_ShouldReturnValue()
        {
            // setup
            var sensor = new Sensor();
            const double testValue = 1.1;
            var sensorValues = new Dictionary<Sensor, double>
            {
                {
                    sensor, testValue
                }
            };
            SensorLocation sensorLocation = CreateValidSensorLocation();

            location.Scenarios[0].PlLineOffsetBelowShoulderBaseInside = testValue;

            sensorLocation.SourceTypePl1PlLineOffsetBelowShoulderBaseInside = DataSourceTypeSensors.LocationData;

            // call
            double? actualValue = sensorLocation.GetValue(x => x.SourceTypePl1PlLineOffsetBelowShoulderBaseInside, sensorValues, sensor);

            // assert            
            Assert.That(actualValue, Is.EqualTo(testValue));
        }

        [Test]
        public void GetValue_PL1PLLineOffsetBelowShoulderBaseInsideAndDataSourceTypeSensor_ShouldReturnNull()
        {
            // setup
            var sensor = new Sensor();
            const double sensorValue = 1.1;
            var sensorValues = new Dictionary<Sensor, double>
            {
                {
                    sensor, sensorValue
                }
            };
            SensorLocation sensorLocation = CreateValidSensorLocation();

            sensorLocation.SourceTypePl1PlLineOffsetBelowShoulderBaseInside = DataSourceTypeSensors.Sensor;

            // call
            double? actualValue = sensorLocation.GetValue(x => x.SourceTypePl1PlLineOffsetBelowShoulderBaseInside, sensorValues, sensor);

            // assert            
            Assert.That(actualValue, Is.Null);
        }

        [Test]
        public void GetValue_WaterLevelAtPolderAndDataSourceTypeIgnore_ShouldReturnNull()
        {
            // setup
            var sensor = new Sensor();
            const double sensorValue = 1.1;
            var sensorValues = new Dictionary<Sensor, double>
            {
                {
                    sensor, sensorValue
                }
            };
            SensorLocation sensorLocation = CreateValidSensorLocation();

            sensorLocation.SourceTypePl1WaterLevelAtPolder = DataSourceTypeSensors.Ignore;

            // call
            double? actualValue = sensorLocation.GetValue(x => x.SourceTypePl1WaterLevelAtPolder, sensorValues, sensor);

            // assert            
            Assert.That(actualValue, Is.Null);
        }

        [Test]
        public void GetValue_WaterLevelAtPolderAndDataSourceTypeLocationData_ShouldReturnValue()
        {
            // setup
            var random = new Random(21);
            double polderLevel = random.NextDouble();
            location.Scenarios[0].PolderLevel = polderLevel;

            var sensor = new Sensor();
            var sensorValues = new Dictionary<Sensor, double>
            {
                {
                    sensor, random.NextDouble()
                }
            };
            SensorLocation sensorLocation = CreateValidSensorLocation();

            sensorLocation.SourceTypePl1WaterLevelAtPolder = DataSourceTypeSensors.LocationData;

            // call
            double? actualValue = sensorLocation.GetValue(x => x.SourceTypePl1WaterLevelAtPolder, sensorValues, sensor);

            // assert            
            Assert.That(actualValue, Is.EqualTo(polderLevel));
        }

        [Test]
        public void GetValue_WaterLevelAtPolderAndDataSourceTypeSensor_ShouldReturnValue()
        {
            // setup
            var sensor = new Sensor();
            const double expectedValue = 1.1;
            var sensorValues = new Dictionary<Sensor, double>
            {
                {
                    sensor, expectedValue
                }
            };
            SensorLocation sensorLocation = CreateValidSensorLocation();

            sensorLocation.SourceTypePl1WaterLevelAtPolder = DataSourceTypeSensors.Sensor;

            // call
            double? actualValue = sensorLocation.GetValue(x => x.SourceTypePl1WaterLevelAtPolder, sensorValues, sensor);

            // assert            
            Assert.That(actualValue, Is.EqualTo(expectedValue));
        }

        [Test]
        public void GetValue_WaterLevelAtRiverAndDataSourceTypeIgnore_ShouldReturnNull()
        {
            // setup
            var sensor = new Sensor();
            const double sensorValue = 1.1;
            var sensorValues = new Dictionary<Sensor, double>
            {
                {
                    sensor, sensorValue
                }
            };
            SensorLocation sensorLocation = CreateValidSensorLocation();

            sensorLocation.SourceTypePl1WaterLevelAtRiver = DataSourceTypeSensors.Ignore;

            // call
            double? actualValue = sensorLocation.GetValue(x => x.SourceTypePl1WaterLevelAtRiver, sensorValues, sensor);

            // assert            
            Assert.That(actualValue, Is.Null);
        }

        [Test]
        public void GetValue_WaterLevelAtRiverAndDataSourceTypeLocationData_ShouldReturnValue()
        {
            // setup
            var sensor = new Sensor();
            const double testValue = 1.1;
            var sensorValues = new Dictionary<Sensor, double>
            {
                {
                    sensor, testValue
                }
            };
            SensorLocation sensorLocation = CreateValidSensorLocation();

            location.Scenarios[0].RiverLevel = testValue;

            sensorLocation.SourceTypePl1WaterLevelAtRiver = DataSourceTypeSensors.LocationData;

            // call
            double? actualValue = sensorLocation.GetValue(x => x.SourceTypePl1WaterLevelAtRiver, sensorValues, sensor);

            // assert            
            Assert.That(actualValue, Is.EqualTo(testValue));
        }

        [Test]
        public void GetValue_WaterLevelAtRiverAndDataSourceTypeSensor_ShouldReturnValue()
        {
            // setup
            var sensor = new Sensor();
            const double expectedValue = 1.1;
            var sensorValues = new Dictionary<Sensor, double>
            {
                {
                    sensor, expectedValue
                }
            };
            SensorLocation sensorLocation = CreateValidSensorLocation();

            sensorLocation.SourceTypePl1WaterLevelAtRiver = DataSourceTypeSensors.Sensor;

            // call
            double? actualValue = sensorLocation.GetValue(x => x.SourceTypePl1WaterLevelAtRiver, sensorValues, sensor);

            // assert            
            Assert.That(actualValue, Is.EqualTo(expectedValue));
        }

        [Test]
        public void GetValue_PL3AndDataSourceTypeIgnore_ShouldReturnNull()
        {
            // setup
            var sensor = new Sensor();
            const double sensorValue = 1.1;
            var sensorValues = new Dictionary<Sensor, double>
            {
                {
                    sensor, sensorValue
                }
            };
            SensorLocation sensorLocation = CreateValidSensorLocation();

            sensorLocation.SourceTypePl3 = DataSourceTypeSensors.Ignore;

            // call
            double? actualValue = sensorLocation.GetValue(x => x.SourceTypePl3, sensorValues, sensor);

            // assert            
            Assert.That(actualValue, Is.Null);
        }

        [Test]
        public void GetValue_PL3AndDataSourceTypeLocationData_ShouldReturnValue()
        {
            // setup
            var sensor = new Sensor();
            const double testValue = 1.1;
            var sensorValues = new Dictionary<Sensor, double>
            {
                {
                    sensor, testValue
                }
            };
            SensorLocation sensorLocation = CreateValidSensorLocation();

            location.Scenarios[0].HeadPl3 = testValue;

            sensorLocation.SourceTypePl3 = DataSourceTypeSensors.LocationData;

            // call
            double? actualValue = sensorLocation.GetValue(x => x.SourceTypePl3, sensorValues, sensor);

            // assert            
            Assert.That(actualValue, Is.EqualTo(testValue));
        }

        [Test]
        public void GetValue_PL3AndDataSourceTypeSensor_ShouldReturnValue()
        {
            // setup
            var sensor = new Sensor();
            const double expectedValue = 1.1;
            var sensorValues = new Dictionary<Sensor, double>
            {
                {
                    sensor, expectedValue
                }
            };
            SensorLocation sensorLocation = CreateValidSensorLocation();

            sensorLocation.SourceTypePl3 = DataSourceTypeSensors.Sensor;

            // call
            double? actualValue = sensorLocation.GetValue(x => x.SourceTypePl3, sensorValues, sensor);

            // assert            
            Assert.That(actualValue, Is.EqualTo(expectedValue));
        }

        [Test]
        public void GetValue_PL4AndDataSourceTypeIgnore_ShouldReturnNull()
        {
            // setup
            var sensor = new Sensor();
            const double sensorValue = 1.1;
            var sensorValues = new Dictionary<Sensor, double>
            {
                {
                    sensor, sensorValue
                }
            };
            SensorLocation sensorLocation = CreateValidSensorLocation();

            sensorLocation.SourceTypePl4 = DataSourceTypeSensors.Ignore;

            // call
            double? actualValue = sensorLocation.GetValue(x => x.SourceTypePl4, sensorValues, sensor);

            // assert            
            Assert.That(actualValue, Is.Null);
        }

        [Test]
        public void GetValue_PL4AndDataSourceTypeLocationData_ShouldReturnValue()
        {
            // setup
            var sensor = new Sensor();
            const double testValue = 1.1;
            var sensorValues = new Dictionary<Sensor, double>
            {
                {
                    sensor, testValue
                }
            };
            SensorLocation sensorLocation = CreateValidSensorLocation();

            location.Scenarios[0].HeadPl4 = testValue;

            sensorLocation.SourceTypePl4 = DataSourceTypeSensors.LocationData;

            // call
            double? actualValue = sensorLocation.GetValue(x => x.SourceTypePl4, sensorValues, sensor);

            // assert            
            Assert.That(actualValue, Is.EqualTo(testValue));
        }

        [Test]
        public void GetValue_PL4AndDataSourceTypeSensor_ShouldReturnValue()
        {
            // setup
            var sensor = new Sensor();
            const double expectedValue = 1.1;
            var sensorValues = new Dictionary<Sensor, double>
            {
                {
                    sensor, expectedValue
                }
            };
            SensorLocation sensorLocation = CreateValidSensorLocation();

            sensorLocation.SourceTypePl4 = DataSourceTypeSensors.Sensor;

            // call
            double? actualValue = sensorLocation.GetValue(x => x.SourceTypePl4, sensorValues, sensor);

            // assert            
            Assert.That(actualValue, Is.EqualTo(expectedValue));
        }

        #endregion
    }
}