/*
 *  Copyright 2017 Anyware Services
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
package org.ametys.core.util;

import java.time.Duration;
import java.time.Instant;
import java.time.LocalDate;
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.time.ZonedDateTime;
import java.time.chrono.IsoChronology;
import java.time.format.DateTimeFormatter;
import java.time.format.ResolverStyle;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Optional;

import org.apache.commons.lang3.StringUtils;

/**
 * Helper for converting dates from the old ({@link Date}) to the new ({@link java.time}) JDK
 * Special thanks to http://stackoverflow.com/questions/21242110/convert-java-util-date-to-java-time-localdate#answer-27378709
 * which inspired this code
 * 
 * See also http://stackoverflow.com/questions/19431234/converting-between-java-time-localdatetime-and-java-util-date
 */
public final class DateUtils
{
    /** The ISO date-time pattern that formats or parses a date-time with an offset */
    public static final String ISO_OFFSET_DATE_TIME_PATTERN = "uuuu-MM-dd'T'HH:mm:ss.SSSXXX";
    
    /**
     * The ISO date-time formatter that formats or parses a date-time with an offset, such as '2011-12-03T10:15:30.000+01:00'. 
     */
    private static final DateTimeFormatter __ISO_OFFSET_DATE_TIME = _createFormatter(ISO_OFFSET_DATE_TIME_PATTERN);
    
    private DateUtils()
    {
        // empty
    }
    
    private static DateTimeFormatter _createFormatter(String pattern) throws IllegalArgumentException
    {
        return DateTimeFormatter.ofPattern(pattern)
                .withResolverStyle(ResolverStyle.STRICT)
                .withChronology(IsoChronology.INSTANCE);
    }
    
    /**
     * Converts this {@link Date} object to an {@link Instant}.
     * @param date The date object
     * @return an instant representing the same point on the time-line as this {@link Date} object
     */
    public static Instant asInstant(Date date)
    {
        return Optional.ofNullable(date).map(Date::toInstant).orElse(null);
    }
    
    /**
     * Converts this {@link Date} object to a {@link ZonedDateTime}, at UTC.
     * @param date The date object
     * @return the {@link ZonedDateTime} formed from this {@link Date}
     */
    public static ZonedDateTime asZonedDateTime(Date date)
    {
        return asZonedDateTime(date, null);
    }
    
    /**
     * Converts this {@link Date} object to a {@link ZonedDateTime}.
     * @param date The date object
     * @param zone The zone. If <code>null</code>, UTC is used
     * @return the {@link ZonedDateTime} formed from this {@link Date}
     */
    public static ZonedDateTime asZonedDateTime(Date date, ZoneId zone)
    {
        return asZonedDateTime(asInstant(date), zone);
    }
    
    /**
     * Converts this {@link Calendar} object to a {@link ZonedDateTime}.
     * @param calendar the calendar
     * @return the {@link ZonedDateTime} formed from this {@link Calendar}
     */
    public static ZonedDateTime asZonedDateTime(Calendar calendar)
    {
        return asZonedDateTime(calendar.toInstant(), ZoneOffset.UTC);
    }
    
    /**
     * Converts this epoch time to a {@link ZonedDateTime}.
     * @param epochMilli the number of milliseconds from 1970-01-01T00:00:00Z
     * @return the {@link ZonedDateTime} formed from this epoch time
     */
    public static ZonedDateTime asZonedDateTime(long epochMilli)
    {
        return asZonedDateTime(epochMilli, null);
    }
    
    /**
     * Converts this epoch time to a {@link ZonedDateTime}.
     * @param epochMilli the number of milliseconds from 1970-01-01T00:00:00Z
     * @param zone the time-zone
     * @return the {@link ZonedDateTime} formed from this epoch time
     */
    public static ZonedDateTime asZonedDateTime(long epochMilli, ZoneId zone)
    {
        Instant instant = Instant.ofEpochMilli(epochMilli);
        return asZonedDateTime(instant, zone);
    }
    
