using System;
using System.Collections.Generic;
using System.Linq;
using Deltares.Dam.Data.Sensors.Specifications;
using Deltares.Geometry;
using Deltares.Geotechnics;
using Deltares.Geotechnics.SurfaceLines;
using Deltares.Standard.Application;
using Deltares.Standard.Specifications.Extensions;

namespace Deltares.Dam.Data.Sensors
{
    internal abstract class SensorPLLineCreatorBase : IPLLineCreator
    {
        internal readonly static LogHelper Logger = LogHelper.Create<SensorPLLineCreatorBase>();

        protected SensorLocation SensorLocation;
        protected readonly IDictionary<Sensor, double> SensorValues;

        /// <summary>
        /// Initializes a new instance of the <see cref="SensorPLLineCreatorBase"/> class.
        /// </summary>
        /// <param name="sensorLocation">The sensor location.</param>
        /// <param name="type">The type.</param>
        /// <param name="sensorValues">The sensor values.</param>
        protected SensorPLLineCreatorBase(SensorLocation sensorLocation, PLLineType type, IDictionary<Sensor, double> sensorValues)
        {
            SensorLocation = sensorLocation;
            SensorValues = sensorValues;
            PLLineType = type;
        }

        /// <summary>
        /// Gets the water level sensor.
        /// </summary>
        public Sensor WaterLevelSensor
        {
            get
            {
                try
                {
                    return SensorLocation.Sensors
                        .GetBySpecification(new WaterLevelSensorSpecification())
                        .Single();
                }
                catch (Exception e)
                {
                    throw new PLLinesCreatorException("There was an error getting the water level sensor. Maybe because there was no water level sensor defined", e);
                }
            }
        }

        /// <summary>
        /// Gets the water level sensor.
        /// </summary>
        public Sensor PolderLevelSensor
        {
            get
            {
                var sensors = SensorLocation.Sensors.GetBySpecification(new PolderLevelSensorSpecification()).ToList();
                if (sensors.Count() == 1)
                {
                    return sensors.First();
                }
                if (!sensors.Any())
                {
                    return null;
                }
                throw new PLLinesCreatorException("There are multiple polder level sensors defined.");
            }
        }

        /// <summary>
        /// Gets the PiezometricHead type sensors sorted along profile.
        /// </summary>
        /// <remarks>
        /// Water level and polder level sensors should not be in this collection
        /// </remarks>
        protected IEnumerable<Sensor> SensorsSortedAlongProfile
        {
            get
            {
                return SensorLocation.GetSensorsSortedByRelativeLocationAlongProfile(PLLineType).Select(s => s.Value);
            }
        }

        /// <summary>
        /// Gets the X begin boundary.
        /// </summary>
        protected double XBeginBoundary
        {
            get
            {
                return SensorLocation.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelOutside).X;
            }
        }

        /// <summary>
        /// Gets the X end boundary.
        /// </summary>
        protected double XEndBoundary
        {
            get
            {
                return SensorLocation.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelInside).X;
            }
        }

        protected bool DikeHasDitch
        {
            get { return SensorLocation.SurfaceLine.HasDitch(); }
        }

        protected bool DikeHasShoulder
        {
            get { return SensorLocation.SurfaceLine.HasShoulderInside(); }
        }


        /// <summary>
        /// Gets the Y value at the end boundary.
        /// </summary>
        protected double YEndBoundary
        {
            get
            {
                return SensorLocation.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelInside).Y;
            }
        }

        protected double XDikeToeAtRiver
        {
            get { return SensorLocation.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtRiver).X; }
        }

        /// <summary>
        /// Intersection of line at river with a given Z value.
        /// </summary>
        /// <returns></returns>
        protected double IntersectionXAtRiverWaterLevel(double waterLevel)
        {
            GeometryPoint point = SensorLocation.SurfaceLine.DetermineIntersectionBetweenTaludRiverSideAndWaterLevel(waterLevel);
            if (point == null)
            {
                throw new PLLinesCreatorException("No intersection point found with water level at dike river side");
            }
            return point.X;
        }

        /// <summary>
        /// Intersection of line at polder with a given Z value.
        /// </summary>
        /// <returns></returns>
        protected double IntersectionXAtPolderZ(double z)
        {
            var intersectionsXatZ = SensorLocation.SurfaceLine.Geometry.IntersectionsXAtZ(z).ToList();
            var hasIntersections = intersectionsXatZ.Count() == 2;
            return hasIntersections ? intersectionsXatZ.Last() : double.NaN;
        }

        /// <summary>
        /// Gets the sensor X value.
        /// </summary>
        /// <param name="sensor">The sensor.</param>
        /// <returns></returns>
        protected double GetSensorXValue(Sensor sensor)
        {
            return sensor.RelativeLocation;
        }

        /// <summary>
        /// Gets the sensor Z value.
        /// </summary>
        /// <param name="sensor">The sensor.</param>
        /// <returns></returns>
        protected double GetSensorZValue(Sensor sensor)
        {
            return SensorValues[sensor];
        }

        /// <summary>
        /// Gets the water level at polder.
        /// </summary>
        protected double WaterLevelAtPolder
        {
            get
            {
                var sensor = SensorLocation.GetSensorsSortedByRelativeLocationAlongProfile(PLLineType).Last().Value;
                var value = SensorLocation.GetValue(x => x.PL1WaterLevelAtPolder, SensorValues, sensor);
                if (value.HasValue)
                    return value.Value;

                var message = string.Format("Water level at polder for the location '{0}' was not set or initialized", SensorLocation.LocationName);
                throw new InvalidOperationException(message);

            }
        }

        /// <summary>
        /// Gets the type of the PL line.
        /// </summary>
        /// <value>
        /// The type of the PL line.
        /// </value>
        public PLLineType PLLineType { get; private set; }

        /// <summary>
        /// Creates the PL line.
        /// </summary>
        /// <returns></returns>
        public abstract PLLine CreatePLLine();
    }
}