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

import org.openconcerto.utils.FormatGroup;
import org.openconcerto.utils.TimeUtils;
import org.openconcerto.utils.XMLCalendarFormat;
import org.openconcerto.utils.XMLDateFormat;

import java.math.BigDecimal;
import java.text.Format;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Locale;
import java.util.TimeZone;

import javax.xml.datatype.Duration;

import net.jcip.annotations.GuardedBy;
import net.jcip.annotations.Immutable;

/**
 * A type of value, as per 16.1 "Data Types" and 6.7.1 "Variable Value Types and Values"
 */
@Immutable
public enum ODValueType {

    /**
     * Parses to {@link BigDecimal} to return the exact number.
     */
    FLOAT("value", Number.class) {

        @Override
        public String format(Object o) {
            // avoid 1.23E+3
            if (o instanceof BigDecimal)
                return ((BigDecimal) o).toPlainString();
            else
                return ((Number) o).toString();
        }

        @Override
        public BigDecimal parse(String s) {
            return new BigDecimal(s);
        }

    },
    PERCENTAGE("value", Number.class) {

        @Override
        public String format(Object o) {
            return FLOAT.format(o);
        }

        @Override
        public Object parse(String s) {
            return FLOAT.parse(s);
        }

    },
    CURRENCY("value", Number.class) {

        @Override
        public String format(Object o) {
            return FLOAT.format(o);
        }

        @Override
        public Object parse(String s) {
            return FLOAT.parse(s);
        }
    },
    // TODO support LocalDateTime
    DATE("date-value", Date.class, Calendar.class) {

        @Override
        public String format(Object o) {
            return formatDate(o);
        }

        @Override
        public Date parse(String date) {
            if (date.length() == 0)
                return null;
            else {
                try {
                    return parseDateValue(date).getTime();
                } catch (ParseException e) {
                    throw new IllegalStateException("wrong date: " + date, e);
                }
            }
        }

    },
    TIME("time-value", Duration.class, java.time.Duration.class, Calendar.class) {

        @Override
        public String format(Object o) {
            if (o instanceof Duration) {
                return o.toString();
            } else if (o instanceof java.time.Duration) {
                // w/o days or larger : PTnHnMnS
                return o.toString();
            } else {
                final Calendar cal = (Calendar) o;
                return TimeUtils.timePartToDuration(cal).toString();
            }
        }

        @Override
        public Duration parse(String date) {
            if (date.length() == 0)
                return null;
            else {
                return TimeUtils.getTypeFactory().newDuration(date);
            }
        }

    },
    BOOLEAN("boolean-value", Boolean.class) {

        @Override
        public String format(Object o) {
            return ((Boolean) o).toString().toLowerCase();
        }

        @Override
        public Boolean parse(String s) {
            return Boolean.valueOf(s);
        }

    },
    STRING("string-value", String.class) {

        @Override
        public String format(Object o) {
            return o.toString();
        }

        @Override
        public String parse(String s) {
            return s;
        }
    };

    private final String attr;
    private final List<Class<?>> acceptedClasses;

    private ODValueType(String attr, Class<?>... classes) {
        this.attr = attr;
        this.acceptedClasses = Arrays.asList(classes);
    }

    /**
     * The name of the value attribute for this value type.
     * 
     * @return the value attribute, e.g. "boolean-value".
     */
    public final String getValueAttribute() {
        return this.attr;
    }

    public boolean canFormat(Class<?> toFormat) {
        for (final Class<?> c : this.acceptedClasses)
            if (c.isAssignableFrom(toFormat))
                return true;
        return false;
    }

    public abstract String format(Object o);

    public abstract Object parse(String s);

    /**
     * The value for the value-type attribute.
     * 
     * @return the value for the value-type attribute, e.g. "float".
     */
    public final String getName() {
        return this.name().toLowerCase();
    }