    /**
     * Converts a {@link LocalDate} to a {@link ZonedDateTime}
     * @param localDate the local date
     * @param zone The time zone. If <code>null</code>, UTC is used
     * @return the {@link ZonedDateTime} formed from this local date
     */
    public static ZonedDateTime asZonedDateTime(LocalDate localDate, ZoneId zone)
    {
        Date date = asDate(localDate, zone);
        return asZonedDateTime(date);
    }
    
    /**
     * Converts an {@link Instant} to a {@link ZonedDateTime}
     * @param instant the instant
     * @return the {@link ZonedDateTime} formed from this local date
     */
    public static ZonedDateTime asZonedDateTime(Instant instant)
    {
        return asZonedDateTime(instant, null);
    }
    
    /**
     * Converts an {@link Instant} to a {@link ZonedDateTime}
     * @param instant the instant
     * @param zone The time zone. If <code>null</code>, UTC is used
     * @return the {@link ZonedDateTime} formed from this local date
     */
    public static ZonedDateTime asZonedDateTime(Instant instant, ZoneId zone)
    {
        return Optional.ofNullable(instant)
            .map(i -> i.atZone(Optional.ofNullable(zone).orElse(ZoneOffset.UTC)))
            .orElse(null);
    }
    
    /**
     * Converts this {@link Date} object to a {@link LocalDate}.
     * 
     * This returns a {@link LocalDate} with the same year, month and day as this {@link Date}.
     * @param date The date object
     * @param zone The zone
     * @return the {@link LocalDate} part of this {@link Date}
     */
    public static LocalDate asLocalDate(Date date, ZoneId zone)
    {
        return asZonedDateTime(date, zone).toLocalDate();
    }
    
    /**
     * Converts this {@link Date} object to a {@link LocalDate}.
     * 
     * This returns a {@link LocalDate} with the same year, month and day as this {@link Date}.
     * @param date The date object
     * @return the {@link LocalDate} part of this {@link Date}
     */
    public static LocalDate asLocalDate(Date date)
    {
        return asLocalDate(date, null);
    }
    
    /**
     * Converts this {@link Calendar} object to a {@link LocalDate}. <br>
     * <b>Warning</b>: this conversion looses the Calendar's time components.
     * @param calendar the calendar
     * @return the {@link LocalDate} object
     */
    public static LocalDate asLocalDate(Calendar calendar)
    {
        return LocalDate.of(calendar.get(Calendar.YEAR), calendar.get(Calendar.MONTH) + 1, calendar.get(Calendar.DAY_OF_MONTH));
    }
    
    /**
     * Converts an {@link Instant} to a {@link LocalDate}
     * @param instant the instant
     * @return the {@link LocalDate} formed from this local date
     */
    public static LocalDate asLocalDate(Instant instant)
    {
        return asLocalDate(instant, null);
    }
    
    /**
     * Converts an {@link Instant} to a {@link LocalDate}
     * @param instant the instant
     * @param zone The time zone. If <code>null</code>, UTC is used
     * @return the {@link LocalDate} formed from this local date
     */
    public static LocalDate asLocalDate(Instant instant, ZoneId zone)
    {
        return LocalDate.ofInstant(instant, Optional.ofNullable(zone).orElse(ZoneOffset.UTC));
    }
    
    /**
     * Converts this {@link LocalDate} object to a {@link Date}.
     * 
     * @param localDate The local date object
     * @return the {@link Date} part of this {@link LocalDate}
     */
    public static Date asDate(LocalDate localDate)
    {
        return asDate(localDate, ZoneOffset.UTC);
    }
    
    /**
     * Converts this {@link LocalDate} object to a {@link Date}.
     * 
     * @param localDate The local date object
     * @param zone The zone. If <code>null</code>, UTC is used
     * @return the {@link Date} part of this {@link LocalDate}
     */
    public static Date asDate(LocalDate localDate, ZoneId zone)
    {
        return Optional.ofNullable(localDate)
                .map(ld -> ld.atStartOfDay(Optional.ofNullable(zone).orElse(ZoneOffset.UTC)))
                .map(ZonedDateTime::toInstant)
                .map(Date::from)
                .orElse(null);
    }

