//-----------------------------------------------------------------------
// <copyright file="TimeSerie.cs" company="Deltares">
//  Copyright (c) 2009 Deltares. All rights reserved.
// </copyright>
// <author>B. Faassen</author>
// <email>barry.faassen@deltares.nl</email>
// <date>22-6-2009</date>
// <summary>n.a.</summary>
//-----------------------------------------------------------------------
namespace Deltares.Dam.Data
{
    using System;
    using System.Collections.Generic;

    public class TimeSerie
    {
        /// <summary>
        /// List of parameter identifiers used in Fews timeseries
        /// </summary>
        public const string WaterLevelParameterId = "Waterlevel";
        public const string WaterLevelMeanParameterId = "WaterlevelMean";
        public const string WaterLevelStdParameterId = "WaterlevelStdev";
        public const string WaterLevelDistParameterId = "WaterlevelDistribution";
        public const string WaterPressureParameterId = "Waterpressure";
        public const string PiezoMetricHeadId = "PiezoMetricHead";

        private readonly TimeStep timeStep;
        //Bka: read only  not possible to serialize to DB private readonly List<TimeSerieEntry> entries;
        private IList<TimeSerieEntry> entries;

        public const double DefaultMissingValue = -999.0;

        public TimeSerie()
        {
            this.timeStep = new TimeStep();
            this.entries = new List<TimeSerieEntry>();
            ForecastDateTime = DateTime.MinValue;
        }

        public string Type { get; set; }
        public string LocationId { get; set; }
        public string ParameterId { get; set; }
        public TimeStep TimeStep { get { return this.timeStep; } }
        public DateTime StartDateTime { get; set; }
        public DateTime EndDateTime { get; set; }
        public DateTime ForecastDateTime { get; set; }
        public double MissVal { get; set; }
        public string LongName { get; set; }
        public string StationName { get; set; }
        public string Units { get; set; }
        public string SourceOrganisation { get; set; }
        public string SourceSystem { get; set; }
        public string FileDescription { get; set; }
        public DateTime? CreationDateTime { get; set; }
        public string Region { get; set; }

        public virtual IList<TimeSerieEntry> Entries
        {
            get { return this.entries; }
            set { this.entries = value; }
        }

        public string Comment { get; set; }

        /// <summary>
        /// Creates a shallow copy of the current time serie and applies the map function to each of its entries
        /// </summary>
        /// <param name="function">The time serie entry function which maps uses the current value as input</param>
        /// <returns>Time serie (clone) with new calculated entries</returns>
        public TimeSerie Map(Func<TimeSerieEntry, TimeSerieEntry> function)
        {
            return this.Map(this.ParameterId, function);
        }

        /// <summary>
        /// Creates a shallow copy of the current time serie and applies the map function to each of its entries
        /// </summary>
        /// <param name="parameterId">The (new) id of the parameter in the cloned time serie</param>
        /// <param name="locationId">The (new) location id of the cloned time serie</param>
        /// <param name="function">The time serie entry function which maps uses the current value as input</param>
        /// <returns>Time serie (clone) with new calculated entries</returns>
        public TimeSerie Map(string parameterId, string locationId, Func<TimeSerieEntry, TimeSerieEntry> function)
        {
            return Map(this, parameterId, locationId, function);
        }

        /// <summary>
        /// Creates a shallow copy of the current time serie and applies the map function to each of its entries
        /// </summary>
        /// <param name="parameterId">The (new) id of the parameter in the cloned time serie</param>
        /// <param name="function">The time serie entry function which maps uses the current value as input</param>
        /// <returns>Time serie (clone) with new calculated entries</returns>
        public TimeSerie Map(string parameterId, Func<TimeSerieEntry, TimeSerieEntry> function)
        {
            return Map(this, parameterId, function);
        }

