using System;
using System.Collections.Generic;
using System.Linq;
using Deltares.Dam.Data;
using Deltares.Standard.Application;

namespace Deltares.Dam.Application.Live
{
    public class LegacyModelRunner : ModelRunner
    {
        public LegacyModelRunner()
        {
            Logger = LogHelper.Create<LegacyModelRunner>();
        }

        private readonly TimeSerieProbablisticCalculator timeSerieProbablisticCalculator = new TimeSerieProbablisticCalculator();
        private readonly TimeSeriePipingCalculator timeSeriePipingCalculator = new TimeSeriePipingCalculator();
        private readonly TimeSerieOvertoppingErosionCalculator timeSerieOvertoppingErosionCalculator = new TimeSerieOvertoppingErosionCalculator();
        private readonly TimeSerieStabilityCalculator timeSerieStabilityCalculator = new TimeSerieStabilityCalculator();

        public override void Initialize()
        {
            timeSeriePipingCalculator.PipingWorkingPath = PipingWorkingPath;
            timeSerieStabilityCalculator.StabilityWorkingPath = StabilityWorkingPath;
            timeSerieStabilityCalculator.IsMStabCalculationOff = !UseMStabForCalculation;
            timeSerieStabilityCalculator.MStabExePath = StabilityExePath;

            // Add offset to water level
            InputTimeSeriesCollection.UpdateAllEntryValues(TimeSerie.WaterLevelParameterId, currentWaterLevel => currentWaterLevel + WaterLevelOffset);
        }

        bool initialized;

        public override void Run()
        {
            if (CalculationParameters != null && CalculationParameters.CalculationModules == null)
                throw new InvalidOperationException("No calculation parameters module available.");
            
            if (!initialized)
            {
                Initialize();
                initialized = true;
            }

            Process();
        }

