using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Xml.Serialization;
using Deltares.Geographic;
using Deltares.Geotechnics;
using Deltares.Geotechnics.GeotechnicalGeometry;
using Deltares.Geotechnics.Mechanisms;
using Deltares.Geotechnics.Soils;
using Deltares.Geotechnics.SurfaceLines;
using Deltares.Standard;
using Deltares.Standard.Attributes;
using Deltares.Standard.EventPublisher;
using Deltares.Standard.Reflection;
using Deltares.Standard.Units;
using Deltares.Standard.Validation;

namespace Deltares.DeltaModel
{
    /// <summary>
    /// DikeLocation as a section with begin and end
    /// </summary>
    public class DikeSection : DikeLocation, IGeographicString
    {
        # region Field variables

        private readonly List<DikeCrossSection> dikeCrossSections = new List<DikeCrossSection>();

        /// <summary>
        /// Start of section
        /// </summary>
        private DikeLinePoint beginPoint;

        /// <summary>
        /// End of section
        /// </summary>
        private DikeLinePoint endPoint;

        /// <summary>
        /// Dike Cross Section which represents this Dike Section
        /// </summary>
        private DikeCrossSection representativeDikeCrossSection;

        # endregion

        /// <summary>
        /// Initializes a new instance of the <see cref="DikeSection"/> class.
        /// </summary>
        public DikeSection()
        {
            DataEventPublisher.OnAfterChange += DataEventPublisher_OnAfterChange;
        }

        /// <summary>
        /// Start of section
        /// </summary>
        /// <value>
        /// The begin point.
        /// </value>
        [Label("")]
        [Description("")]
        [XmlIgnore]
        public DikeLinePoint BeginPoint
        {
            get
            {
                return beginPoint;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, ds => ds.BeginPoint);
                beginPoint = value;
                if (beginPoint != null)
                {
                    beginPoint.DikeLine = DikeLine;
                }
                DataEventPublisher.AfterChange(this, ds => ds.BeginPoint);
            }
        }

        /// <summary>
        /// End of section
        /// </summary>
        /// <value>
        /// The end point.
        /// </value>
        [Label("")]
        [Description("")]
        [XmlIgnore]
        public DikeLinePoint EndPoint
        {
            get
            {
                return endPoint;
            }
            set
            {
                DataEventPublisher.BeforeChange(this,ds => ds.EndPoint);
                endPoint = value;
                if (endPoint != null)
                {
                    endPoint.DikeLine = DikeLine;
                }
                DataEventPublisher.AfterChange(this, ds => ds.EndPoint);
            }
        }

        /// <summary>
        /// Dike Cross Section which represents this Dike Section
        /// </summary>
        [Domain]
        [Category("Location")]
        [XmlIgnore]
        public DikeCrossSection RepresentativeDikeCrossSection
        {
            get
            {
                return representativeDikeCrossSection;
            }
            set
            {
                this.SetAndNotify2(out representativeDikeCrossSection, value, ds => ds.RepresentativeDikeCrossSection);
            }
        }

