Dépôt officiel du code source de l'ERP OpenConcerto

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2011-2019 OpenConcerto, by ILM Informatique. All rights reserved.

 *

 * The contents of this file are subject to the terms of the GNU General Public License Version 3

 * only ("GPL"). You may not use this file except in compliance with the License. You can obtain a

 * copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific

 * language governing permissions and limitations under the License.

 *

 * When distributing the software, include this License Header Notice in each file.

 */

 package org.openconcerto.utils;

import java.math.BigDecimal;

import java.math.BigInteger;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.ZoneId;

import java.util.Arrays;

import java.util.Calendar;

import java.util.Collection;

import java.util.Collections;

import java.util.Date;

import java.util.GregorianCalendar;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.TimeZone;

import java.util.concurrent.TimeUnit;

import javax.xml.datatype.DatatypeConfigurationException;

import javax.xml.datatype.DatatypeConstants;

import javax.xml.datatype.DatatypeConstants.Field;

import javax.xml.datatype.DatatypeFactory;

import javax.xml.datatype.Duration;

import net.jcip.annotations.GuardedBy;

import net.jcip.annotations.Immutable;

public class TimeUtils {

    static public final int SECONDS_PER_MINUTE = 60;

    static public final int MINUTE_PER_HOUR = 60;

    static public final int SECONDS_PER_HOUR = SECONDS_PER_MINUTE * MINUTE_PER_HOUR;

    @GuardedBy("TimeUtils.class")

    static private DatatypeFactory typeFactory = null;

    static private final List<Field> FIELDS_LIST = Arrays.asList(DatatypeConstants.YEARS, DatatypeConstants.MONTHS, DatatypeConstants.DAYS, DatatypeConstants.HOURS, DatatypeConstants.MINUTES,

            DatatypeConstants.SECONDS);

    static private final List<Field> DATE_FIELDS, TIME_FIELDS;

    static {

        final int dayIndex = FIELDS_LIST.indexOf(DatatypeConstants.DAYS);

        DATE_FIELDS = Collections.unmodifiableList(FIELDS_LIST.subList(0, dayIndex + 1));

        TIME_FIELDS = Collections.unmodifiableList(FIELDS_LIST.subList(dayIndex + 1, FIELDS_LIST.size()));

    }

    public static List<Field> getAllFields() {

        return FIELDS_LIST;

    }

    /**

     * Get the fields for the date part.

     *

     * @return fields until {@link DatatypeConstants#DAYS} included.

     */

    public static List<Field> getDateFields() {

        return DATE_FIELDS;

    }

    /**

     * Get the fields for the time part.

     *

     * @return fields from {@link DatatypeConstants#HOURS}.

     */

    public static List<Field> getTimeFields() {

        return TIME_FIELDS;

    }

    private static Class<? extends Number> getFieldClass(final Field f) {

        return f == DatatypeConstants.SECONDS ? BigDecimal.class : BigInteger.class;

    }

    static public synchronized final DatatypeFactory getTypeFactory() {

        if (typeFactory == null)

            try {

                typeFactory = DatatypeFactory.newInstance();

            } catch (DatatypeConfigurationException e) {

                throw new IllegalStateException(e);

            }

        return typeFactory;

    }

    static private final <N extends Number> N getZeroIfNull(final Number n, final Class<N> clazz) {

        final Number res;

        if (n != null)

            res = n;

        else if (clazz == BigInteger.class)

            res = BigInteger.ZERO;

        else if (clazz == BigDecimal.class)

            res = BigDecimal.ZERO;

        else

            throw new IllegalArgumentException("Unknown class : " + n);

        return clazz.cast(res);

    }

    static private final <N extends Number> N getNullIfZero(final N n) {

        if (n == null)

            return null;

        final boolean isZero;

        if (n instanceof BigInteger)

            isZero = n.intValue() == 0;

        else

            isZero = ((BigDecimal) n).compareTo(BigDecimal.ZERO) == 0;

        return isZero ? null : n;

    }

    /**

     * Get non-null seconds with the the correct class.

     *

     * @param d a duration.

     * @return the seconds, never <code>null</code>.

     * @see Duration#getField(javax.xml.datatype.DatatypeConstants.Field)

     * @see Duration#getMinutes()

     */

    static public final BigDecimal getSeconds(final Duration d) {

        return getZeroIfNull(d.getField(DatatypeConstants.SECONDS), BigDecimal.class);

    }