        public override void Process()
        {
            int locationCounter = 0;
            foreach (var dike in ProjectData.WaterBoard.Dikes)
            {
                foreach (Location location in dike.Locations)
                {
                    dike.UpdateLocation(location);

                    List<TimeSerie> waterLevelTimeSerieList;
                    List<TimeSerie> waterLevelProbabilisticTimeSerieList = null;
                    IEnumerable<TimeSerie> gaugeTimeSerieList;
                    if (location.UsesGauges)
                    {
                        gaugeTimeSerieList =
                            InputTimeSeriesCollection.GetSeriesByGageIdAndLocationId(location.Name).Where(
                                x => x.ParameterId.Equals(TimeSerie.WaterPressureParameterId));
                        waterLevelTimeSerieList = new List<TimeSerie>();
                        TimeSerie timeSerieFirst = gaugeTimeSerieList.FirstOrDefault();
                        if (timeSerieFirst != null)
                            waterLevelTimeSerieList.Add(timeSerieFirst);
                    }
                    else
                    {
                        waterLevelTimeSerieList =
                            new List<TimeSerie>(InputTimeSeriesCollection.GetSeriesByLocationId(location.Name).Where(
                                x => x.ParameterId.Equals(TimeSerie.WaterLevelParameterId)));
                        var waterLevelMeanTimeSerieList =
                            new List<TimeSerie>(InputTimeSeriesCollection.GetSeriesByLocationId(location.Name).Where(
                                x => x.ParameterId.Equals(TimeSerie.WaterLevelMeanParameterId)));
                        var waterLevelStdTimeSerieList =
                            new List<TimeSerie>(InputTimeSeriesCollection.GetSeriesByLocationId(location.Name).Where(
                                x => x.ParameterId.Equals(TimeSerie.WaterLevelStdParameterId)));
                        var waterLevelDistTimeSerieList =
                            new List<TimeSerie>(InputTimeSeriesCollection.GetSeriesByLocationId(location.Name).Where(
                                x => x.ParameterId.Equals(TimeSerie.WaterLevelDistParameterId)));
                        waterLevelProbabilisticTimeSerieList =
                            timeSerieProbablisticCalculator.CreateProbabilisticTimeSerieList(waterLevelMeanTimeSerieList,
                                                                                 waterLevelStdTimeSerieList,
                                                                                 waterLevelDistTimeSerieList);
                        gaugeTimeSerieList = null;
                    }

                    // probabilistic calculations
                    if (waterLevelProbabilisticTimeSerieList != null)
                    {
                        foreach (TimeSerie timeSerieIn in waterLevelProbabilisticTimeSerieList)
                        {
                            var locationTimeSerieOutList = new List<TimeSerie>();
                            if (CalculationParameters == null ||
                                CalculationParameters.CalculationModules.PipingSellmeijerProbabilistic)
                            {
                                TimeSerie probablityOfFailureSerie =
                                    timeSeriePipingCalculator.CreateProbabilityOfFailurePipingSellmeijerTimeSerie(
                                        timeSerieIn, location);
                                locationTimeSerieOutList.Add(probablityOfFailureSerie);
                            }

                            foreach (TimeSerie timeSerieOut in locationTimeSerieOutList)
                            {
                                timeSerieOut.LocationId = location.Name;
                                OutputTimeSeriesCollection.Series.Add(timeSerieOut);
                            }
                        }
                    }

                    

                    // Deterministic calculations 
                    foreach (TimeSerie timeSerieIn in waterLevelTimeSerieList)
                    {
                        var locationTimeSerieOutList = new List<TimeSerie>();
                        if (CalculationParameters == null || CalculationParameters.CalculationModules != null && CalculationParameters.CalculationModules.PipingBligh)
                        {
                            TimeSerie pipingFactorBlighSerie =
                                timeSeriePipingCalculator.CreatePipingFactorBlighTimeSerie(timeSerieIn, location);
                            locationTimeSerieOutList.Add(pipingFactorBlighSerie);
                        }

                        if (CalculationParameters == null || CalculationParameters.CalculationModules.PipingSellmeijer)
                        {
                            TimeSerie pipingFactorSellmeijerSerie =
                                timeSeriePipingCalculator.CreatePipingFactorSellmeijerTimeSerie(timeSerieIn,
                                                                                                location);
                            locationTimeSerieOutList.Add(pipingFactorSellmeijerSerie);
                        }

                        if (CalculationParameters == null || CalculationParameters.CalculationModules.Overtopping)
                        {
                            TimeSerie overtoppingErosionSerie =
                                timeSerieOvertoppingErosionCalculator.CreateOvertoppingErosionTimeSerie(timeSerieIn,
                                                                                                        dike,
                                                                                                        location);
                            locationTimeSerieOutList.Add(overtoppingErosionSerie);
                        }


                        MStabParameters mstabParameters = CalculationParameters != null
                                                              ? CalculationParameters.MStabParameters
                                                              : new MStabParameters();
                        string message = String.Format("Error processing time serie in location '{0}'", timeSerieIn.LocationId);

                        if (CalculationParameters == null || CalculationParameters.CalculationModules.Stability)
                        {
                            try
                            {
                                TimeSerie safetyFactorSerie =
                                    timeSerieStabilityCalculator.CreateStabilityInsideSafetyFactorTimeSerie(
                                        timeSerieIn, dike,
                                        location, locationCounter, mstabParameters, gaugeTimeSerieList);
                                locationTimeSerieOutList.Add(safetyFactorSerie);
                            }
                            catch (Exception e)
                            {
                                Logger.LogError(message, e);
                            }
                        }

                        if (CalculationParameters == null || CalculationParameters.CalculationModules.StabilityOutside)
                        {
                            try
                            {
                                TimeSerie safetyFactorSerie =
                                    timeSerieStabilityCalculator.CreateStabilityOutsideSafetyFactorTimeSerie(
                                        timeSerieIn, dike,
                                        location, locationCounter, mstabParameters, gaugeTimeSerieList);
                                locationTimeSerieOutList.Add(safetyFactorSerie);
                            }
                            catch (Exception e)
                            {
                                Logger.LogError(message, e);
                            }
                        }

                        foreach (TimeSerie timeSerieOut in locationTimeSerieOutList)
                        {
                            timeSerieOut.LocationId = location.Name;
                            OutputTimeSeriesCollection.Series.Add(timeSerieOut);
                        }
                    }
                    locationCounter++;
                }

                // Check if we need to calculate
                if ((CalculationParameters != null && !CalculationParameters.CalculationModules.Stability &&
                     !CalculationParameters.CalculationModules.StabilityOutside) || !UseMStabForCalculation)
                    continue;

                if (CalculationParameters != null)
                {
                    timeSerieStabilityCalculator.IsCalculateAllStabilityProjectsAtOnce =
                        CalculationParameters.MStabParameters.IsCalculateAllStabilityProjectsAtOnce;
                }
                timeSerieStabilityCalculator.CalculateSafetyFactorFromTimeSeries(
                    TimeSerieParameters.StabilityInsideFactor.ToString(), dike, OutputTimeSeriesCollection);
            }
        }
    }
}