// Copyright (C) Stichting Deltares 2023. 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 System.Linq;
using Deltares.DamEngine.Data.Standard;

namespace Deltares.DamEngine.Data.General.TimeSeries
{
    public class TimeSerieCollection
    {

        public TimeSerieCollection()
        {
            this.Series = new List<TimeSerie>();
        }

        public List<TimeSerie> Series { get; set; }

        public string Version { get; set; }
        public double TimeZone { get; set; }

        /// <summary>
        /// Updates the time serie entries with new values by applying the function to each value entry
        /// </summary>
        /// <param name="parameterId">The parameter ID of the time serie to update</param>
        /// <param name="function">The function to apply to each entry</param>
        public void UpdateAllEntryValues(string parameterId, Func<double, double> function)
        {
            foreach (var timeSerie in this.GetSeriesByParameterId(parameterId))
            {
                foreach (var sourceEntry in timeSerie.Entries)
                {
                    if (!sourceEntry.Value.AlmostEquals(timeSerie.MissVal))
                    {
                        sourceEntry.Value = function(sourceEntry.Value);
                    }
                }
            }
        }

        /// <summary>
        /// Creates a shallow copy of the current time serie collection and applies the map function to each of its entries
        /// </summary>
        public IEnumerable<TimeSerie> Map(IEnumerable<string> locations, string parameterId, IEnumerable<Func<TimeSerie, TimeSerie>> functionList)
        {
            return from locationId in locations 
                   from timeSerie in this.GetSeriesByLocationId(locationId).Where(x => x.ParameterId.Equals(parameterId)) 
                   from function in functionList 
                   select function(timeSerie);
        }

        /// <summary>
        /// Creates a shallow copy of the current time serie collection and applies the map function to each of its entries
        /// </summary>
        /// <param name="locations">The locations to look for in this collection</param>
        /// <param name="parameterId">The parameter to look for in this collection</param>
        /// <param name="function">The function to apply</param>
        /// <returns>A sequence of new time series with the applied function to its entries</returns>
        public IEnumerable<TimeSerie> Map(IEnumerable<string> locations, string parameterId, Func<TimeSerie, TimeSerie> function)
        {
            return Map(locations, parameterId, new List<Func<TimeSerie, TimeSerie>> { function });
        }

        /// <summary>
        /// Creates a shallow copy of the current time serie collection and applies the map function to each of its entries
        /// </summary>
        public IEnumerable<TimeSerie> Map(string locationId, string parameterId, Func<TimeSerie, TimeSerie> function)
        {
            return Map(new List<string> { locationId }, parameterId, function);
        }

        /// <summary>
        /// Searches for a time series matching the location and parameter id. There should be only 1 or none (null)
        /// </summary>
        /// <param name="parameterId">The parameter id.</param>
        /// <param name="locationId">The location id.</param>
        /// <returns>The time series matching the criterium</returns>
        public TimeSerie FindSerie(string parameterId, string locationId)
        {
            return (from series in this.Series
                    where series.ParameterId.Equals(parameterId, StringComparison.InvariantCultureIgnoreCase) &&
                          series.LocationId.Equals(locationId, StringComparison.InvariantCultureIgnoreCase)
                    select series).SingleOrDefault();
        }

        /// <summary>
        /// Gets all the time series with the given parameter id.
        /// </summary>
        /// <param name="parameterId">The parameter id.</param>
        /// <returns>The time series matching the criteria</returns>
        public IEnumerable<TimeSerie> GetSeriesByParameterId(string parameterId)
        {
            return from series in this.Series
                   where series.ParameterId.Equals(parameterId, StringComparison.InvariantCultureIgnoreCase)
                   select series;
        }

        /// <summary>
        /// Gets all the series with the given location id.
        /// </summary>
        /// <param name="locationId">The location id.</param>
        /// <returns>The time series matching the criteria</returns>
        public IEnumerable<TimeSerie> GetSeriesByLocationId(string locationId)
        {
            return from series in this.Series
                   where series.LocationId.Equals(locationId, StringComparison.InvariantCultureIgnoreCase)
                   select series;
        }


        /// <summary>
        /// Gets the series containing location id and parameter id.
        /// </summary>
        /// <param name="locationId">The location id.</param>
        /// <param name="parameterId">The parameter id.</param>
        /// <returns>The time series matching the criteria</returns>
        public IEnumerable<TimeSerie> GetSeriesByLocationIdAndParameterId(string locationId, string parameterId)
        {
            return from series in this.Series
                   where series.LocationId.Equals(locationId, StringComparison.InvariantCultureIgnoreCase) && 
                         series.ParameterId.Equals(parameterId, StringComparison.InvariantCultureIgnoreCase)
                   select series;
        }

        /// <summary>
        /// Gets all the series containing the combined gage and location id. (using the gage_id/location_id pattern)
        /// </summary>
        /// <param name="combinedGageAndLocationId">The combined gage and location id.</param>
        /// <returns></returns>
        public IEnumerable<TimeSerie> GetSeriesByGageIdAndLocationId(string combinedGageAndLocationId)
        {
            var resultSeries = new List<TimeSerie>();
            foreach (var serie in this.Series)
            {
                string gaugeLocationId = serie.LocationId.Split('/')[0];
                if (combinedGageAndLocationId.Equals(gaugeLocationId, StringComparison.InvariantCultureIgnoreCase))
                {
                    resultSeries.Add(serie);
                }
            }
            return resultSeries;
        }

        public TimeSerieCollection GetShallowCopy()
        {
            var copy = new TimeSerieCollection
                           {
                               Version = Version,
                               TimeZone = TimeZone
                           };

            copy.Series.Clear();
            return copy;
        }

        /// <summary>
        /// Clears the time series.
        /// </summary>
        public void Clear()
        {
            Series.Clear();
        }

        public TimeSerie AddNewSeries(string locationId)
        {
            var series = TimeSerie.CreateTimeSerie(locationId);
            this.Series.Add(series);
            return series;
        }
    }
}