/*

 * Copyright (c) 2012, 2017, Oracle and/or its affiliates. All rights reserved.

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

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package build.tools.cldrconverter;

import static build.tools.cldrconverter.Bundle.jreTimeZoneNames;

import build.tools.cldrconverter.BundleGenerator.BundleType;

import java.io.File;

import java.nio.file.DirectoryStream;

import java.nio.file.FileSystems;

import java.nio.file.Files;

import java.nio.file.Path;

import java.util.*;

import java.util.ResourceBundle.Control;

import java.util.logging.Level;

import java.util.logging.Logger;

import java.util.stream.Collectors;

import javax.xml.parsers.SAXParser;

import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.SAXNotRecognizedException;

import org.xml.sax.SAXNotSupportedException;

/**

 * Converts locale data from "Locale Data Markup Language" format to

 * JRE resource bundle format. LDML is the format used by the Common

 * Locale Data Repository maintained by the Unicode Consortium.

 */

public class CLDRConverter {

    static final String LDML_DTD_SYSTEM_ID = "http://www.unicode.org/cldr/dtd/2.0/ldml.dtd";

    static final String SPPL_LDML_DTD_SYSTEM_ID = "http://www.unicode.org/cldr/dtd/2.0/ldmlSupplemental.dtd";

    private static String CLDR_BASE = "../CLDR/21.0.1/";

    static String LOCAL_LDML_DTD;

    static String LOCAL_SPPL_LDML_DTD;

    private static String SOURCE_FILE_DIR;

    private static String SPPL_SOURCE_FILE;

    private static String NUMBERING_SOURCE_FILE;

    private static String METAZONES_SOURCE_FILE;

    private static String LIKELYSUBTAGS_SOURCE_FILE;

    static String DESTINATION_DIR = "build/gensrc";

    static final String LOCALE_NAME_PREFIX = "locale.displayname.";

    static final String CURRENCY_SYMBOL_PREFIX = "currency.symbol.";

    static final String CURRENCY_NAME_PREFIX = "currency.displayname.";

    static final String CALENDAR_NAME_PREFIX = "calendarname.";

    static final String TIMEZONE_ID_PREFIX = "timezone.id.";

    static final String ZONE_NAME_PREFIX = "timezone.displayname.";

    static final String METAZONE_ID_PREFIX = "metazone.id.";

    static final String PARENT_LOCALE_PREFIX = "parentLocale.";

    private static SupplementDataParseHandler handlerSuppl;

    private static LikelySubtagsParseHandler handlerLikelySubtags;

    static NumberingSystemsParseHandler handlerNumbering;

    static MetaZonesParseHandler handlerMetaZones;

    private static BundleGenerator bundleGenerator;

    // java.base module related

    static boolean isBaseModule = false;

    static final Set<Locale> BASE_LOCALES = new HashSet<>();

    // "parentLocales" map

    private static final Map<String, SortedSet<String>> parentLocalesMap = new HashMap<>();

    private static final ResourceBundle.Control defCon =

        ResourceBundle.Control.getControl(ResourceBundle.Control.FORMAT_DEFAULT);

    static enum DraftType {

        UNCONFIRMED,

        PROVISIONAL,

        CONTRIBUTED,

        APPROVED;

        private static final Map<String, DraftType> map = new HashMap<>();

        static {

            for (DraftType dt : values()) {

                map.put(dt.getKeyword(), dt);

            }

        }

        static private DraftType defaultType = CONTRIBUTED;

        private final String keyword;

        private DraftType() {

            keyword = this.name().toLowerCase(Locale.ROOT);

        }

        static DraftType forKeyword(String keyword) {

            return map.get(keyword);

        }

        static DraftType getDefault() {

            return defaultType;

        }

        static void setDefault(String keyword) {

            defaultType = Objects.requireNonNull(forKeyword(keyword));

        }

        String getKeyword() {

            return keyword;

        }

    }

    static boolean USE_UTF8 = false;

    private static boolean verbose;

