// 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 System.Linq;
using Deltares.DamEngine.Data.General;
using Deltares.DamEngine.Data.General.Results;
using Deltares.DamEngine.Data.General.SchematizationFactor;
using Deltares.DamEngine.Data.Geotechnics;
using Deltares.DamEngine.Data.RWScenarios;
using Deltares.DamEngine.Data.Standard.Calculation;

namespace Deltares.DamEngine.Calculators.SchematizationFactor
{
    public class SchematizationFactorIntermediate
    {
        private string soilProfileName;
        private double safetyFactor;
        private double probPercentage;
        private double summedProbPercentage;

        public string SoilProfileName

        {
            get { return soilProfileName; }
            set { soilProfileName = value; }
        }

        public double SafetyFactor
        {
            get { return safetyFactor; }
            set { safetyFactor = value; }
        }

        public double ProbPercentage
        {
            get { return probPercentage; }
            set { probPercentage = value; }
        }

        public double SummedProbPercentage
        {
            get { return summedProbPercentage; }
            set { summedProbPercentage = value; }
        }
    }

    public class SchematizationFactorIntermediateList
    {
        private List<SchematizationFactorIntermediate> schematizationFactorIntermediates = new List<SchematizationFactorIntermediate>();

        public List<SchematizationFactorIntermediate> SchematizationFactorIntermediates
        {
            get { return schematizationFactorIntermediates; }
            set { schematizationFactorIntermediates = value; }
        }

        public void SortBySafetyFactor()
        {
            // First sort on prob
            var sorted1 = schematizationFactorIntermediates.OrderByDescending(item => item.ProbPercentage);
            List<SchematizationFactorIntermediate> res1 = new List<SchematizationFactorIntermediate>();
            foreach (var schematizationFactorIntermediate in sorted1)
            {
                res1.Add(schematizationFactorIntermediate);
            }
            schematizationFactorIntermediates.Clear();
            schematizationFactorIntermediates = res1;

            // then sort on sf.
            var sorted = schematizationFactorIntermediates.OrderByDescending(item => item.SafetyFactor);
            List<SchematizationFactorIntermediate> res = new List<SchematizationFactorIntermediate>();                    
            
            foreach (var schematizationFactorIntermediate in sorted)
            {
                res.Add(schematizationFactorIntermediate);
            }
            schematizationFactorIntermediates.Clear();
            schematizationFactorIntermediates = res;
        }

        public void SumSoilProfileProbabilities()
        {
            for (int i = 0; i < schematizationFactorIntermediates.Count; i++)
            {
                if (i == 0)
                {
                    schematizationFactorIntermediates[i].SummedProbPercentage =
                        schematizationFactorIntermediates[i].ProbPercentage;
                }
                else
                {
                    schematizationFactorIntermediates[i].SummedProbPercentage =
                        schematizationFactorIntermediates[i - 1].SummedProbPercentage +
                        schematizationFactorIntermediates[i].ProbPercentage;
                }
            }
        }

        public int GetBasicSchematization(double requiredProbability)
        {
            var result = schematizationFactorIntermediates.Count - 1;
            for (int i = 0; i < schematizationFactorIntermediates.Count; i++)
            {
                if (schematizationFactorIntermediates[i].SummedProbPercentage >= requiredProbability)
                {
                    result = i;
                    break;
                }
            }
            return result;
        }
    }

    public class SchematizationFactorCalculation
    {
        private RWScenariosResult scenariosResult; // input: scenariosResult are the results of all scenarios for one location.
        private double detrimentFactor = 0;
        private SchematizationFactorData schematizationFactorData;
        private Location location;

        public RWScenariosResult ScenariosResult
        {
            get { return scenariosResult; }
            set { scenariosResult = value; }
        }

        public double DetrimentFactor
        {
            get { return detrimentFactor; }
            set { detrimentFactor = value; }
        }

