// Copyright (C) Stichting Deltares 2019. 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.Data.General;
using Deltares.DamEngine.Data.General.PlLines;
using Deltares.DamEngine.Data.General.Sensors;
using Deltares.DamEngine.Data.General.Sensors.Specifications;
using Deltares.DamEngine.Data.General.Specifications.Extensions;
using Deltares.DamEngine.Data.Geometry;
using Deltares.DamEngine.Data.Geotechnics;

namespace Deltares.DamEngine.Calculators.PlLinesCreator
{
    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)
        {
            GeometryPointString surfaceLineGeometry = SensorLocation.SurfaceLine.Geometry;
            double shift = surfaceLineGeometry.GetMaxX() - surfaceLineGeometry.GetMinX();
            return GetSensorXLocation(sensor, shift);
        }

        /// <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
            {
                throw new NotImplementedException();
//                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();

        /// <summary>
        /// Gets the X coordinate of the sensor location.
        /// </summary>
        /// <param name="sensor">The <see cref="Sensor"/> to retrieve the X coordinate for.</param>
        /// <param name="offset">The offset for the X Coordinate</param>
        /// <returns>The X location of the sensor.</returns>
        private static double GetSensorXLocation(Sensor sensor, double offset)
        {
            double sensorXCoordinate = sensor.RelativeLocation;
            if (sensorXCoordinate < 0)
            {
                return sensorXCoordinate + offset;
            }

            return sensorXCoordinate;
        }
    }
}