// Copyright (C) Stichting Deltares 2017. All rights reserved.
//
// This file is part of the Dam Engine.
//
// The Dam Engine is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// All names, logos, and references to "Deltares" are registered trademarks of
// Stichting Deltares and remain full property of Stichting Deltares at all times.
// All rights reserved.

using System;
using System.Collections.Generic;
using Deltares.DamEngine.Data.Design;
using Deltares.DamEngine.Data.Geotechnics;
using Deltares.DamEngine.Data.Standard;
using Deltares.DamEngine.Data.Standard.Calculation;

namespace Deltares.DamEngine.Data.General.Results
{
    /// <summary>
    /// Contains the results for the design calculations.
    /// </summary>
    /// <seealso cref="System.ICloneable" />
    public class DesignResult : ICloneable
    {
        private double? safetyFactor;
        private double? failureProbability;

        private string baseFileName;

        private string locationName;
        private string scenarioName;
        private string profileName;
        private CalculationResult calculationResult = CalculationResult.NoRun;

        private StabilityDesignResults stabilityDesignResults;
        private PipingDesignResults pipingDesignResults;

        /// <summary>
        /// Gets the safety factor (derived result).
        /// Note: this is a placeholder, not to be part of the results as written to xml
        /// </summary>
        /// <value>
        /// The safety factor.
        /// </value>
        public double? SafetyFactor
        {
            get
            {
                return safetyFactor;
            }
        }

        /// <summary>
        /// Gets or sets the failure probability (derived result).
        /// Note: this is a placeholder, not to be part of the results as written to xml
        /// </summary>
        /// <value>
        /// The failure probability.
        /// </value>
        public double? FailureProbability
        {
            get
            {
                return failureProbability;
            }
            set
            {
                failureProbability = value;
            }
        }
        /// <summary>
        /// Gets or sets the dam failure mechanisme calculation.
        /// Note: this is a placeholder, not to be part of the results as written to xml
        /// </summary>
        /// <value>
        /// The dam failure mechanisme calculation.
        /// </value>
        public DamFailureMechanismeCalculationSpecification DamFailureMechanismeCalculation { get; set; }

        /// <summary>
        /// Gets or sets the scenario.
        /// Note: this is a placeholder, not to be part of the results as written to xml
        /// </summary>
        /// <value>
        /// The scenario.
        /// </value>
        public DesignScenario Scenario { get; set; }

