using System;
using System.Globalization;
using System.Linq;
using CH = Developpez.Dotnet.CompatibilityHelper;

namespace Developpez.Dotnet
{
    /// <summary>
    /// Permet d'utiliser des methodes d'extensions sur les types de Date.
    /// En particulier, permet d'utiliser des expressions "à la Ruby" en C#
    /// Par exemple, plutôt que de faire <c>DateTime.Now.AddMinutes(5)</c>, on fera:
    /// <c>5.Minutes().FromNow()</c>
    /// </summary>)
    public static partial class DateExtensions
    {
        #region Current time abstraction (for testability)

        private static readonly ITimeProvider _defaultTimeProvider = new DefaultTimeProvider();
        private static ITimeProvider _timeProvider = _defaultTimeProvider;

        internal static ITimeProvider TimeProvider
        {
            get
            {
                return _timeProvider;
            }
            set
            {
                value.CheckArgumentNull("value");
                _timeProvider = value;
            }
        }

        internal static void ResetTimeProvider()
        {
            _timeProvider = _defaultTimeProvider;
        }

        internal interface ITimeProvider
        {
            DateTime Now { get; }
            DateTime UtcNow { get; }
        }

        private class DefaultTimeProvider : ITimeProvider
        {
            public DateTime Now
            {
                get { return DateTime.Now; }
            }

            public DateTime UtcNow
            {
                get { return DateTime.UtcNow; }
            }
        }

        #endregion

        #region Durations

        /// <summary>
        /// Retourne une durée correspondant au nombre de jours passé en paramètre
        /// </summary>
        /// <param name="value">Nombre de jours dans la période</param>
        /// <returns>Une durée correspondant au nombre de jours spécifié</returns>
        public static TimeSpan Days(this int value)
        {
            return TimeSpan.FromDays(value);
        }

        /// <summary>
        /// Retourne une durée correspondant au nombre d'heures passé en paramètre
        /// </summary>
        /// <param name="value">Nombre de heures dans la période</param>
        /// <returns>Une durée correspondant au nombre d'heures spécifié</returns>
        public static TimeSpan Hours(this int value)
        {
            return TimeSpan.FromHours(value);
        }

        /// <summary>
        /// Retourne une durée correspondant au nombre de minutes passé en paramètre
        /// </summary>
        /// <param name="value">Nombre de minutes dans la période</param>
        /// <returns>Une durée correspondant au nombre de minutes spécifié</returns>
        public static TimeSpan Minutes(this int value)
        {
            return TimeSpan.FromMinutes(value);
        }

        /// <summary>
        /// Retourne une durée correspondant au nombre de secondes passé en paramètre
        /// </summary>
        /// <param name="value">Nombre de secondes dans la période</param>
        /// <returns>Une durée correspondant au nombre de secondes spécifié</returns>
        public static TimeSpan Seconds(this int value)
        {
            return TimeSpan.FromSeconds(value);
        }

        /// <summary>
        /// Retourne une durée correspondant au nombre de millisecondes passé en paramètre
        /// </summary>
        /// <param name="value">Nombre de millisecondes dans la période</param>
        /// <returns>Une durée correspondant au nombre de millisecondes spécifié</returns>
        public static TimeSpan Milliseconds(this int value)
        {
            return TimeSpan.FromMilliseconds(value);
        }

        #endregion

        #region Relative dates

        /// <summary>
        /// Retourne une date correspondant à la durée précédant la date courante
        /// </summary>
        /// <param name="timeSpan">Durée que l'on veut soustraire a la date courante</param>
        /// <returns>La date correspondant à la durée précédent la date courante</returns>
        public static DateTime Ago(this TimeSpan timeSpan)
        {
            return TimeProvider.Now - timeSpan;
        }

        /// <summary>
        /// Retourne une date correspondant à la durée suivant la date courante
        /// </summary>
        /// <param name="timeSpan">Durée que l'on veut ajouter a la date courante</param>
        /// <returns>La date correspondant à la durée suivant la date courante</returns>
        public static DateTime FromNow(this TimeSpan timeSpan)
        {
            return TimeProvider.Now + timeSpan;
        }