        public SchematizationFactorData SchematizationFactorData
        {
            get { return schematizationFactorData; }
            set { schematizationFactorData = value; }
        }

        public Location Location
        {
            get { return location; }
            set { location = value; }
        }

        public RWSchematizationFactorsResult CalculateSchematizationFactorResults()
        {
            CheckData();

            var results = new RWSchematizationFactorsResult();
            var macroStabilityInnerSideWetResult =
                CalculateSchematizationFactorResultForType(SchematizationType.MacroStabilityInnerSideWet);
            results.SchematizationFactorResults.Add(macroStabilityInnerSideWetResult);

            var macroStabiltyInnerSideDryResult =
                CalculateSchematizationFactorResultForType(SchematizationType.MacroStabilityInnerSideDry);
            results.SchematizationFactorResults.Add(macroStabiltyInnerSideDryResult);
            
            return results;
        }

        public RWSchematizationFactorResult CalculateSchematizationFactorResultForType(SchematizationType schematizationType)
        {
            CheckData();

            var result = GetSchematizationFactorResult(schematizationType);
            
            return result;
        }

        private void CheckData()
        {
            if (scenariosResult == null)
            {
                throw new ApplicationException("Scenario results must be available to calculate the Schematization Factor.");
            }

            if (detrimentFactor <= 0.0001)
            {
                throw new ApplicationException("Detriment factor must be specified to calculate the Schematization Factor.");
            }

            if (schematizationFactorData == null)
            {
                throw new ApplicationException("Schematization Factor Data must be available to calculate the Schematization Factor.");
            }

            if (this.Location == null)
            {
                throw new ApplicationException("Location name must be available to calculate the Schematization Factor.");
            }
        }

        private RWSchematizationFactorResult GetSchematizationFactorResult(SchematizationType schematizationType)
        {
            var schematizationFactorResult = new RWSchematizationFactorResult(Location);
            schematizationFactorResult.SchematizationType = schematizationType;
            schematizationFactorResult.SchematizationFactor = schematizationFactorData.SchematizationFactorMin;
            schematizationFactorResult.DetrimentFactor = DetrimentFactor;

            var decisiveScenarioResults = GetDecisiveResultsPerSchematizationType(schematizationType);
            if (decisiveScenarioResults != null)
            {                
                var mswIntermediates = SortResultsSchematizationType(decisiveScenarioResults);
                var basicSchematization =
                    mswIntermediates.GetBasicSchematization(schematizationFactorData.RequiredProbability);
                var schematizationFactor = schematizationFactorData.SchematizationFactorMin;
                var allowedProbability = DetermineAllowedProbabilty();
                if ((basicSchematization >= 0) && (CheckOnB6(mswIntermediates, allowedProbability)))
                {
//#Bka hier de SummedProbPercentage initialiseren op 1e laag basisprofiel zodat het % niet op nul blijft staan als je direct aan B7 voldoet!!!! Nagaan bij Erik of dat klopt of dat 
                    // hij toch liever 0 of 100% ziet. 
                    schematizationFactorResult.SummedProfileProbability =
                        mswIntermediates.SchematizationFactorIntermediates[basicSchematization].SummedProbPercentage;
                    schematizationFactorResult.OriginalDecisiveSoilProfileName = mswIntermediates.SchematizationFactorIntermediates[basicSchematization].SoilProfileName;
                    while (!CheckOnB7(mswIntermediates, basicSchematization, allowedProbability, schematizationFactor))
                    {
                        //increase Pallowed
                        schematizationFactor = schematizationFactor + schematizationFactorData.SchematizationFactorDelta;
                        if (schematizationFactor > schematizationFactorData.SchematizationFactorMax)
                        {
                            // reset the factor, go to the next schematization when possible
                            schematizationFactor = schematizationFactorData.SchematizationFactorMin;
                            if (basicSchematization < mswIntermediates.SchematizationFactorIntermediates.Count - 1)
                            {
                                basicSchematization++;
                            }
                            else
                            {
                                schematizationFactorResult.CalculationResult = CalculationResult.RunFailed;
                                break;
                            }
                        }                        
                    }
                    schematizationFactorResult.SchematizationFactor = schematizationFactor;
                    schematizationFactorResult.SummedProfileProbability =
                        mswIntermediates.SchematizationFactorIntermediates[basicSchematization].SummedProbPercentage;
                    schematizationFactorResult.SoilProfileName =
                        mswIntermediates.SchematizationFactorIntermediates[basicSchematization].SoilProfileName;
                    schematizationFactorResult.DecisiveScenarioName = decisiveScenarioResults.ScenarioType;
                    schematizationFactorResult.SafetyFactor =
                        mswIntermediates.SchematizationFactorIntermediates[basicSchematization].SafetyFactor;
                }
                else
                {
                    schematizationFactorResult.CalculationResult = CalculationResult.RunFailed;
                }
            }
            else
            {
                schematizationFactorResult.CalculationResult = CalculationResult.RunFailed;
            }

            if (schematizationFactorResult.CalculationResult != CalculationResult.Succeeded)
            {
                schematizationFactorResult.SchematizationFactor = 0;
            }
            return schematizationFactorResult;
        }