        /// <summary>
        /// Gets or sets the length of the dike as derived value.
        /// Note: this is a placeholder, not to be part of the results as written to xml.
        /// It is currently used by the DamProjectCalculator.
        /// </summary>
        /// <value>
        /// The length of the dike.
        /// </value>
        public double? DikeLength
        {
            get
            {
                double? maxDikeLength = null;
                var dikeLengths = new List<double?>();
                if (Scenario != null && Scenario.Location != null)
                {
                    SurfaceLine2 surfaceLine = Scenario.Location.LocalXZSurfaceLine2;
                    if (surfaceLine != null)
                        dikeLengths.Add(surfaceLine.GetDikeLength());
                }
                if (DamFailureMechanismeCalculation != null)
                {
                    switch (DamFailureMechanismeCalculation.FailureMechanismSystemType)
                    {
                        case FailureMechanismSystemType.StabilityInside:
                            if (stabilityDesignResults != null && stabilityDesignResults.RedesignedSurfaceLine != null)
                                dikeLengths.Add(stabilityDesignResults.RedesignedSurfaceLine.GetDikeLength());
                            break;
                        case FailureMechanismSystemType.Piping:
                            if (pipingDesignResults != null && pipingDesignResults.RedesignedSurfaceLine != null)
                                dikeLengths.Add(pipingDesignResults.RedesignedSurfaceLine.GetDikeLength());
                            break;
                    }
                }
                foreach (double? dikeLength in dikeLengths)
                {
                    if (dikeLength.HasValue && (!maxDikeLength.HasValue || maxDikeLength < dikeLength))
                        maxDikeLength = dikeLength;
                }
                return maxDikeLength;
            }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="DesignResult"/> class.
        /// Is only to be used by this.Clone() and in FillDamFromXmlOutput (used in tests), nowhere else
        /// </summary>
        internal DesignResult()
        {
            // only for Clone() method
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="DesignResult"/> class.
        /// Needed for testing purposes.
        /// </summary>
        /// <param name="locationName">Name of the location.</param>
        /// <param name="scenarioName">Name of the scenario.</param>
        internal DesignResult(string locationName, string scenarioName)
        {
            this.locationName = locationName;
            this.scenarioName = scenarioName;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="DesignResult"/> class.
        /// </summary>
        /// <param name="id">The identifier.</param>
        /// <param name="damFailureMechanismeCalculationSpecification">The dam failure mechanisme calculation specification.</param>
        /// <param name="scenario">The scenario.</param>
        /// <param name="soilProfile">The soil profile.</param>
        /// <param name="soilGeometry2DName">Name of the soil geometry2 d.</param>
        /// <param name="analysisType">Type of the analysis.</param>
        /// <param name="nwoResultIndex">Index of the nwo result.</param>
        public DesignResult(DamFailureMechanismeCalculationSpecification damFailureMechanismeCalculationSpecification, 
            DesignScenario scenario, SoilProfile1D soilProfile, string soilGeometry2DName, AnalysisType analysisType, int nwoResultIndex)
        {
            locationName = scenario.Location.Name;
            scenarioName = scenario.LocationScenarioID; // terughalen vanuit csvexport indien echt nodig
            baseFileName = "";
            DamFailureMechanismeCalculation = damFailureMechanismeCalculationSpecification;
            Scenario = scenario;

            if (damFailureMechanismeCalculationSpecification != null)
            {
                switch (damFailureMechanismeCalculationSpecification.FailureMechanismSystemType)
                {
                    case FailureMechanismSystemType.StabilityInside:
                    case FailureMechanismSystemType.StabilityOutside:
                        profileName = soilGeometry2DName;
                        
                        stabilityDesignResults = new StabilityDesignResults();
                        MStabResults? mstabResults = scenario.GetMStabResults(soilProfile, soilGeometry2DName);
                        stabilityDesignResults.ResultMessage = scenario.GetResultMessage(soilProfile, soilGeometry2DName);
                        calculationResult = DetermineStabilityCalculationResult(stabilityDesignResults.ResultMessage, mstabResults);
                        if (mstabResults != null)
                        {                                
                            baseFileName = mstabResults.Value.CalculationName;
                            stabilityDesignResults.NumberOfIterations = mstabResults.Value.IterationNumber;
                            stabilityDesignResults.SafetyFactor = mstabResults.Value.zone1.safetyFactor;
                            stabilityDesignResults.Zone1SafetyFactor = mstabResults.Value.zone1.safetyFactor;
                            stabilityDesignResults.LocalZone1EntryPointX = mstabResults.Value.zone1.entryPointXCoordinate;
                            stabilityDesignResults.LocalZone1ExitPointX = mstabResults.Value.zone1.exitPointXCoordinate;
                            if (mstabResults.Value.zone2 != null)
                            {
                                stabilityDesignResults.Zone2SafetyFactor = mstabResults.Value.zone2.Value.safetyFactor;
                                stabilityDesignResults.LocalZone2EntryPointX = mstabResults.Value.zone2.Value.entryPointXCoordinate;
                                stabilityDesignResults.LocalZone2ExitPointX = mstabResults.Value.zone2.Value.exitPointXCoordinate;
                            }
                        }
                        stabilityDesignResults.FailureProbability = scenario.GetFailureProbabilityStability(soilProfile, soilGeometry2DName);
                        stabilityDesignResults.RedesignedSurfaceLine = scenario.GetRedesignedSurfaceLine(soilProfile, soilGeometry2DName);
                        failureProbability = stabilityDesignResults.FailureProbability;
                        safetyFactor = stabilityDesignResults.SafetyFactor;
                        UpliftSituation? upliftSituation = scenario.GetStabilityUpliftSituation(soilProfile, soilGeometry2DName);
                        if (upliftSituation != null)
                        {
                            stabilityDesignResults.UpliftSituation = upliftSituation;
                        }
                        break;

                    case FailureMechanismSystemType.Piping:
                        pipingDesignResults = new PipingDesignResults(damFailureMechanismeCalculationSpecification.PipingModelType);
                        profileName = soilProfile.Name;
                        pipingDesignResults.FailureProbability = scenario.GetFailureProbabilityPiping(soilProfile, soilGeometry2DName);
                        failureProbability = pipingDesignResults.FailureProbability;
                        pipingDesignResults.ResultMessage = scenario.GetResultMessage(soilProfile, soilGeometry2DName);
                        pipingDesignResults.RedesignedSurfaceLine = scenario.GetRedesignedSurfaceLine(soilProfile, soilGeometry2DName);
                        UpliftSituation? upliftSituationPiping = scenario.GetStabilityUpliftSituation(soilProfile, soilGeometry2DName);
                        if (upliftSituationPiping != null)
                        {
                            pipingDesignResults.UpliftSituation = upliftSituationPiping;
                        }
                        PipingResults? pipingResults = scenario.GetPipingResults(soilProfile, soilGeometry2DName);
                        if (pipingResults != null)
                        {
                            baseFileName = pipingResults.Value.CalculationName;
                            pipingDesignResults.BlighFactor = pipingResults.Value.BlighPipingFactor;
                            pipingDesignResults.BlighHcritical = pipingResults.Value.BlighHCritical;
                            pipingDesignResults.Sellmeijer4ForcesFactor = pipingResults.Value.Sellmeijer4ForcesPipingFactor;
                            pipingDesignResults.Sellmeijer4ForcesHcritical = pipingResults.Value.Sellmeijer4ForcesHCritical;
                            pipingDesignResults.SellmeijerVnkFactor = pipingResults.Value.SellmeijerVnkPipingFactor;
                            pipingDesignResults.SellmeijerVnkHcritical = pipingResults.Value.SellmeijerVnkHCritical;
                            pipingDesignResults.Wti2017Factor = pipingResults.Value.Wti2017PipingFactor;
                            pipingDesignResults.Wti2017Hcritical = pipingResults.Value.Wti2017HCritical;
                            pipingDesignResults.LocalExitPointX = pipingResults.Value.PipingExitPointX;
                            pipingDesignResults.HeaveFactor = pipingResults.Value.HeaveFactor;
                            pipingDesignResults.UpliftFactor = pipingResults.Value.UpliftFactor;
                        }
                        safetyFactor = pipingDesignResults.SafetyFactor();
                        calculationResult = (pipingDesignResults.SafetyFactor() == null && pipingDesignResults.FailureProbability == null) ? CalculationResult.RunFailed : CalculationResult.Succeeded;
                        break;                    
                }
            }
        }

        //Identifiers, needed to retrace the origin of the result
        /// <summary>
        /// Gets the name of the location.
        /// For identification purpose
        /// </summary>
        /// <value>
        /// The name of the location.
        /// </value>
        public string LocationName
        {
            get { return locationName; }
        }

        /// <summary>
        /// Gets the name of the scenario.
        /// For identification purpose
        /// </summary>
        /// <value>
        /// The name of the scenario.
        /// </value>
        public string ScenarioName
        {
            get { return scenarioName; }
        }

        /// <summary>
        /// Gets or sets the name of the profile.
        /// For identification purpose
        /// </summary>
        /// <value>
        /// The name of the profile.
        /// </value>
        public string ProfileName
        {
            get
            {
                return profileName;
            }
            set
            {
                profileName = value;
            }
        }

        /// <summary>
        /// Gets or sets the name of the base file.
        /// </summary>
        /// <value>
        /// The name of the base file.
        /// Can be used to retrace results files.
        /// </value>
        public string BaseFileName // real result for all.
        {
            get { return baseFileName; }
            set { baseFileName = value; }
        }

        /// <summary>
        /// Gets or sets the calculation result.
        /// This is a derived result.
        /// </summary>
        /// <value>
        /// The calculation result.
        /// </value>
        public CalculationResult CalculationResult
        {
            get { return calculationResult; }
            set { calculationResult = value; }
        }

        /// <summary>
        /// Gets or sets the stability design results.
        /// </summary>
        /// <value>
        /// The stability design results.
        /// </value>
        public StabilityDesignResults StabilityDesignResults
        {
            get
            {
                return stabilityDesignResults;
            }
            set
            {
                stabilityDesignResults = value;
            }
        }

        /// <summary>
        /// Gets or sets the piping design results.
        /// </summary>
        /// <value>
        /// The piping design results.
        /// </value>
        public PipingDesignResults PipingDesignResults
        {
            get
            {
                return pipingDesignResults;
            }
            set
            {
                pipingDesignResults = value;
            }
        }

        /// <summary>
        /// Copy data
        /// </summary>
        /// <param name="designResult"></param>
        private void Assign(DesignResult designResult)
        {
            // copy place holders
            DamFailureMechanismeCalculation = designResult.DamFailureMechanismeCalculation;
            Scenario = designResult.Scenario;

            // copy direct data
            baseFileName = designResult.BaseFileName;
            locationName = designResult.LocationName;
            scenarioName = designResult.ScenarioName;
            profileName = designResult.ProfileName;
            calculationResult = designResult.calculationResult;
            safetyFactor = designResult.SafetyFactor;
            failureProbability = designResult.FailureProbability;
            stabilityDesignResults = new StabilityDesignResults();
            designResult.StabilityDesignResults.CloneProperties(stabilityDesignResults);
            pipingDesignResults = new PipingDesignResults(DamFailureMechanismeCalculation.PipingModelType);
            designResult.PipingDesignResults.CloneProperties(pipingDesignResults);
        }

        /// <summary>
        /// Make a clone of object
        /// </summary>
        /// <returns></returns>
        public object Clone()
        {
            DesignResult designResult = new DesignResult();

            designResult.Assign(this);

            return designResult;
        }

        /// <summary>
        /// Determines the stability calculation run result.
        /// </summary>
        /// <param name="message">The result message.</param>
        /// <param name="mstabResults">The mstab results.</param>
        /// <returns></returns>
        private CalculationResult DetermineStabilityCalculationResult(string message, MStabResults? mstabResults)
        {
            CalculationResult result;
            if ((message != null) && message.Contains("FAIL"))
            {
                result = CalculationResult.UnexpectedError;
            }
            else
            {
                // If no failure and no results, then no run has been made
                result = mstabResults != null ? CalculationResult.Succeeded : CalculationResult.NoRun;
            }
            return result;
        }
    }
}