    private CLDRConverter() {

       // no instantiation

    }

    @SuppressWarnings("AssignmentToForLoopParameter")

    public static void main(String[] args) throws Exception {

        if (args.length != 0) {

            String currentArg = null;

            try {

                for (int i = 0; i < args.length; i++) {

                    currentArg = args[i];

                    switch (currentArg) {

                    case "-draft":

                        String draftDataType = args[++i];

                        try {

                            DraftType.setDefault(draftDataType);

                        } catch (NullPointerException e) {

                            severe("Error: incorrect draft value: %s%n", draftDataType);

                            System.exit(1);

                        }

                        info("Using the specified data type: %s%n", draftDataType);

                        break;

                    case "-base":

                        // base directory for input files

                        CLDR_BASE = args[++i];

                        if (!CLDR_BASE.endsWith("/")) {

                            CLDR_BASE += "/";

                        }

                        break;

                    case "-baselocales":

                        // base locales

                        setupBaseLocales(args[++i]);

                        break;

                    case "-basemodule":

                        // indicates java.base module resource generation

                        isBaseModule = true;

                        break;

                    case "-o":

                        // output directory

                        DESTINATION_DIR = args[++i];

                        break;

                    case "-utf8":

                        USE_UTF8 = true;

                        break;

                    case "-verbose":

                        verbose = true;

                        break;

                    case "-help":

                        usage();

                        System.exit(0);

                        break;

                    default:

                        throw new RuntimeException();

                    }

                }

            } catch (RuntimeException e) {

                severe("unknown or imcomplete arg(s): " + currentArg);

                usage();

                System.exit(1);

            }

        }

        // Set up path names

        LOCAL_LDML_DTD = CLDR_BASE + "/dtd/ldml.dtd";

        LOCAL_SPPL_LDML_DTD = CLDR_BASE + "/dtd/ldmlSupplemental.dtd";

        SOURCE_FILE_DIR = CLDR_BASE + "/main";

        SPPL_SOURCE_FILE = CLDR_BASE + "/supplemental/supplementalData.xml";

        LIKELYSUBTAGS_SOURCE_FILE = CLDR_BASE + "/supplemental/likelySubtags.xml";

        NUMBERING_SOURCE_FILE = CLDR_BASE + "/supplemental/numberingSystems.xml";

        METAZONES_SOURCE_FILE = CLDR_BASE + "/supplemental/metaZones.xml";

        if (BASE_LOCALES.isEmpty()) {

            setupBaseLocales("en-US");

        }

        bundleGenerator = new ResourceBundleGenerator();

        // Parse data independent of locales

        parseSupplemental();

        List<Bundle> bundles = readBundleList();

        convertBundles(bundles);

    }

    private static void usage() {

        errout("Usage: java CLDRConverter [options]%n"

                + "\t-help          output this usage message and exit%n"

                + "\t-verbose       output information%n"

                + "\t-draft [contributed | approved | provisional | unconfirmed]%n"

                + "\t\t       draft level for using data (default: contributed)%n"

                + "\t-base dir      base directory for CLDR input files%n"

                + "\t-basemodule    generates bundles that go into java.base module%n"

                + "\t-baselocales loc(,loc)*      locales that go into the base module%n"

                + "\t-o dir         output directory (default: ./build/gensrc)%n"

                + "\t-o dir         output directory (defaut: ./build/gensrc)%n"

                + "\t-utf8          use UTF-8 rather than \\uxxxx (for debug)%n");

    }

    static void info(String fmt, Object... args) {

        if (verbose) {

            System.out.printf(fmt, args);

        }

    }

    static void info(String msg) {

        if (verbose) {

            System.out.println(msg);

        }

    }

    static void warning(String fmt, Object... args) {

        System.err.print("Warning: ");

        System.err.printf(fmt, args);

    }

    static void warning(String msg) {

        System.err.print("Warning: ");

        errout(msg);

    }

    static void severe(String fmt, Object... args) {

        System.err.print("Error: ");

        System.err.printf(fmt, args);

    }

