using System;
using System.IO;
using Deltares.Geometry;
using Deltares.Geotechnics;
using Deltares.Geotechnics.Soils;
using Deltares.Geotechnics.SurfaceLines;
using Deltares.Standard;
using Deltares.Standard.Calculate;
using Deltares.Standard.Language;
using Deltares.Standard.Logging;

namespace Deltares.Stability.Calculation2
{
    public class StabilityCalculation : Standard.Calculate.Calculation
    {
        private const bool dump = false;

        public CalculationResult RunCalculation(StabilityModel stabilityModel)
        {
            try
            {
                //afhankelijk van soort berekening
                //bishop creeer grid / GA; spencer glijvlakken / GA; uplift grids / GA
                //loop over glijvlakken / grid / GA
                //per glijvlak test glijvlak
                //opdelen in lamellen (slicedivision)
                //vullen van lamellen (rtofillslices)
                //berekening (geeft stab factor, onthoud de laagste

                // Set the right calculation routine
                SlidingCurveCalculation slidingCurveCalculation = GetStabilityCalculation(stabilityModel.ModelOption);

                //GenerateWaternet();
                //ValidateData();
                //EnsureAvailabilityData();

                // Instantiates the stress providing routines
                var stressProvider = new PreProcesStabilityCalculation();

                stressProvider.SetSoilProfile2D(stabilityModel.SoilProfile);
                stressProvider.SetPreConsolidationStress(stabilityModel.SoilProfile.PreconsolidationStresses);
                stressProvider.SetMultiplicationFactorOnCPhi(stabilityModel.MultiplicationFactorsCPhiForUpliftList);
                stressProvider.PreconsolidationStressModelFactor = stabilityModel.PreconsolidationStressModelFactor;

                stabilityModel.UpdateAutomaticDefinitions();

                //if (stabilityModel.Location.WaternetCreationMode == WaternetCreationMode.CreateWaternet && updatingWaternet == false)
                //{
                //    WaternetCreator creator = new WaternetCreator();

                //    updatingWaternet = true;
                //    if (stabilityModel.GridOrientation == GridOrientation.Inwards)
                //    {
                //        creator.UpdateWaternet(stabilityModel.GeotechnicsData.CurrentWaternet, stabilityModel.Location, true);
                //    }
                //    else
                //    {
                //        creator.UpdateWaternet(stabilityModel.GeotechnicsData.CurrentWaternet, stabilityModel.Location, false);
                //    }
                //    var upliftValuesPl3 = creator.GetUpliftOutputValuesPl3();
                //    var upliftValuesPl4 = creator.GetUpliftOutputValuesPl4();
                //    updatingWaternet = false;
                //}

                stressProvider.SetWaternet(stabilityModel.GeotechnicsData.CurrentWaternet);
                stressProvider.SetSurfaceLine(stabilityModel.SurfaceLine2);
                stressProvider.SetDegreeOfConsolidationLoads(stabilityModel.ConsolidationMatrix);
                stressProvider.SetUniformLoads(stabilityModel.UniformLoads);

                if (stressProvider.UniformLoads.Count == 0)
                {
                    UniformLoad trafficLoad = GetUniformLoad(stabilityModel.SurfaceLine2);
                    if (trafficLoad != null)
                    {
                        stressProvider.UniformLoads.Add(trafficLoad);
                    }
                }

                stressProvider.SetSlipPlaneConstraints(stabilityModel.SlipPlaneConstraints); //.Constraints = constraints;
                stressProvider.StartPreProcessing();

                slidingCurveCalculation.PreProcessCalculation = stressProvider;
                slidingCurveCalculation.Surface = stabilityModel.SurfaceLine2.Geometry;
                slidingCurveCalculation.Freaticline = stabilityModel.GeotechnicsData.CurrentWaternet.PhreaticLine;
                slidingCurveCalculation.GammaWater = stabilityModel.GeotechnicsData.CurrentWaternet.UnitWeight;

                SlidingCurvesProcessor slidingCurvesProcessor = GetSlidingCurvesCalculator(stabilityModel);
                slidingCurvesProcessor.Initialize(stabilityModel);

                slidingCurvesProcessor.SlidingCurveValidators.Add(new SlidingCurveValidator(stabilityModel.SlipPlaneConstraints));
                slidingCurvesProcessor.SlidingCurveValidators.Add(new StabilityModelSlidingCurveValidator(stabilityModel));
                slidingCurvesProcessor.SlidingCurveValidators.Add(new SlidingCurveWithGeometryValidator(stabilityModel.SurfaceLine2.Geometry));
                slidingCurvesProcessor.SlidingCurveValidators.Add(new IntersectsForbiddenLineValidation(stabilityModel.ForbiddenLinesList));
                slidingCurvesProcessor.SlidingCurveValidators.Add(new AscendingSlidingPlaneValidator());
                slidingCurvesProcessor.SlidingCurveValidators.Add(new SmoothSlidingPlaneValidator(stabilityModel.MaxAllowedAngleBetweenSlices, stabilityModel.RequiredForcePointsInSlices));
                slidingCurvesProcessor.SlidingCurveValidators.Add(new SlidingPlaneBelowSurfaceLineValidator(stabilityModel.SurfaceLine2.Geometry));

                slidingCurvesProcessor.Calculation = slidingCurveCalculation;

                if (stabilityModel.OnlyMinimumSafetyCurve && stabilityModel.MinimumSafetyCurve != null)
                {
                    slidingCurvesProcessor.GetSafetyFactor(stabilityModel.MinimumSafetyCurve);
                }
                else
                {
                    stabilityModel.MinimumSafetyCurve = slidingCurvesProcessor.Calculate();
                }

                if (stabilityModel.MinimumSafetyCurve == null)
                {
                    foreach (var validator in slidingCurvesProcessor.SlidingCurveValidators)
                    {
                        if (validator is SmoothSlidingPlaneValidator)
                        {
                            ((SmoothSlidingPlaneValidator) validator).LogEvaluations();
                        }
                    }
                }

                if (dump)
                {
                    DoDumpMinimumSlidingCurve(stabilityModel.MinimumSafetyCurve);
                }
                if (stabilityModel.MinimumSafetyCurve == null &&
                    stabilityModel.ResultSlidingCurve.SafetyFactor == double.MaxValue)
                {
                    var message = new LogMessage(LogMessageType.Error, this, LocalizationManager.GetTranslatedText(this, "NoValidSlipCircles"));
                    LogManager.Add(message);
                    return CalculationResult.UnexpectedError;
                }
                return CalculationResult.Succeeded;
            }
            catch
            {
                return CalculationResult.UnexpectedError;
            }
        }

