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

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 * 
 * Copyright 2011 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.style.data;

import org.openconcerto.openoffice.Log;
import org.openconcerto.openoffice.ODEpoch;
import org.openconcerto.openoffice.ODPackage;
import org.openconcerto.openoffice.ODValueType;
import org.openconcerto.openoffice.OOUtils;
import org.openconcerto.openoffice.Style;
import org.openconcerto.openoffice.StyleDesc;
import org.openconcerto.openoffice.StyleProperties;
import org.openconcerto.openoffice.XMLVersion;
import org.openconcerto.openoffice.spreadsheet.CellStyle;
import org.openconcerto.openoffice.text.TextStyle.StyleTextProperties;
import org.openconcerto.utils.NumberUtils;

import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map.Entry;
import java.util.Set;
import java.util.SortedMap;
import java.util.TreeMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.jdom.Attribute;
import org.jdom.Element;
import org.jdom.Namespace;

// from section 16.27 in v1.2-cs01-part1
public abstract class DataStyle extends Style {
    private static final int DEFAULT_GROUPING_SIZE = new DecimalFormat().getGroupingSize();
    // 15 as of LibreOffice 6, was 10 earlier
    /**
     * The default number of decimal digits if neither defined in the style nor in default-style.
     */
    public static final int DEFAULT_DECIMAL_PLACES;
    private static final Pattern QUOTE_PATRN = Pattern.compile("'", Pattern.LITERAL);
    private static final Pattern EXP_PATTERN = Pattern.compile("E(\\d+)$");

    public static int getDecimalPlaces(final CellStyle defaultStyle) {
        if (defaultStyle != null) {
            final int res = defaultStyle.getTableCellProperties(null).getDecimalPlaces();
            // Ignore invalid value
            return res < 0 ? DEFAULT_DECIMAL_PLACES : res;
        } else {
            return DEFAULT_DECIMAL_PLACES;
        }
    }

    protected static final int parsePositive(final String attr, final boolean lenient) {
        final int res = Integer.parseInt(attr);
        if (res < 0) {
            reportError("Negative value for " + attr, lenient);
            return 0;
        }
        return res;
    }

    public static void addStringLiteral(final StringBuilder formatSB, final String s) {
        formatSB.append('\'');
        formatSB.append(QUOTE_PATRN.matcher(s).replaceAll("''"));
        formatSB.append('\'');
    }

    public static final Set<Class<? extends DataStyle>> DATA_STYLES;
    private static final DataStyleDesc<?>[] DATA_STYLES_DESCS = new DataStyleDesc<?>[] { NumberStyle.DESC, PercentStyle.DESC, TextStyle.DESC, CurrencyStyle.DESC, DateStyle.DESC, TimeStyle.DESC,
            BooleanStyle.DESC };
    static {
        final Set<Class<? extends DataStyle>> l = new HashSet<Class<? extends DataStyle>>(DATA_STYLES_DESCS.length);
        l.add(NumberStyle.class);
        l.add(PercentStyle.class);
        l.add(TextStyle.class);
        l.add(CurrencyStyle.class);
        l.add(DateStyle.class);
        l.add(TimeStyle.class);
        l.add(BooleanStyle.class);
        DATA_STYLES = Collections.unmodifiableSet(l);
        assert DATA_STYLES_DESCS.length == DATA_STYLES.size() : "Discrepancy between classes and descs";

        final String decPlacesProp = System.getProperty("openDocument.defaultDecimalPlaces");
        final int decPlacesParsed = decPlacesProp == null ? -1 : Integer.parseInt(decPlacesProp);
        // Ignore invalid value
        DEFAULT_DECIMAL_PLACES = decPlacesParsed < 0 ? 15 : decPlacesParsed;
        assert DEFAULT_DECIMAL_PLACES >= 0;
    }

    public static abstract class DataStyleDesc<S extends DataStyle> extends StyleDesc<S> {

        protected DataStyleDesc(Class<S> clazz, XMLVersion version, String elemName, String baseName) {
            super(clazz, version, elemName, baseName);
            this.setElementNS(getVersion().getNS("number"));
            // from 19.469 in v1.2-cs01-part1
            this.getRefElementsMap().addAll("style:data-style-name",
                    Arrays.asList("presentation:date-time-decl", "style:style", "text:creation-date", "text:creation-time", "text:database-display", "text:date", "text:editing-duration",
                            "text:expression", "text:meta-field", "text:modification-date", "text:modification-time", "text:print-date", "text:print-time", "text:table-formula", "text:time",
                            "text:user-defined", "text:user-field-get", "text:user-field-input", "text:variable-get", "text:variable-input", "text:variable-set"));
            this.getRefElementsMap().add("style:apply-style-name", "style:map");
        }
    }

