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.utils.i18n;

import org.openconcerto.utils.CollectionUtils;
import org.openconcerto.utils.Log;
import org.openconcerto.utils.PropertiesUtils;
import org.openconcerto.utils.Tuple2;

import java.beans.Introspector;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.MissingResourceException;
import java.util.Objects;
import java.util.Properties;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import com.ibm.icu.text.MessageFormat;
import com.ibm.icu.text.MessagePattern;
import com.ibm.icu.text.MessagePattern.Part;
import com.ibm.icu.text.MessagePattern.Part.Type;

import net.jcip.annotations.ThreadSafe;

/**
 * Translation manager. The translations are provided by {@link Translator} instances, they are
 * created either from a class ending in a language tag that implements it, or by properties files
 * that must contain values that will be passed to {@link MessageFormat}. In the latter case,
 * messages can reference {@link #createValue(Map, Object[], String) virtual named arguments}.
 * 
 * @author Sylvain
 * @see LocalizedInstances
 */
@ThreadSafe
public class TM {

    static public enum MissingMode {
        EXCEPTION {
            @Override
            protected String returnMissing(TM tm, String key) throws MissingResourceException {
                throw new MissingResourceException("Missing translation", tm.getBaseName(), key);
            }
        },
        NULL {
            @Override
            protected String returnMissing(TM tm, String key) {
                return null;
            }
        },
        STRING {
            @Override
            protected String returnMissing(TM tm, String key) {
                return '!' + key + '!';
            }
        };

        protected abstract String returnMissing(final TM tm, final String key) throws MissingResourceException;

        // method to avoid array allocation and Arrays.toString()
        protected final String returnResult(final TM tm, final String res, final String key) throws MissingResourceException {
            return res == null ? this.returnMissing(tm, key) : res;
        }

        protected final String returnResult(final TM tm, final String res, final String... keys) throws MissingResourceException {
            return res == null ? this.returnMissing(tm, Arrays.toString(keys)) : res;
        }
    }

    static public final String NOUN_CLASS_PROP = "nounClass";
    static {
        assert NOUN_CLASS_PROP.equals(Introspector.decapitalize(NounClass.class.getSimpleName()));
    }

    static private final MissingMode DEFAULT_MISSING_MODE = MissingMode.STRING;

    private static final TMPool<TM> POOL = new TMPool<TM>(TM::new);
    static private final Pattern splitPtrn = Pattern.compile("__", Pattern.LITERAL);
    static private boolean USE_DYNAMIC_MAP = true;

    public static synchronized void setUseDynamicMap(boolean b) {
        USE_DYNAMIC_MAP = b;
    }

    /**
     * Whether to use a {@link DynamicMap} or add all possible keys up front.
     * <code>DynamicMap</code> is the default since it's faster : only required keys are computed,
     * otherwise every key that may be used must be computed. So if your pattern has a lot of
     * plurals and choices it might make a difference. However <code>DynamicMap</code> is less
     * robust, since it twists a little the definition of {@link Map}.
     * 
     * @return <code>true</code> if <code>DynamicMap</code> should be used.
     */
    public static synchronized boolean useDynamicMap() {
        return USE_DYNAMIC_MAP;
    }

    /**
     * The default locale for {@link #getInstance()}. Currently just {@link Locale#getDefault()}.
     * 
     * @return the default locale.
     */
    public static final Locale getDefaultLocale() {
        return Locale.getDefault();
    }

    static public TM getInstance() {
        return getInstance(getDefaultLocale());
    }

    static public TM getInstance(final Locale l) {
        return POOL.get(l);
    }

    static public String tr(final Locale l, final String key, final Object... args) {
        return getInstance(l).translate(key, args);
    }

    static public String tr(final String key, final Object... args) {
        return getInstance().translate(key, args);
    }

    private Locale locale;
    private TranslatorChain translations;
    private Locale translationsLocale;

    protected TM(final Locale locale) {
        setLocale(locale);
    }

