// 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.Data.Geometry;
using Deltares.DamEngine.Data.Standard;
using Deltares.DamEngine.Data.Standard.Language;
using Deltares.DamEngine.Data.Standard.Validation;

namespace Deltares.DamEngine.Data.Geotechnics
{
    /// <summary>
    /// Representation of a surface line with characteristic point annotations.
    /// </summary>
    /// <remarks>Extension methods can be found in <see cref="SurfaceLine2Extensions"/>.</remarks>
    public class SurfaceLine2 : GeometryObject
    {
        private CharacteristicPointSet characteristicPoints;
        private GeometryPointString geometry;

        /// <summary>
        /// Create a new empty surface line.
        /// </summary>
        public SurfaceLine2()
        {
            geometry = new GeometryPointString();
            characteristicPoints = new CharacteristicPointSet
                {
                    GeometryMustContainPoint = true
                };
            LandwardDirection = LandwardDirection.PositiveX;
            Name = LocalizationManager.GetTranslatedText(this, "DefaultNameSurfaceLine2");
        }

        /// <summary>
        /// Deep clone the object.
        /// </summary>
        /// <returns></returns>
        public SurfaceLine2 FullDeepClone()
        {
            SurfaceLine2 surfaceLine2 = new SurfaceLine2();
            surfaceLine2.SetValuesFromOtherSurfaceLine(this, true);
            return surfaceLine2;
        }

        /// <summary>
        /// The geometrical description of the surface line.
        /// </summary>
        /// <remarks>Aggregation relationship.</remarks>
        public GeometryPointString Geometry
        {
            get
            {
                return geometry;
            }
            set
            {
                geometry = value;
                CharacteristicPoints.Geometry = geometry;
            }
        }

        /// <summary>
        /// The characteristic point annotations for <see cref="Geometry"/>.
        /// </summary>
        /// <remarks>Cannot be null.</remarks>
        public CharacteristicPointSet CharacteristicPoints
        {
            get
            {
                return characteristicPoints;
            }
            set
            {
                characteristicPoints = value;
                characteristicPoints.Geometry = geometry;
            }
        }

        /// <summary>
        /// Determines toward which direction land is expected. Value is used as reference.
        /// </summary>
        public LandwardDirection LandwardDirection { get; set; }

        /// <summary>
        /// Define a new characteristic point on the surface line with the given characteristic 
        /// point annotation.
        /// </summary>
        /// <param name="geometryPoint">The point to be added. Cannot be null.</param>
        /// <param name="annotations">The annotations for <paramref name="geometryPoint"/>.</param>
        public void AddCharacteristicPoint(GeometryPoint geometryPoint, params CharacteristicPointType[] annotations)
        {
            if (annotations == null || annotations.Length == 0)
            {
                CharacteristicPoints.Add(new CharacteristicPoint
                    {
                        GeometryPoint = geometryPoint,
                        CharacteristicPointType = CharacteristicPointType.None
                    });
            }
            else
            {
                foreach (var type in annotations)
                {

                    CharacteristicPoints.Add(new CharacteristicPoint
                        {
                            GeometryPoint = geometryPoint,
                            CharacteristicPointType = type
                        });
                }
            }
        }

        /// <summary>
        /// Define a new characteristic point on the surface line with the given characteristic
        /// point annotation.
        /// </summary>
        /// <param name="x">The x.</param>
        /// <param name="z">The y.</param>
        /// <param name="annotations">The annotations for geometryPoint with x, z/>.</param>
        public void AddCharacteristicPoint(double x, double z, params CharacteristicPointType[] annotations)
        {
            GeometryPoint geometryPoint = new GeometryPoint(x, z);
            AddCharacteristicPoint(geometryPoint, annotations);            
        }

        /// <summary>
        /// Find all characteristic point annotations corresponding with the given location.
        /// </summary>
        /// <param name="geometryPoint"></param>
        /// <returns></returns>
        public IEnumerable<CharacteristicPointType> GetCharacteristicPoints(GeometryPoint geometryPoint)
        {
            return CharacteristicPoints.Where(cp => ReferenceEquals(cp.GeometryPoint, geometryPoint))
                                       .Select(cp => cp.CharacteristicPointType);
        }

        /// <summary>
        /// Sort all points on X in a ascending manner.
        /// </summary>
        public void SortPoints()
        {
            CharacteristicPoints.Sort();
        }

