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.text;

import org.openconcerto.utils.CollectionUtils;

import org.openconcerto.utils.StringUtils;

import org.openconcerto.utils.text.DateTimeFormat.Literal;

import java.text.SimpleDateFormat;

import java.time.format.DateTimeFormatterBuilder;

import java.time.format.SignStyle;

import java.time.format.TextStyle;

import java.time.temporal.ChronoField;

import java.util.Arrays;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Locale;

import java.util.Map;

import java.util.Objects;

import java.util.Set;

import java.util.SortedMap;

import java.util.TreeMap;

import java.util.function.Function;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import com.ibm.icu.text.DateTimePatternGenerator;

public final class DateProp extends DateTimeFormatComponent {

    static public final DateProp YEAR = new DateProp("year with four digits");

    static public final DateProp MONTH_NAME = new DateProp("full name of the month");

    static public final DateProp MONTH_NUMBER = new DateProp("2 digits number of the month (starting at 1)");

    static public final DateProp DAY_IN_MONTH = new DateProp("2 digits day number in the month");

    static public final DateProp DAY_NAME_IN_WEEK = new DateProp("full name of day");

    static public final DateProp HOUR = new DateProp("hour in day (00-23)");

    static public final DateProp MINUTE = new DateProp("minute in hour");

    static public final DateProp SECOND = new DateProp("second in minute");

    static public final DateProp MICROSECOND = new DateProp("microseconds (000000-999999)");

    static public final Set<DateProp> ALL_INSTANCES = Collections

            .unmodifiableSet(new HashSet<>(Arrays.asList(YEAR, MONTH_NAME, MONTH_NUMBER, DAY_IN_MONTH, DAY_NAME_IN_WEEK, HOUR, MINUTE, SECOND, MICROSECOND)));

    static public final Set<DateProp> LOCALE_SENSITIVE_INSTANCES = Collections.unmodifiableSet(new HashSet<>(Arrays.asList(MONTH_NAME, DAY_NAME_IN_WEEK)));

    static public final DateTimeSkeleton TIME_SKELETON = DateTimeFormatBuilder.buildSkeleton(HOUR, MINUTE, SECOND);

    static public final DateTimeSkeleton SHORT_DATE_SKELETON = DateTimeFormatBuilder.buildSkeleton(DAY_IN_MONTH, MONTH_NUMBER, YEAR);

    static public final DateTimeSkeleton LONG_DATE_SKELETON = DateTimeFormatBuilder.buildSkeleton(DAY_NAME_IN_WEEK, DAY_IN_MONTH, MONTH_NAME, YEAR);

    static public final DateTimeSkeleton SHORT_DATETIME_SKELETON = DateTimeFormatBuilder.buildSkeleton(DAY_IN_MONTH, MONTH_NUMBER, YEAR, HOUR, MINUTE);

    static public final DateTimeSkeleton LONG_DATETIME_SKELETON = DateTimeFormatBuilder.buildSkeleton(DAY_NAME_IN_WEEK, DAY_IN_MONTH, MONTH_NAME, YEAR, HOUR, MINUTE, SECOND);

    // pure format (i.e. no literal string)

    static private final Map<DateProp, String> JAVA_DATE_SPECS_PURE;

    static public final Map<DateProp, String> DATE_PROP_TO_JAVA;

    static private final SortedMap<String, DateProp> REVERSE_JAVA_SPEC;

    static private final Pattern REVERSE_SPEC_PATTERN;