        /// <summary>
        /// Retourne une date correspondant à la durée suivant la date de départ spécifiée
        /// </summary>
        /// <param name="timeSpan">Durée que l'on veut ajouter a la date de départ spécifiée</param>
        /// <param name="startDate">Date de départ</param>
        /// <returns>La date correspondant à la durée suivant la date de départ spécifiée</returns>
        public static DateTime From(this TimeSpan timeSpan, DateTime startDate)
        {
            return startDate + timeSpan;
        }

        /// <summary>
        /// Retourne une date correspondant à la durée précédent la date spécifiée
        /// </summary>
        /// <param name="timeSpan">Durée que l'on veut retrancher de la date spécifiée</param>
        /// <param name="endDate">Date de fin</param>
        /// <returns>La date correspondant à la durée précédent la date spécifiée</returns>
        public static DateTime Before(this TimeSpan timeSpan, DateTime endDate)
        {
            return endDate - timeSpan;
        }

        #endregion

        #region Time of day

        /// <summary>
        /// Renvoie une date correspondant à l'heure spécifiée pour la date spécifiée.
        /// </summary>
        /// <param name="date">Date</param>
        /// <param name="time">Heure</param>
        /// <returns>La date correspondant à l'heure spécifiée pour la date spécifiée.</returns>
        public static DateTime At(this DateTime date, TimeSpan time)
        {
            return date.Date.Add(time);
        }

        /// <summary>
        /// Renvoie une date correspondant à l'heure spécifiée pour la date spécifiée.
        /// </summary>
        /// <param name="date">Date</param>
        /// <param name="timeParts">Composantes de l'heure</param>
        /// <returns>La date correspondant à l'heure spécifiée pour la date spécifiée.</returns>
        public static DateTime At(this DateTime date, params TimeSpan[] timeParts)
        {
            return timeParts.Aggregate(date.Date, (d, t) => d.Add(t));
        }

        /// <summary>
        /// Renvoie une date correspondant à l'heure spécifiée pour la date spécifiée.
        /// </summary>
        /// <param name="date">Date</param>
        /// <param name="hours">Heures</param>
        /// <returns>La date correspondant à l'heure spécifiée pour la date spécifiée.</returns>
        public static DateTime At(this DateTime date, int hours)
        {
            return date.Date.AddHours(hours);
        }

        /// <summary>
        /// Renvoie une date correspondant à l'heure spécifiée pour la date spécifiée.
        /// </summary>
        /// <param name="date">Date</param>
        /// <param name="hours">Heures</param>
        /// <param name="minutes">Minutes</param>
        /// <returns>La date correspondant à l'heure spécifiée pour la date spécifiée.</returns>
        public static DateTime At(this DateTime date, int hours, int minutes)
        {
            return date.Date.AddHours(hours).AddMinutes(minutes);
        }

        /// <summary>
        /// Renvoie une date correspondant à l'heure spécifiée pour la date spécifiée.
        /// </summary>
        /// <param name="date">Date</param>
        /// <param name="hours">Heures</param>
        /// <param name="minutes">Minutes</param>
        /// <param name="seconds">Secondes</param>
        /// <returns>La date correspondant à l'heure spécifiée pour la date spécifiée.</returns>
        public static DateTime At(this DateTime date, int hours, int minutes, int seconds)
        {
            return date.Date.AddHours(hours).AddMinutes(minutes).AddSeconds(seconds);
        }

        #endregion

        #region UNIX timestamps

        private static readonly DateTime _unixEpoch = new DateTime(1970, 1, 1);

        /// <summary>
        /// Convertit un DateTime en timestamp Unix
        /// </summary>
        /// <param name="date">La date à convertir</param>
        /// <returns>Le timestamp Unix équivalent</returns>
        public static long ToUnixTimestamp(this DateTime date)
        {
            TimeSpan span = date - _unixEpoch;
            return (long)CH.Math.Truncate(span.TotalSeconds);
        }