    /**
     * The instance for the passed value type.
     * 
     * @param name the value of the value-type attribute, e.g. "date".
     * @return the corresponding instance, never <code>null</code>, e.g. {@link #DATE}.
     * @throws IllegalArgumentException if <code>name</code> isn't a valid type.
     */
    public static ODValueType get(String name) {
        return ODValueType.valueOf(name.toUpperCase());
    }

    /**
     * Try to guess the value type for the passed object.
     * 
     * @param o the object.
     * @return a value type capable of formatting <code>o</code> or <code>null</code>.
     * @throws NullPointerException if <code>o</code> is <code>null</code>.
     */
    public static ODValueType forObject(Object o) throws NullPointerException {
        if (o == null)
            throw new NullPointerException();
        if (o instanceof Number)
            return FLOAT;
        else if (o instanceof Boolean)
            return BOOLEAN;
        else if (o instanceof String)
            return STRING;
        else if (o instanceof Duration || o instanceof java.time.Duration)
            return TIME;
        else if (DATE.canFormat(o.getClass()))
            return DATE;
        else
            return null;
    }

    static private final TimeZone UTC_TZ = TimeZone.getTimeZone("UTC");
    // use nulls and not (TimeZone|Locale).getDefault() so as to not need to listen to changes
    // LibreOffice behavior as of 4.1 is to no longer ignore explicit time zone when reading dates.
    @GuardedBy("ODValueType")
    static private DateConfig DATE_CONFIG = new DateConfig(null, null, null, Boolean.FALSE);

    // see http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/#isoformats

    @GuardedBy("ODValueType")
    static private Format DATE_FORMAT, DATE_PARSER;
    static {
        updateFormat();
    }

    static private synchronized String formatDate(Object obj) {
        return DATE_FORMAT.format(obj);
    }

    static private synchronized void updateFormat() {
        // always remove time zone on write
        DATE_FORMAT = new XMLCalendarFormat(getTimeZone(false), getLocale(false));
        DATE_PARSER = getFormatParser(DATE_CONFIG, true);
    }

    static private synchronized SimpleDateFormat createDateFormat(final String pattern, final DateConfig dateConf) {
        final SimpleDateFormat res = new SimpleDateFormat(pattern, dateConf.getLocale(true));
        res.setTimeZone(!dateConf.isTimeZoneIgnored() ? UTC_TZ : dateConf.getTimeZone(true));
        return res;
    }

    static private synchronized Format getFormatParser(final DateConfig dateConf, final boolean forceCreate) {
        if (!forceCreate && dateConf.equals(DATE_CONFIG)) {
            return DATE_PARSER;
        } else {
            final Format xmlDF;
            if (dateConf.isTimeZoneIgnored()) {
                xmlDF = new XMLCalendarFormat(dateConf.getTimeZone(false), dateConf.getLocale(false));
            } else {
                xmlDF = new XMLDateFormat(UTC_TZ, null);
            }
            // first date and time so we don't loose time information on format() or parse()
            // MAYBE add HH':'mm':'ss,SSS for OOo 1
            return new FormatGroup(xmlDF, createDateFormat("yyyy-MM-dd'T'HH':'mm':'ss", dateConf), createDateFormat("yyyy-MM-dd", dateConf));
        }
    }

    static private synchronized final void setDateConfig(final DateConfig newVal) {
        if (!newVal.equals(DATE_CONFIG)) {
            DATE_CONFIG = newVal;
            updateFormat();
        }
    }

    /**
     * Set the framework default time zone. Pass <code>null</code> to always use the VM default
     * (passing {@link TimeZone#getDefault()} would set the value once and for all and wouldn't be
     * changed by {@link TimeZone#setDefault(TimeZone)}).
     * 
     * @param tz the new default time zone, <code>null</code> to use the VM default.
     */
    static public synchronized final void setTimeZone(final TimeZone tz) {
        setDateConfig(DATE_CONFIG.setTimeZone(tz));
    }