    /**
     * Converts this {@link ZonedDateTime} object to a {@link Date}.
     * 
     * @param zonedDateTime The local date time object
     * @return the {@link Date} part of this {@link ZonedDateTime}
     */
    public static Date asDate(ZonedDateTime zonedDateTime)
    {
        return Date.from(zonedDateTime.toInstant());
    }
    
    /**
     * Converts this {@link ZonedDateTime} object to a {@link Calendar}, setting the time zone to UTC.
     * @param zonedDateTime the zoned date time.
     * @return the converted {@link Calendar} object.
     */
    public static Calendar asCalendar(ZonedDateTime zonedDateTime)
    {
        ZonedDateTime dateTimeOnDefaultZone = zonedDateTime.withZoneSameInstant(ZoneOffset.UTC);
        return GregorianCalendar.from(dateTimeOnDefaultZone);
    }
    
    /**
     * Converts this {@link LocalDate} object to a {@link Calendar}.
     * @param localDate the local date
     * @return the {@link Calendar} object
     */
    public static Calendar asCalendar(LocalDate localDate)
    {
        ZonedDateTime zdt = localDate.atStartOfDay(ZoneOffset.UTC);
        return GregorianCalendar.from(zdt);
    }
    
    /**
     * Format a duration for logs
     * @param duration duration to log
     * @return a string representing the duration
     */
    public static String formatDuration(Duration duration)
    {
        return formatDuration(duration.toMillis());
    }
    
    /**
     * Format a duration for logs
     * @param duration miliseconds representing the duration
     * @return a string representing the duration
     */
    public static String formatDuration(long duration)
    {
        StringBuilder sb = new StringBuilder();
        long durationCopy = duration;
        long ms = durationCopy % 1000;
        durationCopy /= 1000;
        long s = durationCopy % 60;
        durationCopy /= 60;
        long m = durationCopy % 60;
        durationCopy /= 60;
        long h = durationCopy % 24;
        durationCopy /= 24;
        
        boolean showDays = durationCopy > 0;
        boolean showHours = showDays || h > 0;
        boolean showMinuts = showHours || m > 0;
        boolean showSeconds = showMinuts || s > 0;

        if (showDays)
        {
            sb.append(durationCopy);
            sb.append("j ");
        }
        if (showHours)
        {
            sb.append(formatNumber(h, 2));
            sb.append("h ");
        }
        if (showMinuts)
        {
            sb.append(formatNumber(m, 2));
            sb.append("m ");
        }
        if (showSeconds)
        {
            sb.append(formatNumber(s, 2));
            sb.append("s ");
        }
        sb.append(formatNumber(ms, 3));
        sb.append("ms");
        return sb.toString();
    }
    private static String formatNumber(long number, int nbNumbers)
    {
        String numberFormatted = String.valueOf(number);
        while (numberFormatted.length() < nbNumbers)
        {
            numberFormatted = "0" + numberFormatted;
        }
        return numberFormatted;
    }
    
    /**
     * Get the ISO date-time formatter that formats or parses a date-time with an offset, such as '2011-12-03T10:15:30.000+01:00'. 
     * This formatter is similar to {@link DateTimeFormatter#ISO_OFFSET_DATE_TIME} but force 3-digits milliseconds.
     * @return ISO date-time formatter
     */
    public static DateTimeFormatter getISODateTimeFormatter()
    {
        return __ISO_OFFSET_DATE_TIME;
    }
    
    /**
     * Converts a {@link Date} object to {@link String} using the ISO date formatter, at UTC time zone.
     * @param value the value to convert
     * @return the date as a {@link String}
     */
    public static String dateToString(Date value)
    {
        if (value == null)
        {
            return null;
        }
        
        ZonedDateTime zdt = DateUtils.asZonedDateTime(value, null);
        return zonedDateTimeToString(zdt);
    }
    
    /**
     * Converts this epoch time to a {@link String} using the ISO date formatter
     * @param epochMilli the number of milliseconds from 1970-01-01T00:00:00Z
     * @return the epoch time to a {@link String}
     */
    public static String epochMilliToString(long epochMilli)
    {
        ZonedDateTime zdt = DateUtils.asZonedDateTime(epochMilli, ZoneOffset.UTC);
        return zonedDateTimeToString(zdt);
    }
    