        /// <summary>
        /// Convertit un timestamp Unix en DateTime
        /// </summary>
        /// <param name="unixTimestamp">Le timestamp à convertir</param>
        /// <returns>Le DateTime équivalent</returns>
        public static DateTime ToDateTime(this long unixTimestamp)
        {
            return _unixEpoch.AddSeconds(unixTimestamp);
        }

        #endregion

        #region Next/previous day of week

        /// <summary>
        /// Renvoie le prochain jour de la semaine spécifié à partir d'une date
        /// </summary>
        /// <param name="from">la date à partir de laquelle on recherche</param>
        /// <param name="dayOfWeek">le jour de la semaine recherché</param>
        /// <returns>Le prochain <c>dayOfWeek</c> spécifié à partir de la date</returns>
        public static DateTime Next(this DateTime from, DayOfWeek dayOfWeek)
        {
            int start = (int)from.DayOfWeek;
            int wanted = (int)dayOfWeek;
            if (wanted <= start)
                wanted += 7;
            return from.AddDays(wanted - start);
        }

        /// <summary>
        /// Renvoie le prochain jour de la semaine spécifié à partir de la date courante
        /// </summary>
        /// <param name="dayOfWeek">le jour de la semaine recherché</param>
        /// <returns>Le prochain <c>dayOfWeek</c> spécifié à partir de la date courante</returns>
        public static DateTime Next(this DayOfWeek dayOfWeek)
        {
            return TimeProvider.Now.Next(dayOfWeek);
        }

        /// <summary>
        /// Renvoie le précédent jour de la semaine spécifié à partir d'une date
        /// </summary>
        /// <param name="from">la date à partir de laquelle on recherche</param>
        /// <param name="dayOfWeek">le jour de la semaine recherché</param>
        /// <returns>Le précédent <c>dayOfWeek</c> spécifié à partir de la date</returns>
        public static DateTime Previous(this DateTime from, DayOfWeek dayOfWeek)
        {
            int end = (int)from.DayOfWeek;
            int wanted = (int)dayOfWeek;
            if (wanted >= end)
                end += 7;
            return from.AddDays(wanted - end);
        }

        /// <summary>
        /// Renvoie le précédent jour de la semaine spécifié à partir de la date courante
        /// </summary>
        /// <param name="dayOfWeek">le jour de la semaine recherché</param>
        /// <returns>Le précédent <c>dayOfWeek</c> spécifié à partir de la date courante</returns>
        public static DateTime Previous(DayOfWeek dayOfWeek)
        {
            return TimeProvider.Now.Previous(dayOfWeek);
        }

        #endregion

        #region Working days

        /// <summary>
        /// Ajoute le nombre spécifié de jours ouvrés à la date
        /// </summary>
        /// <param name="date">Date d'origine</param>
        /// <param name="days">Nombre de jours ouvrés à ajouter</param>
        /// <returns>La date <c>days</c> jours ouvrés après <c>date</c> (ou avant si <c>days</c> est négatif)</returns>
        /// <remarks>Cette méthode suppose que la semaine comporte 5 jours ouvrés, du lundi au vendredi. Les jours fériés ne sont pas pris en compte.</remarks>
        public static DateTime AddWorkingDays(this DateTime date, int days)
        {
            if (days == 0)
                return date;
            int sign = days < 0 ? -1 : 1;
            while (days % 5 != 0 || !date.IsWorkingDay())
            {
                date = date.AddDays(sign);
                if (!date.IsWorkingDay())
                    continue;
                days -= sign;
            }

            int nWeekEnds = days / 5;
            DateTime result = date.AddDays(days + nWeekEnds * 2);
            return result;
        }