        internal SlidingCurveCalculation GetStabilityCalculation(ModelOptions option)
        {
            switch (option)
            {
                case ModelOptions.UpliftVan:
                    return new UpliftVanCalculation();
                case ModelOptions.Fellenius:
                case ModelOptions.Bishop:
                    return new BishopCalculation();
                case ModelOptions.Spencer:
                    return new SpencerCalculation();
                default:
                    throw new NotImplementedException(option.ToString());
            }
        }

        private UniformLoad GetUniformLoad(SurfaceLine2 surfaceLine)
        {
            if (surfaceLine.IsDefined(CharacteristicPointType.TrafficLoadInside) &&
                surfaceLine.IsDefined(CharacteristicPointType.TrafficLoadOutside))
            {
                GeometryPoint trafficLoadInside = surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.TrafficLoadInside);
                GeometryPoint trafficLoadOutside = surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.TrafficLoadOutside);

                var uniformLoad = new UniformLoad
                    {
                        XStart = Math.Min(trafficLoadInside.X, trafficLoadOutside.X),
                        XEnd = Math.Max(trafficLoadInside.X, trafficLoadOutside.X),
                        Magnitude = 13.3,
                        LoadType = UniformLoad.LoadTypeEnum.Temporary
                    };

                return uniformLoad;
            }