        /// <summary>
        /// Gets the points orderd by x.
        /// </summary>
        /// <value>
        /// The points orderd by x.
        /// </value>
        private IEnumerable<GeometryPoint> PointsOrderdByX
        {
            get
            {
                return Geometry.Points.OrderBy(p => p.X);
            }
        }

        /// <summary>
        /// Tests if the given point is between the given start X and end X.
        /// </summary>
        /// <param name="point">The point.</param>
        /// <param name="startX">The start x.</param>
        /// <param name="endX">The end x.</param>
        /// <returns><c>true</c> if the given point is between the given start X and end X, otherwise <c>false</c></returns>
        private bool TestIncluding(GeometryPoint point, double startX, double endX)
        {
            if (point == null)
            {
                return false;
            }

            double x = point.X;
            return (x >= startX || x.AlmostEquals(startX, GeometryPoint.Precision))
                   && (x < endX || x.AlmostEquals(endX, GeometryPoint.Precision));
        }

        /// <summary>
        /// Gets the point segment including given start x and end x.
        /// </summary>
        /// <param name="startX">The start x.</param>
        /// <param name="endX">The end x.</param>
        /// <returns>collection of points between start X and end X (inlcuding those)</returns>
        /// <exception cref="System.ArgumentException">End value is smaller then the start value</exception>
        public virtual IEnumerable<GeometryPoint> GetPointSegmentIncluding(double startX, double endX)
        {
            if (endX < startX)
            {
                throw new ArgumentException("End value is smaller then the start value");
            }

            return from point in PointsOrderdByX
                   where TestIncluding(point, startX, endX)
                   orderby point.X ascending
                   select point;
        }

        /// <summary>
        /// Validates this surfaceline.
        /// </summary>
        /// <returns>All validation messages.</returns>
        [Validate]
        public ValidationResult[] Validate()
        {
            return new SurfaceLine2Validator().Validate(this).ToArray();
        }

        /// <summary>
        /// Returns a <see cref="System.String" /> that represents this instance.
        /// </summary>
        /// <returns>
        /// A <see cref="System.String" /> that represents this instance.
        /// </returns>
        public override string ToString()
        {
            return Name;
        }

        /// <summary>
        /// Gets the geometry bounds (i.e. the extents for drawing)
        /// </summary>
        /// <returns></returns>
        public override GeometryBounds GetGeometryBounds()
        {
            if (CharacteristicPoints.Geometry != null)
            {
                return CharacteristicPoints.Geometry.GetGeometryBounds();
            }
            return null;
        }

        /// <summary>
        /// Copy all characteristic point related data from another <see cref="SurfaceLine2"/>.
        /// </summary>
        /// <param name="source">Data source</param>
        public void Assign(SurfaceLine2 source)
        {
            SetValuesFromOtherSurfaceLine(source);
        }

        /// <summary>
        /// Sets the values from another surface line.
        /// </summary>
        /// <param name="source">The source.</param>
        /// <param name="cloneGeometry">If set to true, the <see cref="Geometry"/> of
        /// <paramref name="source"/> will be deep cloned, otherwise the reference is shared.</param>
        private void SetValuesFromOtherSurfaceLine(SurfaceLine2 source, bool cloneGeometry = false)
        {
            CharacteristicPoints.Clear(); // clears the whole characteristic points state.

            Name = source.Name;
            Geometry.Name = Name;
            LandwardDirection = source.LandwardDirection;

            CharacteristicPoints.GeometryMustContainPoint = source.CharacteristicPoints.GeometryMustContainPoint;
            Geometry = cloneGeometry ? source.Geometry.Clone() : source.Geometry;

            var geometryAnnotations = GetCharacteristicAnnotationsInSource(source, cloneGeometry);

            // Reconstruct annotation state from dictionary:
            if (CharacteristicPoints.GeometryMustContainPoint)
            {
                foreach (var annotation in geometryAnnotations)
                {
                    for (int i = 0; i < annotation.Value.Length; i++)
                    {
                        var index = -1;
                        for (int j = 0; j < CharacteristicPoints.Count; j++)
                        {
                            if (ReferenceEquals(CharacteristicPoints[j].GeometryPoint, annotation.Key))
                            {
                                index = j;
                                break;
                            }
                        }

                        if (i == 0)
                        {
                            // Reassign annotation of already created CharacteristicPoint:
                            CharacteristicPoints.Annotate(index, annotation.Value[i]);
                        }
                        else
                        {
                            // Add new CharacteristicPoint instance for all subsequent annotations and ensuring to keep the defined order:
                            CharacteristicPoints.Insert(index + i, new CharacteristicPoint(CharacteristicPoints, annotation.Key)
                            {
                                CharacteristicPointType = annotation.Value[i]
                            });
                        }
                    }
                }
            }
            else
            {
                foreach (var annotation in geometryAnnotations)
                {
                    AddCharacteristicPoint((GeometryPoint)annotation.Key.Clone(), annotation.Value);
                }
            }
        }