        /// <summary>
        /// Indique si la date est un jour ouvré
        /// </summary>
        /// <param name="date">La date à vérifier</param>
        /// <returns><c>true</c> si la date est un jour ouvré, sinon <c>false</c>.</returns>
        /// <remarks>Cette méthode suppose que la semaine comporte 5 jours ouvrés, du lundi au vendredi. Les jours fériés ne sont pas pris en compte.</remarks>
        public static bool IsWorkingDay(this DateTime date)
        {
            return !(date.DayOfWeek == DayOfWeek.Saturday || date.DayOfWeek == DayOfWeek.Sunday);
        }

        #endregion

        #region Start of week

        ///<summary>
        /// Calcule la date du début de la semaine spécifiée, en utilisant la règle
        /// de calcul et le premier jour de la semaine de la culture courante.
        ///</summary>
        ///<param name="year">Année</param>
        ///<param name="weekOfYear">Numéro de semaine</param>
        ///<returns>La date de début de la semaine spécifiée</returns>
        ///<exception cref="ArgumentOutOfRangeException">L'un des paramètres
        /// est en dehors de sa plage de valeurs autorisée. Peut se produire
        /// notamment si l'année <c>year</c> a moins de <c>weekNumber</c>
        /// semaines.</exception>
        public static DateTime GetStartOfWeek(int year, int weekOfYear)
        {
            return GetStartOfWeek(
                year,
                weekOfYear,
                CultureInfo.CurrentCulture.DateTimeFormat.CalendarWeekRule,
                CultureInfo.CurrentCulture.DateTimeFormat.FirstDayOfWeek);
        }

        ///<summary>
        /// Calcule la date du début de la semaine spécifiée, en utilisant la règle
        /// de calcul spécifiée et le premier jour de la semaine de la culture courante.
        ///</summary>
        ///<param name="year">Année</param>
        ///<param name="weekOfYear">Numéro de semaine</param>
        ///<param name="rule">Règle de calcul du numéro de semaine</param>
        ///<returns>La date de début de la semaine spécifiée</returns>
        ///<exception cref="ArgumentOutOfRangeException">L'un des paramètres
        /// est en dehors de sa plage de valeurs autorisée. Peut se produire
        /// notamment si l'année <c>year</c> a moins de <c>weekNumber</c>
        /// semaines.</exception>
        public static DateTime GetStartOfWeek(int year, int weekOfYear, CalendarWeekRule rule)
        {
            return GetStartOfWeek(
                year,
                weekOfYear,
                rule,
                CultureInfo.CurrentCulture.DateTimeFormat.FirstDayOfWeek);
        }

        ///<summary>
        /// Calcule la date du début de la semaine spécifiée, en utilisant la règle
        /// de calcul de la culture courante et le premier jour de la semaine spécifié.
        ///</summary>
        ///<param name="year">Année</param>
        ///<param name="weekOfYear">Numéro de semaine</param>
        ///<param name="firstDayOfWeek">Premier jour de la semaine</param>
        ///<returns>La date de début de la semaine spécifiée</returns>
        ///<exception cref="ArgumentOutOfRangeException">L'un des paramètres
        /// est en dehors de sa plage de valeurs autorisée. Peut se produire
        /// notamment si l'année <c>year</c> a moins de <c>weekNumber</c>
        /// semaines.</exception>
        public static DateTime GetStartOfWeek(int year, int weekOfYear, DayOfWeek firstDayOfWeek)
        {
            return GetStartOfWeek(
                year,
                weekOfYear,
                CultureInfo.CurrentCulture.DateTimeFormat.CalendarWeekRule,
                firstDayOfWeek);
        }

