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

namespace Deltares.Dam.Data
{
    public abstract class TimeSeriesProcessor
    {
        internal readonly static LogHelper Logger = LogHelper.Create("Time Series Processor");

        #region Constants

        /// <summary>
        /// Defines the default output file 
        /// </summary>
        private const string DefaultOutputFileName = "output.xml";

        /// <summary>e
        /// Defines the water level location id used in the FEWS time serie
        /// </summary>
        public const string WaterLevelInputLocationID = "outside";

        /// <summary>
        /// Defines the parameter id of the water level defined in the FEWS time serie
        /// </summary>
        public const string WaterLevelInputParameterID = "Waterlevel";

        /// <summary>
        /// Defines the parameter id for water pressure used in the FEWS time serie
        /// </summary>
        public const string WaterPressureParameterID = "Waterpressure";

        /// <summary>
        /// Defines the sensor state missing value
        /// </summary>
        internal const double MissingValue = -999;

        #endregion

        public ICalculator Calculator { protected get; set; }

        /// <summary>
        /// Gets or sets the output parameter ID.
        /// </summary>
        /// <remarks>This name or ID is used in the output (FEWS) time series</remarks>
        /// <value>
        /// The output parameter ID.
        /// </value>
        public IEnumerable<string> OutputParameters { get; set; }

        /// <summary>
        /// Sets the input time series, used in the calculations
        /// </summary>
        public TimeSerieCollection InputTimeSeriesCollection { protected get; set; }

        /// <summary>
        /// Gets or sets the output location ID colletion used for creating the output time series
        /// </summary>
        public virtual IEnumerable<string> OutputLocations { get; set; }

        /// <summary>
        /// Gets or the output time series
        /// </summary>
        public TimeSerieCollection OutputTimeSeriesCollection { get; set; }

        /// <summary>
        /// Resets the monitoring point list
        /// </summary>
        public virtual void Initialize()
        {
            if (OutputTimeSeriesCollection == null)
                OutputTimeSeriesCollection = InputTimeSeriesCollection.GetShallowCopy();
            else
                OutputTimeSeriesCollection.Clear();
        }

        /// <summary>
        /// Loads the input time series.
        /// </summary>
        /// <param name="fileName">Name of the file.</param>
        public void LoadInputTimeSeries(string fileName)
        {
            ThrowHelper.ThrowIfFileNameNullOrEmpty(fileName);
            try
            {
                // load the input time serie containing all water levels
                InputTimeSeriesCollection = TimeSerieCollection.LoadFromFile(fileName);
            }
            catch (Exception e)
            {
                throw new InvalidOperationException("There was an error loading the input time series", e);
            }
        }

        /// <summary>
        /// Saves the output time series to the specified file
        /// </summary>
        /// <param name="fileName">
        /// The output file that will contain the monitored and calculated results for each time entry</param>
        public void SaveResultsToFile(string fileName)
        {
            if (OutputTimeSeriesCollection == null)
                throw new InvalidOperationException("No output time series collection to write");

            if (string.IsNullOrWhiteSpace(fileName))
            {
                fileName = DefaultOutputFileName;
            }

            // save the time serie to the output file
            OutputTimeSeriesCollection.Save(fileName);
        }

        /// <summary>
        /// Processes the FEWS input time series files to ouput 
        /// time series
        /// </summary>        
        public virtual void Process()
        {
            if (InputTimeSeriesCollection == null)
                return;

            if (OutputTimeSeriesCollection == null)
                throw new InvalidOperationException("No output time series set to write the results to");            

            if (OutputLocations == null)
                throw new InvalidOperationException("No output locations set. Set or override OutputLocations");

            if (OutputParameters == null)
                throw new InvalidOperationException("No output parameters set. Set or override OutputParameters");
            
            try
            {
                // Process the time series entries for each sensor and set the 
                // value in the output time series
                CreateOutputSeries();
            }
            catch (Exception e)
            {
                const string message = "There was an error processing the time series";
                Logger.LogFatal(message, e);                
                throw new InvalidOperationException(message, e);                
            }
        }

        /// <summary>
        /// Processes the actual input to the output collection. This is a template method which will 
        /// be called in the public ProcessSeries() method (if not overriden)
        /// </summary>
        protected virtual void CreateOutputSeries()
        {
            foreach (var timeSeries in InputTimeSeriesCollection.Series)
            {
                foreach (var location in OutputLocations)
                {
                    foreach (var parameter in OutputParameters)
                    {
                        var copyOfSeries = timeSeries.GetShallowCopy();
                        foreach (var entry in timeSeries.Entries)
                        {
                            // get copy of the input entry
                            var copyOfEntry = entry.GetShallowCopy();
                            // calculate its value
                            copyOfEntry.Value = Calculator.Calculate(location, parameter) ?? MissingValue;

                            // set parameter and location id's and add the projected entry to the output
                            copyOfSeries.LocationId = location;
                            copyOfSeries.ParameterId = parameter;
                            copyOfSeries.Entries.Add(copyOfEntry);
                        }
                        // add the output series to the output collection
                        OutputTimeSeriesCollection.Series.Add(copyOfSeries);                        
                    }
                }
            }
        }
    }
}