using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Xml.Serialization;
using Deltares.DeltaModel;
using Deltares.Geographic;
using Deltares.Geometry;
using Deltares.Geotechnics;
using Deltares.Geotechnics.GeotechnicalGeometry;
using Deltares.Geotechnics.Mechanisms;
using Deltares.Geotechnics.Soils;
using Deltares.Geotechnics.SurfaceLines;
using Deltares.Probabilistic;
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.AssessmentMechanism
{
    /// <summary>
    /// This class represents all the parameters for a <see cref="DikeLocation"/> which may be required for a specific <see cref="Deltares.AssessmentMechanism.AssessmentCalculation"/>. The <see cref="DikeLocationInfo"/>
    /// contains the schematizations of the imported data and allows for modifications thereupon. 
    /// </summary>
    public class DikeLocationInfo : IName, IHasGeographic, IHasSurfaceLine, IHasSchematizedSurfaceLine, IComparable<DikeLocationInfo>, IComparable, IVisibleEnabled, IDomain, IDisposable
    {
        private readonly List<DikeLocationInfo> locations = new List<DikeLocationInfo>();
        protected readonly List<AssessmentScenario> scenarios = new List<AssessmentScenario>();
        private double allowedFailureProbability = double.NaN;
        private AssessmentScenario currentScenario;
        private StochasticSoilProfile currentStochasticSoilProfile;
        protected Soil defaultDikeEmbankmentMaterial;
        private DikeLocation dikeLocation = new DikeLocation();

        private SurfaceLine2 schematizedSurfaceLine = new SurfaceLine2
        {
            CharacteristicPoints =
            {
                GeometryMustContainPoint = false
            }
        };

        private SoilProfile1D soilProfile;
        private SoilProfile2D soilProfile2D;
        protected SoilSurfaceProfile soilSurfaceProfile;
        protected SoilSurfaceProfile2D soilSurfaceProfile2D;
        private StochasticSoilModel stochasticSoilModel;
        private LocalizedGeometryPointString surfaceLine = new LocalizedGeometryPointString();

        /// <summary>
        /// Initializes a new instance of the <see cref="DikeLocationInfo"/> class.
        /// </summary>
        public DikeLocationInfo()
        {
            schematizedSurfaceLine.Geometry = surfaceLine;

            // Initialize with default 1D soil profile in order to provide a default soil schematization (also when no actual soil profiles are involved)
            SoilProfile = new SoilProfile1D();

            DataEventPublisher.OnAfterChange += DataEventPublisher_OnAfterChange;
        }

        /// <summary>
        /// Gets or sets the dike location that this dike location info was created for. Composite relation.
        /// </summary>
        [Browsable(false)]
        [Validate]
        public virtual DikeLocation DikeLocation
        {
            get
            {
                return dikeLocation;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, "DikeLocation");
                if (null != dikeLocation)
                {
                    dikeLocation.Dispose();
                }
                dikeLocation = value;

                DataEventPublisher.AfterChange(this, "DikeLocation");
            }
        }

        /// <summary>
        /// Gets or sets the offset end point.
        /// </summary>
        /// <value>
        /// The offset end point.
        /// </value>
        [Unit(UnitType.Length)]
        [Minimum(0.0)]
        [Format("F1")]
        [PropertyOrder(2, 8)]
        public virtual double OffsetEndPoint
        {
            get
            {
                var dikeSection = DikeLocation as DikeSection;
                if (dikeSection != null)
                {
                    return dikeSection.EndPoint.Offset;
                }
                return 0.0;
            }
            set
            {
                var dikeSection = DikeLocation as DikeSection;
                if (dikeSection != null)
                {
                    DataEventPublisher.BeforeChange(this, "OffsetEndPoint");
                    dikeSection.OffsetEndPoint = value;
                    UpdateDikeSection(dikeSection, value, false);
                    DataEventPublisher.AfterChange(this, "OffsetEndPoint");
                }
            }
        }

        /// <summary>
        /// Gets or sets the offset begin point.
        /// </summary>
        /// <value>
        /// The offset begin point.
        /// </value>
        [Unit(UnitType.Length)]
        [Minimum(0.0)]
        [Format("F1")]
        [PropertyOrder(1, 7)]
        public virtual double OffsetBeginPoint
        {
            get
            {
                var dikeSection = DikeLocation as DikeSection;
                if (dikeSection != null)
                {
                    return dikeSection.BeginPoint.Offset;
                }
                return 0.0;
            }
            set
            {
                var dikeSection = DikeLocation as DikeSection;
                if (dikeSection != null)
                {
                    DataEventPublisher.BeforeChange(this, "OffsetBeginPoint");
                    dikeSection.OffsetBeginPoint = value;
                    UpdateDikeSection(dikeSection, value, true);
                    DataEventPublisher.AfterChange(this, "OffsetBeginPoint");
                }
            }
        }

        /// <summary>
        /// Gets the length.
        /// </summary>
        /// <value>
        /// The length.
        /// </value>
        [Unit(UnitType.Length)]
        [Description("Length of the dike section")]
        [Format("F1")]
        [PropertyOrder(2, 9)]
        [Label("Length")]
        public double Length
        {
            get
            {
                return OffsetEndPoint - OffsetBeginPoint;
            }
        }

        /// <summary>
        /// Gets or sets a list of DunesDikeLocationInfo. Used in the DunesCalculation.
        /// </summary>
        public List<DikeLocationInfo> Locations
        {
            get
            {
                return locations;
            }
        }

        /// <summary>
        /// Gets or sets the soil profile (1D) for location
        /// </summary>
        [PropertyOrder(2, 2)]
        [Mechanism(Mechanism.PipingUpliftGradient, Mechanism.Piping, Mechanism.Stability)]
        [Validate]
        [XmlIgnore]
        public virtual SoilProfile1D SoilProfile
        {
            get
            {
                return soilProfile;
            }
            set
            {
                if (soilProfile == value)
                {
                    return;
                }

                DataEventPublisher.BeforeChange(this, dli => dli.SoilProfile);

                soilProfile = value;

                SoilSurfaceProfile = soilProfile != null
                                         ? new SoilSurfaceProfile
                                           {
                                               SurfaceLine = surfaceLine,
                                               SoilProfile = soilProfile,
                                               DikeEmbankmentMaterial = DefaultDikeEmbankmentMaterial
                                           }
                                         : null;

                DataEventPublisher.AfterChange(this, dli => dli.SoilProfile);
            }
        }

        /// <summary>
        /// Gets or sets the soil profile (2D) for location
        /// </summary>
        [PropertyOrder(2, 3)]
        [Mechanism(Mechanism.Stability)]
        [Validate]
        [XmlIgnore]
        public virtual SoilProfile2D SoilProfile2D
        {
            get
            {
                return soilProfile2D;
            }
            set
            {
                if (soilProfile2D == value)
                {
                    return;
                }

                DataEventPublisher.BeforeChange(this, "SoilProfile2D");

                soilProfile2D = value;

                SoilSurfaceProfile2D = soilProfile2D != null
                                           ? new SoilSurfaceProfile2D
                                             {
                                                 SurfaceLine = surfaceLine,
                                                 SoilProfile2D = soilProfile2D,
                                                 DikeEmbankmentMaterial = DefaultDikeEmbankmentMaterial
                                             }
                                           : null;

                DataEventPublisher.AfterChange(this, "SoilProfile2D");
            }
        }

        /// <summary>
        /// Gets or sets the stochastic soil model for the location
        /// </summary>
        [Mechanism(Mechanism.PipingUpliftGradient, Mechanism.Piping, Mechanism.Stability)]
        public virtual StochasticSoilModel StochasticSoilModel
        {
            get
            {
                return stochasticSoilModel;
            }
            set
            {
                this.SetAndNotify2(out stochasticSoilModel, value, dli => dli.StochasticSoilModel);
            }
        }

        /// <summary>
        /// Gets or sets the currently active Stochastic soil profile for the location.
        /// </summary>
        [Browsable(false)]
        [XmlIgnore]
        public StochasticSoilProfile CurrentStochasticSoilProfile
        {
            get
            {
                return currentStochasticSoilProfile;
            }
            set // Don't remove: used by scenario items in derived classes
            {
                DataEventPublisher.BeforeChange(this, dli => dli.CurrentStochasticSoilProfile);

                currentStochasticSoilProfile = value;

                if (currentStochasticSoilProfile == null || currentStochasticSoilProfile.Profile == null)
                {
                    SoilProfile2D = null;
                    SoilProfile = null;
                }
                else if (currentStochasticSoilProfile.Profile is SoilProfile2D)
                {
                    SoilProfile2D = (SoilProfile2D)currentStochasticSoilProfile.Profile;
                    SoilProfile = null;
                }
                else if (currentStochasticSoilProfile.Profile is SoilProfile1D)
                {
                    SoilProfile = (SoilProfile1D)currentStochasticSoilProfile.Profile;
                    SoilProfile2D = null;
                }

                DataEventPublisher.AfterChange(this, dli => dli.CurrentStochasticSoilProfile);
            }
        }

        /// <summary>
        /// Gets or sets the active scenario for which the assessment will be performed.
        /// </summary>
        // TODO Should the current active scenario always be part of the known Scenario's property?
        [XmlOmit(null)]
        [Mechanism(Mechanism.PipingUpliftGradient, Mechanism.Piping, Mechanism.Stability)]
        public virtual AssessmentScenario CurrentScenario
        {
            get
            {
                if (currentScenario == null)
                {
                    if (!DataEventPublisher.IsDataEventPublishStopped && scenarios.Count == 0)
                    {
                        InitializeScenarios();
                    }
                }

                return currentScenario;
            }
            set
            {
                if (currentScenario != value)
                {
                    try
                    {
                        Delayed.BeginDelay();
                        DataEventPublisher.BeforeChange(this, dli => dli.CurrentScenario);

                        if (currentScenario != null)
                        {
                            currentScenario.Synchronize();
                            if (value == null)
                            {
                                currentScenario.Unapply();
                            }
                            else
                            {
                                DataEventPublisher.InvokeWithoutPublishingEvents(() => currentScenario.Unapply());
                            }
                        }
                        currentScenario = value;
                        if (currentScenario != null)
                        {
                            currentScenario.Apply();
                        }

                        DataEventPublisher.AfterChange(this, dli => dli.CurrentScenario);
                    }
                    finally
                    {
                        Delayed.EndDelay();    
                    }                    
                }
            }
        }

        /// <summary>
        /// Gets the combination of soil profile (2D) and surface line.
        /// </summary>
        [Browsable(false)]
        public virtual SoilSurfaceProfile2D SoilSurfaceProfile2D
        {
            get
            {
                return soilSurfaceProfile2D;
            }
            protected set
            {
                DataEventPublisher.BeforeChange(this, dli => dli.SoilSurfaceProfile2D);

                if (soilSurfaceProfile2D != null)
                {
                    soilSurfaceProfile2D.Dispose();
                }

                soilSurfaceProfile2D = value;

                DataEventPublisher.AfterChange(this, dli => dli.SoilSurfaceProfile2D);
            }
        }

        /// <summary>
        /// Gets or sets the combination of soil profile (1D) and surface line.
        /// </summary>
        [Browsable(false)]
        public virtual SoilSurfaceProfile SoilSurfaceProfile
        {
            get
            {
                return soilSurfaceProfile;
            }
            protected set
            {
                DataEventPublisher.BeforeChange(this, dli => dli.SoilSurfaceProfile);

                if (soilSurfaceProfile != null)
                {
                    soilSurfaceProfile.Dispose();
                }

                soilSurfaceProfile = value;

                DataEventPublisher.AfterChange(this, dli => dli.SoilSurfaceProfile);
            }
        }

        /// <summary>
        /// Default embankment material to be used in <see cref="SoilSurfaceProfile"/> and/or <see cref="SoilSurfaceProfile2D"/>.
        /// </summary>
        [Browsable(false)]
        public virtual Soil DefaultDikeEmbankmentMaterial
        {
            get
            {
                return defaultDikeEmbankmentMaterial;
            }
            set
            {
                this.SetAndNotify2(out defaultDikeEmbankmentMaterial, value, x => x.DefaultDikeEmbankmentMaterial);

                if (SoilSurfaceProfile != null)
                {
                    SoilSurfaceProfile.DikeEmbankmentMaterial = value;
                }

                if (SoilSurfaceProfile2D != null)
                {
                    SoilSurfaceProfile2D.DikeEmbankmentMaterial = value;
                }
            }
        }

        /// <summary>
        /// Gets the list of <see cref="AssessmentScenario"/>.
        /// </summary>
        [Mechanism(Mechanism.PipingUpliftGradient, Mechanism.Piping, Mechanism.Stability)]
        public virtual IList<AssessmentScenario> Scenarios
        {
            get
            {
                if (!DataEventPublisher.IsDataEventPublishStopped && scenarios.Count == 0)
                {
                    InitializeScenarios();
                }

                return scenarios;
            }
        }

        /// <summary>
        /// Gets or sets the maximum allowed failure probability based on the failure probability of the <see cref="Deltares.DeltaModel.DikeSection"/> which the <see cref="DikeLocation"/> 
        /// is part of.
        /// </summary>
        [Unit(UnitType.ProbabilityPerYear)]
        [Format("F2")]
        [ReadOnly(true)]
        [PropertyOrder(1, 1)]
        public double AllowedFailureProbability
        {
            get
            {
                return allowedFailureProbability;
            }
            set
            {
                if (value != allowedFailureProbability)
                {
                    this.SetAndNotify2(out allowedFailureProbability, value, dli => dli.AllowedFailureProbability);
                }
            }
        }

        /// <summary>
        /// Returns the geographic part of the dike location
        /// </summary>
        [Browsable(false)]
        public IGeographic Geographic
        {
            get
            {
                return DikeLocation;
            }
        }

        /// <summary>
        /// Gets or sets the schematized surface line for a specific mechanism.
        /// </summary>
        [PropertyOrder(2, 1)]
        [Label("Surface line")]
        [Description("Surface line")]
        [Browsable(false)]
        [Validate]
        public virtual SurfaceLine2 SchematizedSurfaceLine
        {
            get
            {
                return schematizedSurfaceLine;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, "SchematizedSurfaceLine");
                if (null != schematizedSurfaceLine)
                {
                    schematizedSurfaceLine.Dispose();
                }
                schematizedSurfaceLine = value;
                if (schematizedSurfaceLine != null)
                {
                    schematizedSurfaceLine.Geometry = surfaceLine;
                }
                DataEventPublisher.AfterChange(this, "SchematizedSurfaceLine");
            }
        }

        /// <summary>
        /// Gets or sets the adapted surface line for the failure mechanism.
        /// </summary>
        public virtual LocalizedGeometryPointString SurfaceLine
        {
            get
            {
                return surfaceLine;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, "SurfaceLine");
                surfaceLine = value;

                schematizedSurfaceLine.Geometry = surfaceLine;

                if (soilSurfaceProfile != null)
                {
                    soilSurfaceProfile.SurfaceLine = surfaceLine;
                }

                if (soilSurfaceProfile2D != null)
                {
                    soilSurfaceProfile2D.SurfaceLine = surfaceLine;
                }

                DataEventPublisher.AfterChange(this, "SurfaceLine");
            }
        }

        /// <summary>
        /// Name visible to the end user
        /// </summary>
        [Label("Name")]
        [PropertyOrder(0, 1)]
        [XmlIgnore]
        public virtual string Name
        {
            get
            {
                return DikeLocation.Name;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, "Name");
                DikeLocation.Name = value;
                DataEventPublisher.AfterChange(this, "Name");
            }
        }

        /// <summary>
        /// Initializes the <see cref="DikeLocation"/> for a calculation. This method is invoked from HydraRing to gain a specific
        /// state for this <see cref="DikeLocationInfo"/> instance. Invoking this method means that <see cref="FinalizeFromCalculation"/>
        /// has to be called after the calculation has been executed.
        /// </summary>
        public virtual void InitializeForCalculation() {}

        /// <summary>
        /// Finalizes the <see cref="DikeLocation"/> from a calculation. If parameters have changed in <see cref="InitializeForCalculation"/>
        /// which could influence successive calculations, then this method will reset them appropriately.
        /// </summary>
        public virtual void FinalizeFromCalculation() {}

        /// <summary>
        /// Updates the dike section.
        /// TODO: Comment
        /// </summary>
        /// <param name="dikeSection">The dike section.</param>
        /// <param name="offset">The offset.</param>
        /// <param name="beginP">if set to <c>true</c> [begin p].</param> TODO: Comment: what is beginP?
        public void UpdateDikeSection(DikeSection dikeSection, double offset, bool beginP)
        {
            var newSection = dikeSection;
            if (beginP)
            {
                var index = 0;
                var point = GeographicHelper.Instance.FindGeographicPointByOffsetOnLine(offset, newSection.DikeLine);
                newSection.BeginPoint.SetCoordinate(point.X, point.Y);

                DataEventPublisher.AfterChange(this);
            }

            if (!beginP)
            {
                var index = 0;
                var point = GeographicHelper.Instance.FindGeographicPointByOffsetOnLine(offset, newSection.DikeLine);
                newSection.EndPoint.SetCoordinate(point.X, point.Y);

                DataEventPublisher.AfterChange(this);
            }
            DikeLocation = newSection;
        }

        /// <summary>
        /// Gets the stochasts.
        /// </summary>
        /// <returns>list with stochasts</returns>
        public virtual List<Stochast> GetStochasts()
        {
            return new List<Stochast>();
        }

        /// <summary>
        /// Initialize the scenarios for this instance.
        /// </summary>
        public virtual void InitializeScenarios()
        {
            // Clear any previous scenarios
            scenarios.Clear();

            // Add a dummy scenario
            scenarios.Add(new AssessmentScenario
                          {
                              Probability = 1.0
                          });
            CurrentScenario = scenarios[0];
        }

        /// <summary>
        /// Reverts the surface line.
        /// </summary>
        [Label("Revert")]
        public virtual void RevertSurfaceLine()
        {
            // First, re-clone the SchematizedSurfaceLine according to the original SchematizedSurfaceLine
            DikeLocation.SchematizedSurfaceLine.FullDeepClone(SchematizedSurfaceLine, MechanismSupport.Mechanisms);
            InitializeScenarios();
            // Second, also re-clone the SurfaceLine line when it doesn't equal OriginalDikeLocation.SurfaceLine
            if (!ReferenceEquals(SurfaceLine, DikeLocation.SurfaceLine))
            {
                SurfaceLine = SchematizedSurfaceLine.Geometry; // Note: the newly cloned SchematizedSurfaceLine already holds a new clone of the original SurfaceLine, so use that one

                DataEventPublisher.DataListModified(SurfaceLine.Points);
            }

            DataEventPublisher.DataListModified(SchematizedSurfaceLine.CharacteristicPoints);
            DataEventPublisher.DataListModified(SchematizedSurfaceLine.Geometry.Points);
            DataEventPublisher.DataListModified(Scenarios);

            // Send an event which will be handled to complete the revert of the dike location
            DataEventPublisher.AfterChange(DikeLocation, "Revert");
        }

        /// <summary>
        /// Gets the name.
        /// </summary>
        /// <param name="property">The property.</param>
        /// <returns>null</returns>
        public virtual string GetName(string property)
        {
            return null;
        }

        /// <summary>
        /// Gets the part of the surface line which is relevant for the mechanism.
        /// </summary>
        /// <returns>All relevant surface line points.</returns>
        public virtual GeometryPointString GetRelevantSurfacePoints()
        {
            return SurfaceLine;
        }

        /// <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()
        {
            if (Geographic != null)
            {
                return Geographic.ToString();
            }
            else
            {
                return base.ToString();
            }
        }

        #region IDisposable

        public virtual void Dispose()
        {
            DataEventPublisher.OnAfterChange -= DataEventPublisher_OnAfterChange;

            if (soilSurfaceProfile != null)
            {
                soilSurfaceProfile.Dispose();
            }
            if (soilSurfaceProfile2D != null)
            {
                soilSurfaceProfile2D.Dispose();
            }

            if (schematizedSurfaceLine != null)
            {
                schematizedSurfaceLine.Dispose();
            }

            if (dikeLocation != null)
            {
                dikeLocation.Dispose();
            }
        }

        #endregion

        #region IDomain Members

        public virtual ICollection GetDomain(string property)
        {
            if (property == this.GetMemberName(dli => dli.CurrentScenario))
            {
                return Scenarios.ToArray();
            }
            return null;
        }

        #endregion

        private void DataEventPublisher_OnAfterChange(object sender, PublishEventArgs e)
        {
            var windHydraulicBoundary = sender as WindHydraulicBoundary;
            if (windHydraulicBoundary != null && DikeLocation.WaveZone.Waves.Count > 0)
            {
                if (DikeLocation.HydraulicBoundary1 != null && DikeLocation.HydraulicBoundary1.WindHydraulicBoundaries.Contains(windHydraulicBoundary))
                {
                    DikeLocation.WaveZone.Waves[0].Height = Double.NaN;
                }
                else if (DikeLocation.HydraulicBoundary2 != null && DikeLocation.HydraulicBoundary2.WindHydraulicBoundaries.Contains(windHydraulicBoundary))
                {
                    DikeLocation.WaveZone.Waves[0].Height = Double.NaN;
                }
            }
        }

        #region IVisibleEnabled Members

        /// <summary>
        /// Determines whether the specified property is enabled.
        /// </summary>
        /// <param name="property">The property.</param>
        /// <returns><c>true</c></returns>
        public virtual bool IsEnabled(string property)
        {
            return true;
        }

        public virtual bool IsVisible(string property)
        {
            var visible = MechanismSupport.IsMechanismVisible(typeof(DikeLocationInfo), property);
            if (visible && property == this.GetMemberName(dli => dli.CurrentScenario))
            {
                // Ensure you have a scenario to choose from:
                visible = Scenarios.Count >= 2;
            }
            return visible;
        }

        #endregion

        #region IComparable Members

        /// <summary>
        /// Compares the current instance with another object of the same type
        /// </summary>
        /// <param name="obj">An object to compare with this instance.</param>
        /// <returns>
        /// if object is DikeLocationInfo, calls above function, otherwise returns 1
        /// </returns>
        public int CompareTo(object obj)
        {
            if (obj is DikeLocationInfo)
            {
                return CompareTo((DikeLocationInfo) obj);
            }
            else
            {
                return 1;
            }
        }

        /// <summary>
        /// Compares the current object with another object of the same type.
        /// </summary>
        /// <param name="other">An object to compare with this object.</param>
        /// <returns>
        /// value of comparing offsetBeginPoints
        /// </returns>
        public int CompareTo(DikeLocationInfo other)
        {
            return OffsetBeginPoint.CompareTo(other.OffsetBeginPoint);
        }

        #endregion
    }
}