        ///<summary>
        /// Calcule la date du début de la semaine spécifiée, en utilisant la règle
        /// de calcul spécifiée et le premier jour de la semaine spécifié.
        ///</summary>
        ///<param name="year">Année</param>
        ///<param name="weekOfYear">Numéro de semaine</param>
        ///<param name="rule">Règle de calcul du numéro de semaine</param>
        ///<param name="firstDayOfWeek">Premier jour de la semaine</param>
        ///<returns>La date de début de la semaine spécifiée</returns>
        ///<exception cref="ArgumentOutOfRangeException">L'un des paramètres
        /// est en dehors de sa plage de valeurs autorisée. Peut se produire
        /// notamment si l'année <c>year</c> a moins de <c>weekNumber</c>
        /// semaines.</exception>
        public static DateTime GetStartOfWeek(int year, int weekOfYear, CalendarWeekRule rule, DayOfWeek firstDayOfWeek)
        {
            year.CheckArgumentOutOfRange("year", 1, 9999);
            weekOfYear.CheckArgumentOutOfRange("weekOfYear", 1, 54);
            firstDayOfWeek.CheckArgumentInEnum("firstDayOfWeek");
            switch (rule)
            {
                case CalendarWeekRule.FirstDay:
                    return GetStartOfWeekWithFirstDayRule(year, weekOfYear, firstDayOfWeek);
                case CalendarWeekRule.FirstFullWeek:
                    return GetStartOfWeekWithFirstFullWeekRule(year, weekOfYear, firstDayOfWeek);
                case CalendarWeekRule.FirstFourDayWeek:
                    return GetStartOfWeekWithFirstFourDayWeekRule(year, weekOfYear, firstDayOfWeek);
                default:
                    throw new ArgumentOutOfRangeException("rule");
            }
        }

        static DateTime GetStartOfWeekWithFirstDayRule(int year, int weekOfYear, DayOfWeek firstDayOfWeek)
        {
            DateTime jan1 = new DateTime(year, 1, 1);
            DateTime startOfFirstWeek =
                jan1.DayOfWeek == firstDayOfWeek
                    ? jan1
                    : jan1.Previous(firstDayOfWeek);
            DateTime startOfWeek = startOfFirstWeek.AddDays(7 * (weekOfYear - 1));
            if (startOfWeek.Year < year)
                return jan1;
            if (startOfWeek.Year > year)
                throw new ArgumentOutOfRangeException("weekOfYear");
            return startOfWeek;
        }

        static DateTime GetStartOfWeekWithFirstFullWeekRule(int year, int weekOfYear, DayOfWeek firstDayOfWeek)
        {
            DateTime jan1 = new DateTime(year, 1, 1);
            int diff = ((firstDayOfWeek - jan1.DayOfWeek) + 7) % 7;
            DateTime startOfFirstWeek = jan1.AddDays(diff);
            DateTime startOfWeek = startOfFirstWeek.AddDays(7 * (weekOfYear - 1));
            if (startOfWeek.Year > year)
                throw new ArgumentOutOfRangeException("weekOfYear");
            return startOfWeek;
        }

        static DateTime GetStartOfWeekWithFirstFourDayWeekRule(int year, int weekOfYear, DayOfWeek firstDayOfWeek)
        {
            DateTime jan1 = new DateTime(year, 1, 1);
            DayOfWeek fourthDayOfWeek = (DayOfWeek)(((int)firstDayOfWeek + 3) % 7);
            DateTime firstFourDayOfWeek =
                jan1.DayOfWeek == fourthDayOfWeek
                    ? jan1
                    : jan1.Next(fourthDayOfWeek);

            DateTime startOfFirstWeek = firstFourDayOfWeek.Previous(firstDayOfWeek);
            DateTime startOfWeek = startOfFirstWeek.AddDays(7 * (weekOfYear - 1));
            if (startOfWeek.Year < year)
                return jan1;
            if (startOfWeek.Year > year)
                throw new ArgumentOutOfRangeException("weekOfYear");
            return startOfWeek;
        }

        #endregion

        #region WeekOfYear

        /// <summary>
        /// Calcule le numéro de la semaine à laquelle appartient une date, en utilisant la règle de calcul
        /// et le premier jour de la semaine de la culture courante.
        /// </summary>
        /// <param name="date">La date dont on veut le numéro de semaine</param>
        /// <returns>Le numéro de la semaine à laquelle appartient la date</returns>
        public static int WeekOfYear(this DateTime date)
        {
            return WeekOfYear(date, CalendarWeekRule.FirstDay);
        }