    static void severe(String msg) {

        System.err.print("Error: ");

        errout(msg);

    }

    private static void errout(String msg) {

        if (msg.contains("%n")) {

            System.err.printf(msg);

        } else {

            System.err.println(msg);

        }

    }

    /**

     * Configure the parser to allow access to DTDs on the file system.

     */

    private static void enableFileAccess(SAXParser parser) throws SAXNotSupportedException {

        try {

            parser.setProperty("http://javax.xml.XMLConstants/property/accessExternalDTD", "file");

        } catch (SAXNotRecognizedException ignore) {

            // property requires >= JAXP 1.5

        }

    }

    private static List<Bundle> readBundleList() throws Exception {

        List<Bundle> retList = new ArrayList<>();

        Path path = FileSystems.getDefault().getPath(SOURCE_FILE_DIR);

        try (DirectoryStream<Path> dirStr = Files.newDirectoryStream(path)) {

            for (Path entry : dirStr) {

                String fileName = entry.getFileName().toString();

                if (fileName.endsWith(".xml")) {

                    String id = fileName.substring(0, fileName.indexOf('.'));

                    Locale cldrLoc = Locale.forLanguageTag(toLanguageTag(id));

                    StringBuilder sb = getCandLocales(cldrLoc);

                    if (sb.indexOf("root") == -1) {

                        sb.append("root");

                    }

                    Bundle b = new Bundle(id, sb.toString(), null, null);

                    // Insert the bundle for root at the top so that it will get

                    // processed first.

                    if ("root".equals(id)) {

                        retList.add(0, b);

                    } else {

                        retList.add(b);

                    }

                }

            }

        }

        return retList;

    }

    private static final Map<String, Map<String, Object>> cldrBundles = new HashMap<>();

    private static Map<String, SortedSet<String>> metaInfo = new HashMap<>();

    static {

        // For generating information on supported locales.

        metaInfo.put("AvailableLocales", new TreeSet<>());

    }

    static Map<String, Object> getCLDRBundle(String id) throws Exception {

        Map<String, Object> bundle = cldrBundles.get(id);

        if (bundle != null) {

            return bundle;

        }

        File file = new File(SOURCE_FILE_DIR + File.separator + id + ".xml");

        if (!file.exists()) {

            // Skip if the file doesn't exist.

            return Collections.emptyMap();

        }

        info("..... main directory .....");

        bundle = handler.getData();

        cldrBundles.put(id, bundle);

            if (bundle != null) {

                //merge two maps into one map

                Map<String, Object> temp = cldrBundles.remove(id);

                bundle.putAll(temp);

                cldrBundles.put(id, bundle);

            }

        }

