using System;
using System.ComponentModel;
using System.Xml.Serialization;
using Deltares.Geometry;
using Deltares.Geotechnics;
using Deltares.Geotechnics.Mechanisms;
using Deltares.Standard;
using Deltares.Standard.Attributes;
using Deltares.Standard.EventPublisher;
using Deltares.Standard.Units;
using Deltares.Standard.Validation;

namespace Deltares.DeltaModel
{
    public abstract class RevetmentSegment : GeometryObject, IComparable<RevetmentSegment>
    {
        protected SurfaceLineGeometryPoint firstPoint = new SurfaceLineGeometryPoint(Double.NaN, 0, Double.NaN)
            {
                SendEvents = true
            };

        protected SurfaceLineGeometryPoint lastPoint = new SurfaceLineGeometryPoint(Double.NaN, 0, Double.NaN)
            {
                SendEvents = true
            };

        private ISegmentDescription segmentDescription;

        /// <summary>
        /// Constructor.
        /// </summary>
        protected RevetmentSegment()
        {
            firstPoint.Next = lastPoint;
            lastPoint.Previous = firstPoint;
        }

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="segmentDescription">The data to attach to the segment.</param>
        protected RevetmentSegment(ISegmentDescription segmentDescription)
        {
            SegmentDescription = segmentDescription;
        }

        /// <summary>
        /// Gets the x coordinate of the start point.
        /// </summary>
        [Format("F2")]
        [Unit(UnitType.Length)]
        [PropertyOrder(1, 1)]
        [Category("Position")]
        [XmlIgnore]
        public double StartX
        {
            get
            {
                return firstPoint.X;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, x => x.StartX);
                firstPoint.X = value;
                DataEventPublisher.AfterChange(this, x => x.StartX);
            }
        }

        /// <summary>
        /// Gets the x coordinate of the end point.
        /// </summary>
        [Format("F2")]
        [Unit(UnitType.Length)]
        [PropertyOrder(1, 3)]
        [Category("Position")]
        [XmlIgnore]
        public double EndX
        {
            get
            {
                return lastPoint.X;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, x => x.EndX);
                lastPoint.X = value;
                DataEventPublisher.AfterChange(this, x => x.EndX);
            }
        }

        /// <summary>
        /// The data attached to the segment, e.g. roughness characteristics
        /// </summary>
        [Validate]
        [Browsable(false)]
        public virtual ISegmentDescription SegmentDescription
        {
            get
            {
                return segmentDescription;
            }
            set
            {
                this.SetAndNotify2(out segmentDescription, value, x => x.SegmentDescription);
            }
        }

        [XmlIgnore]
        [ReadOnly(false)]
        [PropertyOrder(1, 0)]
        [Mechanism(Mechanism.Overtopping, Mechanism.AsphaltRevetment)]
        public override string Name
        {
            get
            {
                return SegmentDescription != null ? SegmentDescription.Name : "";
            }
            set
            {
                if (SegmentDescription != null)
                {
                    DataEventPublisher.BeforeChange(this, x => x.Name);
                    SegmentDescription.Name = value;
                    DataEventPublisher.AfterChange(this, x => x.Name);
                }
            }
        }

        public bool HasPoint(GeometryPoint point)
        {
            return firstPoint == point || lastPoint == point;
        }

        /// <summary>
        /// Connect this segment's last point to the first point of the next <see cref="RevetmentSegment"/>. After connecting,
        /// changing the endpoint of this segment, will also change the firstpoint of the next <see cref="RevetmentSegment"/>.
        /// </summary>
        /// <param name="nextSegment">The segment to connect to.</param>
        public void ConnectTo(RevetmentSegment nextSegment)
        {
            lastPoint = nextSegment.firstPoint;

            lastPoint.Previous = firstPoint;
            firstPoint.Next = lastPoint;
        }

        /// <summary>
        /// Disconnects the segment from the next <see cref="RevetmentSegment"/>. After disconnecting, the endpoints
        /// of the segments can be changed independently.
        /// </summary>
        /// <param name="nextSegment">The segment to disconnect from.</param>
        public void DisconnectFrom(RevetmentSegment nextSegment)
        {
            if (IsConnectedTo(nextSegment))
            {
                lastPoint = (SurfaceLineGeometryPoint) lastPoint.Clone();
                lastPoint.Next = null;
                firstPoint.Next = lastPoint;
                nextSegment.firstPoint.Previous = null;
            }
        }

        /// <summary>
        /// Returns true if this segment is connected to the next <see cref="RevetmentSegment"/>.
        /// </summary>
        /// <param name="nextSegment">The segment which is possibly connected to.</param>
        /// <returns>True if the segments are connected, false otherwise.</returns>
        public bool IsConnectedTo(RevetmentSegment nextSegment)
        {
            return lastPoint == nextSegment.firstPoint;
        }

        /// <summary>
        /// Returns the geometry bounds.
        /// </summary>
        public override GeometryBounds GetGeometryBounds()
        {
            if (!Double.IsNaN(StartX) && !Double.IsNaN(EndX))
            {
                return firstPoint.GetGeometryBounds() + lastPoint.GetGeometryBounds();
            }
            if (Double.IsNaN(StartX) && !Double.IsNaN(EndX))
            {
                return lastPoint.GetGeometryBounds();
            }
            if (Double.IsNaN(EndX) && !Double.IsNaN(StartX))
            {
                return firstPoint.GetGeometryBounds();
            }

            return null;
        }

        public override string ToString()
        {
            return Name ?? "UnknownSegment";
        }

        public int CompareTo(RevetmentSegment other)
        {
            var compare = StartX.CompareTo(other.StartX);

            if (compare == 0)
            {
                compare = EndX.CompareTo(other.EndX);
            }

            return compare;
        }

        /// <remarks>Used in serialization</remarks>
        [Obsolete("Used only for serialization.", true)]
        protected SurfaceLineGeometryPoint FirstPoint
        {
            get
            {
                return firstPoint;
            }
            set
            {
                firstPoint = value;
            }
        }

        /// <remarks>Used in serialization</remarks>
        [Obsolete("Used only for serialization.", true)]
        protected SurfaceLineGeometryPoint LastPoint
        {
            get
            {
                return lastPoint;
            }
            set
            {
                lastPoint = value;
            }
        }
    }
}