    static public void registerDesc() {
        for (final StyleDesc<?> d : DATA_STYLES_DESCS)
            Style.registerAllVersions(d);
    }

    static public <S extends DataStyle> DataStyleDesc<S> getDesc(final Class<S> clazz, final XMLVersion version) {
        return (DataStyleDesc<S>) Style.getStyleDesc(clazz, version);
    }

    private final ODValueType type;
    private StyleTextProperties textProps;

    protected DataStyle(final ODPackage pkg, Element elem, final ODValueType type) {
        super(pkg, elem);
        this.type = type;
    }

    public final ODValueType getDataType() {
        return this.type;
    }

    public final ODEpoch getEpoch() {
        return this.getPackage().getODDocument().getEpoch();
    }

    /**
     * Convert the passed object to something that {@link #format(Object, CellStyle, boolean)} can
     * accept.
     * 
     * @param o the object to convert.
     * @return an object that can be formatted, <code>null</code> if <code>o</code> cannot be
     *         converted.
     * @throws NullPointerException if <code>o</code> is <code>null</code>.
     * @see #canFormat(Class)
     */
    public final Object convert(final Object o) throws NullPointerException {
        if (o == null)
            throw new NullPointerException();

        final Object res;
        if (this.canFormat(o.getClass()))
            res = o;
        else
            res = this.convertNonNull(o);
        assert res == null || this.canFormat(res.getClass());
        return res;
    }

    // o is not null and canFormat(o.getClass()) is false
    // return null if o cannot be converted
    protected abstract Object convertNonNull(Object o);

    /**
     * Whether instances of the passed class can be {@link #format(Object, CellStyle, boolean)
     * formatted}.
     * 
     * @param toFormat the class.
     * @return <code>true</code> if instances of <code>toFormat</code> can be formatted.
     */
    public final boolean canFormat(Class<?> toFormat) {
        return this.getDataType().canFormat(toFormat);
    }

    public final String getTitle() {
        return this.getElement().getAttributeValue("title", getElement().getNamespace());
    }

    public final StyleTextProperties getTextProperties() {
        if (this.textProps == null)
            this.textProps = new StyleTextProperties(this);
        return this.textProps;
    }

    public abstract String format(final Object o, final CellStyle defaultStyle, boolean lenient) throws UnsupportedOperationException;

    static protected final void reportError(String msg, boolean lenient) throws UnsupportedOperationException {
        if (lenient)
            Log.get().warning(msg);
        else
            throw new UnsupportedOperationException(msg);
    }

    public final Locale getLocale() {
        return this.getLocale(false);
    }

    public final Locale getLocale(final boolean local) {
        return this.getLocale(this.getElement(), local);
    }

    protected final Locale getLocale(final Element elem, final boolean local) {
        final Locale res = OOUtils.getElementLocale(elem);
        return local || res != null ? res : this.getPackage().getLocale();
    }

    public final void setLocale(final Locale l) {
        OOUtils.setElementLocale(this.getElement(), this.getElement().getNamespace(), l);
    }

    @SuppressWarnings("unchecked")
    public final List<Element> getMapChildren() {
        return this.getElement().getChildren("map", getSTYLE());
    }

    protected final String formatNumberOrScientificNumber(final Element elem, final Number n, CellStyle defaultStyle, final boolean lenient) {
        return this.formatNumberOrScientificNumber(elem, n, 1, defaultStyle, lenient);
    }