    /**
     * Converts a {@link ZonedDateTime} object to {@link String} in the given zone, so as to format the instant in another zone,
     * using the ISO date time formatter with pattern 'uuuu-MM-dd'T'HH:mm:ss.SSSXXX'. For instance: 
     * <ul>
     * <li>for UTC zone, the zone date time corresponding to '2011-12-03T11:15:30+01:00' will be formatted as '2011-12-03T10:15:30Z'</li>
     * <li>for +02:00 zone, the zone date time corresponding to '2011-12-03T11:15:30+01:00' will be formatted as '2011-12-03T12:15:30+02:00'</li>
     * </ul>
     * @param zonedDateTime the zoned date time
     * @param zoneId the target zone
     * @return the zoned date time as a {@link String}, in the given zone
     */
    public static String zonedDateTimeToString(ZonedDateTime zonedDateTime, ZoneId zoneId)
    {
        ZonedDateTime sameInstantAtZone = zonedDateTime.withZoneSameInstant(zoneId);
        return zonedDateTimeToString(sameInstantAtZone);
    }
    
    /**
     * Converts a {@link ZonedDateTime} object to {@link String} using the {@link #__ISO_OFFSET_DATE_TIME ISO date formatter}
     * @param zonedDateTime the zoned date time
     * @return the zoned date time as a {@link String}
     */
    public static String zonedDateTimeToString(ZonedDateTime zonedDateTime)
    {
        return zonedDateTime.format(getISODateTimeFormatter());
    }
    
    /**
     * Converts a {@link ZonedDateTime} object to {@link String} using the given pattern for formatting, 
     * in the given zone, so as to format the instant in another zone
     * <br>For instance, if provided pattern is 'uuuu-MM-dd'T'HH:mm:ss.SSSXXX': 
     * <ul>
     * <li>for UTC zone, the zone date time corresponding to '2011-12-03T11:15:30+01:00' will be formatted as '2011-12-03T10:15:30Z'</li>
     * <li>for +02:00 zone, the zone date time corresponding to '2011-12-03T11:15:30+01:00' will be formatted as '2011-12-03T12:15:30+02:00'</li>
     * </ul>
     * @param zonedDateTime the zoned date time
     * @param zoneId the target zone
     * @param pattern the pattern for formatting
     * @return the zoned date time as a {@link String}, in the given zone
     * @throws IllegalArgumentException  if the pattern is invalid
     */
    public static String zonedDateTimeToString(ZonedDateTime zonedDateTime, ZoneId zoneId, String pattern) throws IllegalArgumentException
    {
        ZonedDateTime sameInstantAtZone = zonedDateTime.withZoneSameInstant(zoneId);
        DateTimeFormatter formatter = _createFormatter(pattern);
        return sameInstantAtZone.format(formatter);
    }
    
    /**
     * Converts a {@link LocalDate} object to {@link String} using the ISO date formatter
     * @param localDate the local date
     * @return the local date as a {@link String}
     */
    public static String localDateToString(LocalDate localDate)
    {
        return localDate.format(DateTimeFormatter.ISO_LOCAL_DATE);
    }
    
    /**
     * Converts a {@link LocalDate} object to {@link String} using the given pattern for formatting
     * @param localDate the local date
     * @param pattern the pattern for formatting
     * @return the local date as a {@link String}
     * @throws IllegalArgumentException  if the pattern is invalid
     */
    public static String localDateToString(LocalDate localDate, String pattern) throws IllegalArgumentException
    {
        DateTimeFormatter formatter = _createFormatter(pattern);
        return localDate.format(formatter);
    }
    
    /**
     * Parses a String into a {@link Date}, using ISO 8601 format.
     * @param value an ISO 8601 formatted String.
     * @return the corresponding Date, or null if the input is null.
     */
    public static Date parse(String value)
    {
        if (StringUtils.isEmpty(value))
        {
            return null;
        }
        
        ZonedDateTime zdt = ZonedDateTime.parse(value, DateTimeFormatter.ISO_DATE_TIME);
        return asDate(zdt);
    }
    
