using System;
using Deltares.Geometry;
using Deltares.Geotechnics.Exception;
using Deltares.Mathematics;

namespace Deltares.DeltaModel
{
    /// <summary>
    /// This class represents a <see cref="GeometryPoint"/>, for which it is not possible to move it 
    /// beyond its previous and next points' X coordinates.
    /// </summary>
    public class SurfaceLineGeometryPoint : GeometryPoint
    {
        private GeometryPoint next;
        private GeometryPoint previous;

        public SurfaceLineGeometryPoint(double x, double y, double z) : base(x, y, z) {}

        /// <summary>
        /// Parameterless constructor is used in deserialization.
        /// </summary>
        private SurfaceLineGeometryPoint()
            : base(Double.NaN, Double.NaN, Double.NaN) {}

        private SurfaceLineGeometryPoint(SurfaceLineGeometryPoint point)
            : base(point) {}

        /// <summary>
        /// Sets the next point for this point.
        /// </summary>
        /// <exception cref="PointLocationIncorrectException">Thrown when the point passed has an <see cref="X"/> which is less than <see cref="X"/> of this point.</exception>
        public GeometryPoint Next
        {
            private get
            {
                return next;
            }
            set
            {
                if (null == value || Double.IsNaN(X) || value.X.IsGreaterThanOrEqualTo(X))
                {
                    next = value;
                }
                else
                {
                    throw new PointLocationIncorrectException();
                }
            }
        }

        /// <summary>
        /// Sets the next point for this point.
        /// </summary>
        /// <exception cref="PointLocationIncorrectException">Thrown when the point passed has an <see cref="X"/> which is greater than <see cref="X"/> of this point.</exception>
        public GeometryPoint Previous
        {
            private get
            {
                return previous;
            }
            set
            {
                if (null == value || Double.IsNaN(X) || value.X.IsLessThanOrEqualTo(X))
                {
                    previous = value;
                }
                else
                {
                    throw new PointLocationIncorrectException();
                }
            }
        }

        public override double X
        {
            get
            {
                return base.X;
            }
            set
            {
                base.X = CutOffX(value);
            }
        }

        public override object Clone()
        {
            return new SurfaceLineGeometryPoint(this)
                {
                    next = next,
                    previous = previous
                };
        }

        private double CutOffX(double value)
        {
            var newX = value;
            if (next != null && !Double.IsNaN(next.X))
            {
                newX = Math.Min(value, next.X);
            }
            if (previous != null && !Double.IsNaN(previous.X))
            {
                newX = Math.Max(newX, previous.X);
            }
            return newX;
        }
    }
}