        private double DetermineProbabilty(double factor)
        {
//            var beta = 4 + ((factor - 1)/0.13);
//            var prob = Probabilistic.Probabilistic.NormalDistribution(beta * -1);
//            return prob;##Bka
            return double.MaxValue;
        }

        internal double DetermineAllowedProbabilty()
        {
            return DetermineProbabilty(detrimentFactor);            
        }

        private double DetermineProbabiltyForSchematization(double safetyFactor)
        {
            return DetermineProbabilty(safetyFactor);
        }

        private SchematizationFactorIntermediateList SortResultsSchematizationType(RWScenarioResult result)
        {
            var intermediateResults = new SchematizationFactorIntermediateList();
            foreach (var rwScenarioProfileResult in result.RWScenarioProfileResults)
            {
                var inter = new SchematizationFactorIntermediate();
                inter.SafetyFactor = rwScenarioProfileResult.SafetyFactor;
                inter.SoilProfileName = rwScenarioProfileResult.SoilProfileName;
                inter.ProbPercentage = rwScenarioProfileResult.SoilProfileProbability;
                intermediateResults.SchematizationFactorIntermediates.Add(inter);
            }
            intermediateResults.SortBySafetyFactor();
            intermediateResults.SumSoilProfileProbabilities();
            return intermediateResults;
        }

