/*
 * Copyright (c) 2012, 2024, 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 build.tools.cldrconverter.BundleGenerator.BundleType;
import java.io.File;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.nio.file.*;
import java.time.*;
import java.util.*;
import java.util.ResourceBundle.Control;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;
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";
    static final String BCP47_LDML_DTD_SYSTEM_ID = "http://www.unicode.org/cldr/dtd/2.0/ldmlBCP47.dtd";


    private static String CLDR_BASE;
    static String LOCAL_LDML_DTD;
    static String LOCAL_SPPL_LDML_DTD;
    static String LOCAL_BCP47_LDML_DTD;
    private static String SOURCE_FILE_DIR;
    private static String SPPL_SOURCE_FILE;
    private static String SPPL_META_SOURCE_FILE;
    private static String NUMBERING_SOURCE_FILE;
    private static String METAZONES_SOURCE_FILE;
    private static String LIKELYSUBTAGS_SOURCE_FILE;
    private static String TIMEZONE_SOURCE_FILE;
    private static String WINZONES_SOURCE_FILE;
    private static String PLURALS_SOURCE_FILE;
    private static String DAYPERIODRULE_SOURCE_FILE;
    private static String COVERAGELEVELS_FILE;
    static String DESTINATION_DIR = "build/gensrc";

    static final String LOCALE_NAME_PREFIX = "locale.displayname.";
    static final String LOCALE_SEPARATOR = LOCALE_NAME_PREFIX + "separator";
    static final String LOCALE_KEYTYPE = LOCALE_NAME_PREFIX + "keytype";
    static final String LOCALE_KEY_PREFIX = LOCALE_NAME_PREFIX + "key.";
    static final String LOCALE_TYPE_PREFIX = LOCALE_NAME_PREFIX + "type.";
    static final String LOCALE_TYPE_PREFIX_CA = LOCALE_TYPE_PREFIX + "ca.";
    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 CALENDAR_FIRSTDAY_PREFIX = "firstDay.";
    static final String CALENDAR_MINDAYS_PREFIX = "minDays.";
    static final String TIMEZONE_ID_PREFIX = "timezone.id.";
    static final String EXEMPLAR_CITY_PREFIX = "timezone.excity.";
    static final String ZONE_NAME_PREFIX = "timezone.displayname.";
    static final String METAZONE_ID_PREFIX = "metazone.id.";
    static final String PARENT_LOCALE_PREFIX = "parentLocale.";
    static final String LIKELY_SCRIPT_PREFIX = "likelyScript.";
    static final String META_EMPTY_ZONE_NAME = "EMPTY_ZONE";
    static final String[] EMPTY_ZONE = {"", "", "", "", "", ""};
    static final String META_ETCUTC_ZONE_NAME = "ETC_UTC";

    // constants used for TZDB short names
    private static final String NBSP = "\u00A0";
    private static final String STD = "std";
    private static final String DST = "dst";
    private static final String NO_SUBST = "-";

    private static SupplementalDataParseHandler handlerSuppl;
    private static LikelySubtagsParseHandler handlerLikelySubtags;
    private static WinZonesParseHandler handlerWinZones;
    static PluralsParseHandler handlerPlurals;
    static SupplementalMetadataParseHandler handlerSupplMeta;
    static NumberingSystemsParseHandler handlerNumbering;
    static MetaZonesParseHandler handlerMetaZones;
    static TimeZoneParseHandler handlerTimeZone;
    static DayPeriodRuleParseHandler handlerDayPeriodRule;
    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<>();
    static boolean nonlikelyScript;
    private static final ResourceBundle.Control defCon =
        ResourceBundle.Control.getControl(ResourceBundle.Control.FORMAT_DEFAULT);

    // "likelyScript" map
    private static final Map<String, SortedSet<String>> likelyScriptMap = new HashMap<>();

    private static Set<String> AVAILABLE_TZIDS;
    static int copyrightYear;
    static String jdkHeaderTemplate;
    private static String zoneNameTempFile;
    private static String tzDataDir;
    private static final Map<String, String> canonicalTZMap = new HashMap<>();

    // rules maps
    static Map<String, String> pluralRules;
    static Map<String, String> dayPeriodRules;

    // TZDB maps
    private static final Map<String, String> tzdbShortNamesMap = HashMap.newHashMap(512);
    private static final Map<String, String> tzdbSubstLetters = HashMap.newHashMap(512);
    private static final Map<String, String> tzdbLinks = HashMap.newHashMap(512);

    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 "-year":
                        copyrightYear = Integer.parseInt(args[++i]);
                        break;

                    case "-zntempfile":
                        zoneNameTempFile = args[++i];
                        break;

                    case "-tzdatadir":
                        tzDataDir = args[++i];
                        break;

                    case "-jdk-header-template":
                        jdkHeaderTemplate = Files.readString(Paths.get(args[++i]));
                        break;

                    case "-help":
                        usage();
                        System.exit(0);
                        break;

                    default:
                        throw new RuntimeException();
                    }
                }
            } catch (RuntimeException e) {
                severe("unknown or incomplete 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";
        LOCAL_BCP47_LDML_DTD = CLDR_BASE + "/dtd/ldmlBCP47.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";
        TIMEZONE_SOURCE_FILE = CLDR_BASE + "/bcp47/timezone.xml";
        SPPL_META_SOURCE_FILE = CLDR_BASE + "/supplemental/supplementalMetadata.xml";
        WINZONES_SOURCE_FILE = CLDR_BASE + "/supplemental/windowsZones.xml";
        PLURALS_SOURCE_FILE = CLDR_BASE + "/supplemental/plurals.xml";
        DAYPERIODRULE_SOURCE_FILE = CLDR_BASE + "/supplemental/dayPeriods.xml";
        COVERAGELEVELS_FILE = CLDR_BASE + "/properties/coverageLevels.txt";

        if (BASE_LOCALES.isEmpty()) {
            setupBaseLocales("en-US");
        }

        if (copyrightYear == 0) {
            copyrightYear = ZonedDateTime.now(ZoneId.of("America/Los_Angeles")).getYear();
        }

        bundleGenerator = new ResourceBundleGenerator();

        // Parse data independent of locales
        parseSupplemental();
        parseBCP47();

        // rules maps
        pluralRules = generateRules(handlerPlurals);
        dayPeriodRules = generateRules(handlerDayPeriodRule);

        // TZDB short names map
        generateTZDBShortNamesMap();

        List<Bundle> bundles = readBundleList();
        convertBundles(bundles);

        if (isBaseModule) {
            // Generate java.time.format.ZoneName.java
            generateZoneName();

            // Generate Windows tzmappings
            generateWindowsTZMappings();
        }
    }

    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-year year     copyright year in output%n"
                + "\t-zntempfile    template file for java.time.format.ZoneName.java%n"
                + "\t-tzdatadir     tzdata directory for java.time.format.ZoneName.java%n"
                + "\t-utf8          use UTF-8 rather than \\uxxxx (for debug)%n"
                + "\t-jdk-header-template <file>%n"
                + "\t\t       override default GPL header with contents of file%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);
        var coverageMap = coverageLevelsMap();
        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));
                    List<Locale> candList = getCandidateLocales(cldrLoc);
                    if (!"root".equals(id) && candList.stream().noneMatch(coverageMap::containsKey)) {
                        continue;
                    }
                    StringBuilder sb = getCandLocales(candList);
                    if (sb.indexOf("root") == -1) {
                        sb.append("root");
                    }
                    retList.add(new Bundle(id, sb.toString(), null, null));
                }
            }
        }

        // Sort the bundles based on id. This will make sure all the parent bundles are
        // processed first, e.g., for en_GB bundle, en_001, and "root" comes before
        // en_GB. In order for "root" to come at the beginning, "root" is replaced with
        // empty string on comparison.
        retList.sort((o1, o2) -> {
            String id1 = o1.getID();
            String id2 = o2.getID();
            if(id1.equals("root")) {
                id1 = "";
            }
            if(id2.equals("root")) {
                id2 = "";
            }
            return id1.compareTo(id2);
        });
        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 .....");
        LDMLParseHandler handler = new LDMLParseHandler(id);
        parseLDMLFile(file, handler);

        bundle = handler.getData();
        cldrBundles.put(id, bundle);

        if (id.equals("root")) {
            // Calendar data (firstDayOfWeek & minDaysInFirstWeek)
            bundle = handlerSuppl.getData("root");
            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 SupplementalDataParseHandler();
        parseLDMLFile(new File(SPPL_SOURCE_FILE), handlerSuppl);
        Map<String, Object> parentData = handlerSuppl.getData("root");
        parentData.keySet().stream()
            .filter(key -> key.startsWith(PARENT_LOCALE_PREFIX))
            .forEach(key -> {
                parentLocalesMap.put(key, new TreeSet<String>(
                    Arrays.asList(((String)parentData.get(key)).split(" "))));
            });

        // Parse numberingSystems to get digit zero character information.
        handlerNumbering = new NumberingSystemsParseHandler();
        parseLDMLFile(new File(NUMBERING_SOURCE_FILE), handlerNumbering);

        // Parse metaZones to create mappings between Olson tzids and CLDR meta zone names
        handlerMetaZones = new MetaZonesParseHandler();
        parseLDMLFile(new File(METAZONES_SOURCE_FILE), handlerMetaZones);

        // Parse likelySubtags
        handlerLikelySubtags = new LikelySubtagsParseHandler();
        parseLDMLFile(new File(LIKELYSUBTAGS_SOURCE_FILE), handlerLikelySubtags);
        handlerLikelySubtags.getData().forEach((from, to) -> {
            if (!from.contains("-")) { // look for language-only tag
                var script = to.split("-")[1];
                var key = LIKELY_SCRIPT_PREFIX + script;
                var prev = likelyScriptMap.putIfAbsent(key, new TreeSet<String>(Set.of(from)));
                if (prev != null) {
                    prev.add(from);
                }
            }
        });

        // Parse supplementalMetadata
        // Currently interested in deprecated time zone ids and language aliases.
        handlerSupplMeta = new SupplementalMetadataParseHandler();
        parseLDMLFile(new File(SPPL_META_SOURCE_FILE), handlerSupplMeta);

        // Parse windowsZones
        handlerWinZones = new WinZonesParseHandler();
        parseLDMLFile(new File(WINZONES_SOURCE_FILE), handlerWinZones);

        // Parse plurals
        handlerPlurals = new PluralsParseHandler();
        parseLDMLFile(new File(PLURALS_SOURCE_FILE), handlerPlurals);

        // Parse day period rules
        handlerDayPeriodRule = new DayPeriodRuleParseHandler();
        parseLDMLFile(new File(DAYPERIODRULE_SOURCE_FILE), handlerDayPeriodRule);
    }

    // Parsers for data in "bcp47" directory
    //
    private static void parseBCP47() throws Exception {
        // Parse timezone
        handlerTimeZone = new TimeZoneParseHandler();
        parseLDMLFile(new File(TIMEZONE_SOURCE_FILE), handlerTimeZone);

        // canonical tz name map
        // alias -> primary
        handlerTimeZone.getData().forEach((k, v) -> {
            String[] ids = ((String)v).split("\\s");
            for (int i = 1; i < ids.length; i++) {
                canonicalTZMap.put(ids[i], ids[0]);
            }
        });
    }

    private static void parseLDMLFile(File srcfile, AbstractLDMLHandler<?> handler) throws Exception {
        info("..... Parsing " + srcfile.getName() + " .....");
        SAXParserFactory pf = SAXParserFactory.newInstance();
        pf.setValidating(true);
        SAXParser parser = pf.newSAXParser();
        enableFileAccess(parser);
        parser.parse(srcfile, handler);
    }

    private static StringBuilder getCandLocales(List<Locale> candList) {
        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 {
        var availableLangTags = metaInfo.get("AvailableLocales");

        // parent locales map. The mappings are put in base metaInfo file
        // for now.
        if (isBaseModule) {
            metaInfo.putAll(parentLocalesMap);
            metaInfo.putAll(likelyScriptMap);
        }

        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();
            var id = bundle.getID();

            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, id);
                if (!localeNamesMap.isEmpty() || bundle.isRoot()) {
                    bundleGenerator.generateBundle("util", "LocaleNames", id, true, localeNamesMap, BundleType.OPEN);
                }
            }
            if (bundleTypes.contains(Bundle.Type.CURRENCYNAMES)) {
                Map<String, Object> currencyNamesMap = extractCurrencyNames(targetMap, id, bundle.getCurrencies());
                if (!currencyNamesMap.isEmpty() || bundle.isRoot()) {
                    bundleGenerator.generateBundle("util", "CurrencyNames", id, true, currencyNamesMap, BundleType.OPEN);
                }
            }
            if (bundleTypes.contains(Bundle.Type.TIMEZONENAMES)) {
                Map<String, Object> zoneNamesMap = extractZoneNames(targetMap, id);
                if (!zoneNamesMap.isEmpty() || bundle.isRoot()) {
                    bundleGenerator.generateBundle("util", "TimeZoneNames", id, true, zoneNamesMap, BundleType.TIMEZONE);
                }
            }
            if (bundleTypes.contains(Bundle.Type.CALENDARDATA)) {
                Map<String, Object> calendarDataMap = extractCalendarData(targetMap, id);
                if (!calendarDataMap.isEmpty() || bundle.isRoot()) {
                    bundleGenerator.generateBundle("util", "CalendarData", id, true, calendarDataMap, BundleType.PLAIN);
                }
            }
            if (bundleTypes.contains(Bundle.Type.FORMATDATA)) {
                Map<String, Object> formatDataMap = extractFormatData(targetMap, id);
                if (!formatDataMap.isEmpty() || bundle.isRoot()) {
                    bundleGenerator.generateBundle("text", "FormatData", id, true, formatDataMap, BundleType.PLAIN);
                }
            }

            // For AvailableLocales
            var langTag = toLanguageTag(id);
            availableLangTags.add(langTag);
            addLikelySubtags(langTag);
        }

        // Add extra language tags from likely subtags that meet the following conditions
        // 1. Its likely subtag is supported (already in the available langtag set)
        // 2. Neither of old obsolete ones (in/iw/ji)
        handlerLikelySubtags.getData().entrySet().stream()
            .filter(e -> availableLangTags.contains(e.getValue()))
            .map(Map.Entry::getKey)
            .filter(t -> !t.equals("in") && !t.equals("iw") && !t.equals("ji"))
            .forEach(availableLangTags::add);

        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) {
        for (String key : aliases.keySet()) {
            var sourceKey = aliases.get(key);
            if (key.startsWith("ListPatterns_")) {
                String k;
                while ((k = aliases.get(sourceKey)) != null) {
                    sourceKey = k;
                }
            }
            var source = bundleMap.get(sourceKey);
            if (source != null) {
                if (bundleMap.get(key) instanceof String[] sa) {
                    // fill missing elements in case of String array
                    for (int i = 0; i < sa.length; i++) {
                        if (sa[i] == null && ((String[])source)[i] != null) {
                            sa[i] = ((String[])source)[i];
                        }
                    }
                }
                bundleMap.putIfAbsent(key, source);
            }
        }
    }

    /*
     * Returns the language portion of the given id.
     * If id is "root", "" is returned.
     */
    static String getLanguageCode(String id) {
        return "root".equals(id) ? "" : Locale.forLanguageTag(id.replaceAll("_", "-")).getLanguage();
    }

    /**
     * Examine if the id includes the country (territory) code. If it does, it returns
     * the country code.
     * Otherwise, it returns null. eg. when the id is "zh_Hans_SG", it returns "SG".
     * It does NOT return UN M.49 code, e.g., '001', as those three digit numbers cannot
     * be translated into package names.
     */
    static String getCountryCode(String id) {
        String rgn = getRegionCode(id);
        return rgn.length() == 2 ? rgn: null;
    }

    /**
     * Examine if the id includes the region code. If it does, it returns
     * the region code.
     * Otherwise, it returns null. eg. when the id is "zh_Hans_SG", it returns "SG".
     * It DOES return UN M.49 code, e.g., '001', as well as ISO 3166 two letter country codes.
     */
    static String getRegionCode(String id) {
        return Locale.forLanguageTag(id.replaceAll("_", "-")).getCountry();
    }

    /**
     * Examine if the id includes the script code. If it does, it returns
     * the script code.
     */
    static String getScriptCode(String id) {
        return Locale.forLanguageTag(id.replaceAll("_", "-")).getScript();
    }

    private static class KeyComparator implements Comparator<String> {
        static KeyComparator INSTANCE = new KeyComparator();

        private KeyComparator() {
        }

        @Override
        public int compare(String o1, String o2) {
            int len1 = o1.length();
            int len2 = o2.length();
            if (!isDigit(o1.charAt(0)) && !isDigit(o2.charAt(0))) {
                // Shorter string comes first unless either starts with a digit.
                if (len1 < len2) {
                    return -1;
                }
                if (len1 > len2) {
                    return 1;
                }
            }
            return o1.compareTo(o2);
        }

        private boolean isDigit(char c) {
            return c >= '0' && c <= '9';
        }
    }

    private static Map<String, Object> extractLocaleNames(Map<String, Object> map, String id) {
        Map<String, Object> localeNames = new TreeMap<>(KeyComparator.INSTANCE);
        for (String key : map.keySet()) {
            if (key.startsWith(LOCALE_NAME_PREFIX)) {
                switch (key) {
                    case LOCALE_SEPARATOR:
                        localeNames.put("ListCompositionPattern", map.get(key));
                        break;
                    case LOCALE_KEYTYPE:
                        localeNames.put("ListKeyTypePattern", map.get(key));
                        break;
                    default:
                        localeNames.put(key.substring(LOCALE_NAME_PREFIX.length()), map.get(key));
                        break;
                }
            }
        }

        if (id.equals("root")) {
            // Add display name pattern, which is not in CLDR
            localeNames.put("DisplayNamePattern", "{0,choice,0#|1#{1}|2#{1} ({2})}");
        }

        return localeNames;
    }

    @SuppressWarnings("AssignmentToForLoopParameter")
    private static Map<String, Object> extractCurrencyNames(Map<String, Object> map, String id, String names)
            throws Exception {
        Map<String, Object> currencyNames = new TreeMap<>(KeyComparator.INSTANCE);
        for (String key : map.keySet()) {
            if (key.startsWith(CURRENCY_NAME_PREFIX)) {
                currencyNames.put(key.substring(CURRENCY_NAME_PREFIX.length()), map.get(key));
            } else if (key.startsWith(CURRENCY_SYMBOL_PREFIX)) {
                currencyNames.put(key.substring(CURRENCY_SYMBOL_PREFIX.length()), map.get(key));
            }
        }
        return currencyNames;
    }

    private static Map<String, Object> extractZoneNames(Map<String, Object> map, String id) {
        Map<String, Object> names = new TreeMap<>(KeyComparator.INSTANCE);
        var availableIds = getAvailableZoneIds();

        availableIds.forEach(tzid -> {
            // If the tzid is deprecated, get the data for the replacement id
            String tzKey = Optional.ofNullable((String)handlerSupplMeta.get(tzid))
                                   .orElse(tzid);
            // Follow link, if needed
            String tzLink = getTZDBLink(tzKey);
            if (tzLink == null && tzdbLinks.containsValue(tzKey)) {
                // reverse link search
                // this is needed as in tzdb, "America/Buenos_Aires" links to
                // "America/Argentina/Buenos_Aires", but CLDR contains metaZone
                // "Argentina" only for "America/Buenos_Aires" (as of CLDR 44)
                // Both tzids should have "Argentina" meta zone names
                tzLink = tzdbLinks.entrySet().stream()
                        .filter(e -> e.getValue().equals(tzKey))
                        .map(Map.Entry::getKey)
                        .findAny()
                        .orElse(null);

            }
            Object data = map.get(TIMEZONE_ID_PREFIX + tzKey);
            if (data == null && tzLink != null) {
                // data for tzLink
                data = map.get(TIMEZONE_ID_PREFIX + tzLink);
            }

            String meta = handlerMetaZones.get(tzKey);
            if (meta == null && tzLink != null) {
                // Check for tzLink
                meta = handlerMetaZones.get(tzLink);
            }
            String metaKey = meta != null ? METAZONE_ID_PREFIX + meta : null;

            if (data instanceof String[] tznames) {
                // Hack for UTC. UTC is an alias to Etc/UTC in CLDR
                if (tzid.equals("Etc/UTC") && !map.containsKey(TIMEZONE_ID_PREFIX + "UTC")) {
                    names.put(METAZONE_ID_PREFIX + META_ETCUTC_ZONE_NAME, tznames);
                    names.put(tzid, META_ETCUTC_ZONE_NAME);
                    names.put("UTC", META_ETCUTC_ZONE_NAME);
                } else {
                    // TZDB short names
                    tznames = Arrays.copyOf(tznames, tznames.length);
                    fillTZDBShortNames(tzKey, tznames);
                    names.put(tzid, tznames);
                    if (meta != null && map.get(metaKey) instanceof String[] metaNames) {
                        recordMetazone(names, meta, tzKey, metaNames);
                    }
                }
            } else {
                if (meta != null) {
                    if (map.get(metaKey) instanceof String[] metaNames) {
                        recordMetazone(names, meta, tzKey, metaNames);
                        names.put(tzid, meta);
                        if (tzLink != null && availableIds.contains(tzLink)) {
                            names.put(tzLink, meta);
                        }
                    }
                } else if (id.equals("root")) {
                    // supply TZDB short names if available
                    if (tzdbShortNamesMap.containsKey(tzid)) {
                        var tznames = new String[6];
                        fillTZDBShortNames(tzid, tznames);
                        names.put(tzid, tznames);
                    }
                }
            }
        });

        // exemplar cities.
        Map<String, Object> exCities = map.entrySet().stream()
            .filter(e -> e.getKey().startsWith(CLDRConverter.EXEMPLAR_CITY_PREFIX))
            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
        names.putAll(exCities);

        // If there's no UTC entry at this point, add an empty one
        if (!names.isEmpty() && !names.containsKey("UTC")) {
            names.putIfAbsent(METAZONE_ID_PREFIX + META_EMPTY_ZONE_NAME, EMPTY_ZONE);
            names.put("UTC", META_EMPTY_ZONE_NAME);
        }

        // Finally some compatibility stuff
        ZoneId.SHORT_IDS.entrySet().stream()
            .filter(e -> !names.containsKey(e.getKey()) && names.containsKey(e.getValue()))
            .forEach(e -> {
                names.put(e.getKey(), names.get(e.getValue()));
            });

        return names;
    }

    /**
     * Extracts the language independent calendar data. Each of the two keys,
     * "firstDayOfWeek" and "minimalDaysInFirstWeek" has a string value consists of
     * one or multiple occurrences of:
     *  i: rg1 rg2 ... rgn;
     * where "i" is the data for the following regions (delimited by a space) after
     * ":", and ends with a ";".
     */
    private static Map<String, Object> extractCalendarData(Map<String, Object> map, String id) {
        Map<String, Object> calendarData = new LinkedHashMap<>();
        if (id.equals("root")) {
            calendarData.put("firstDayOfWeek",
                IntStream.range(1, 8)
                    .mapToObj(String::valueOf)
                    .filter(d -> map.keySet().contains(CALENDAR_FIRSTDAY_PREFIX + d))
                    .map(d -> d + ": " + map.get(CALENDAR_FIRSTDAY_PREFIX + d))
                    .collect(Collectors.joining(";")));
            calendarData.put("minimalDaysInFirstWeek",
                IntStream.range(0, 7)
                    .mapToObj(String::valueOf)
                    .filter(d -> map.keySet().contains(CALENDAR_MINDAYS_PREFIX + d))
                    .map(d -> d + ": " + map.get(CALENDAR_MINDAYS_PREFIX + d))
                    .collect(Collectors.joining(";")));
        }
        return calendarData;
    }

    static final String[] FORMAT_DATA_ELEMENTS = {
        "MonthNames",
        "standalone.MonthNames",
        "MonthAbbreviations",
        "standalone.MonthAbbreviations",
        "MonthNarrows",
        "standalone.MonthNarrows",
        "DayNames",
        "standalone.DayNames",
        "DayAbbreviations",
        "standalone.DayAbbreviations",
        "DayNarrows",
        "standalone.DayNarrows",
        "QuarterNames",
        "standalone.QuarterNames",
        "QuarterAbbreviations",
        "standalone.QuarterAbbreviations",
        "QuarterNarrows",
        "standalone.QuarterNarrows",
        "AmPmMarkers",
        "narrow.AmPmMarkers",
        "abbreviated.AmPmMarkers",
        "long.Eras",
        "Eras",
        "narrow.Eras",
        "field.era",
        "field.year",
        "field.month",
        "field.week",
        "field.weekday",
        "field.dayperiod",
        "field.hour",
        "timezone.hourFormat",
        "timezone.gmtFormat",
        "timezone.gmtZeroFormat",
        "timezone.regionFormat",
        "timezone.regionFormat.daylight",
        "timezone.regionFormat.standard",
        "field.minute",
        "field.second",
        "field.zone",
        "TimePatterns",
        "DatePatterns",
        "DateTimePatterns",
        "DateTimePatternChars",
        "PluralRules",
        "DayPeriodRules",
        "DateFormatItemInputRegions.allowed",
        "DateFormatItemInputRegions.preferred",
        "ListPatterns",
    };

    static final Set<String> availableSkeletons = new HashSet<>();

    private static Map<String, Object> extractFormatData(Map<String, Object> map, String id) {
        Map<String, Object> formatData = new LinkedHashMap<>();
        for (CalendarType calendarType : CalendarType.values()) {
            String prefix = calendarType.keyElementName();
            Arrays.stream(FORMAT_DATA_ELEMENTS)
                .forEach(elem -> {
                    var key = prefix + elem;
                    copyIfPresent(map, "java.time." + key, formatData);
                    copyIfPresent(map, key, formatData);
                });
            availableSkeletons.forEach(s ->
                copyIfPresent(map, prefix + "DateFormatItem." + s, formatData));
        }

        for (String key : map.keySet()) {
            // Copy available calendar names
            if (key.startsWith(CLDRConverter.LOCALE_TYPE_PREFIX_CA)) {
                String type = key.substring(CLDRConverter.LOCALE_TYPE_PREFIX_CA.length());
                for (CalendarType calendarType : CalendarType.values()) {
                    if (type.equals(calendarType.lname())) {
                        Object value = map.get(key);
                        String dataKey = key.replace(LOCALE_TYPE_PREFIX_CA,
                                CALENDAR_NAME_PREFIX);
                        formatData.put(dataKey, value);
                        String ukey = CALENDAR_NAME_PREFIX + calendarType.uname();
                        if (!dataKey.equals(ukey)) {
                            formatData.put(ukey, value);
                        }
                    }
                }
            }
        }

        copyIfPresent(map, "DefaultNumberingSystem", formatData);

        @SuppressWarnings("unchecked")
        List<String> numberingScripts = (List<String>) map.remove("numberingScripts");
        if (numberingScripts != null) {
            for (String script : numberingScripts) {
                copyIfPresent(map, script + ".NumberElements", formatData);
                copyIfPresent(map, script + ".NumberPatterns", formatData);
            }
        } else {
            copyIfPresent(map, "NumberElements", formatData);
            copyIfPresent(map, "NumberPatterns", formatData);
        }
        copyIfPresent(map, "short.CompactNumberPatterns", formatData);
        copyIfPresent(map, "long.CompactNumberPatterns", formatData);

        // put extra number elements for available scripts into formatData, if it is "root"
        if (id.equals("root")) {
            handlerNumbering.keySet().stream()
                .filter(k -> !numberingScripts.contains(k))
                .forEach(k -> {
                    String[] ne = (String[])map.get("latn.NumberElements");
                    String[] neNew = Arrays.copyOf(ne, ne.length);
                    neNew[4] = handlerNumbering.get(k).substring(0, 1);
                    formatData.put(k + ".NumberElements", neNew);
                });
        }

        // ListPatterns
        for (var lpKey : Bundle.LIST_PATTERN_KEYS) {
            copyIfPresent(map, lpKey, formatData);
            copyIfPresent(map, lpKey + "-short", formatData);
            copyIfPresent(map, lpKey + "-narrow", formatData);
        }

        return formatData;
    }

    private static void copyIfPresent(Map<String, Object> src, String key, Map<String, Object> dest) {
        Object value = src.get(key);
        if (value != null) {
            dest.put(key, value);
        }
    }

    // --- code below here is adapted from java.util.Properties ---
    private static final String specialSaveCharsJava = "\"";
    private static final String specialSaveCharsProperties = "=: \t\r\n\f#!";

    /*
     * Converts unicodes to encoded &#92;uxxxx
     * and writes out any of the characters in specialSaveChars
     * with a preceding slash
     */
    static String saveConvert(String theString, boolean useJava) {
        if (theString == null) {
            return "";
        }

        String specialSaveChars;
        if (useJava) {
            specialSaveChars = specialSaveCharsJava;
        } else {
            specialSaveChars = specialSaveCharsProperties;
        }
        boolean escapeSpace = false;

        int len = theString.length();
        StringBuilder outBuffer = new StringBuilder(len * 2);
        Formatter formatter = new Formatter(outBuffer, Locale.ROOT);

        for (int x = 0; x < len; x++) {
            char aChar = theString.charAt(x);
            switch (aChar) {
            case ' ':
                if (x == 0 || escapeSpace) {
                    outBuffer.append('\\');
                }
                outBuffer.append(' ');
                break;
            case '\\':
                outBuffer.append('\\');
                outBuffer.append('\\');
                break;
            case '\t':
                outBuffer.append('\\');
                outBuffer.append('t');
                break;
            case '\n':
                outBuffer.append('\\');
                outBuffer.append('n');
                break;
            case '\r':
                outBuffer.append('\\');
                outBuffer.append('r');
                break;
            case '\f':
                outBuffer.append('\\');
                outBuffer.append('f');
                break;
            default:
                if (aChar < 0x0020 || (!USE_UTF8 && aChar > 0x007e)) {
                    formatter.format("\\u%04x", (int)aChar);
                } else {
                    if (specialSaveChars.indexOf(aChar) != -1) {
                        outBuffer.append('\\');
                    }
                    outBuffer.append(aChar);
                }
            }
        }
        return outBuffer.toString();
    }

    static String toLanguageTag(String locName) {
        if (locName.indexOf('_') == -1) {
            return locName;
        }
        String tag = locName.replaceAll("_", "-");
        Locale loc = Locale.forLanguageTag(tag);
        return loc.toLanguageTag();
    }

    private static void addLikelySubtags(String langTag) {
        String likelySubtag = handlerLikelySubtags.get(langTag);
        if (likelySubtag != null) {
            var availableLangTags = metaInfo.get("AvailableLocales");
            availableLangTags.add(likelySubtag.replaceFirst("-[A-Z][a-z]{3}", ""));
            availableLangTags.add(likelySubtag);
        }
    }

    private static String toLocaleName(String tag) {
        if (tag.indexOf('-') == -1) {
            return tag;
        }
        return tag.replaceAll("-", "_");
    }

    private static void setupBaseLocales(String localeList) {
        Arrays.stream(localeList.split(","))
            .map(Locale::forLanguageTag)
            .map(l -> new Locale.Builder().setLocale(l).setScript("Latn").build())
            .map(l -> Control.getControl(Control.FORMAT_DEFAULT)
                             .getCandidateLocales("", l))
            .forEach(BASE_LOCALES::addAll);
    }

    // applying parent locale rules to the passed candidates list
    // This has to match with the one in sun.util.cldr.CLDRLocaleProviderAdapter
    private static Map<Locale, Locale> childToParentLocaleMap = null;
    private static List<Locale> applyParentLocales(String baseName, List<Locale> candidates) {
        if (Objects.isNull(childToParentLocaleMap)) {
            childToParentLocaleMap = new HashMap<>();
            parentLocalesMap.keySet().forEach(key -> {
                String parent = key.substring(PARENT_LOCALE_PREFIX.length()).replaceAll("_", "-");
                parentLocalesMap.get(key).stream().forEach(child -> {
                    childToParentLocaleMap.put(Locale.forLanguageTag(child),
                        "root".equals(parent) ? Locale.ROOT : Locale.forLanguageTag(parent));
                });
            });
        }

        // check irregular parents
        for (int i = 0; i < candidates.size(); i++) {
            Locale l = candidates.get(i);
            Locale p = getParentLocale(l);
            if (!l.equals(Locale.ROOT) &&
                Objects.nonNull(p) &&
                !candidates.get(i+1).equals(p)) {
                List<Locale> applied = candidates.subList(0, i+1);
                if (applied.contains(p)) {
                    // avoid circular recursion (could happen with nb/no case)
                    continue;
                }
                applied.addAll(applyParentLocales(baseName, defCon.getCandidateLocales(baseName, p)));
                return applied;
            }
        }

        return candidates;
    }

    private static Locale getParentLocale(Locale child) {
        Locale parent = childToParentLocaleMap.get(child);

        // check non-likely script for root
        if (nonlikelyScript && parent == null && child.getCountry().isEmpty()) {
            var lang = " " + child.getLanguage() + " ";
            var script = child.getScript();

            if (!script.isEmpty()) {
                parent = likelyScriptMap.entrySet().stream()
                    .filter(e -> e.getValue().contains(lang))
                    .findAny()
                    .map(Map.Entry::getKey)
                    .map(likely -> likely.equals(script) ? null : Locale.ROOT)
                    .orElse(null);
            }
        }

        return parent;
    }

    private static void generateZoneName() throws Exception {
        Files.createDirectories(Paths.get(DESTINATION_DIR, "java", "time", "format"));
        Files.write(Paths.get(DESTINATION_DIR, "java", "time", "format", "ZoneName.java"),
            Files.lines(Paths.get(zoneNameTempFile))
                .flatMap(l -> {
                    if (l.equals("%%%%ZIDMAP%%%%")) {
                        return zidMapEntry();
                    } else if (l.equals("%%%%MZONEMAP%%%%")) {
                        return handlerMetaZones.mzoneMapEntry();
                    } else if (l.equals("%%%%DEPRECATED%%%%")) {
                        return handlerSupplMeta.deprecatedMap();
                    } else if (l.equals("%%%%TZDATALINK%%%%")) {
                        return tzDataLinkEntry();
                    } else {
                        return Stream.of(l);
                    }
                })
                .collect(Collectors.toList()),
            StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING);
    }

    // This method assumes handlerMetaZones is already initialized
    private static Set<String> getAvailableZoneIds() {
        assert handlerMetaZones != null;
        if (AVAILABLE_TZIDS == null) {
            AVAILABLE_TZIDS = new HashSet<>(Arrays.asList(TimeZone.getAvailableIDs()));
            AVAILABLE_TZIDS.addAll(handlerMetaZones.keySet());
            AVAILABLE_TZIDS.remove(MetaZonesParseHandler.NO_METAZONE_KEY);
        }

        return AVAILABLE_TZIDS;
    }

    private static Stream<String> zidMapEntry() {
        return getAvailableZoneIds().stream()
                .map(id -> {
                    String canonId = canonicalTZMap.getOrDefault(id, id);
                    String meta = handlerMetaZones.get(canonId);
                    String zone001 = handlerMetaZones.zidMap().get(meta);
                    return zone001 == null ? "" :
                            String.format("        \"%s\", \"%s\", \"%s\",",
                                            id, meta, zone001);
                })
                .filter(s -> !s.isEmpty())
                .sorted();
    }

    private static Stream<String> tzDataLinkEntry() {
        try {
            return Files.walk(Paths.get(tzDataDir), 1)
                .filter(p -> p.toFile().isFile())
                .filter(p -> p.getFileName().toString().matches("africa|antarctica|asia|australasia|backward|etcetera|europe|northamerica|southamerica"))
                .flatMap(CLDRConverter::extractLinks)
                .sorted();
        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
    }

    private static Stream<String> extractLinks(Path tzFile) {
        try {
            return Files.lines(tzFile)
                .filter(l -> l.startsWith("Link"))
                .map(l -> l.replaceFirst("^Link[\\s]+(\\S+)\\s+(\\S+).*",
                                         "        \"$2\", \"$1\","));
        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
    }

    // Generate tzmappings for Windows. The format is:
    //
    // (Windows Zone Name):(REGION):(Java TZID)
    //
    // where:
    //   Windows Zone Name: arbitrary time zone name string used in Windows
    //   REGION: ISO3166 or UN M.49 code
    //   Java TZID: Java's time zone ID
    //
    // Note: the entries are alphabetically sorted, *except* the "world" region
    // code, i.e., "001". It should be the last entry for the same windows time
    // zone name entries. (cf. TimeZone_md.c)
    //
    // The default entries from CLDR's windowsZones.xml file can be modified
    // with <tzDataDir>/tzmappings.override where mapping overrides
    // can be specified.
    private static Pattern OVERRIDE_PATTERN = Pattern.compile("(?<win>([^:]+:[^:]+)):(?<java>[^:]+):");
    private static void generateWindowsTZMappings() throws Exception {
        Files.createDirectories(Paths.get(DESTINATION_DIR, "windows", "conf"));
        var override = Path.of(tzDataDir, "tzmappings.override");
        if (override.toFile().exists()) {
            Files.readAllLines(override).stream()
                .map(String::trim)
                .filter(o -> !o.isBlank() && !o.startsWith("#"))
                .forEach(o -> {
                    var m = OVERRIDE_PATTERN.matcher(o);
                    if (m.matches()) {
                        handlerWinZones.put(m.group("win"), m.group("java"));
                    } else {
                        System.out.printf("Unrecognized tzmappings override: %s. Ignored%n", o);
                    }
                });
        }
        Files.write(Paths.get(DESTINATION_DIR, "windows", "conf", "tzmappings"),
            handlerWinZones.keySet().stream()
                .filter(k -> k.endsWith(":001") ||
                             !handlerWinZones.get(k).equals(handlerWinZones.get(k.replaceFirst(":\\w{2,3}$", ":001"))))
                .map(k -> k + ":" + handlerWinZones.get(k) + ":")
                .sorted(new Comparator<String>() {
                    public int compare(String t1, String t2) {
                        String[] s1 = t1.split(":");
                        String[] s2 = t2.split(":");
                        if (s1[0].equals(s2[0])) {
                            if (s1[1].equals("001")) {
                                return 1;
                            } else if (s2[1].equals("001")) {
                                return -1;
                            } else {
                                return s1[1].compareTo(s2[1]);
                            }
                        } else {
                            return s1[0].compareTo(s2[0]);
                        }
                    }
                })
                .collect(Collectors.toList()),
            StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING);
    }

    /**
     * Generates rules map for Plural rules and DayPeriod rules. The key is the locale id,
     * and the value is rules, defined by the LDML spec. Each rule consists of {@code type:rule}
     * notation, concatenated with a ";" as a delimiter.
     * @param handler handler containing rules
     * @return the map
     */
    private static Map<String, String> generateRules(AbstractLDMLHandler<Map<String, String>> handler) {
        return handler.getData().entrySet().stream()
            .collect(Collectors.toMap(Map.Entry::getKey, e -> {
                Map<String, String> rules = e.getValue();
                return rules.entrySet().stream()
                    .map(rule -> rule.getKey() + ":" + rule.getValue().replaceFirst("@.*", ""))
                    .map(String::trim)
                    .collect(Collectors.joining(";"));
            }));
    }

    private static Map<Locale, String> coverageLevelsMap() throws Exception {
        // First, parse `coverageLevels.txt` file
        var covMap = Files.readAllLines(Path.of(COVERAGELEVELS_FILE)).stream()
            .filter(line -> !line.isBlank() && !line.startsWith("#"))
            .map(line -> line.split("[\s\t]*;[\s\t]*", 3))
            .filter(a -> a[1].matches("basic|moderate|modern|comprehensive"))
            .collect(Collectors.toMap(
                    a -> Locale.forLanguageTag(a[0].replaceAll("_", "-")),
                    a -> a[1],
                    (v1, v2) -> v2, // should never happen
                    HashMap::new));

        // Add other common (non-seed) locales (below `basic` coverage level) as of v42
        ResourceBundle.getBundle(CLDRConverter.class.getPackageName() + ".OtherCommonLocales")
            .keySet()
            .forEach(k -> covMap.put(Locale.forLanguageTag(k), ""));

        return covMap;
    }

    /*
     * Generates three maps from TZ database files, where they have usual abbreviation
     * of the time zone names as "FORMAT".
     *
     * `tzdbShortNamesMap` maps the time zone id, such as "America/Los_Angeles" to
     * its FORMAT and Rule which determines the substitution. In "America/Los_Angeles"
     * case, its FORMAT is "P%sT" and the Rule is "US". They are concatenated with
     * an NBSP, so the eventual mapping will be:
     *
     * "America/Los_Angeles" -> "P%sT<NBSP>US"
     *
     * The map, `tzdbSubstLetters` maps the Rule to its substitution letters.
     * The key of the map is the Rule name, appended with "<NBSP>std" or "<NBSP>dst"
     * depending on the savings, e.g.,
     *
     * "US<NBSP>std" -> "S"
     * "US<NBSP>dst" -> "D"
     *
     * These mappings resolve the short names for time zones in each type,
     * such as:
     *
     * Standard short name for "America/Los_Angeles" -> "PST"
     * DST short name for "America/Los_Angeles" -> "PDT"
     * Generic short name for "America/Los_Angeles" -> "PT"
     *
     * The map, `tzdbLinks` retains `Link`s of time zones. For example,
     * the mapping:
     *
     * "US/Hawaii" -> "Pacific/Honolulu"
     *
     * resolves names for "US/Hawaii" correctly with "Pacific/Honolulu"
     * names.
     */
    private static void generateTZDBShortNamesMap() throws IOException {
        Files.walk(Path.of(tzDataDir), 1, FileVisitOption.FOLLOW_LINKS)
            .filter(p -> p.toFile().isFile())
            .filter(p -> p.getFileName().toString().matches("africa|antarctica|asia|australasia|backward|etcetera|europe|northamerica|southamerica"))
            .forEach(p -> {
                try {
                    String zone = null;
                    String rule = null;
                    String format = null;
                    boolean inVanguard = false;
                    for (var line : Files.readAllLines(p)) {
                        // check for Vanguard lines
                        if (line.startsWith("# Vanguard section")) {
                            inVanguard = true;
                            continue;
                        }
                        if (inVanguard && line.startsWith("# Rearguard section")) {
                            inVanguard = false;
                            continue;
                        }
                        if (line.isBlank() || line.matches("^[ \t]*#.*")) {
                            // ignore blank/comment lines
                            continue;
                        }
                        // remove comments in-line
                        line = line.replaceAll("[ \t]*#.*", "");
                        var tokens = line.split("[ \t]+", -1);
                        var token0len = tokens.length > 0 ? tokens[0].length() : 0;
                        // Zone line
                        if (token0len > 0 && tokens[0].regionMatches(true, 0, "Zone", 0, token0len)) {
                            if (zone != null) {
                                tzdbShortNamesMap.put(zone, format + NBSP + rule);
                            }
                            zone = tokens[1];
                            rule = tokens[3];
                            format = flipIfNeeded(inVanguard, tokens[4]);
                        } else {
                            if (zone != null) {
                                if (token0len > 0 &&
                                   (tokens[0].regionMatches(true, 0, "Rule", 0, token0len) ||
                                    tokens[0].regionMatches(true, 0, "Link", 0, token0len))) {
                                    tzdbShortNamesMap.put(zone, format + NBSP + rule);
                                    zone = null;
                                    rule = null;
                                    format = null;
                                } else {
                                    rule = tokens[2];
                                    format = flipIfNeeded(inVanguard, tokens[3]);
                                }
                            }
                        }

                        // Rule line
                        if (token0len > 0 && tokens[0].regionMatches(true, 0, "Rule", 0, token0len)) {
                            tzdbSubstLetters.put(tokens[1] + NBSP + (tokens[8].equals("0") ? STD : DST),
                                    tokens[9].replace(NO_SUBST, ""));
                        }

                        // Link line
                        if (token0len > 0 && tokens[0].regionMatches(true, 0, "Link", 0, token0len)) {
                            tzdbLinks.put(tokens[2], tokens[1]);
                        }
                    }

                    // Last entry
                    if (zone != null) {
                        tzdbShortNamesMap.put(zone, format + NBSP + rule);
                    }
                } catch (IOException ioe) {
                    throw new UncheckedIOException(ioe);
                }
            });
    }

    // Reverse the std/dst FORMAT in Vanguard so that it
    // correctly handles negative DST cases, such as "GMT/IST"
    // vs. "IST/GMT" case for Europe/Dublin
    private static String flipIfNeeded(boolean inVanguard, String format) {
        if (inVanguard) {
            var stddst = format.split("/");
            if (stddst.length == 2) {
                return stddst[1] + "/" + stddst[0];
            }
        }
        return format;
    }

    /*
     * Fill the TZDB short names if there is no name provided by the CLDR
     */
    private static void fillTZDBShortNames(String tzid, String[] names) {
        var val = tzdbShortNamesMap.getOrDefault(tzid, tzdbShortNamesMap.get(getTZDBLink(tzid)));
        if (val != null) {
            var format = val.split(NBSP)[0];
            var rule = val.split(NBSP)[1];
            IntStream.of(1, 3, 5).forEach(i -> {
                if (names[i] == null || names[i].isEmpty()) {
                    if (format.contains("%s")) {
                        names[i] = switch (i) {
                            case 1 -> format.formatted(tzdbSubstLetters.get(rule + NBSP + STD));
                            case 3 -> format.formatted(tzdbSubstLetters.get(rule + NBSP + DST));
                            case 5 -> format.formatted("");
                            default -> throw new InternalError();
                        };
                    } else if (format.contains("/")) { // such as "+08/+09" or "GMT/BST"
                        names[i] = switch (i) {
                            case 1, 5 -> convertGMTName(format.substring(0, format.indexOf("/")));
                            case 3 -> convertGMTName(format.substring(format.indexOf("/") + 1));
                            default -> throw new InternalError();
                        };
                    } else {
                        names[i] = convertGMTName(format);
                    }
                }
            });
        }
    }

    private static void recordMetazone(Map<String, Object> names, String meta, String tzid, String[] tznames) {
        String zone001 = handlerMetaZones.zidMap().get(meta);
        var tzLink = getTZDBLink(tzid);

        // Record the metazone names only from the default
        // (001) zone, with short names filled from TZDB
        if (canonicalTZMap.getOrDefault(tzid, tzid).equals(zone001) ||
            tzLink != null && canonicalTZMap.getOrDefault(tzLink, tzLink).equals(zone001)) {
            tznames = Arrays.copyOf(tznames, tznames.length);
            fillTZDBShortNames(tzid, tznames);
            names.put(METAZONE_ID_PREFIX + meta, tznames);
        }
    }

    private static String getTZDBLink(String tzid) {
        String tzLink = null;
        for (var k = tzid; tzdbLinks.containsKey(k);) {
            k = tzLink = tzdbLinks.get(k);
        }
        return tzLink;
    }

    /*
     * Convert TZDB offsets to JDK's offsets, eg, "-08" to "GMT-08:00".
     * If it cannot recognize the pattern, return the argument as is.
     * Returning null results in generating the GMT format at runtime.
     */
    private static String convertGMTName(String f) {
        try {
            if (!f.equals("%z")) {
                // Validate if the format is an offset
                ZoneOffset.of(f);
            }
            return null;
        } catch (DateTimeException dte) {
            // textual representation. return as is
        }
        return f;
    }

    // for debug
    static void dumpMap(Map<String, Object> map) {
        map.entrySet().stream()
            .sorted(Map.Entry.comparingByKey())
            .map(e -> {
                Object val = e.getValue();
                String valStr = null;

                if (val instanceof String[]) {
                    valStr = Arrays.asList((String[])val).toString();
                } else if (val != null) {
                    valStr = val.toString();
                }
                return e.getKey() + " = " + valStr;
            })
            .forEach(System.out::println);
    }
}