    /**
     * Parses a String into a {@link ZonedDateTime}, using ISO date time formatter.
     * @param zonedDateTimeAsString the zoned date time as string
     * @return the {@link ZonedDateTime} object or null if the input is null.
     */
    public static ZonedDateTime parseZonedDateTime(String zonedDateTimeAsString)
    {
        return parseZonedDateTime(zonedDateTimeAsString, Optional.empty());
    }
    
    /**
     * Parses a String into a {@link ZonedDateTime}, using ISO date time formatter.
     * @param zonedDateTimeAsString the zoned date time as string
     * @param pattern the pattern to use to parse the given date
     * @return the {@link ZonedDateTime} object or null if the input is null.
     * @throws IllegalArgumentException  if the pattern is invalid
     */
    public static ZonedDateTime parseZonedDateTime(String zonedDateTimeAsString, String pattern) throws IllegalArgumentException
    {
        DateTimeFormatter formatter = _createFormatter(pattern);
        return parseZonedDateTime(zonedDateTimeAsString, Optional.of(formatter));
    }
    
    /**
     * Parses a String into a {@link ZonedDateTime}, using the given formatter.
     * If no formatter, the ISO date time formatter is used
     * @param zonedDateTimeAsString the zoned date time as string
     * @param formatter the date time formatter
     * @return the {@link ZonedDateTime} object or null if the input is null.
     */
    public static ZonedDateTime parseZonedDateTime(String zonedDateTimeAsString, Optional<DateTimeFormatter> formatter)
    {
        if (StringUtils.isEmpty(zonedDateTimeAsString))
        {
            return null;
        }
        
        return ZonedDateTime.parse(zonedDateTimeAsString, formatter.orElse(DateTimeFormatter.ISO_DATE_TIME));
    }
    
    /**
     * Parses a String into a {@link LocalDate}, using ISO local date formatter.
     * @param localDateAsString the local date as string
     * @return the {@link LocalDate} object or null if the input is null.
     */
    public static LocalDate parseLocalDate(String localDateAsString)
    {
        return parseLocalDate(localDateAsString, Optional.empty());
    }
    
    /**
     * Parses a String into a {@link LocalDate}, using ISO local date formatter.
     * @param localDateAsString the local date as string
     * @param pattern the pattern to use to parse the given date
     * @return the {@link LocalDate} object or null if the input is null.
     * @throws IllegalArgumentException  if the pattern is invalid
     */
    public static LocalDate parseLocalDate(String localDateAsString, String pattern) throws IllegalArgumentException
    {
        DateTimeFormatter formatter = _createFormatter(pattern);
        return parseLocalDate(localDateAsString, Optional.of(formatter));
    }
    
    /**
     * Parses a String into a {@link LocalDate}, using the given formatter.
     * If no formatter, the ISO local date formatter is used
     * @param localDateAsString the local date as string
     * @param formatter the date time formatter
     * @return the {@link LocalDate} object or null if the input is null.
     */
    public static LocalDate parseLocalDate(String localDateAsString, Optional<DateTimeFormatter> formatter)
    {
        if (StringUtils.isEmpty(localDateAsString))
        {
            return null;
        }
        
        return LocalDate.parse(localDateAsString, formatter.orElse(DateTimeFormatter.ISO_LOCAL_DATE));
    }
    
    /**
     * Determines if a date is at midnight (00:00) for the given time-zone
     * @param zonedDateTimeAsString the zoned date time as string
     * @param zoneId the time-zone id. If empty the system default time-zone will be used.
     * @return true if the date is at midnight
     */
    public static boolean isAtMidnight(String zonedDateTimeAsString, String zoneId)
    {
        ZonedDateTime zonedDateTime = parseZonedDateTime(zonedDateTimeAsString);
        zonedDateTime = zonedDateTime.withZoneSameInstant(StringUtils.isEmpty(zoneId) ? ZoneId.systemDefault() : ZoneId.of(zoneId));
        return zonedDateTime.getHour() == 0 && zonedDateTime.getMinute() == 0;
    }
}