using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Xml.Serialization;

using Deltares.Geotechnics;
using Deltares.Geotechnics.Soils;
using Deltares.Standard;
using Deltares.Standard.Attributes;
using Deltares.Standard.EventPublisher;
using Deltares.Standard.Reflection;
using Deltares.Standard.Scenarios;
using Deltares.Standard.Units;
using Deltares.Standard.Validation;

namespace Deltares.AssessmentMechanism
{
    /// <summary>
    /// An <see cref="Scenario{T}"/> object to be used for <see cref="Deltares.AssessmentMechanism.AssessmentCalculation"/>
    /// to hold scenario dependent data, based on a <see cref="StochasticSoilProfile"/>.
    /// </summary>
    public class AssessmentScenario : Scenario<object>, IDomain, IVisibleEnabled
    {
        private AssessmentCalculationResult assessmentCalculationResult = new AssessmentCalculationResult();
        private double probability;

        /// <summary>
        /// Initializes a new instance of the <see cref="AssessmentScenario"/> class without
        /// any <see cref="ScenarioItem{T}"/> definitions.
        /// </summary>
        public AssessmentScenario()
        {
            Name = String.Empty;
            Description = String.Empty;
        }

        /// <summary>
        /// Indicates the probability of the scenario
        /// </summary>
        [Clearable]
        [Unit(UnitType.Probability, ProbabilityUnit.Fraction)]
        [Format("F2", true)]
        [PropertyOrder(3, 0)]
        [Minimum(0)]
        [Maximum(1)]
        public double Probability
        {
            get
            {
                return probability;
            }
            set
            {
                this.SetAndNotify2(out probability, value, s => s.Probability);
            }
        }

        /// <summary>
        /// Gets or sets the name of the scenario.
        /// </summary>
        [PropertyOrder(1, 0)]
        [ReadOnly(true)]
        public string Name { get; set; }

        /// <summary>
        /// Gets or sets the description of the scenario.
        /// </summary>
        [PropertyOrder(1, 1)]
        public string Description { get; set; }

        [PropertyOrder(2, 0)]
        public bool Calculated
        {
            get
            {
                return assessmentCalculationResult.Calculated;
            }
        }

        /// <summary>
        /// Gets or sets the soil profile of the scenario from the <see cref="StochasticSoilProfile"/>
        /// on which this scenario is based. If you set a different value, the corresponding
        /// <see cref="StochasticSoilProfile"/> will replace the value for that <see cref="ScenarioItem{T}"/>
        /// </summary>
        /// <exception cref="InvalidOperationException">When setting a new value while there 
        /// is no <see cref="StochasticSoilProfile"/> available as <see cref="ScenarioItem{T}"/>
        ///  or <see cref="GetAvailableStochasticSoilProfiles"/> is not set.</exception>
        [XmlIgnore]
        [PropertyOrder(4, 0)]
        public SoilProfile SoilProfile
        {
            get
            {
                return Values.OfType<StochasticSoilProfile>().Select(ssp => ssp.Profile).FirstOrDefault();
            }
            set
            {
                if (GetAvailableStochasticSoilProfiles == null)
                {
                    throw new InvalidOperationException("AssessmentScenario requires to have GetAvailableStochasticSoilProfiles set.");
                }
                ScenarioItem<object> soilProfileItem = ScenarioItems.FirstOrDefault(si => si.Value is StochasticSoilProfile);
                if (soilProfileItem == null)
                {
                    throw new InvalidOperationException("AssessmentScenario requires to have a ScenarioItem with a StochasticSoilProfile.");
                }

                soilProfileItem.Value = GetStochasticSoilProfile(value);

                // Updating SoilProfile in scenario should update target -> Send event to notify this action:
                DataEventPublisher.AfterChange(this, s => s.SoilProfile);
            }
        }

        /// <summary>
        /// Gets or sets the result from an <see cref="Deltares.AssessmentMechanism.AssessmentCalculation"/>.
        /// </summary>
        public AssessmentCalculationResult AssessmentCalculationResult
        {
            get
            {
                return assessmentCalculationResult;
            }
            set
            {
                assessmentCalculationResult = value;
            }
        }

        /// <summary>
        /// Injection point for method to retrieve all available stochastic soil profiles
        /// for this scenario to be based upon.
        /// </summary>
        public Func<StochasticSoilProfile[]> GetAvailableStochasticSoilProfiles { get; set; }

        [DynamicProperties]
        [PropertyOrder(4, 1)]
        public override List<object> Values
        {
            get
            {
                return base.Values;
            }
        }

        public override string ToString()
        {
            return Name ?? string.Empty;
        }

        #region IDomain

        public ICollection GetDomain(string property)
        {
            switch (property)
            {
                case "SoilProfile":
                    return GetAvailableStochasticSoilProfiles != null ?
                               GetAvailableStochasticSoilProfiles().Select(ssp => ssp.Profile).ToArray() :
                               null;
                default:
                    return null;
            }
        }

        #endregion

        private StochasticSoilProfile GetStochasticSoilProfile(SoilProfile value)
        {
            StochasticSoilProfile scenarioItemStochasticSoilProfile = null;
            DataEventPublisher.InvokeWithoutPublishingEvents(() =>
            {
                var stochasticSoilProfile = GetAvailableStochasticSoilProfiles().FirstOrDefault(si => ReferenceEquals(si.Profile, value));
                if (stochasticSoilProfile != null)
                {
                    scenarioItemStochasticSoilProfile = (StochasticSoilProfile)stochasticSoilProfile.Clone();
                }
            });
            return scenarioItemStochasticSoilProfile;
        }

        #region IVisibleEnabled

        public bool IsVisible(string property)
        {
            return true;
        }

        public bool IsEnabled(string property)
        {
            var enabled = true;
            if (this.GetMemberName(s => s.SoilProfile) == property)
            {
                enabled = GetAvailableStochasticSoilProfiles != null;
            }
            return enabled;
        }

        #endregion
    }
}