    static {

        JAVA_DATE_SPECS_PURE = new HashMap<DateProp, String>();

        JAVA_DATE_SPECS_PURE.put(YEAR, "yyyy");

        JAVA_DATE_SPECS_PURE.put(MONTH_NAME, "MMMM");

        JAVA_DATE_SPECS_PURE.put(MONTH_NUMBER, "MM");

        JAVA_DATE_SPECS_PURE.put(DAY_IN_MONTH, "dd");

        JAVA_DATE_SPECS_PURE.put(DAY_NAME_IN_WEEK, "EEEE");

        JAVA_DATE_SPECS_PURE.put(HOUR, "HH");

        JAVA_DATE_SPECS_PURE.put(MINUTE, "mm");

        JAVA_DATE_SPECS_PURE.put(SECOND, "ss");

        final Map<DateProp, String> tmp = new HashMap<>(DateProp.JAVA_DATE_SPECS_PURE);

        tmp.put(DateProp.MICROSECOND, "SSS000");

        DATE_PROP_TO_JAVA = Collections.unmodifiableMap(tmp);

        assert DATE_PROP_TO_JAVA.keySet().equals(ALL_INSTANCES);

        // reverse, so longer strings come first (e.g. MMMM|MM to match the longer one)

        final SortedMap<String, DateProp> m = new TreeMap<>(Collections.reverseOrder());

        REVERSE_JAVA_SPEC = CollectionUtils.invertMap(m, JAVA_DATE_SPECS_PURE);

        assert REVERSE_JAVA_SPEC.size() == JAVA_DATE_SPECS_PURE.size() : "Duplicate values";

        assert !JAVA_DATE_SPECS_PURE.containsKey(null) : "Null spec";

        assert !JAVA_DATE_SPECS_PURE.containsValue(null) : "Null value";

        REVERSE_SPEC_PATTERN = Pattern.compile(CollectionUtils.join(REVERSE_JAVA_SPEC.keySet(), "|"));

    }

    /**

     * Convert the passed pattern to a {@link SimpleDateFormat} pattern.

     *

     * @param simpleFormat either {@link #ALL_INSTANCES} or arbitrary literal string that will be

     *        quoted.

     * @return the {@link SimpleDateFormat java} pattern.

     */

    public static String toJavaPattern(final List<? extends DateTimeFormatComponent> simpleFormat) {

        return toStringPattern(simpleFormat, DATE_PROP_TO_JAVA::get, StringUtils::singleQuote);

    }

    public static final String toStringPattern(final List<? extends DateTimeFormatComponent> simpleFormat, final Function<? super DateProp, String> datePropToString,

            final Function<String, String> literalToString) {

        final StringBuilder sb = new StringBuilder(simpleFormat.size() * 6);

        // needed because if there's 2 consecutive literal text then 'text1''text2' which evaluates

        // to text1'text2.

        final StringBuilder literalText = new StringBuilder(64);

        for (final DateTimeFormatComponent p : simpleFormat) {

            if (p instanceof Literal) {

                literalText.append(((Literal) p).getValue());

            } else {

                final String javaComp = Objects.requireNonNull(datePropToString.apply((DateProp) p));

                if (literalText.length() > 0) {

                    sb.append(literalToString.apply(literalText.toString()));

                    literalText.setLength(0);

                }

                sb.append(javaComp);

            }

        }

        if (literalText.length() > 0) {

            sb.append(literalToString.apply(literalText.toString()));

        }

        return sb.toString();

    }

    public static DateTimeFormatterBuilder createJavaFormatterBuilder(final List<? extends DateTimeFormatComponent> simpleFormat) {

        final DateTimeFormatterBuilder res = new DateTimeFormatterBuilder();

        for (final DateTimeFormatComponent p : simpleFormat) {

            if (p instanceof Literal) {

                res.appendLiteral(((Literal) p).getValue());

            } else {

                // from DateTimeFormatterBuilder.appendPattern()

                if (p == YEAR)

                    res.appendValue(ChronoField.YEAR, 4, 19, SignStyle.EXCEEDS_PAD);

                else if (p == MONTH_NAME)

                    res.appendText(ChronoField.MONTH_OF_YEAR, TextStyle.FULL);

                else if (p == MONTH_NUMBER)

                    res.appendValue(ChronoField.MONTH_OF_YEAR, 2);

                else if (p == DAY_IN_MONTH)

                    res.appendValue(ChronoField.DAY_OF_MONTH, 2);

                else if (p == DAY_NAME_IN_WEEK)

                    res.appendText(ChronoField.DAY_OF_WEEK, TextStyle.FULL);

                else if (p == HOUR)

                    res.appendValue(ChronoField.HOUR_OF_DAY, 2);

                else if (p == MINUTE)

                    res.appendValue(ChronoField.MINUTE_OF_HOUR, 2);

                else if (p == SECOND)

                    res.appendValue(ChronoField.SECOND_OF_MINUTE, 2);

                else if (p == MICROSECOND)

                    res.appendValue(ChronoField.MICRO_OF_SECOND, 6);

                else

                    throw new IllegalArgumentException("Unknown " + p);

            }

        }

        return res;

    }