        /// <summary>
        /// Creates a shallow copy of the current time serie and applies the map function to each of its entries
        /// </summary>
        /// <param name="timeSerie">The time serie to map from</param>
        /// <param name="parameterId">The (new) id of the parameter in the cloned time serie</param>        
        /// <param name="function">The time serie entry function which maps uses the current value as input</param>
        /// <returns>Time serie (clone) with new calculated entries</returns>
        public static TimeSerie Map(TimeSerie timeSerie, string parameterId, Func<TimeSerieEntry, TimeSerieEntry> function)
        {
            return Map(timeSerie, parameterId, null, function);
        }

        /// <summary>
        /// Creates a shallow copy of the current time serie and applies the map function to each of its entries
        /// </summary>
        /// <param name="timeSerie">The time serie to map from</param>
        /// <param name="parameterId">The (new) id of the parameter in the cloned time serie</param>
        /// <param name="locationId">The (new) location id of the cloned time serie</param>
        /// <param name="function">The time serie entry function which maps uses the current value as input</param>
        /// <returns>Time serie (clone) with new calculated entries</returns>
        public static TimeSerie Map(TimeSerie timeSerie, string parameterId, string locationId, Func<TimeSerieEntry, TimeSerieEntry> function)
        {
            var result = CreateTimeSerie(timeSerie, parameterId);
            if (!(string.IsNullOrEmpty(locationId) || locationId.Trim() == ""))
                result.LocationId = locationId;

            foreach (var entry in timeSerie.Entries)
                result.Entries.Add(function(entry));
            return result;
        }

        /// <summary>
        /// Gets a shallow copy of the time serie without the time serie entries
        /// </summary>
        /// <returns>A copy of this time serie</returns>
        public TimeSerie GetShallowCopy()
        {
            var serie = new TimeSerie
                            {
                                Type = Type,
                                ParameterId = ParameterId,
                                LocationId = LocationId,
                                StartDateTime = StartDateTime,
                                EndDateTime = EndDateTime,
                                ForecastDateTime = ForecastDateTime,
                                MissVal = MissVal,
                                LongName = LongName,
                                StationName = StationName,
                                SourceOrganisation = SourceOrganisation,
                                SourceSystem = SourceSystem,
                                FileDescription = FileDescription,
                                CreationDateTime = CreationDateTime,
                                Region = Region,
                                Units = Units,
                                TimeStep =
                                    {
                                        Multiplier = TimeStep.Multiplier,
                                        Divider = TimeStep.Divider,
                                        Unit = TimeStep.Unit
                                    }
                            };

            serie.Entries.Clear();
            return serie;
        }

        public static TimeSerie CreateTimeSerie(string locationId)
        {
            var timeSerie = new TimeSerie
            {
                MissVal = DefaultMissingValue,
                ParameterId = WaterLevelParameterId,
                LocationId = locationId,
                StationName = locationId,
                Type = "instantaneous",
                Units = "m",
                Comment = ""
            };

            return timeSerie;
        }


        /// <summary>
        /// Creates a time serie by copying data from the source time serie without 
        /// time serie entries (shallow copy)
        /// </summary>
        /// <param name="source">The source time serie used to copy from</param>
        /// <param name="parameterId">The new parameter ID</param>
        /// <returns>A time serie copy without time entries</returns>
        public static TimeSerie CreateTimeSerie(TimeSerie source, string parameterId)
        {
            var serie = source.GetShallowCopy();
            serie.ParameterId = parameterId;
            serie.Units = "-";
            serie.Comment = "";
            return serie;
        }

        public double GetValue(DateTime dateTime)
        {
            foreach (TimeSerieEntry entry in this.Entries)
            {
                if (entry.DateTime >= dateTime)
                {
                    return entry.Value;
                }
            }

            return -1;
        }

        public string GetNearestBasisFileName(DateTime dateTime)
        {
            string res = "";
            double mindiff = 1e99;
            double diff = 0;
            foreach (TimeSerieEntry entry in this.Entries)
            {
                diff = Math.Abs(entry.DateTime.ToFileTimeUtc() - dateTime.ToFileTimeUtc());
                if (diff < mindiff)
                {
                    res = entry.BasisFileName;
                    mindiff = diff;
                }
            }
            return res;
        }
    }
}