        /// <summary>
        /// Collapses all characteristic point annotations in the given surfaceline into
        /// a dictionary keyed on <see cref="GeometryPoint"/> instances in that surfaceline
        /// and their annotations.
        /// </summary>
        /// <param name="source">The referenced surfaceline.</param>
        /// <param name="cloneGeometry">True if <see cref="Geometry"/> should be a clone from
        /// <paramref name="source"/>.<see cref="SurfaceLine2.Geometry"/>; false if it should
        /// take the same instance instead.</param>
        /// <returns>Dictionary keyed on <see cref="GeometryPoint"/> instances in the surfaceline
        /// that have annotations.</returns>
        private Dictionary<GeometryPoint, CharacteristicPointType[]> GetCharacteristicAnnotationsInSource(SurfaceLine2 source, bool cloneGeometry)
        {
            return CharacteristicPoints.GeometryMustContainPoint
                       ? GetCharacteristicAnnotationsInSource_GeometryMustContainPoints(source, cloneGeometry)
                       : GetCharacteristicAnnotationsInSource_GeometryMustNotContainPoints(source);
        }

        /// <summary>
        /// Handlers <see cref="GetCharacteristicAnnotationsInSource"/> return value in case
        /// <see cref="CharacteristicPointSet.GeometryMustContainPoint"/> is true.
        /// </summary>
        /// <param name="source">The referenced surfaceline.</param>
        /// <param name="cloneGeometry">True if <see cref="Geometry"/> should be a clone from
        /// <paramref name="source"/>.<see cref="SurfaceLine2.Geometry"/>; false if it should
        /// take the same instance instead.</param>
        /// <returns>Dictionary keyed on <see cref="GeometryPoint"/> instances in the surfaceline
        /// that have annotations.</returns>
        private Dictionary<GeometryPoint, CharacteristicPointType[]> GetCharacteristicAnnotationsInSource_GeometryMustContainPoints(SurfaceLine2 source, bool cloneGeometry)
        {
            var geometryAnnotations = new Dictionary<GeometryPoint, CharacteristicPointType[]>();
            for (int i = 0; i < source.Geometry.Count; i++)
            {
                var annotationsForPoint = source.GetCharacteristicPoints(source.Geometry.Points[i]).Where(cpt => cpt != CharacteristicPointType.None).ToArray();
                if (annotationsForPoint.Length > 0)
                {
                    geometryAnnotations[Geometry.Points[i]] = annotationsForPoint;
                }
            }
            return geometryAnnotations;
        }

        /// <summary>
        /// Handles <see cref="GetCharacteristicAnnotationsInSource"/> return value in case
        /// <see cref="CharacteristicPointSet.GeometryMustContainPoint"/> is false.
        /// </summary>
        /// <param name="source">The referenced surfaceline.</param>
        /// <returns>Dictionary keyed on <see cref="GeometryPoint"/> instances in the surfaceline
        /// that have annotations.</returns>
        private static Dictionary<GeometryPoint, CharacteristicPointType[]> GetCharacteristicAnnotationsInSource_GeometryMustNotContainPoints(SurfaceLine2 source)
        {
            var geometryAnnotations = new Dictionary<GeometryPoint, CharacteristicPointType[]>();
            foreach (var characteristicPoint in source.CharacteristicPoints)
            {
                if (!geometryAnnotations.ContainsKey(characteristicPoint.GeometryPoint))
                {
                    geometryAnnotations[characteristicPoint.GeometryPoint] =
                        source.GetCharacteristicPoints(characteristicPoint.GeometryPoint).ToArray();
                }
            }
            return geometryAnnotations;
        }

    }
}