        /// <summary>
        /// Gets or sets the offset end point.
        /// </summary>
        /// <value>
        /// The offset end point.
        /// </value>
        [Browsable(false)]
        [PropertyOrder(1, 14)]
        [Format("F2")]
        [Unit(UnitType.Length)]
        [Category("Location")]
        [XmlIgnore]
        public double OffsetEndPoint
        {
            get
            {
                return EndPoint.Offset;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, ds => ds.OffsetEndPoint);
                EndPoint.Offset = value;
                DataEventPublisher.AfterChange(this, ds => ds.OffsetEndPoint);
            }
        }

        /// <summary>
        /// Gets or sets the offset begin point.
        /// </summary>
        /// <value>
        /// The offset begin point.
        /// </value>
        [Browsable(false)]
        [PropertyOrder(1, 13)]
        [Format("F2")]
        [Unit(UnitType.Length)]
        [Category("Location")]
        [XmlIgnore]
        public double OffsetBeginPoint
        {
            get
            {
                return BeginPoint.Offset;
            }
            set
            {
                DataEventPublisher.BeforeChange(this,ds => ds.OffsetBeginPoint);
                BeginPoint.Offset = value;
                DataEventPublisher.AfterChange(this, ds => ds.OffsetBeginPoint);
            }
        }

        /// <summary>
        /// Gets or sets the name.
        /// </summary>
        /// <value>
        /// The name.
        /// </value>
        [XmlIgnore]
        public override string Name
        {
            get
            {
                if (string.IsNullOrWhiteSpace(base.Name))
                {
                    return RepresentativeDikeCrossSection != null
                               ? RepresentativeDikeCrossSection.Name
                               : base.Name;
                }

                return base.Name;
            }
        }

        /// <summary>
        /// The dikeline to which this location belongs
        /// </summary>
        // TODO can be replaced by the Point's implementation...
        [XmlIgnore]
        public override DikeLine DikeLine
        {
            get
            {
                return base.DikeLine;
            }
            set
            {
                base.DikeLine = value;
                if (beginPoint != null)
                {
                    beginPoint.DikeLine = value;
                }
                if (endPoint != null)
                {
                    endPoint.DikeLine = value;
                }
            }
        }

        /// <summary>
        /// Gets the offset, which is the center point of the section, of the section along the dike line.
        /// </summary>
        [XmlIgnore]
        public override double Offset
        {
            get
            {
                if (EndPoint.Offset >= BeginPoint.Offset)
                {
                    return (BeginPoint.Offset + EndPoint.Offset)/2;
                }
                else
                {
                    // Cyclic
                    return (BeginPoint.Offset + Length/2)%DikeLine.Length;
                }
            }
        }

        /// <summary>
        /// Gets or sets the original dike location.
        /// </summary>
        /// <value>
        /// The original dike location.
        /// </value>
        [Browsable(false)]
        [XmlIgnore]
        public override DikeLocation OriginalDikeLocation
        {
            get
            {
                return RepresentativeDikeCrossSection != null ? RepresentativeDikeCrossSection.OriginalDikeLocation : null;
            }
            set
            {
                if (RepresentativeDikeCrossSection != null)
                {
                    RepresentativeDikeCrossSection.OriginalDikeLocation = value;
                }
            }
        }

        [XmlIgnore]
        public override BlockRevetmentCrossSection BlockRevetmentCrossSection
        {
            get
            {
                return RepresentativeDikeCrossSection != null
                           ? RepresentativeDikeCrossSection.BlockRevetmentCrossSection
                           : null;
            }
            set
            {
                if (RepresentativeDikeCrossSection != null)
                {
                    DataEventPublisher.BeforeChange(this, x => x.BlockRevetmentCrossSection);
                    RepresentativeDikeCrossSection.BlockRevetmentCrossSection = value;
                    DataEventPublisher.AfterChange(this, x => x.BlockRevetmentCrossSection);
                }
            }
        }

        [XmlIgnore]
        public override BlockRevetmentRegion BlockRevetmentRegion
        {
            get
            {
                return RepresentativeDikeCrossSection != null
                           ? RepresentativeDikeCrossSection.BlockRevetmentRegion
                           : null;
            }
            set
            {
                if (RepresentativeDikeCrossSection != null)
                {
                    DataEventPublisher.BeforeChange(this, ds => ds.BlockRevetmentRegion);
                    RepresentativeDikeCrossSection.BlockRevetmentRegion = value;
                    DataEventPublisher.AfterChange(this, ds => ds.BlockRevetmentRegion);
                }
            }
        }

        [XmlIgnore]
        public override RoughnessCrossSection RoughnessCrossSection
        {
            get
            {
                return RepresentativeDikeCrossSection != null
                           ? RepresentativeDikeCrossSection.RoughnessCrossSection
                           : null;
            }
            set
            {
                if (RepresentativeDikeCrossSection != null)
                {
                    DataEventPublisher.BeforeChange(this, ds => ds.RoughnessCrossSection);
                    RepresentativeDikeCrossSection.RoughnessCrossSection = value;
                    DataEventPublisher.AfterChange(this, ds => ds.RoughnessCrossSection);
                }
            }
        }

        [XmlIgnore]
        public override AsphaltCrossSection AsphaltCrossSection
        {
            get
            {
                return RepresentativeDikeCrossSection != null
                           ? RepresentativeDikeCrossSection.AsphaltCrossSection
                           : null;
            }
            set
            {
                if (RepresentativeDikeCrossSection != null)
                {
                    DataEventPublisher.BeforeChange(this, ds => ds.AsphaltCrossSection);
                    RepresentativeDikeCrossSection.AsphaltCrossSection = value;
                    DataEventPublisher.AfterChange(this, ds => ds.AsphaltCrossSection);
                }
            }
        }

        [XmlIgnore]
        public override AsphaltRegion AsphaltRegion
        {
            get
            {
                return RepresentativeDikeCrossSection != null
                           ? RepresentativeDikeCrossSection.AsphaltRegion
                           : null;
            }
            set
            {
                if (RepresentativeDikeCrossSection != null)
                {
                    DataEventPublisher.BeforeChange(this, ds => ds.AsphaltRegion);
                    RepresentativeDikeCrossSection.AsphaltRegion = value;
                    DataEventPublisher.AfterChange(this, ds => ds.AsphaltRegion);
                }
            }
        }

        /// <summary>
        /// Length of the dike location
        /// </summary>
        [Label("Length")]
        [Description("Length of the section")]
        [Unit(UnitType.Length)]
        [Format("F2")]
        [ReadOnly(true)]
        [XmlIgnore]
        [PropertyOrder(1, 15)]
        public override double Length
        {
            get
            {
                return EndPoint.Offset - BeginPoint.Offset;
            }
            set {}
        }

        /// <summary>
        /// Soil Segments (per failure mechanism) for the location
        /// </summary>
        [XmlIgnore]
        public override Dictionary<Mechanism, SoilSegment> SoilSegments
        {
            get
            {
                return RepresentativeDikeCrossSection != null ? RepresentativeDikeCrossSection.SoilSegments : base.SoilSegments;
            }
        }

        /// <summary>
        /// Gets or sets the break water.
        /// </summary>
        /// <value>
        /// The break water.
        /// </value>
        [XmlIgnore]
        public override BreakWater BreakWater
        {
            get
            {
                return RepresentativeDikeCrossSection != null ? RepresentativeDikeCrossSection.BreakWater : null;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, ds => ds.BreakWater);
                RepresentativeDikeCrossSection.BreakWater = value;
                DataEventPublisher.AfterChange(this, ds => ds.BreakWater);
            }
        }

        /// <summary>
        /// Gets or sets the auto setting for break water.
        /// </summary>
        /// <value>
        /// The break water.
        /// </value>
        [XmlIgnore]
        public override bool IsAutoLinkedToBreakWater
        {
            get
            {
                return RepresentativeDikeCrossSection != null ? RepresentativeDikeCrossSection.IsAutoLinkedToBreakWater : base.IsAutoLinkedToBreakWater;
            }
            set
            {
                if (RepresentativeDikeCrossSection != null)
                {
                    DataEventPublisher.BeforeChange(this, ds => ds.IsAutoLinkedToBreakWater);
                    RepresentativeDikeCrossSection.IsAutoLinkedToBreakWater = value;
                    DataEventPublisher.AfterChange(this, ds => ds.IsAutoLinkedToBreakWater);
                }
            }
        }

        /// <summary>
        /// Reference to the first station
        /// Relative share of hydraulic boundary 1
        /// </summary>
        [XmlIgnore]
        public override HydraulicBoundary HydraulicBoundary1
        {
            get
            {
                return RepresentativeDikeCrossSection != null ? RepresentativeDikeCrossSection.HydraulicBoundary1 : null;
            }
            set
            {
                if (RepresentativeDikeCrossSection != null)
                {
                    DataEventPublisher.BeforeChange(this, x => x.HydraulicBoundary1);
                    RepresentativeDikeCrossSection.HydraulicBoundary1 = value;
                    DataEventPublisher.AfterChange(this, x => x.HydraulicBoundary1);
                }
            }
        }

        /// <summary>
        /// Reference to the first station
        /// Relative share of hydraulic boundary 2
        /// </summary>
        [XmlIgnore]
        public override HydraulicBoundary HydraulicBoundary2
        {
            get
            {
                return RepresentativeDikeCrossSection != null ? RepresentativeDikeCrossSection.HydraulicBoundary2 : null;
            }
            set
            {
                if (RepresentativeDikeCrossSection != null)
                {
                    DataEventPublisher.BeforeChange(this, x => HydraulicBoundary2);
                    RepresentativeDikeCrossSection.HydraulicBoundary2 = value;
                    DataEventPublisher.AfterChange(this, x => HydraulicBoundary2);
                }
            }
        }

        /// <summary>
        /// Surfaceline that is schematized for a specific mechanism
        /// </summary>
        /// <value>
        /// The schematized surface line.
        /// </value>
        [XmlIgnore]
        [Validate]
        public override SurfaceLine2 SchematizedSurfaceLine
        {
            get
            {
                return RepresentativeDikeCrossSection != null ? RepresentativeDikeCrossSection.SchematizedSurfaceLine : null;
            }
            set
            {
                if (RepresentativeDikeCrossSection != null)
                {
                    DataEventPublisher.BeforeChange(this, ds => ds.SchematizedSurfaceLine);
                    RepresentativeDikeCrossSection.SchematizedSurfaceLine = value;
                    DataEventPublisher.AfterChange(this, ds => ds.SchematizedSurfaceLine);
                }
            }
        }

        /// <summary>
        /// gets or sets Surfaceline
        /// </summary>
        /// <value>
        /// The surface line.
        /// </value>
        [XmlIgnore]
        public override LocalizedGeometryPointString SurfaceLine
        {
            get
            {
                return RepresentativeDikeCrossSection != null ? RepresentativeDikeCrossSection.SurfaceLine : null;
            }
            set
            {
                if (RepresentativeDikeCrossSection != null)
                {
                    DataEventPublisher.BeforeChange(this, ds => ds.SurfaceLine);
                    RepresentativeDikeCrossSection.SurfaceLine = value;
                    DataEventPublisher.AfterChange(this, ds => ds.SurfaceLine);
                }
            }
        }

        /// <summary>
        /// gets or sets piezometric heads
        /// </summary>
        [XmlIgnore]
        public override PiezometricHeads PiezometricHeads
        {
            get
            {
                return RepresentativeDikeCrossSection != null ? RepresentativeDikeCrossSection.PiezometricHeads : null;
            }
            set
            {
                if (RepresentativeDikeCrossSection != null)
                {
                    DataEventPublisher.BeforeChange(this, x => x.PiezometricHeads);
                    RepresentativeDikeCrossSection.PiezometricHeads = value;
                    DataEventPublisher.AfterChange(this, x => x.PiezometricHeads);
                }
            }
        }

        /// <summary>
        /// Get or Set Assessment Level
        /// </summary>
        public override double AssessmentLevel
        {
            get
            {
                if (RepresentativeDikeCrossSection != null)
                {
                    return RepresentativeDikeCrossSection.AssessmentLevel;
                }
                return double.NaN;
            }
        }

        /// <summary>
        /// Gets or sets the flow speed.
        /// </summary>
        /// <value>
        /// The flow speed.
        /// </value>
        [XmlIgnore]
        public override double FlowSpeed
        {
            get
            {
                return RepresentativeDikeCrossSection != null ? RepresentativeDikeCrossSection.FlowSpeed : 1;
            }
            set
            {
                if (RepresentativeDikeCrossSection != null)
                {
                    RepresentativeDikeCrossSection.FlowSpeed = value;
                }
            }
        }

        /// <summary>
        /// Gets the design values.
        /// </summary>
        /// <value>
        /// The design values.
        /// </value>
        [XmlIgnore]
        public override List<DesignValue> DesignValues
        {
            get
            {
                return RepresentativeDikeCrossSection != null ? RepresentativeDikeCrossSection.DesignValues : base.DesignValues;
            }
        }

        /// <summary>
        /// Gets a representation of this dike section using <see cref="Points"/>. This representation starts with the <see cref="BeginPoint"/>
        /// and ends with the <see cref="EndPoint"/> and all the points on the <see cref="DikeLine"/> which are between these two points.
        /// </summary>
        /// <remarks>Shallow copy of <see cref="BeginPoint"/>, points of <see cref="DikeLine"/> and <see cref="EndPoint"/>.</remarks>
        [XmlIgnore]
        public IList<IGeographicPoint> Points
        {
            get
            {
                if (BeginPoint == null || DikeLine == null)
                {
                    return null;
                }

                var points = new List<IGeographicPoint>
                {
                    BeginPoint
                };
                points.AddRange(DikeLine.GetPointBetweenOffsets(BeginPoint.Offset, EndPoint.Offset));
                points.Add(EndPoint);

                return points;
            }
        }

        /// <summary>
        /// Function to get the ten nearest BreakWaters
        /// </summary>
        [XmlIgnore]
        [Browsable(false)]
        public static Func<DikeSection, IEnumerable<DikeCrossSection>> GetCrossSections { get; set; }

        /// <summary>
        /// Creates a dike section based on the dike line end begin point info.
        /// </summary>
        /// <param name="dikeLine">The dike line.</param>
        /// <param name="begin">The begin.</param>
        /// <returns>dike section</returns>
        public static DikeSection Create(DikeLine dikeLine, DikeLinePoint begin)
        {
            var dikeSection = Create(dikeLine, begin, new DikeLinePoint(dikeLine.Length, dikeLine));
            return dikeSection;
        }

        /// <summary>
        /// Creates a dike section based on the dike line, begin and end point info.
        /// </summary>
        /// <param name="dikeLine">The dike line.</param>
        /// <param name="begin">The begin.</param>
        /// <param name="end">The end.</param>
        /// <returns>dike section</returns>
        public static DikeSection Create(DikeLine dikeLine, DikeLinePoint begin, DikeLinePoint end)
        {
            return new DikeSection
            {
                DikeLine = dikeLine,
                BeginPoint = begin,
                EndPoint = end
            };
        }

        /// <summary>
        /// Gets the representive point.
        /// </summary>
        /// <returns>
        /// representative point
        /// </returns>
        public override IGeographicPoint GetRepresentivePoint()
        {
            return RepresentativeDikeCrossSection != null ? RepresentativeDikeCrossSection.GetRepresentivePoint() : BeginPoint;
        }

        /// <summary>
        /// Gets the distance to a given location along the same dike line
        /// </summary>
        /// <param name="x">Location</param>
        /// <returns>Distance</returns>
        public override double GetDistance(double x)
        {
            if (OffsetBeginPoint <= OffsetEndPoint)
            {
                if (OffsetBeginPoint <= x && OffsetEndPoint >= x)
                {
                    return 0;
                }
                else if (x < OffsetBeginPoint)
                {
                    return OffsetBeginPoint - x;
                }
                else
                {
                    return x - OffsetEndPoint;
                }
            }
            else
            {
                // Cyclic
                if (x <= OffsetEndPoint || x >= OffsetBeginPoint)
                {
                    return 0;
                }
                else if (x < OffsetBeginPoint)
                {
                    return OffsetBeginPoint - x;
                }
                else
                {
                    return x - OffsetEndPoint;
                }
            }
        }

        [Obsolete("Only used for serialization", true)]
        private SerializedDikeSection State
        {
            get
            {
                return new SerializedDikeSection(this);
            }
            set
            {
                DikeLine = value.DikeLine;
                BeginPoint = value.BeginPoint;
                EndPoint = value.EndPoint;
                RepresentativeDikeCrossSection = value.RepresentativeDikeCrossSection;
                Name = value.Name;
            }
        }

        private void DataEventPublisher_OnAfterChange(object sender, PublishEventArgs e)
        {
            var offsetChanged = e.Property == StaticReflection.GetMemberName<DikeSection>(ds => ds.Offset);
            if (ReferenceEquals(sender, BeginPoint) && offsetChanged)
            {
                RestrictBeginPointOffsets();
                DataEventPublisher.AfterChange(this, ds => ds.BeginPoint);
            }
            if (ReferenceEquals(sender, EndPoint) && offsetChanged)
            {
                RestrictEndPointOffsets();
            }
            if (ReferenceEquals(sender, RepresentativeDikeCrossSection))
            {
                DataEventPublisher.AfterChange(this, e.Properties);
            }
        }

        private void RestrictEndPointOffsets()
        {
            if (endPoint.Offset - beginPoint.Offset <= 0)
            {
                endPoint.Offset = beginPoint.Offset + 1;
            }
        }

        private void RestrictBeginPointOffsets()
        {
            if (endPoint.Offset - beginPoint.Offset <= 0)
            {
                beginPoint.Offset = endPoint.Offset - 1;
            }
        }

        # region Methods

        /// <summary>
        /// Gets the dike cross sections.
        /// </summary>
        /// <value>
        /// The dike cross sections.
        /// </value>
        public List<DikeCrossSection> DikeCrossSections
        {
            get
            {
                return dikeCrossSections;
            }
        }

        /// <summary>
        /// Gets the domain.
        /// </summary>
        /// <param name="property">The property.</param>
        /// <returns>
        /// domain
        /// </returns>
        public override ICollection GetDomain(string property)
        {
            if (property == StaticReflection.GetMemberName<DikeSection>(ds => RepresentativeDikeCrossSection))
            {
                return GetCrossSectionsDomain();
            }

            return base.GetDomain(property);
        }

        /// <summary>
        /// Gets the cross sections domain.
        /// </summary>
        /// <returns>Domain</returns>
        private ICollection GetCrossSectionsDomain()
        {
            if (GetCrossSections == null)
            {
                return null;
            }

            return GetCrossSections(this).ToList();
        }

        #region IDisposable

        public override void Dispose()
        {
            DataEventPublisher.OnAfterChange -= DataEventPublisher_OnAfterChange;
            base.Dispose();
        }

        #endregion

        #endregion

        #region class SerializedDikeSection

        private class SerializedDikeSection
        {
            public SerializedDikeSection(DikeSection point)
            {
                DikeLine = point.DikeLine;
                BeginPoint = point.BeginPoint;
                EndPoint = point.EndPoint;
                RepresentativeDikeCrossSection = point.RepresentativeDikeCrossSection;
                Name = point.Name;
            }

            private SerializedDikeSection() { }

            public DikeLine DikeLine { get; private set; }
            public DikeLinePoint BeginPoint { get; private set; }
            public DikeLinePoint EndPoint { get; private set; }
            public DikeCrossSection RepresentativeDikeCrossSection { get; private set; }
            public String Name { get; private set; }
        }

        #endregion
    }
}