using System;
using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Linq;

using Deltares.AssessmentMechanism;
using Deltares.Geotechnics;
using Deltares.Geotechnics.Soils;
using Deltares.Standard;
using Deltares.Standard.Attributes;
using Deltares.Standard.Language;
using Deltares.Standard.Logging;

namespace Deltares.Stability.Calculation2
{
    /// <summary>
    /// Calculator of stability inwards for Ringtoets Level 2a
    /// Executes a spencer calculation, if evaluation is not correct a LiftVanUp calculation
    /// </summary>
    [XmlOldName("Deltares.Ringtoets.StabilityInwardsCalculation")]
    public class StabilityInwardsCalculation : AssessmentCalculation
    {
        internal StabilitySafetyFactorCalculation StabilitySafetyFactorCalculation = new StabilitySafetyFactorCalculation();
        // SmoothSlidingPlaneValidator slidingPlaneValidator = new SmoothSlidingPlaneValidator(min, MaxAllowedAngleBetweenSlices);

        /// <summary>
        /// Executes the specified location information.
        /// </summary>
        /// <param name="dikeLocationInfo">The location information.</param>
        /// <returns></returns>
        public override AssessmentCalculationResult Execute(DikeLocationInfo dikeLocationInfo)
        {
            Contract.Assume(dikeLocationInfo is StabilityDikeLocationInfo);

            LogManager.Messages.Clear();

            var stabilityDikeLocationInfo = (StabilityDikeLocationInfo) dikeLocationInfo;

            ApplySettings(stabilityDikeLocationInfo);

            SlidingCurve resultCurve = null;

            switch (stabilityDikeLocationInfo.StabilityMethod)
            {
                case StabilityMethod.Bishop:
                    resultCurve = RunBishop(stabilityDikeLocationInfo);
                    break;
                case StabilityMethod.Spencer:
                    resultCurve = RunSpencer(stabilityDikeLocationInfo);
                    break;
                case StabilityMethod.UpliftVan:
                    resultCurve = RunUpliftVan(stabilityDikeLocationInfo);
                    break;
                case StabilityMethod.SpencerUpliftVan:
                    resultCurve = RunSpencerUpliftVan(stabilityDikeLocationInfo);
                    break;
                default:
                    throw new NotImplementedException(String.Format("Modeloption {0} not implemented", stabilityDikeLocationInfo.StabilityModel.ModelOption));
            }

            var result = new StabilityAssessmentCalculationResult
                {
                    FactorOfSafety = resultCurve != null ? CalculateFactorOfSafetyBasedOnModelUncertainty(stabilityDikeLocationInfo.Settings.ModelUncertaintyParameter, resultCurve) : double.NaN,
                    ZValue = resultCurve != null ? resultCurve.SafetyFactor - 1 : double.NaN,
                    Calculated = resultCurve != null,
                    Curve = resultCurve,
                    Location = stabilityDikeLocationInfo.StabilityModel.Location,
                    Waternet = stabilityDikeLocationInfo.StabilityModel.GeotechnicsData.CurrentWaternet
                };

            result.Approved = resultCurve != null && !double.IsNaN(resultCurve.SafetyFactor) && result.FactorOfSafety >= stabilityDikeLocationInfo.AllowedFailureProbability;
            result.Messages.AddRange(LogManager.Messages);

            stabilityDikeLocationInfo.SafetyFactor = result.FactorOfSafety;
            stabilityDikeLocationInfo.SafetyFactorCorrected = result.FactorOfSafety;
            stabilityDikeLocationInfo.StabilityAcceptable = result.Approved;

            return result;
        }

        internal double CalculateFactorOfSafetyBasedOnModelUncertainty(double modelFactor, SlidingCurve resultCurve)
        {
            Contract.Assume(modelFactor > 0.0);

            resultCurve.SafetyFactor = resultCurve.SafetyFactor/modelFactor;

            return resultCurve.SafetyFactor;
        }

        /// <summary>
        /// Set the correct setting for an UpliftVan calculation and executes.
        /// </summary>
        /// <param name="locationInfo">The stability dike location information.</param>
        /// <returns></returns>
        /// <exception cref="System.NotImplementedException"></exception>
        internal SlidingCurve RunUpliftVan(StabilityDikeLocationInfo locationInfo)
        {
            SetUpliftVanSettings(locationInfo);

            var result = StabilitySafetyFactorCalculation.Execute(locationInfo);
            if (!result.Calculated)
            {
                LogManager.Add(new LogMessage(LogMessageType.Error, this, LocalizationManager.GetTranslatedText(this, "UpliftVanCalculationError")));
            }
            return locationInfo.SlidingCurve;
        }

        /// <summary>
        /// Runs the spencer calculation with high slip planes
        /// </summary>
        /// <param name="locationInfo">The stability dike location information.</param>
        /// <returns>Resulting sliding curve</returns>
        internal SlidingCurve RunSpencerHigh(StabilityDikeLocationInfo locationInfo)
        {
            Contract.Requires(locationInfo.StabilityModel != null);
            Contract.Ensures(Contract.Result<SlidingCurve>() != null);

            locationInfo.StabilityModel.SlipPlanePosition = SlipPlanePosition.High;

            return RunSpencer(locationInfo);
        }

        /// <summary>
        /// Runs the spencer calculation with low slip planes
        /// </summary>
        /// <param name="locationInfo">The stability dike location information.</param>
        /// <returns>Resulting sliding curve</returns>
        internal SlidingCurve RunSpencerLow(StabilityDikeLocationInfo locationInfo)
        {
            Contract.Requires(locationInfo.StabilityModel != null);
            Contract.Ensures(Contract.Result<SlidingCurve>() != null);

            locationInfo.StabilityModel.SlipPlanePosition = SlipPlanePosition.Low;

            return RunSpencer(locationInfo);
        }

