using System;
using System.ComponentModel;
using System.Xml.Serialization;
using Deltares.Geographic;
using Deltares.Standard;
using Deltares.Standard.Attributes;
using Deltares.Standard.EventPublisher;
using Deltares.Standard.Units;

namespace Deltares.DeltaModel
{
    /// <summary>
    /// This class describes a point constrained to be on a dike line.
    /// </summary>
    public sealed class DikeLinePoint : GeographicPoint, IComparable<DikeLinePoint>
    {
        private DikeLine dikeLine;
        private string name = "Dike line point";
        private double offset;
        
        /// <summary>
        /// Initializes a DikeLinePoint with no offset or dike line associated to it.
        /// </summary>
        [Obsolete("Only to be used in serialization", true)]
        public DikeLinePoint()
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="DikeLinePoint" /> class using given x and y and <see cref="DikeLine"/>.
        /// </summary>
        /// <param name="point">The point.</param>
        /// <param name="dikeLine">The dike line.</param>
        public DikeLinePoint(IGeographicPoint point, DikeLine dikeLine)
            : this(NotNull(point).X, NotNull(point).Y, dikeLine) {}

        /// <summary>
        /// Initializes a new instance of the <see cref="DikeLinePoint" /> class using given point and <see cref="DikeLine"/>.
        /// </summary>
        /// <param name="point">The point.</param>
        public DikeLinePoint(double x, double y, DikeLine dikeLine)
        {
            DikeLine = dikeLine;
            SetCoordinate(x, y);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="DikeLinePoint" /> class using given offset and <see cref="DikeLine"/>.
        /// </summary>
        /// <param name="offset">The offset.</param>
        /// <param name="dikeLine">The dike line.</param>
        public DikeLinePoint(double offset, DikeLine dikeLine)
        {
            DikeLine = dikeLine;
            Offset = offset;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="DikeLinePoint" /> from another <see cref="DikeLinePoint" />.
        /// </summary>
        private DikeLinePoint(DikeLinePoint point)
            : this(point.offset, point.DikeLine) {}

        /// <summary>
        /// Gets or sets the name of this <see cref="DikeLinePoint"/>
        /// </summary>
        [Label("Name")]
        [PropertyOrder(0, 1)]
        public string Name
        {
            get
            {
                return name;
            }
            set
            {
                this.SetAndNotify2(out name, value, dlp => dlp.Name);
            }
        }

        /// <summary>
        /// Gets the <see cref="DikeLine"/> that this point lays on.
        /// </summary>
        [PropertyOrder(1, 4)]
        [XmlIgnore]
        // TODO only used in dikeCrossSection and DikeSection .. This should never change I guess, only set at construction time (check this)
        public DikeLine DikeLine
        {
            get
            {
                return dikeLine;
            }
            set
            {
                dikeLine = NotNullOrEmpty(value);
            }
        }

        /// <summary>
        /// Gets or sets the offset of this <see cref="DikeLinePoint"/> on the <see cref="DikeLine"/>.
        /// </summary>
        [PropertyOrder(1, 5)]
        [Format("F3")]
        [Unit(UnitType.Length)]
        [XmlIgnore]
        public double Offset
        {
            get
            {
                return offset;
            }
            set
            {
                if (value > DikeLine.Length && value <= DikeLine.Length + 1e-6)
                {
                    value = DikeLine.Length;
                }
                else if (value < 0.0 || value > DikeLine.Length)
                {
                    throw new ArgumentException(String.Format("Offset should be in range [0, {0}].", DikeLine.Length));
                }

                var point = DikeLine.GetPointAtOffset(value);
                base.X = point.X;
                base.Y = point.Y;

                this.SetAndNotify2(out offset, value, dlp => dlp.Offset);
            }
        }

        /// <summary>
        /// Gets or sets the X coordinate of this <see cref="DikeLinePoint"/>.
        /// </summary>
        /// <exception cref="ArgumentException">Thrown when the resulting <paramref name="x"/>,<paramref name="y"/> coordinate could not be found on the <see cref="DikeLine"/>.</exception>
        /// <remarks>Only use the getter. Setting this property will most likely result in a <see cref="ArgumentException"/>, so use <see cref="SetCoordinate"/> for setting the coordinate instead.</remarks>
        [PropertyOrder(1, 2)]
        [Format("F2")]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        [XmlIgnore]
        public override double X
        {
            get
            {
                return base.X;
            }
            set
            {
                SetCoordinate(value, Y);
            }
        }

        /// <summary>
        /// Gets or sets the Y coordinate of this <see cref="DikeLinePoint"/>.
        /// </summary>
        /// <exception cref="ArgumentException">Thrown when the resulting <paramref name="x"/>,<paramref name="y"/> coordinate could not be found on the <see cref="DikeLine"/>.</exception>
        /// <remarks>Only use the getter. Setting this property will most likely result in a <see cref="ArgumentException"/>, so use <see cref="SetCoordinate"/> for setting the coordinate instead.</remarks>
        [PropertyOrder(1, 3)]
        [Format("F2")]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        [XmlIgnore]
        public override double Y
        {
            get
            {
                return base.Y;
            }
            set
            {
                SetCoordinate(X, value);
            }
        }

        /// <summary>
        /// Sets the offset of this point by looking at the offset of the coordinate of the <see cref="DikeLine"/> closest 
        /// to the given (<paramref name="x"/>,<paramref name="y"/>) coordinate. 
        /// </summary>
        /// <param name="x">The new x coordinate of this <see cref="DikeLinePoint"/>.</param>
        /// <param name="y">The new y coordinate of this <see cref="DikeLinePoint"/>.</param>
        /// <exception cref="ArgumentException">Thrown when no point with given <paramref name="x"/>,<paramref name="y"/> coordinate could not be found on the <see cref="DikeLine"/>.</exception>
        public override void SetCoordinate(double x, double y)
        {
            var newOffset = DikeLine.GetOffset(new GeographicPoint(x, y));

            if (newOffset < 0)
            {
                throw new ArgumentException(String.Format("Point ({0},{1}) is not on the dike line; could not determine offset.", x, y));
            }

            Offset = newOffset;
        }

        /// <summary>
        /// Creates a partial clone of this <see cref="DikeLinePoint"/>, while keeping the reference to the <see cref="DikeLinePoint.DikeLine"/> intact.
        /// </summary>
        /// <returns>A partial clone.</returns>
        public override IGeographicPoint Clone()
        {
            return new DikeLinePoint(this);
        }

        public override string ToString()
        {
            return String.Format("{0} {1}", Name, Offset);
        }

        public override bool Equals(object obj)
        {
            var dikeLinePoint = obj as DikeLinePoint;
            return dikeLinePoint != null && dikeLinePoint.DikeLine == DikeLine && CompareTo(dikeLinePoint) == 0;
        }

        public int CompareTo(DikeLinePoint other)
        {
            var comparedDikeLines = DikeLine.CompareTo(other.DikeLine);
            return comparedDikeLines == 0 ? Offset.CompareTo(other.Offset) : comparedDikeLines;
        }

        public override int GetHashCode()
        {
            return (int) Offset / 10;
        }
        
        [Obsolete("Only used for serialization", true)]
        private SerializedDikeLinePoint State
        {
            get
            {
                return new SerializedDikeLinePoint(this);
            }
            set
            {
                DikeLine = value.DikeLine;
                Offset = value.Offset;
                Name = value.Name;
            }
        }

        private class SerializedDikeLinePoint
        {
            public SerializedDikeLinePoint(DikeLinePoint point)
            {
                DikeLine = point.dikeLine;
                Offset = point.offset;
                Name = point.name;
            }

            private SerializedDikeLinePoint() {}

            public DikeLine DikeLine { get; private set; }
            public double Offset { get; private set; }
            public String Name { get; private set; }
        }

        #region parameter validation

        private static IGeographicPoint NotNull(IGeographicPoint point)
        {
            if (point == null)
            {
                throw new ArgumentNullException("point", @"Cannot initialize DikeLinePoint from a null point.");
            }
            return point;
        }

        private static DikeLine NotNullOrEmpty(DikeLine dikeLine)
        {
            if (dikeLine == null)
            {
                throw new ArgumentNullException("dikeLine", @"Cannot set a null dike line for a DikeLinePoint.");
            }
            if (dikeLine.Points.Count == 0)
            {
                throw new ArgumentException(@"Cannot set an empty dike line for a DikeLinePoint.", "dikeLine");
            }
            return dikeLine;
        }

        #endregion
    }
}