    private final void setLocale(final Locale locale) {
        final LocalizedInstances<Translator> localizedInstances = new LocalizedInstances<Translator>(Translator.class, TranslationManager.getControl()) {
            @Override
            protected Translator createInstance(final String bundleName, final Locale l, final Class<?> cl) throws IOException {
                final Properties props = PropertiesUtils.createFromResource(cl, '/' + this.getControl().toResourceName(bundleName, "properties"));
                if (props == null) {
                    return null;
                } else {
                    return new Translator() {
                        @Override
                        public String translate(final String key, final MessageArgs args) {
                            final String msg = props.getProperty(key);
                            if (msg == null)
                                return null;
                            // replaceMap() handles virtual keys (e.g.
                            // element__pluralDefiniteArticle)
                            return new MessageFormat(msg, l).format(replaceMap(args, msg).getAll());
                        }
                    };
                }
            };
        };
        final Tuple2<Locale, List<Translator>> createInstances = localizedInstances.createInstances(getBaseName(), locale);
        synchronized (this) {
            this.locale = locale;
            this.translationsLocale = createInstances.get0();
            this.translations = new TranslatorChain(createInstances.get1());
        }
    }

    /**
     * The requested locale.
     * 
     * @return the requested locale.
     * @see #setLocale(Locale)
     */
    public final synchronized Locale getLocale() {
        return this.locale;
    }

    /**
     * The actual locale of the loaded translations.
     * 
     * @return the actual locale.
     */
    public final synchronized Locale getTranslationsLocale() {
        return this.translationsLocale;
    }

    private final synchronized TranslatorChain getTranslations() {
        return this.translations;
    }

    protected String getBaseName() {
        return I18nUtils.getBaseName(this.getClass());
    }

    // translate array
    public final String trA(final String key, final Object... args) {
        return translate(key, args);
    }

    public final String translate(final String key, final Object... args) {
        return translate(DEFAULT_MISSING_MODE, key, args);
    }

    // translate map
    public final String trM(final String key, final String name1, final Object arg1) {
        return trM(key, Collections.singletonMap(name1, arg1));
    }

    public final String trM(final String key, final String name1, final Object arg1, final String name2, final Object arg2) {
        return trM(key, CollectionUtils.createMap(name1, arg1, name2, arg2));
    }

    public final String trM(final String key, final Map<String, ?> args) {
        return trM(DEFAULT_MISSING_MODE, key, args);
    }

    public final String trM(final MissingMode mode, final String key, Map<String, ?> map) throws MissingResourceException {
        return translate(mode, key, new MessageArgs(map));
    }

    public final String translate(final MissingMode mode, final String key, final Object... args) throws MissingResourceException {
        return translate(mode, key, args.length == 0 ? MessageArgs.getEmpty() : new MessageArgs(args));
    }

    public final String translateFirst(final MissingMode mode, final String... keys) throws MissingResourceException {
        return translateFirst(mode, MessageArgs.getEmpty(), keys);
    }

    /**
     * Return the first non-<code>null</code> result.
     * 
     * @param mode what to do if all keys are <code>null</code>.
     * @param args the arguments.
     * @param keys the keys to search for.
     * @return the first non-<code>null</code> result.
     * @throws MissingResourceException if {@link MissingMode#EXCEPTION} and all keys are
     *         <code>null</code>.
     */
    public final String translateFirst(final MissingMode mode, final MessageArgs args, final String... keys) throws MissingResourceException {
        String res = null;
        for (int i = 0; i < keys.length && res == null; i++) {
            final String key = keys[i];
            if (key != null)
                res = this.translate(MissingMode.NULL, key, args);
        }
        return mode.returnResult(this, res, keys);
    }

    private final String translate(final MissingMode mode, final String key, MessageArgs args) throws MissingResourceException {
        Objects.requireNonNull(mode, "Null mode");
        Objects.requireNonNull(key, "Null key");
        Objects.requireNonNull(args, "Null arguments");
        final String res = this.getTranslations().translate(key, args);
        return mode.returnResult(this, res, key);
    }

