using System;

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 DateTime.Now.AddMinutes(5), on fera:
    /// 5.Minutes().FromNow()
    /// </summary>)
    public static class DateExtensions
    {

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

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

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

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

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

        /// <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 DateTime.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 DateTime.Now.Previous(dayOfWeek);
        }

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