            return null;
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2008-12-03  Best Created
        // =======================================================================================================================
        private void DoDumpMinimumSlidingCurve(SlidingCurve MinimumSafetyCurve)
        {
            int i = 0;
            int LNSlices = 0;
            double Rad_Deg = 180.0/Math.PI;
            StreamWriter writer;
            Slice LSlice;
            LNSlices = MinimumSafetyCurve.Slices.Count;
            writer = new StreamWriter("testSpencer.txt");
            writer.WriteLine("Slice| X-coor |  Y-bot |  Y-top |  Width | Angle  | Angle  |Arc.len.|Cohesion|");
            writer.WriteLine("     |   [m]  |   [m]  |   [m]  |   [m]  | bottom |  top   |   [m]  | [kN/m2]|");
            writer.WriteLine("-----|--------|--------|--------|--------|--------|--------|--------|--------|");
            for (i = 0; i < LNSlices; i++)
            {
                LSlice = MinimumSafetyCurve.Slices[i];
                writer.WriteLine("{0,4:0} |{1,7:0.00} |{2,7:0.00} |{3,7:0.00} |{4,7:0.00} |{5,7:0.00} |{6,7:0.00} |{7,7:0.00} |{8,7:0.00} |",
                                 i + 1, LSlice.XCenter, LSlice.ZCenterBottom, LSlice.ZCenterTop, LSlice.Width, LSlice.BottomAngle*Rad_Deg,
                                 LSlice.TopAngle*Rad_Deg, LSlice.ArcLength, LSlice.Cohesion);
            }
            writer.WriteLine("      ");
            writer.WriteLine("      ");
            writer.WriteLine("      ");

            writer.WriteLine("Slice|  Phi   | Sw surf| Fw hor.| Fw ver.| Weight | S-tot. | S-eff. |Sw-hydro|");
            writer.WriteLine("     | degree | [kN/m2]|  [kN]  |  [kN]  |   [kN] | [kN/m2]| [kN/m2]| [kN/m2]|");
            writer.WriteLine("-----|--------|--------|--------|--------|--------|--------|--------|--------|");
            for (i = 0; i < LNSlices; i++)
            {
                LSlice = MinimumSafetyCurve.Slices[i];
                writer.WriteLine("{0,4:0} |{1,7:0.00} |{2,7:0.00} |{3,7:0.00} |{4,7:0.00} |{5,7:0.00} |{6,7:0.00} |{7,7:0.00} |{8,7:0.00} |",
                                 i + 1, LSlice.Phi, LSlice.PoreOnSurface, LSlice.HPoreOnSurface, LSlice.VPoreOnSurface, LSlice.Weight,
                                 LSlice.TotalStress, LSlice.EffectiveStress, LSlice.HydrostaticPorePressure);
            }

            writer.WriteLine("      ");
            writer.WriteLine("      ");
            writer.WriteLine("      ");

            writer.WriteLine("Slice| Sw-extr| Sw tot.|S shear |");
            writer.WriteLine("     | [kN/m2]| [kN/m2]| [kN/m2]|");
            writer.WriteLine("-----|--------|--------|--------|");
            for (i = 0; i < LNSlices; i++)
            {
                LSlice = MinimumSafetyCurve.Slices[i];
                writer.WriteLine("{0,4:0} |{1,7:0.00} |{2,7:0.00} |{3,7:0.00} |",
                                 i + 1, LSlice.ExcessPorePressure, LSlice.TotalPorePressure, LSlice.ShearStress);
            }

            writer.WriteLine("      ");
            writer.WriteLine("      ");
            writer.WriteLine("      ");

            writer.WriteLine("     | Interslice force  LEFT   | Interslice force  RIGHT  |");
            writer.WriteLine("Slice|  Force |  Angle |ap.point|  Force |  Angle |ap.point|");
            writer.WriteLine("     |  [kN]  |  [deg] |  [m]   |  [kN]  |  [deg] |  [m]   |");
            writer.WriteLine("-----|--------|--------|--------|--------|--------|--------|");
            for (i = 0; i < LNSlices; i++)
            {
                LSlice = MinimumSafetyCurve.Slices[i];
                writer.WriteLine(
                    "{0,4:0} |{1,7:0.00} |{2,7:0.00} |{3,7:0.00} |{4,7:0.00} |{5,7:0.00} |{6,7:0.00} |",
                    i + 1, LSlice.LeftForce, LSlice.LeftForceAngle, LSlice.LeftForceY, LSlice.RightForce,
                    LSlice.RightForceAngle, LSlice.RightForceY);
            }

            writer.Close();
        }

