// Copyright (C) Stichting Deltares 2018. 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.General.TimeSeries;
using Deltares.DamEngine.Data.Standard;

namespace Deltares.DamEngine.Calculators.Sensors
{
    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)
        {
            throw new NotImplementedException();
//            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)
        {
            throw new NotImplementedException();
//            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);                        
                    }
                }
            }
        }
    }
}