    protected MessageArgs replaceMap(final MessageArgs args, final String msg) {
        final MessageArgs res;
        if (args.isMapPrimary()) {
            final Map<String, ?> map = args.getMap();
            final Map<String, Object> copy;
            if (MessageArgs.isOrdered(map)) {
                copy = new LinkedHashMap<String, Object>(map);
            } else {
                copy = new HashMap<String, Object>(map);
            }
            final Object[] array = args.getArray();
            final Map<String, Object> newMap;
            if (useDynamicMap()) {
                newMap = new DynamicMap<Object>(copy) {
                    @Override
                    protected Object createValueNonNull(String key) {
                        return TM.this.createValue(this, array, key);
                    }
                };
            } else {
                newMap = copy;
                final MessagePattern messagePattern = new MessagePattern(msg);
                if (messagePattern.hasNamedArguments()) {
                    final int countParts = messagePattern.countParts();
                    String argName;
                    for (int i = 0; i < countParts; i++) {
                        final Part part = messagePattern.getPart(i);
                        if (part.getType() == Type.ARG_NAME && !newMap.containsKey(argName = messagePattern.getSubstring(part))) {
                            final Object createValue = this.createValue(newMap, array, argName);
                            if (createValue != null)
                                newMap.put(argName, createValue);
                        }
                    }
                }
            }
            res = new MessageArgs(newMap);
        } else {
            res = args;
        }
        return res;
    }

    /**
     * Try to create a value for a missing key. The syntax of keys must be phraseName(__name)+ and
     * if you need to have __ in a name it must be doubled (i.e. ____). <code>phraseName</code>, as
     * its name implies, must reference an existing phrase in <code>map</code>. If this phrase is
     * suffixed by {@value #NOUN_CLASS_PROP} then the {@link NounClass#getName() name} of the noun
     * class of the phrase is returned. Else this phrase and the list of <code>name</code> are
     * passed to {@link Grammar#eval(Phrase, Number, List)}. The count is
     * <code>phraseNameCount</code> if it exists and is a {@link Number}, then <code>count</code>
     * else <code>null</code>.
     * 
     * @param map the current map.
     * @param objects the original map as an array.
     * @param key the missing key.
     * @return its value, or <code>null</code> to leave the map unmodified.
     */
    protected Object createValue(final Map<String, Object> map, final Object[] objects, final String key) {
        if (key.length() == 1 && Character.isDigit(key.charAt(0))) {
            final int index = Integer.parseInt(key);
            if (index < objects.length) {
                return objects[index];
            } else {
                Log.get().warning("Only " + objects.length + " arguments : " + index);
                return null;
            }
        }

        final Matcher m = splitPtrn.matcher(key);
        final String pattern = splitPtrn.pattern();
        final int patternL = pattern.length();
        final StringBuffer sb = new StringBuffer(key.length());
        final List<String> l = new ArrayList<String>();
        int pos = 0;
        while (m.find(pos)) {
            // double to escape pattern
            if (key.length() >= m.end() + patternL && pattern.equals(key.substring(m.end(), m.end() + patternL))) {
                // go to the end to include one
                sb.append(key.substring(pos, m.end()));
                // and set pos after the second one
                pos = m.end() + patternL;
            } else {
                sb.append(key.substring(pos, m.start()));
                l.add(sb.toString());
                sb.setLength(0);
                pos = m.end();
            }
        }
        sb.append(key.substring(pos));
        l.add(sb.toString());

        final String first = CollectionUtils.getFirst(l);
        // at least the whole key
        assert first != null;
        final Object firstObj = handleGet(map, first);
        final Phrase phrase = firstObj instanceof Phrase ? (Phrase) firstObj : null;
        if (phrase != null && l.size() == 2 && NOUN_CLASS_PROP.equals(l.get(1))) {
            if (phrase.getNounClass() == null) {
                Log.get().warning("No noun class for " + phrase);
                return phrase.getBase();
            } else {
                return phrase.getNounClass().getName();
            }
        } else if (phrase != null && phrase.getGrammar() != null) {
            Object countObj = handleGet(map, first + "Count");
            if (!(countObj instanceof Number))
                countObj = handleGet(map, "count");
            final Number count = countObj instanceof Number ? (Number) countObj : null;
            return phrase.getGrammar().eval(phrase, count, l.subList(1, l.size()));
        } else if (phrase != null) {
            Log.get().warning("While splitting " + key + ", " + first + " is a Phrase without grammar : " + phrase);
            return phrase.getBase();
        } else {
            Log.get().warning("While splitting " + key + " : " + first + " isn't a Phrase");
            return null;
        }
    }

    private final Object handleGet(final Map<String, Object> map, final String key) {
        if (map instanceof DynamicMap)
            return ((DynamicMap<Object>) map).handleGet(key);
        else
            return map.get(key);
    }
}