using System;
using System.Collections;
using System.ComponentModel;
using System.Linq;
using Deltares.Geographic;
using Deltares.Probabilistic;
using Deltares.Standard;
using Deltares.Standard.Attributes;
using Deltares.Standard.EventPublisher;
using Deltares.Standard.Reflection;
using Deltares.Standard.Units;

namespace Deltares.DeltaModel
{
    /// <summary>
    ///     A dike line is a ‘backbone’ of a dike and applicable for all failure mechanisms.
    ///     The user can select points along the dike line to view properties such as a name.
    ///     Points have global XYZ-coordinates and local L-coordinates along dike line.
    ///     Locations can have name (labels) or L-coordinate indications (km-pole)
    /// </summary>
    [TrackChanges]
    public class DikeLine : GeographicString, IName, IDomain, IDisposable, IComparable<DikeLine>
    {
        private ProbabilityDefinition allowedFailureProbability;
        private DikeLinePoint beginPoint;
        private DikeLinePoint endPoint;
        private string name;

        /// <summary>
        ///     Initializes a new instance of the <see cref="DikeLine" /> class.
        /// </summary>
        public DikeLine()
        {
            name = string.Empty;

            DataEventPublisher.OnDataListModified += DataEventPublisher_OnDataListModified;
            DataEventPublisher.OnAfterChange += DataEventPublisher_OnAfterChange;
        }

        /// <summary>
        ///     Gets or sets the allowed failure probability of the DikeLine.
        /// </summary>
        /// <value>
        ///     The allowed failure probability.
        /// </value>
        [Unit(UnitType.None)]
        [Format("F2")]
        [Label("Allowed failure probability")]
        [Description("AllowedFailureProbability")]
        [PropertyOrder(1)]
        public ProbabilityDefinition AllowedFailureProbability
        {
            get
            {
                if (allowedFailureProbability == null && ProbabilityDefinitionCollection.ProbabilityDefinitions.Count > 0)
                {
                    allowedFailureProbability = ProbabilityDefinitionCollection.ProbabilityDefinitions[0];
                }

                return allowedFailureProbability;
            }
            set
            {
                this.SetAndNotify2(out allowedFailureProbability, value, dl => dl.AllowedFailureProbability);
            }
        }

        #region IDisposable

        public void Dispose()
        {
            DataEventPublisher.OnDataListModified -= DataEventPublisher_OnDataListModified;
            DataEventPublisher.OnAfterChange -= DataEventPublisher_OnAfterChange;
        }

        #endregion

        /// <summary>
        ///     Gets or sets the name of the DikeLine.
        /// </summary>
        /// <value>
        ///     The name.
        /// </value>
        [Label("Name")]
        [Description("Name")]
        [PropertyOrder(0)]
        public string Name
        {
            get
            {
                return name;
            }
            set
            {
                this.SetAndNotify2(out name, value, dl => dl.Name);
            }
        }

        /// <summary>
        ///     Gets the DikeLine as a WKTstring,
        ///     mainly to export to csv
        /// </summary>
        public string GetWKTstring()
        {
            var coordList = "LINESTRING(";
            foreach (var point in Points)
            {
                coordList += point.X + " " + point.Y + ",";
            }
            return coordList.Remove(coordList.Length - 1) + ")";
        }

        /// <summary>
        ///     Gets the maximum X coordinate of all points
        /// </summary>
        /// <returns>max X</returns>
        public double GetMaxX()
        {
            return Points.Select(point => point.X).Concat(new[]
                {
                    double.MinValue
                }).Max();
        }

        /// <summary>
        ///     Gets the minimum X coordinate of all points
        /// </summary>
        /// <returns>min X</returns>
        public double GetMinX()
        {
            return Points.Select(point => point.X).Concat(new[]
                {
                    double.MaxValue
                }).Min();
        }

        /// <summary>
        ///     Gets the maximum Y coordinate of all points
        /// </summary>
        /// <returns>max Y</returns>
        public double GetMaxY()
        {
            return Points.Select(point => point.Y).Concat(new[]
                {
                    double.MinValue
                }).Max();
        }

        /// <summary>
        ///     Gets the minimum Y coordinate of all points
        /// </summary>
        /// <returns>min Y</returns>
        public double GetMinY()
        {
            return Points.Select(point => point.Y).Concat(new[]
                {
                    double.MaxValue
                }).Min();
        }

        /// <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 domain.
        /// </summary>
        /// <param name="property">The property.</param>
        /// <returns>Domain</returns>
        public ICollection GetDomain(string property)
        {
            if (property == this.GetMemberName(dl => dl.AllowedFailureProbability))
            {
                return ProbabilityDefinitionCollection.ProbabilityDefinitions;
            }
            return null;
        }

        public int CompareTo(DikeLine dikeLine)
        {
            return Name.CompareTo(dikeLine.Name);
        }

        public override bool Equals(object obj)
        {
            DikeLine dikeLine = obj as DikeLine;
            if (dikeLine == null)
            {
                return false;
            }
            if (dikeLine.Points.Count != Points.Count)
            {
                return false;
            }
            for (int i = 0; i < dikeLine.Points.Count; i++)
            {
                if (!Points[i].Equals(dikeLine.Points[i]))
                {
                    return false;
                }
            }

            return true;
        }

        public override int GetHashCode()
        {
            return Points.Count;
        }

        /// <summary>
        ///     Handles the OnAfterChange event of the DataEventPublisher control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="PublishEventArgs" /> instance containing the event data.</param>
        private void DataEventPublisher_OnAfterChange(object sender, PublishEventArgs e)
        {
            if (ReferenceEquals(sender, AllowedFailureProbability))
            {
                DataEventPublisher.AfterChange(this, this.GetMemberName(dl => dl.AllowedFailureProbability));
            }
            var geographicPoint = sender as IGeographicPoint;
            if (geographicPoint != null && Points.Any(p => ReferenceEquals(p, geographicPoint)))
            {
                DataEventPublisher.AfterChange(this);
            }
        }

        /// <summary>
        ///     Handles the OnDataListModified event of the DataEventPublisher control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="PublishEventArgs" /> instance containing the event data.</param>
        private void DataEventPublisher_OnDataListModified(object sender, PublishEventArgs e)
        {
            if (ReferenceEquals(sender, Points))
            {
                DataEventPublisher.AfterChange(this);
            }
        }
    }
}