    protected final String formatNumberOrScientificNumber(final Element elem, final Number n, final int multiplier, CellStyle defaultStyle, final boolean lenient) {
        final Namespace numberNS = this.getElement().getNamespace();
        final StringBuilder numberSB = new StringBuilder();

        final List<?> embeddedTexts = elem.getChildren("embedded-text", numberNS);
        final SortedMap<Integer, String> embeddedTextByPosition = new TreeMap<Integer, String>(Collections.reverseOrder());
        for (final Object o : embeddedTexts) {
            final Element embeddedText = (Element) o;
            embeddedTextByPosition.put(Integer.valueOf(embeddedText.getAttributeValue("position", numberNS)), embeddedText.getText());
        }

        final Attribute factorAttr = elem.getAttribute("display-factor", numberNS);
        final double factor = (factorAttr != null ? Double.valueOf(factorAttr.getValue()) : 1) / multiplier;

        // default value from 19.348
        final boolean grouping = StyleProperties.parseBoolean(elem.getAttributeValue("grouping", numberNS), false);

        final String minIntDigitsAttr = elem.getAttributeValue("min-integer-digits", numberNS);
        final int minIntDig = minIntDigitsAttr == null ? 0 : Integer.parseInt(minIntDigitsAttr);
        if (minIntDig == 0) {
            numberSB.append('#');
        } else {
            for (int i = 0; i < minIntDig; i++)
                numberSB.append('0');
        }

        // e.g. if it's "--", 12,3 is displayed "12,3" and 12 is displayed "12,--"
        // From v1.3 §19.356.2 decimal-replacement can be empty
        final String decReplacement = elem.getAttributeValue("decimal-replacement", numberNS, "");
        final boolean decSeparatorAlwaysShown;
        if (!decReplacement.isEmpty() && !NumberUtils.hasFractionalPart(n)) {
            decSeparatorAlwaysShown = true;
            numberSB.append('.');
            // escape quote in replacement
            addStringLiteral(numberSB, decReplacement);
        } else {
            decSeparatorAlwaysShown = false;
            // see 19.343.2
            final String decPlacesAttr = elem.getAttributeValue("decimal-places", numberNS, "");
            final String minDecPlacesAttr = elem.getAttributeValue("min-decimal-places", numberNS, "");
            final int forcedPlaces, nonZeroPlaces;
            if (!decPlacesAttr.isEmpty()) {
                final int decPlaces = parsePositive(decPlacesAttr, lenient);
                if (minDecPlacesAttr.isEmpty()) {
                    forcedPlaces = decPlaces;
                    nonZeroPlaces = 0;
                } else {
                    forcedPlaces = parsePositive(minDecPlacesAttr, lenient);
                    if (forcedPlaces > decPlaces) {
                        DataStyle.reportError("min-decimal-places greater than decimal-places : " + minDecPlacesAttr + " > " + decPlacesAttr, lenient);
                        nonZeroPlaces = 0;
                    } else {
                        nonZeroPlaces = decPlaces - forcedPlaces;
                    }
                }
            } else {
                // default style specifies the maximum
                forcedPlaces = 0;
                nonZeroPlaces = getDecimalPlaces(defaultStyle);
            }

            if (forcedPlaces + nonZeroPlaces > 0) {
                numberSB.append('.');
                for (int i = 0; i < forcedPlaces; i++)
                    numberSB.append('0');
                for (int i = 0; i < nonZeroPlaces; i++)
                    numberSB.append('#');
            }
        }

        final Attribute minExpAttr = elem.getAttribute("min-exponent-digits", numberNS);
        final boolean forcedExpSign;
        if (minExpAttr != null) {
            forcedExpSign = Boolean.parseBoolean(elem.getAttributeValue("forced-exponent-sign", numberNS, "true"));
            numberSB.append('E');
            for (int i = 0; i < Integer.parseInt(minExpAttr.getValue()); i++)
                numberSB.append('0');
        } else {
            forcedExpSign = false;
        }

        final DecimalFormatSymbols symbols = new DecimalFormatSymbols(this.getLocale());

        final DecimalFormat decFormat = new DecimalFormat(numberSB.toString(), symbols);
        // Java always use HALF_EVEN
        decFormat.setRoundingMode(RoundingMode.HALF_UP);
        decFormat.setGroupingUsed(grouping);
        // needed since the default size is overwritten by the pattern
        decFormat.setGroupingSize(DEFAULT_GROUPING_SIZE);
        decFormat.setDecimalSeparatorAlwaysShown(decSeparatorAlwaysShown);
        String res = decFormat.format(NumberUtils.divide(n, factor));
        // There's no way to force the plus sign in DecimalFormat
        if (forcedExpSign) {
            final Matcher m = EXP_PATTERN.matcher(res);
            if (m.find())
                res = res.substring(0, m.start()) + "E+" + m.group(1);
        }
        if (embeddedTextByPosition.size() > 0) {
            final int intDigits = Math.max(minIntDig, NumberUtils.intDigits(n));
            // each time we insert text the decimal point moves
            int offset = 0;
            // sorted descending to avoid overwriting
            for (Entry<Integer, String> e : embeddedTextByPosition.entrySet()) {
                final String embeddedText = e.getValue();
                // the text will be before this index
                final int index = Math.max(0, offset + intDigits - e.getKey().intValue());
                res = res.substring(0, index) + embeddedText + res.substring(index);
                offset += embeddedText.length();
            }
        }
        return res;
    }
}