    /**

     * Convert the time part of a calendar to a duration.

     *

     * @param cal a calendar, e.g. 23/12/2011 11:55:33.066 GMT+02.

     * @return a duration, e.g. P0Y0M0DT11H55M33.066S.

     */

    public final static Duration timePartToDuration(final Calendar cal) {

        final BigDecimal seconds = BigDecimal.valueOf(cal.get(Calendar.SECOND)).add(BigDecimal.valueOf(cal.get(Calendar.MILLISECOND)).movePointLeft(3));

        return getTypeFactory().newDuration(true, BigInteger.ZERO, BigInteger.ZERO, BigInteger.ZERO, BigInteger.valueOf(cal.get(Calendar.HOUR_OF_DAY)), BigInteger.valueOf(cal.get(Calendar.MINUTE)),

                seconds);

    }

    // removes explicit 0

    public final static Duration trimDuration(final Duration dur) {

        return DurationNullsChanger.ALL_TO_NULL.apply(dur);

    }

    // replace null by 0

    public final static Duration removeNulls(final Duration dur) {

        return DurationNullsChanger.NONE_TO_NULL.apply(dur);

    }

    public static enum EmptyFieldPolicy {

        AS_IS, SET_TO_NULL, SET_TO_ZERO

    }

    public final static class DurationNullsBuilder {

        private final Map<Field, EmptyFieldPolicy> policy;

        public DurationNullsBuilder() {

            this(EmptyFieldPolicy.AS_IS);

        }

        public DurationNullsBuilder(final EmptyFieldPolicy initialPolicy) {

            this.policy = new HashMap<Field, EmptyFieldPolicy>();

            this.setPolicy(FIELDS_LIST, initialPolicy);

        }

        public final void setPolicy(Collection<Field> fields, final EmptyFieldPolicy to) {

            for (final Field f : fields)

                this.policy.put(f, to);

        }

        public final DurationNullsBuilder setToNull(Collection<Field> fields) {

            setPolicy(fields, EmptyFieldPolicy.SET_TO_NULL);

            return this;

        }

        public final DurationNullsBuilder setToZero(Collection<Field> fields) {

            setPolicy(fields, EmptyFieldPolicy.SET_TO_ZERO);

            return this;

        }

        public final DurationNullsBuilder dontChange(Collection<Field> fields) {

            setPolicy(fields, EmptyFieldPolicy.AS_IS);

            return this;

        }

        public final DurationNullsChanger build() {

            return new DurationNullsChanger(this.policy);

        }

    }

    /**

     * Allow to change empty fields between two equivalent state. In a {@link Duration} an empty

     * field can be set to <code>null</code> and it won't be output or it can be set to 0 and it

     * will be explicitly output.

     *

     * @author Sylvain

     * @see DurationNullsBuilder

     */

    @Immutable

    public final static class DurationNullsChanger {

        public final static DurationNullsChanger ALL_TO_NULL = new DurationNullsBuilder(EmptyFieldPolicy.SET_TO_NULL).build();

        public final static DurationNullsChanger NONE_TO_NULL = new DurationNullsBuilder(EmptyFieldPolicy.SET_TO_ZERO).build();

        private final Map<Field, EmptyFieldPolicy> policy;

        private DurationNullsChanger(final Map<Field, EmptyFieldPolicy> policy) {

            this.policy = Collections.unmodifiableMap(new HashMap<Field, EmptyFieldPolicy>(policy));

        }

        // doesn't change the duration value, just nulls and 0s

        public final Duration apply(final Duration dur) {

            boolean changed = false;

            final Map<Field, Number> newValues = new HashMap<Field, Number>();

            for (final Field f : FIELDS_LIST) {

                final Number oldVal = dur.getField(f);

                final EmptyFieldPolicy pol = this.policy.get(f);

                final Number newVal;

                if (pol == EmptyFieldPolicy.SET_TO_NULL) {

                    newVal = getNullIfZero(oldVal);

                } else if (pol == EmptyFieldPolicy.SET_TO_ZERO) {

                    newVal = getZeroIfNull(oldVal, getFieldClass(f));

                } else {

                    assert pol == EmptyFieldPolicy.AS_IS;

                    newVal = oldVal;

                }

                newValues.put(f, newVal);

                changed |= !CompareUtils.equals(newVal, oldVal);

            }

            if (!changed) {

                // Duration is immutable

                return dur;

            } else {

                return getTypeFactory().newDuration(dur.getSign() >= 0, (BigInteger) newValues.get(DatatypeConstants.YEARS), (BigInteger) newValues.get(DatatypeConstants.MONTHS),

                        (BigInteger) newValues.get(DatatypeConstants.DAYS), (BigInteger) newValues.get(DatatypeConstants.HOURS), (BigInteger) newValues.get(DatatypeConstants.MINUTES),

                        (BigDecimal) newValues.get(DatatypeConstants.SECONDS));

            }

        }

    }

