// Copyright (C) Stichting Deltares 2024. All rights reserved.
// 
// This file is part of the application DAM - UI.
// 
// DAM - UI is free software: you can redistribute it and/or modify
// it under the terms of the GNU 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 General Public License for more details.
// 
// You should have received a copy of the GNU 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.Standard.Application;

namespace Deltares.Dam.Data;

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

    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 (TimeSerie timeSeries in InputTimeSeriesCollection.Series)
        {
            foreach (string location in OutputLocations)
            {
                foreach (string parameter in OutputParameters)
                {
                    TimeSerie copyOfSeries = timeSeries.GetShallowCopy();
                    foreach (TimeSerieEntry entry in timeSeries.Entries)
                    {
                        // get copy of the input entry
                        TimeSerieEntry 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);
                }
            }
        }
    }

    #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
}