    /**

     * Return the best pattern matching the input skeleton.

     *

     * @param simpleFormat the fields needed, e.g. [YEAR, DAY_IN_MONTH, MONTH_NUMBER].

     * @param l the locale needed.

     * @return the best match, e.g. "dd/MM/yyyy" for {@link Locale#FRANCE} , "MM/dd/yyyy" for

     *         {@link Locale#US}.

     */

    public static String getBestJavaPattern(final List<DateProp> simpleFormat, final Locale l) {

        final StringBuilder sb = new StringBuilder(128);

        for (final DateProp p : simpleFormat) {

            final String javaComp = JAVA_DATE_SPECS_PURE.get(p);

            if (javaComp != null)

                sb.append(javaComp);

            else

                throw new IllegalArgumentException("Unsupported spec : " + p);

        }

        // needs same length so our pattern works

        return DateTimePatternGenerator.getInstance(l).getBestPattern(sb.toString(), DateTimePatternGenerator.MATCH_ALL_FIELDS_LENGTH);

    }

    /**

     * Return the best pattern matching the input skeleton.

     *

     * @param simpleFormat the fields needed, e.g. [YEAR, DAY_IN_MONTH, MONTH_NUMBER].

     * @param l the locale needed.

     * @return the best match, e.g. [DAY_IN_MONTH, "/", MONTH_NUMBER, "/", YEAR] for

     *         {@link Locale#FRANCE} , [MONTH_NUMBER, "/", DAY_IN_MONTH, "/", YEAR] for

     *         {@link Locale#US}.

     */

    public static DateTimeFormat getBestPattern(final List<DateProp> simpleFormat, final Locale l) {

        return parseJavaPattern(getBestJavaPattern(simpleFormat, l));

    }

    static DateTimeFormat parseJavaPattern(final String bestPattern) {

        final Matcher matcher = REVERSE_SPEC_PATTERN.matcher(bestPattern);

        final Matcher quotedMatcher = StringUtils.SINGLE_QUOTED_PATTERN.matcher(bestPattern);

        final DateTimeFormatBuilder res = new DateTimeFormatBuilder();

        int index = 0;

        while (index < bestPattern.length()) {

            final int quoteIndex = bestPattern.indexOf('\'', index);

            final int endSansQuote = quoteIndex < 0 ? bestPattern.length() : quoteIndex;

            // parse quote-free string

            matcher.region(index, endSansQuote);

            while (matcher.find()) {

                if (index < matcher.start())

                    res.addLiteral(bestPattern.substring(index, matcher.start()));

                res.add(REVERSE_JAVA_SPEC.get(matcher.group()));

                index = matcher.end();

            }

            assert index <= endSansQuote : "region() failed";

            if (index < endSansQuote)

                res.addLiteral(bestPattern.substring(index, endSansQuote));

            index = endSansQuote;

            // parse quoted string

            if (index < bestPattern.length()) {

                quotedMatcher.region(index, bestPattern.length());

                if (!quotedMatcher.find() || quotedMatcher.start() != quotedMatcher.regionStart())

                    throw new IllegalStateException("Quoted string error : " + bestPattern.substring(quoteIndex));

                res.addLiteral(StringUtils.unSingleQuote(quotedMatcher));

                index = quotedMatcher.end();

            }

        }

        return res.build();

    }

    private final String name;

    private DateProp(String name) {

        this.name = name;

    }

    public final String getName() {

        return this.name;

    }

    @Override

    public String toString() {

        return this.getClass().getSimpleName() + ' ' + this.getName();

    }

}