    /**

     * Normalize <code>cal</code> so that any Calendar with the same local time have the same

     * result. If you don't need a Calendar this is faster than

     * {@link #copyLocalTime(Calendar, Calendar)}.

     *

     * @param cal a calendar, e.g. 0:00 CEST.

     * @return the time in millisecond of the UTC calendar with the same local time, e.g. 0:00 UTC.

     */

    public final static long normalizeLocalTime(final Calendar cal) {

        return cal.getTimeInMillis() + cal.getTimeZone().getOffset(cal.getTimeInMillis());

    }

    /**

     * Copy the local time from one calendar to another. Except if both calendars have the same time

     * zone, from.getTimeInMillis() will be different from to.getTimeInMillis().

     * <p>

     * NOTE : In case the two calendars are not from the same class but one of them is a

     * {@link GregorianCalendar} then this method will use a GregorianCalendar with the time zone

     * and absolute time of the other.

     * </p>

     * <p>

     * Also note that the local time of <code>from</code> can be {@link #isAmbiguous(Calendar)

     * ambiguous} in <code>to</code> or skipped. In the former case, the absolute time is

     * unspecified (e.g. 2h30 in WET can either be 2h30 CEST or CET in fall). In the latter case, a

     * round trip back to <code>from</code> will yield a different local time (e.g. in spring 2h30

     * in WET to 3h30 in CEST, back to 3h30 in WEST).

     * </p>

     *

     * @param from the source calendar, e.g. 23/12/2011 11:55:33.066 GMT-12.

     * @param to the destination calendar, e.g. 01/01/2000 0:00 GMT+13.

     * @return the modified destination calendar, e.g. 23/12/2011 11:55:33.066 GMT+13.

     * @throws IllegalArgumentException if both calendars aren't from the same class and none of

     *         them are Gregorian.

     */

    public final static Calendar copyLocalTime(final Calendar from, final Calendar to) throws IllegalArgumentException {

        final boolean sameClass = from.getClass() == to.getClass();

        final boolean createGregSource = !sameClass && to.getClass() == GregorianCalendar.class;

        final boolean createGregDest = !sameClass && from.getClass() == GregorianCalendar.class;

        if (!sameClass && !createGregSource && !createGregDest)

            throw new IllegalArgumentException("Calendars mismatch " + from.getClass() + " != " + to.getClass());

        final Calendar source = createGregSource ? new GregorianCalendar(from.getTimeZone()) : from;

        if (createGregSource) {

            source.setTime(from.getTime());

        }

        final Calendar dest = createGregDest ? new GregorianCalendar(to.getTimeZone()) : to;

        assert source.getClass() == dest.getClass();

        if (source.getTimeZone().equals(dest.getTimeZone())) {

            dest.setTimeInMillis(source.getTimeInMillis());

        } else {

            dest.clear();

            for (final int field : new int[] { Calendar.ERA, Calendar.YEAR, Calendar.DAY_OF_YEAR, Calendar.HOUR_OF_DAY, Calendar.MINUTE, Calendar.SECOND, Calendar.MILLISECOND }) {

                dest.set(field, source.get(field));

            }

        }

        if (createGregDest) {

            to.setTime(dest.getTime());

        }

        return to;

    }

    /**

     * Whether the wall time of the passed calendar is ambiguous (i.e. happens twice the same day).

     * E.g. in France, Sun Oct 27 02:30 CEST 2013 then one hour later Sun Oct 27 02:30 CET 2013.

     *

     * @param cal a calendar.

     * @return <code>true</code> if the wall time (without time zone) is ambiguous.

     */

    public final static boolean isAmbiguous(final Calendar cal) {

        return isAmbiguous(getDSTChange(cal));

    }

    public final static boolean isAmbiguous(final DSTChange dstChange) {

        return dstChange == DSTChange.BEFORE_WINTER || dstChange == DSTChange.AFTER_WINTER;

    }

    /**

     * Relation to a DST change. Useful to test corner cases.

     *

     * @author Sylvain

     */

    static public enum DSTChange {

        /**

         * No change nearby.

         */

        NO,

