// Copyright (C) Stichting Deltares 2019. All rights reserved.
//
// This file is part of the application DAM - Clients Library.
//
// 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 System.Linq;
using System.Xml.Linq;
using System.IO;
using Deltares.Dam.Data.Assemblers;
using Deltares.Standard.Extensions;

namespace Deltares.Dam.Data
{

    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>
        /// Loads a time serie collection from file and validates the file with the resource embedded XSD
        /// </summary>
        /// <param name="fileInfo">The file info object containing the file to load</param>
        /// <returns>When valid a loaded time serie collection</returns>
        /// <exception cref="TimeSerieSchemaValidationException"></exception>
        public static TimeSerieCollection LoadFromFile(FileInfo fileInfo)
        {
            return LoadFromFile(fileInfo.FullName, true);
        }

        /// <summary>
        /// Loads a time serie collection from file and validates the file with the resource embedded XSD
        /// </summary>
        /// <param name="fileName">The file to load</param>
        /// <returns>When valid a loaded time serie collection</returns>
        /// <exception cref="TimeSerieSchemaValidationException"></exception>
        public static TimeSerieCollection LoadFromFile(string fileName)
        {
            return LoadFromFile(fileName, true);
        }

        /// <summary>
        /// Loads a time serie collection from file. 
        /// </summary>
        /// <param name="fileName">The file name of the time serie</param>
        /// <param name="validateWithEmbeddedXsd">The value indicating if the file needs to be validated</param>
        /// <returns>The loaded time serie collection</returns>
        public static TimeSerieCollection LoadFromFile(string fileName, bool validateWithEmbeddedXsd)
        {
            string message;
            var assembler = new TimeSeriesAssembler();
            var doc = XDocument.Load(fileName);
            if (validateWithEmbeddedXsd)
                if (!assembler.ValidateSchema(doc, out message))
                    throw new TimeSerieSchemaValidationException(message);

            return assembler.CreateDomainObject(doc);
        }

        /// <summary>
        /// Saves the time serie collection to a specified file using the time serie assembler
        /// </summary>
        /// <param name="fileName">The name of the file</param>
        public void Save(string fileName)
        {
            ThrowHelper.ThrowIfFileNameNullOrEmpty(fileName, StringResourceNames.FileNameNotValid);

            var timeSerieAssembler = new TimeSeriesAssembler();
            XDocument doc = timeSerieAssembler.CreateDataTransferDocument(this);
            doc.Save(fileName);
            FileWriterUtil.RemoveThreeBytesFromXml(fileName); // apply this fix for FEWS!
        }

        /// <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;
        }
    }
}