        /// <summary>
        /// Calcule le numéro de la semaine à laquelle appartient une date, en utilisant la règle de calcul
        /// spécifiée et le premier jour de la semaine de la culture courante.
        /// </summary>
        /// <param name="date">La date dont on veut le numéro de semaine</param>
        /// <param name="rule">La règle de calcul du numéro de semaine à utiliser</param>
        /// <returns>Le numéro de la semaine à laquelle appartient la date</returns>
        public static int WeekOfYear(this DateTime date, CalendarWeekRule rule)
        {
            return date.WeekOfYear(rule, CultureInfo.CurrentCulture.DateTimeFormat.FirstDayOfWeek);
        }

        /// <summary>
        /// Calcule le numéro de la semaine à laquelle appartient une date, en utilisant la règle de calcul
        /// de la culture courante, et le premier jour de la semaine spécifié.
        /// </summary>
        /// <param name="date">La date dont on veut le numéro de semaine</param>
        /// <param name="firstDayOfWeek">Le premier jour de la semaine</param>
        /// <returns>Le numéro de la semaine à laquelle appartient la date</returns>
        public static int WeekOfYear(this DateTime date, DayOfWeek firstDayOfWeek)
        {
            return date.WeekOfYear(CultureInfo.CurrentCulture.DateTimeFormat.CalendarWeekRule, firstDayOfWeek);
        }

        /// <summary>
        /// Calcule le numéro de la semaine à laquelle appartient une date, en utilisant la règle de calcul
        /// et le premier jour de la semaine spécifiés.
        /// </summary>
        /// <param name="date">La date dont on veut le numéro de semaine</param>
        /// <param name="rule">La règle de calcul du numéro de semaine à utiliser</param>
        /// <param name="firstDayOfWeek">Le premier jour de la semaine</param>
        /// <returns>Le numéro de la semaine à laquelle appartient la date</returns>
        public static int WeekOfYear(this DateTime date, CalendarWeekRule rule, DayOfWeek firstDayOfWeek)
        {
            return CultureInfo.CurrentCulture.Calendar.GetWeekOfYear(date, rule, firstDayOfWeek);
        }

        #endregion

        #region Misc

        /// <summary>
        /// Tronque une date au composant (année, mois, jour, heure, minute, seconde, milliseconde) spécifié
        /// </summary>
        /// <param name="date">Date à tronquer</param>
        /// <param name="component">Composant auquel la date doit être tronquée</param>
        /// <returns>La date tronquée au composant spécifié</returns>
        public static DateTime Truncate(this DateTime date, DateTimeComponent component)
        {
            int year = 1;
            int month = 1;
            int day = 1;
            int hour = 0;
            int minute = 0;
            int second = 0;
            int millisecond = 0;

            if (component <= DateTimeComponent.Millisecond)
                millisecond = date.Millisecond;
            if (component <= DateTimeComponent.Second)
                second = date.Second;
            if (component <= DateTimeComponent.Minute)
                minute = date.Minute;
            if (component <= DateTimeComponent.Hour)
                hour = date.Hour;
            if (component <= DateTimeComponent.Day)
                day = date.Day;
            if (component <= DateTimeComponent.Month)
                month = date.Month;
            if (component <= DateTimeComponent.Year)
                year = date.Year;

            return new DateTime(year, month, day, hour, minute, second, millisecond, date.Kind);
        }

        #endregion
    }

    /// <summary>
    /// Représente les différents composants d'une date
    /// </summary>
    public enum DateTimeComponent
    {
        /// <summary>
        /// Milliseconde
        /// </summary>
        Millisecond,
        /// <summary>
        /// Seconde
        /// </summary>
        Second,
        /// <summary>
        /// Minute
        /// </summary>
        Minute,
        /// <summary>
        /// Heure
        /// </summary>
        Hour,
        /// <summary>
        /// Jour
        /// </summary>
        Day,
        /// <summary>
        /// Mois
        /// </summary>
        Month,
        /// <summary>
        /// Année
        /// </summary>
        Year
    }
}