        /**

         * DST will come, i.e. the next hour will be skipped.

         */

        BEFORE_SUMMER,

        /**

         * DST just came, i.e. the previous hour was skipped.

         */

        AFTER_SUMMER,

        /**

         * DST will go, the current hour will be happen again this day.

         */

        BEFORE_WINTER,

        /**

         * DST just went, the current wall time has already happened this day.

         */

        AFTER_WINTER

    }

    public final static DSTChange getDSTChange(final Calendar cal) {

        final TimeZone tz = cal.getTimeZone();

        if (!tz.useDaylightTime())

            return DSTChange.NO;

        final long currentMillis = cal.getTimeInMillis();

        final int hourInMillis = tz.getDSTSavings();

        final boolean isSTBefore = tz.inDaylightTime(new Date(currentMillis - hourInMillis));

        final boolean isST = tz.inDaylightTime(new Date(currentMillis));

        final boolean isSTAfter = tz.inDaylightTime(new Date(currentMillis + hourInMillis));

        if (isSTBefore != isST) {

            // only one change

            assert isST == isSTAfter;

            return isSTBefore ? DSTChange.AFTER_WINTER : DSTChange.AFTER_SUMMER;

        } else if (isST != isSTAfter) {

            // only one change

            assert isST == isSTBefore;

            return isSTAfter ? DSTChange.BEFORE_SUMMER : DSTChange.BEFORE_WINTER;

        } else {

            return DSTChange.NO;

        }

    }

    static public final Calendar clearTime(final Calendar cal) {

        // reset doesn't work, see javadoc

        cal.set(Calendar.HOUR_OF_DAY, 0);

        cal.clear(Calendar.MINUTE);

        cal.clear(Calendar.SECOND);

        cal.clear(Calendar.MILLISECOND);

        return cal;

    }

    /**

     * Whether 2 dates are in the same day.

     *

     * @param date1 the first date, it won't be modified (it will be {@link Calendar#clone()

     *        cloned}).

     * @param date2 the second date.

     * @return <code>true</code> if both dates are in the same day according to the passed calendar.

     */

    static public final boolean isSameDay(final Calendar date1, final Date date2) {

        return isSameDay((Calendar) date1.clone(), date1.getTime(), date2);

    }

    /**

     * Whether 2 dates are in the same day.

     *

     * @param cal the calendar to use, it will be modified.

     * @param date1 the first date.

     * @param date2 the second date.

     * @return <code>true</code> if both dates are in the same day according to the passed calendar.

     */

    static public final boolean isSameDay(final Calendar cal, final Date date1, final Date date2) {

        cal.setTime(date1);

        TimeUtils.clearTime(cal);

        final long day1 = cal.getTimeInMillis();

        cal.setTime(date2);

        TimeUtils.clearTime(cal);

        final long day2 = cal.getTimeInMillis();

        return day1 == day2;

    }

    static public final boolean isEqual(final long amount1, final TimeUnit unit1, final long amount2, final TimeUnit unit2) {

        final long finerAmount, coarserAmount;

        final TimeUnit finer, coarser;

        // don't truncate

        if (unit1.compareTo(unit2) < 0) {

            finerAmount = amount1;

            finer = unit1;

            coarserAmount = amount2;

            coarser = unit2;

        } else {

            finerAmount = amount2;

            finer = unit2;

            coarserAmount = amount1;

            coarser = unit1;

        }

        return finerAmount == finer.convert(coarserAmount, coarser);

    }

    public static LocalDateTime toLocalDateTime(Calendar calendar) {

        if (calendar == null)

            return null;

        return LocalDateTime.ofInstant(calendar.toInstant(), getTZ(calendar));

    }

    private static ZoneId getTZ(Calendar calendar) {

        final TimeZone tz = calendar.getTimeZone();

        return tz == null ? ZoneId.systemDefault() : tz.toZoneId();

    }

    public static final Calendar toCalendar(final LocalDateTime dt) {

        final Calendar cal = Calendar.getInstance();

        cal.setTimeInMillis(dt.atZone(getTZ(cal)).toInstant().toEpochMilli());

        return cal;

    }

    public static LocalDate toLocalDate(Calendar calendar) {

        if (calendar == null)

            return null;

        if (calendar instanceof GregorianCalendar)

            return LocalDate.of(calendar.get(Calendar.YEAR), calendar.get(Calendar.MONTH) + 1, calendar.get(Calendar.DAY_OF_MONTH));

        else

            return toLocalDateTime(calendar).toLocalDate();

    }

}