        private RWScenarioResult GetDecisiveResultsPerSchematizationType(SchematizationType schematizationType)
        {
            RWScenarioResult result = null;
            double minSafetyFactor = Double.MaxValue;
            switch (schematizationType)
            {
                case SchematizationType.MacroStabilityInnerSideWet:
                    {
                        // scenarios 3, 4, 7 and 8 are relevant.
                        foreach (RWScenarioResult scenarioResult in scenariosResult.RWScenarioResults)
                        {
                            //#bka: nagaan bij Erik/Tom of dit de bedoeling is! 
                            // nog groter mogelijk probleem : ik krijg niet alle resultaten door. Van de 37 profiles krijg ik er hier maar 
                            // 27 door omdat de rest gefaald is en daarmee geen deel zijn van de scenarioResults!
                            if (scenarioResult.CalculationResult == CalculationResult.Succeeded)
                            {
                                if ((scenarioResult.ScenarioType == ScenarioType.Scenario03) || (scenarioResult.ScenarioType == ScenarioType.Scenario04) ||
                                    (scenarioResult.ScenarioType == ScenarioType.Scenario07) || (scenarioResult.ScenarioType == ScenarioType.Scenario08))
                                {
                                    if (scenarioResult.SafetyFactor < minSafetyFactor)
                                    {
                                        minSafetyFactor = scenarioResult.SafetyFactor;
                                        result = scenarioResult;
                                    }                                    
                                }
                            }
                        }
                        break;
                    }
                case SchematizationType.MacroStabilityInnerSideDry:
                    {
                        // scenarios 1, 2, 5 and 6 are relevant.
                        foreach (RWScenarioResult scenarioResult in scenariosResult.RWScenarioResults)
                        {
                            //#bka: nagaan bij Erik/Tom of dit de bedoeling is! Non Succceeded heeft sf = -1 dus komt goed bij bepaling B06.
                            if (scenarioResult.CalculationResult == CalculationResult.Succeeded)
                            {
                                if ((scenarioResult.ScenarioType == ScenarioType.Scenario01) || (scenarioResult.ScenarioType == ScenarioType.Scenario02) ||
                                    (scenarioResult.ScenarioType == ScenarioType.Scenario05) || (scenarioResult.ScenarioType == ScenarioType.Scenario06))
                                {
                                    if (scenarioResult.SafetyFactor < minSafetyFactor)
                                    {
                                        minSafetyFactor = scenarioResult.SafetyFactor;
                                        result = scenarioResult;
                                    }
                                }
                            }
                        }
                        break;
                    }
                default:
                    {
                        throw new ApplicationException("Schematization Factor not yet implemented for other things than macro stability.");
                    }    
                    
            }
            return result;
        }

        /// <summary>
        /// Checks condition B.6: sum of all ( P(D|Si) * P(Si) ) smaller than or equal to Pallowed
        /// P(D|Si) is the probability of failure for the schematization i
        /// P(Si) is the probability of occurence for the schematization i
        /// </summary>
        /// <param name="intermediates"></param>
        /// <param name="allowedProbability"></param>
        /// <returns></returns>
        private bool CheckOnB6(SchematizationFactorIntermediateList intermediates, double allowedProbability)
        {
            double summedProbability = 0;
            foreach (var intermediate in intermediates.SchematizationFactorIntermediates)
            {
                summedProbability = summedProbability + (DetermineProbabiltyForSchematization(intermediate.SafetyFactor) * 
                    (intermediate.ProbPercentage / 100));
            }
            var result = (summedProbability <= allowedProbability);
            return result;
        }

        /// <summary>
        /// Checks condition B.7: (1 - sum of P(Si)) * P(D|Sk) + sum of ( P(D|Si) * P(Si) ) smaller than or equal to Pallowed
        /// Note that the summing starts at i = k+1 with k being the number of the basic schematization
        /// P(D|Sk) is the probability of failure for the schematization k
        /// P(D|Si) is the probability of failure for the schematization i
        /// P(Si) is the probability of occurence for the schematization i
        /// </summary>
        /// <param name="intermediates"></param>
        /// <param name="basicScenario"></param>
        /// <param name="allowedProbability"></param>
        /// <param name="schematizationFactor"></param>
        /// <returns></returns>
        private bool CheckOnB7(SchematizationFactorIntermediateList intermediates, int basicScenario, double allowedProbability, double schematizationFactor)
        {
            var result = false;
            if (basicScenario >= 0)
            {
                var summedProbability = (DetermineProbabiltyForSchematization(intermediates.SchematizationFactorIntermediates[basicScenario].SafetyFactor *
                    schematizationFactor) * (intermediates.SchematizationFactorIntermediates[basicScenario].SummedProbPercentage / 100.0)); ;
                
                for (int i = basicScenario + 1; i < intermediates.SchematizationFactorIntermediates.Count; i++)
                {
                    var prob = DetermineProbabiltyForSchematization(intermediates.SchematizationFactorIntermediates[i].SafetyFactor*schematizationFactor)*
                         (intermediates.SchematizationFactorIntermediates[i].ProbPercentage/100.0);
                    summedProbability = summedProbability + prob;
                }
                result = (summedProbability <= allowedProbability);
            }
            return result;

        }

    }
}