        return bundle;

    }

    // Parsers for data in "supplemental" directory

    //

    private static void parseSupplemental() throws Exception {

        // Parse SupplementalData file and store the information in the HashMap

        // Calendar information such as firstDay and minDay are stored in

        // supplementalData.xml as of CLDR1.4. Individual territory is listed

        // with its ISO 3166 country code while default is listed using UNM49

        // region and composition numerical code (001 for World.)

        //

        // SupplementalData file also provides the "parent" locales which

        // are othrwise not to be fallen back. Process them here as well.

        //

        handlerSuppl = new SupplementDataParseHandler();

        Map<String, Object> parentData = handlerSuppl.getData("root");

                parentLocalesMap.put(key, new TreeSet(

                    Arrays.asList(((String)parentData.get(key)).split(" "))));

            });

        // Parse numberingSystems to get digit zero character information.

        handlerNumbering = new NumberingSystemsParseHandler();

        // Parse metaZones to create mappings between Olson tzids and CLDR meta zone names

        handlerMetaZones = new MetaZonesParseHandler();

        // Parse likelySubtags

        handlerLikelySubtags = new LikelySubtagsParseHandler();

    }

    }

    private static StringBuilder getCandLocales(Locale cldrLoc) {

        List<Locale> candList = getCandidateLocales(cldrLoc);

        StringBuilder sb = new StringBuilder();

        for (Locale loc : candList) {

            if (!loc.equals(Locale.ROOT)) {

                sb.append(toLocaleName(loc.toLanguageTag()));

                sb.append(",");

            }

        }

        return sb;

    }

    private static List<Locale> getCandidateLocales(Locale cldrLoc) {

        List<Locale> candList = new ArrayList<>();

        candList = applyParentLocales("", defCon.getCandidateLocales("",  cldrLoc));

        return candList;

    }

    private static void convertBundles(List<Bundle> bundles) throws Exception {

        // parent locales map. The mappings are put in base metaInfo file

        // for now.

        if (isBaseModule) {

            metaInfo.putAll(parentLocalesMap);

        }

        for (Bundle bundle : bundles) {

            // Get the target map, which contains all the data that should be

            // visible for the bundle's locale

            Map<String, Object> targetMap = bundle.getTargetMap();

            EnumSet<Bundle.Type> bundleTypes = bundle.getBundleTypes();

            if (bundle.isRoot()) {

                // Add DateTimePatternChars because CLDR no longer supports localized patterns.

                targetMap.put("DateTimePatternChars", "GyMdkHmsSEDFwWahKzZ");

            }

            // Now the map contains just the entries that need to be in the resources bundles.

            // Go ahead and generate them.

            if (bundleTypes.contains(Bundle.Type.LOCALENAMES)) {

                Map<String, Object> localeNamesMap = extractLocaleNames(targetMap, bundle.getID());

                if (!localeNamesMap.isEmpty() || bundle.isRoot()) {

                    bundleGenerator.generateBundle("util", "LocaleNames", bundle.getJavaID(), true, localeNamesMap, BundleType.OPEN);

                }

            }

            if (bundleTypes.contains(Bundle.Type.CURRENCYNAMES)) {

                Map<String, Object> currencyNamesMap = extractCurrencyNames(targetMap, bundle.getID(), bundle.getCurrencies());

                if (!currencyNamesMap.isEmpty() || bundle.isRoot()) {

                    bundleGenerator.generateBundle("util", "CurrencyNames", bundle.getJavaID(), true, currencyNamesMap, BundleType.OPEN);

                }

            }

            if (bundleTypes.contains(Bundle.Type.TIMEZONENAMES)) {

                Map<String, Object> zoneNamesMap = extractZoneNames(targetMap, bundle.getID());

                if (!zoneNamesMap.isEmpty() || bundle.isRoot()) {

                    bundleGenerator.generateBundle("util", "TimeZoneNames", bundle.getJavaID(), true, zoneNamesMap, BundleType.TIMEZONE);

                }

            }

            if (bundleTypes.contains(Bundle.Type.CALENDARDATA)) {

                Map<String, Object> calendarDataMap = extractCalendarData(targetMap, bundle.getID());

                if (!calendarDataMap.isEmpty() || bundle.isRoot()) {

                    bundleGenerator.generateBundle("util", "CalendarData", bundle.getJavaID(), true, calendarDataMap, BundleType.PLAIN);

                }

            }

            if (bundleTypes.contains(Bundle.Type.FORMATDATA)) {

                Map<String, Object> formatDataMap = extractFormatData(targetMap, bundle.getID());

                if (!formatDataMap.isEmpty() || bundle.isRoot()) {

                    bundleGenerator.generateBundle("text", "FormatData", bundle.getJavaID(), true, formatDataMap, BundleType.PLAIN);

                }

            }

            // For AvailableLocales

            metaInfo.get("AvailableLocales").add(toLanguageTag(bundle.getID()));

            addLikelySubtags(metaInfo, "AvailableLocales", bundle.getID());

        }

        bundleGenerator.generateMetaInfo(metaInfo);

    }

    static final Map<String, String> aliases = new HashMap<>();

    /**

     * Translate the aliases into the real entries in the bundle map.

     */

    static void handleAliases(Map<String, Object> bundleMap) {