        private SlidingCurvesProcessor GetSlidingCurvesCalculator(StabilityModel stabilityModel)
        {
            // get the grid boundaries
            var rtoCalculationGrid = new RTOCalculationgrid(stabilityModel);
            rtoCalculationGrid.CreateGrid(stabilityModel);

            if (stabilityModel.SearchAlgorithm == SearchAlgorithm.Genetic)
            {
                switch (stabilityModel.ModelOption)
                {
                    case ModelOptions.UpliftVan:
                        return new GeneticAlgorithmDualCircleCalculation(stabilityModel);
                    case ModelOptions.Fellenius:
                    case ModelOptions.Bishop:
                        return new GeneticAlgorithmSingleCircleCalculation(stabilityModel.SlipCircle);
                    case ModelOptions.Spencer:
                        var Gm =
                            new GeneticAlgorithmFreePlaneCalculation(stabilityModel);
                        Gm.CalculationSequence.Clear();
                        Gm.CalculationSequence.Add(SearchAlgorithm.Genetic);
                        // Test for lm after gen algorithm
                        Gm.IsLMCalculation = false;
                        return Gm;
                    default:
                        throw new NotImplementedException("SlidingCurvesCalculator " + stabilityModel.ModelOption);
                }
            }
            else if (stabilityModel.SearchAlgorithm == SearchAlgorithm.Grid)
            {
                switch (stabilityModel.ModelOption)
                {
                    case ModelOptions.UpliftVan:
                        return new ControlUpliftcalculation();
                    case ModelOptions.Fellenius:
                    case ModelOptions.Bishop:
                        return new ControlBishopCalculation(stabilityModel.SlipCircle);
                        // spencer uses only genetic algorithm
                    case ModelOptions.Spencer:
                        var Gm =
                            new GeneticAlgorithmFreePlaneCalculation(stabilityModel);
                        Gm.CalculationSequence.Clear();
                        // spencer has no grid option so use genetic algorithm
                        Gm.CalculationSequence.Add(SearchAlgorithm.Genetic);
                        Gm.IsLMCalculation = false;
                        return Gm;
                    default:
                        throw new NotImplementedException("SlidingCurvesCalculator " + stabilityModel.ModelOption);
                }
            }
            else if (stabilityModel.SearchAlgorithm == SearchAlgorithm.LevenbergMarquardt)
            {
                switch (stabilityModel.ModelOption)
                {
                    case ModelOptions.UpliftVan:
                        return new LevenbergMarquardtDualCircleCalculation(stabilityModel);
                    case ModelOptions.Fellenius:
                    case ModelOptions.Bishop:
                        return new LevenbergMarquardtSingleCircleCalculation(stabilityModel.SlipCircle);
                    case ModelOptions.Spencer:
                        var Lm =
                            new GeneticAlgorithmFreePlaneCalculation(stabilityModel);
                        Lm.CalculationSequence.Clear();
                        Lm.CalculationSequence.Add(SearchAlgorithm.LevenbergMarquardt);

                        Lm.IsLMCalculation = true;
                        return Lm;

                        //  return new LevenbergMarquardtFreePlaneCalculation(stabilityModel);
                    default:
                        throw new NotImplementedException("SlidingCurvesCalculator " + stabilityModel.ModelOption);
                }
            }
            else if (stabilityModel.SearchAlgorithm == SearchAlgorithm.GeneticAndLevenbergMarquardt)
            {
                switch (stabilityModel.ModelOption)
                {
                    case ModelOptions.UpliftVan:
                        return new LevenbergMarquardtDualCircleCalculation(stabilityModel);
                    case ModelOptions.Fellenius:
                    case ModelOptions.Bishop:
                        return new LevenbergMarquardtSingleCircleCalculation(stabilityModel.SlipCircle);
                    case ModelOptions.Spencer:
                        var Lm =
                            new GeneticAlgorithmFreePlaneCalculation(stabilityModel);
                        Lm.CalculationSequence.Clear();
                        Lm.CalculationSequence.Add(SearchAlgorithm.Genetic);
                        Lm.CalculationSequence.Add(SearchAlgorithm.LevenbergMarquardt);
                        Lm.IsLMCalculation = false;
                        return Lm;

                        //  return new LevenbergMarquardtFreePlaneCalculation(stabilityModel);
                    default:
                        throw new NotImplementedException("SlidingCurvesCalculator " + stabilityModel.ModelOption);
                }
            }

            else

            {
                throw new NotImplementedException("SlidingCurvesCalculator " + stabilityModel.SearchAlgorithm);
            }
        }
    }
}