    /**
     * The framework default time zone.
     * 
     * @param notNull <code>true</code> if <code>null</code> should be replaced by
     *        {@link TimeZone#getDefault()}.
     * @return the default time zone, can only be <code>null</code> if <code>notNull</code> is
     *         <code>false</code>.
     */
    static public synchronized final TimeZone getTimeZone(final boolean notNull) {
        return DATE_CONFIG.getTimeZone(notNull);
    }

    /**
     * Set the framework default locale. Pass <code>null</code> to always use the VM default
     * (passing {@link Locale#getDefault()} would set the value once and for all and wouldn't be
     * changed by {@link Locale#setDefault(Locale)}).
     * 
     * @param locale the new default locale, <code>null</code> to use the VM default.
     */
    static public synchronized final void setLocale(final Locale locale) {
        setDateConfig(DATE_CONFIG.setLocale(locale));
    }

    /**
     * The framework default locale.
     * 
     * @param notNull <code>true</code> if <code>null</code> should be replaced by
     *        {@link Locale#getDefault()}.
     * @return the default locale, can only be <code>null</code> if <code>notNull</code> is
     *         <code>false</code>.
     */
    static public synchronized final Locale getLocale(final boolean notNull) {
        return DATE_CONFIG.getLocale(notNull);
    }

    /**
     * Get the framework default calendar.
     * 
     * @return the default calendar.
     * @see #getTimeZone(boolean)
     * @see #getLocale(boolean)
     */
    static public synchronized final Calendar getCalendar() {
        return DATE_CONFIG.getCalendar();
    }

    static public synchronized final void setTimeZoneIgnored(final boolean b) {
        setDateConfig(DATE_CONFIG.setTimeZoneIgnored(b));
    }

    /**
     * Whether to ignore explicit time zone in dates. Prior to 4.1 LibreOffice would ignore explicit
     * time zones, i.e. "2013-11-15T12:00:00.000" and "2013-11-15T12:00:00.000+01:00" would both
     * parse to noon. As of 4.1 the first one parse to noon, the second one to 11 AM.
     * 
     * @return <code>true</code> if the time zone part should be ignored.
     */
    static public synchronized final boolean isTimeZoneIgnored() {
        return DATE_CONFIG.isTimeZoneIgnored();
    }

    /**
     * Parse an OpenDocument date value with the framework defaults.
     * 
     * @param date the string formatted value.
     * @return a calendar with the local time of the passed date.
     * @throws ParseException if the value couldn't be parsed.
     * @see #parseDateValue(String, TimeZone, Locale, Boolean)
     */
    static public synchronized Calendar parseDateValue(final String date) throws ParseException {
        return parseDateValue(date, null, null, null);
    }

    /**
     * Parse an OpenDocument date value with the passed parameters.
     * 
     * @param date the string formatted value.
     * @param tz the time zone of the returned calendar, <code>null</code> meaning
     *        {@link #getTimeZone(boolean)}.
     * @param locale the locale of the returned calendar, <code>null</code> meaning
     *        {@link #getLocale(boolean)}.
     * @param ignoreTZ whether to ignore the time zone part of <code>part</code>, <code>null</code>
     *        meaning {@link #isTimeZoneIgnored()}.
     * @return a calendar with the local time of the passed date.
     * @throws ParseException if the value couldn't be parsed.
     */
    static public synchronized Calendar parseDateValue(final String date, final TimeZone tz, final Locale locale, final Boolean ignoreTZ) throws ParseException {
        final DateConfig conf = new DateConfig(DATE_CONFIG, tz, locale, ignoreTZ);
        final Object parsed = getFormatParser(conf, false).parseObject(date);
        if (parsed instanceof Calendar) {
            // XMLCalendarFormat
            return (Calendar) parsed;
        } else {
            final Calendar res = conf.getCalendar();
            if (conf.isTimeZoneIgnored()) {
                // SimpleDateFormat
                res.setTime((Date) parsed);
                return res;
            } else {
                // XMLDateFormat or SimpleDateFormat
                final Calendar cal = Calendar.getInstance(UTC_TZ);
                cal.setTime((Date) parsed);
                return TimeUtils.copyLocalTime(cal, res);
            }
        }
    }
}