        /// <summary>
        /// Runs the spencer.
        /// </summary>
        /// <param name="locationInfo">The stability dike location information.</param>
        /// <returns></returns>
        internal SlidingCurve RunSpencer(StabilityDikeLocationInfo locationInfo)
        {
            Contract.Requires(locationInfo.StabilityModel != null);
            Contract.Ensures(Contract.Result<SlidingCurve>() != null);

            SetSpencerSettings(locationInfo);

            //Run
            var result = StabilitySafetyFactorCalculation.Execute(locationInfo);
            if (!result.Calculated)
            {
                LogManager.Add(new LogMessage(LogMessageType.Error, this, LocalizationManager.GetTranslatedText(this, "SpencerCalculationError")));
            }

            return locationInfo.SlidingCurve;
        }

        private static void ApplySettings(StabilityDikeLocationInfo stabilityDikeLocationInfo)
        {
            stabilityDikeLocationInfo.ApplySettings();

            stabilityDikeLocationInfo.UpdateTrafficLoad();
        }

        private static void SetUpliftVanSettings(StabilityDikeLocationInfo locationInfo)
        {
            locationInfo.StabilityModel.CalculationModel = CalculationModel.RTO;
            locationInfo.StabilityModel.GridOrientation = GridOrientation.Inwards;
            locationInfo.StabilityModel.ModelOption = ModelOptions.UpliftVan;
            locationInfo.StabilityModel.SearchAlgorithm = SearchAlgorithm.Grid;
        }

        /// <summary>
        /// Set the correct setting for a Bishop calculation and executes.
        /// </summary>
        /// <param name="locationInfo">The stability dike location information.</param>
        /// <returns></returns>
        private SlidingCurve RunBishop(StabilityDikeLocationInfo locationInfo)
        {
            SetBishopSettings(locationInfo);

            var result = StabilitySafetyFactorCalculation.Execute(locationInfo);
            if (!result.Calculated)
            {
                LogManager.Add(new LogMessage(LogMessageType.Error, this, LocalizationManager.GetTranslatedText(this, "UpliftVanCalculationError")));
            }
            return locationInfo.SlidingCurve;
        }

        private static void SetBishopSettings(StabilityDikeLocationInfo locationInfo)
        {
            locationInfo.StabilityModel.CalculationModel = CalculationModel.RTO;
            locationInfo.StabilityModel.GridOrientation = GridOrientation.Inwards;
            locationInfo.StabilityModel.ModelOption = ModelOptions.Bishop;
            locationInfo.StabilityModel.SearchAlgorithm = SearchAlgorithm.Grid;
        }

        /// <summary>
        /// Executes a spencer calculation, if evaluation is not correct a LiftVanUp calculation
        /// </summary>
        /// <param name="stabilityDikeLocationInfo">The stability dike location information.</param>
        /// <returns></returns>
        private SlidingCurve RunSpencerUpliftVan(StabilityDikeLocationInfo stabilityDikeLocationInfo)
        {
            SlidingCurve lowCurve = RunSpencerLow(stabilityDikeLocationInfo);
            SlidingCurve highCurve = RunSpencerHigh(stabilityDikeLocationInfo);
            SlidingCurve upliftVanCurve = null;

            if (highCurve == null || lowCurve == null)
            {
                upliftVanCurve = RunUpliftVan(stabilityDikeLocationInfo);
            }

            var resultCurves = new List<SlidingCurve>();

            if (highCurve != null)
            {
                resultCurves.Add(highCurve);
            }

            if (lowCurve != null)
            {
                resultCurves.Add(lowCurve);
            }

            if (upliftVanCurve != null)
            {
                resultCurves.Add(upliftVanCurve);
            }

            SlidingCurve resultCurve = null;
            if (resultCurves.Count > 0)
            {
                resultCurve = resultCurves.OrderBy(p => p.SafetyFactor).First();

                stabilityDikeLocationInfo.StabilityModel.MinimumSafetyCurve = resultCurve;

                if (resultCurve == highCurve)
                {
                    SetSpencerSettings(stabilityDikeLocationInfo);
                    stabilityDikeLocationInfo.StabilityModel.SlipPlanePosition = SlipPlanePosition.High;
                }
                else if (resultCurve == lowCurve)
                {
                    SetSpencerSettings(stabilityDikeLocationInfo);
                    stabilityDikeLocationInfo.StabilityModel.SlipPlanePosition = SlipPlanePosition.Low;
                }
                else if (resultCurve == upliftVanCurve)
                {
                    SetUpliftVanSettings(stabilityDikeLocationInfo);
                }

                stabilityDikeLocationInfo.StabilityModel.UpdateAutomaticDefinitions();
            }

            return resultCurve;
        }

        private static void SetSpencerSettings(StabilityDikeLocationInfo locationInfo)
        {
            locationInfo.StabilityModel.CalculationModel = CalculationModel.RTO;
            locationInfo.StabilityModel.GridOrientation = GridOrientation.Inwards;
            locationInfo.StabilityModel.ModelOption = ModelOptions.Spencer;
            locationInfo.StabilityModel.SearchAlgorithm = SearchAlgorithm.GeneticAndLevenbergMarquardt;
            if (!locationInfo.StabilityModel.SlipPlanes.Any())
            {
                locationInfo.StabilityModel.SlipPlanes.Add(new SlipPlane());
            }
        }
    }
}