/*

 * Copyright (c) 2014, 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.tzdb;

import java.io.IOException;

import java.nio.charset.StandardCharsets;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import java.util.NavigableMap;

import java.util.Objects;

import java.util.Set;

import java.util.TreeMap;

import java.util.TreeSet;

import java.util.concurrent.ConcurrentHashMap;

import java.time.*;

import java.time.Year;

import java.time.chrono.IsoChronology;

import java.time.temporal.TemporalAdjusters;

import java.time.zone.ZoneOffsetTransition;

import java.time.zone.ZoneOffsetTransitionRule;

import java.time.zone.ZoneOffsetTransitionRule.TimeDefinition;

import java.time.zone.ZoneRulesException;

/**

 * Compile and build time-zone rules from IANA timezone data

 *

 * @author Xueming Shen

 * @author Stephen Colebourne

 * @author Michael Nascimento Santos

 *

 * @since   9

 */

class TzdbZoneRulesProvider {

    /**

     * Creates an instance.

     *

     * @throws ZoneRulesException if unable to load

     */

    public TzdbZoneRulesProvider(List<Path> files) {

        try {

             load(files);

        } catch (Exception ex) {

            throw new ZoneRulesException("Unable to load TZDB time-zone rules", ex);

        }

    }

    public Set<String> getZoneIds() {

        return new TreeSet(regionIds);

    }

    public Map<String, String> getAliasMap() {

        return links;

    }

    public ZoneRules getZoneRules(String zoneId) {

        Object obj = zones.get(zoneId);

        if (obj == null) {

            String zoneId0 = zoneId;

            if (links.containsKey(zoneId)) {

                zoneId = links.get(zoneId);

                obj = zones.get(zoneId);

            }

            if (obj == null) {

                // Timezone link can be located in 'backward' file and it

                // can refer to another link, so we need to check for

                // link one more time, before throwing an exception

                String zoneIdBack = zoneId;

                if (links.containsKey(zoneId)) {

                    zoneId = links.get(zoneId);

                    obj = zones.get(zoneId);

                }

                if (obj == null) {

                    throw new ZoneRulesException("Unknown time-zone ID: " + zoneIdBack);

                }

            }

        }

        if (obj instanceof ZoneRules) {

            return (ZoneRules)obj;

        }

        try {

            ZoneRules zrules = buildRules(zoneId, (List<ZoneLine>)obj);

            zones.put(zoneId, zrules);

            return zrules;

        } catch (Exception ex) {

            throw new ZoneRulesException(

                "Invalid binary time-zone data: TZDB:" + zoneId, ex);

        }

    }

    //////////////////////////////////////////////////////////////////////

    /**

     * All the regions that are available.

     */

    private List<String> regionIds = new ArrayList<>(600);

    /**

     * Zone region to rules mapping

     */

    private final Map<String, Object> zones = new ConcurrentHashMap<>();

    /**

     * compatibility list

     */

    private static HashSet<String> excludedZones;

    static {

        // (1) exclude EST, HST and MST. They are supported

        //     via the short-id mapping

        // (2) remove UTC and GMT

        // (3) remove ROC, which is not supported in j.u.tz

        excludedZones = new HashSet<>(10);

        excludedZones.add("EST");

        excludedZones.add("HST");

        excludedZones.add("MST");

        excludedZones.add("GMT+0");

        excludedZones.add("GMT-0");

        excludedZones.add("ROC");

    }

    private Map<String, String> links = new HashMap<>(150);

    private Map<String, List<RuleLine>> rules = new HashMap<>(500);

    private void load(List<Path> files) throws IOException {

        for (Path file : files) {

            List<ZoneLine> openZone = null;

            try {

                for (String line : Files.readAllLines(file, StandardCharsets.ISO_8859_1)) {

                    if (line.length() == 0 || line.charAt(0) == '#') {

                        continue;

                    }

                    //StringIterator itr = new StringIterator(line);

                    String[] tokens = split(line);

                    if (openZone != null &&               // continuing zone line

                        Character.isWhitespace(line.charAt(0)) &&

                        tokens.length > 0) {

                        ZoneLine zLine = new ZoneLine();

                        openZone.add(zLine);

                        if (zLine.parse(tokens, 0)) {

                            openZone = null;

                        }

                        continue;

                    }

                    if (line.startsWith("Zone")) {        // parse Zone line

                        String name = tokens[1];

                        if (excludedZones.contains(name)){

                            continue;

                        }

                        if (zones.containsKey(name)) {

                            throw new IllegalArgumentException(

                                "Duplicated zone name in file: " + name +

                                ", line: [" + line + "]");

                        }

                        openZone = new ArrayList<>(10);

                        zones.put(name, openZone);

                        regionIds.add(name);

                        ZoneLine zLine = new ZoneLine();

                        openZone.add(zLine);

                        if (zLine.parse(tokens, 2)) {

                            openZone = null;

                        }

                    } else if (line.startsWith("Rule")) { // parse Rule line

                        String name = tokens[1];

                        if (!rules.containsKey(name)) {

                            rules.put(name, new ArrayList<RuleLine>(10));

                        }

                        rules.get(name).add(new RuleLine().parse(tokens));

                    } else if (line.startsWith("Link")) { // parse link line

                        if (tokens.length >= 3) {

                            String realId = tokens[1];

                            String aliasId = tokens[2];

                            if (excludedZones.contains(aliasId)){

                                continue;

                            }

                            links.put(aliasId, realId);

                            regionIds.add(aliasId);

                        } else {

                            throw new IllegalArgumentException(

                                "Invalid Link line in file" +

                                file + ", line: [" + line + "]");

                        }

                    } else {

                        // skip unknown line

                    }

                }

            } catch (Exception ex) {

                throw new RuntimeException("Failed while processing file [" + file +

                                           "]", ex);

            }

        }

    }

    private String[] split(String str) {

        int off = 0;

        int end = str.length();

        ArrayList<String> list = new ArrayList<>(10);

        while (off < end) {

            char c = str.charAt(off);

            if (c == '\t' || c == ' ') {

                off++;

                continue;

            }

            if (c == '#') {    // comment

                break;

            }

            int start = off;

            while (off < end) {

                c = str.charAt(off);

                if (c == ' ' || c == '\t') {

                    break;

                }

                off++;

            }

            if (start != off) {

                list.add(str.substring(start, off));

            }

        }

        return list.toArray(new String[list.size()]);

    }

    /**

     * Class representing a month-day-time in the TZDB file.

     */

    private static abstract class MonthDayTime {

        /** The month of the cutover. */

        Month month = Month.JANUARY;

        /** The day-of-month of the cutover. */

        int dayOfMonth = 1;

        /** Whether to adjust forwards. */

        boolean adjustForwards = true;

        /** The day-of-week of the cutover. */

        DayOfWeek dayOfWeek;

        /** The time of the cutover, in second of day */

        int secsOfDay = 0;

        /** Whether this is midnight end of day. */

        boolean endOfDay;

        /** The time of the cutover. */

        TimeDefinition timeDefinition = TimeDefinition.WALL;

        void adjustToForwards(int year) {

            if (adjustForwards == false && dayOfMonth > 0) {

                // weekDay<=monthDay case, don't have it in tzdb data for now

                LocalDate adjustedDate = LocalDate.of(year, month, dayOfMonth).minusDays(6);

                dayOfMonth = adjustedDate.getDayOfMonth();

                month = adjustedDate.getMonth();

                adjustForwards = true;

            }

        }

        LocalDateTime toDateTime(int year) {

            LocalDate date;

            if (dayOfMonth < 0) {

                int monthLen = month.length(IsoChronology.INSTANCE.isLeapYear(year));

                date = LocalDate.of(year, month, monthLen + 1 + dayOfMonth);

                if (dayOfWeek != null) {

                    date = date.with(TemporalAdjusters.previousOrSame(dayOfWeek));

                }

            } else {

                date = LocalDate.of(year, month, dayOfMonth);

                if (dayOfWeek != null) {

                    date = date.with(TemporalAdjusters.nextOrSame(dayOfWeek));

                }

            }

            if (endOfDay) {

                date = date.plusDays(1);

            }

            return LocalDateTime.of(date, LocalTime.ofSecondOfDay(secsOfDay));

        }

        /**

         * Parses the MonthDaytime segment of a tzdb line.

         */

        private void parse(String[] tokens, int off) {

            month = parseMonth(tokens[off++]);

            if (off < tokens.length) {

                String dayRule = tokens[off++];

                if (dayRule.startsWith("last")) {

                    dayOfMonth = -1;

                    dayOfWeek = parseDayOfWeek(dayRule.substring(4));

                    adjustForwards = false;

                } else {

                    int index = dayRule.indexOf(">=");

                    if (index > 0) {

                        dayOfWeek = parseDayOfWeek(dayRule.substring(0, index));

                        dayRule = dayRule.substring(index + 2);

                    } else {

                        index = dayRule.indexOf("<=");

                        if (index > 0) {

                            dayOfWeek = parseDayOfWeek(dayRule.substring(0, index));

                            adjustForwards = false;

                            dayRule = dayRule.substring(index + 2);

                        }

                    }

                    dayOfMonth = Integer.parseInt(dayRule);

                    if (dayOfMonth < -28 || dayOfMonth > 31 || dayOfMonth == 0) {

                       throw new IllegalArgumentException(

                          "Day of month indicator must be between -28 and 31 inclusive excluding zero");

                    }

                }

                if (off < tokens.length) {

                    String timeStr = tokens[off++];

                    secsOfDay = parseSecs(timeStr);

                    if (secsOfDay == 86400) {

                        // time must be midnight when end of day flag is true

                        endOfDay = true;

                        secsOfDay = 0;

                    }

                    timeDefinition = parseTimeDefinition(timeStr.charAt(timeStr.length() - 1));

                }

            }

        }

        int parseYear(String year, int defaultYear) {

            switch (year.toLowerCase()) {

            case "min":  return 1900;

            case "max":  return Year.MAX_VALUE;

            case "only": return defaultYear;

            }

            return Integer.parseInt(year);

        }

        Month parseMonth(String mon) {

            switch (mon) {

            case "Jan": return Month.JANUARY;

            case "Feb": return Month.FEBRUARY;

            case "Mar": return Month.MARCH;

            case "Apr": return Month.APRIL;

            case "May": return Month.MAY;

            case "Jun": return Month.JUNE;

            case "Jul": return Month.JULY;

            case "Aug": return Month.AUGUST;

            case "Sep": return Month.SEPTEMBER;

            case "Oct": return Month.OCTOBER;

            case "Nov": return Month.NOVEMBER;

            case "Dec": return Month.DECEMBER;

            }

            throw new IllegalArgumentException("Unknown month: " + mon);

        }

        DayOfWeek parseDayOfWeek(String dow) {

            switch (dow) {

            case "Mon": return DayOfWeek.MONDAY;

            case "Tue": return DayOfWeek.TUESDAY;

            case "Wed": return DayOfWeek.WEDNESDAY;

            case "Thu": return DayOfWeek.THURSDAY;

            case "Fri": return DayOfWeek.FRIDAY;

            case "Sat": return DayOfWeek.SATURDAY;

            case "Sun": return DayOfWeek.SUNDAY;

            }

            throw new IllegalArgumentException("Unknown day-of-week: " + dow);

        }

        String parseOptional(String str) {

            return str.equals("-") ? null : str;

        }

        static final boolean isDigit(char c) {

            return c >= '0' && c <= '9';

        }

        private int parseSecs(String time) {

            if (time.equals("-")) {

                return 0;

            }

            // faster hack

            int secs = 0;

            int sign = 1;

            int off = 0;

            int len = time.length();

            if (off < len && time.charAt(off) == '-') {

                sign = -1;

                off++;

            }

            char c0, c1;

            if (off < len && isDigit(c0 = time.charAt(off++))) {

                int hour = c0 - '0';

                if (off < len && isDigit(c1 = time.charAt(off))) {

                    hour = hour * 10 + c1 - '0';

                    off++;

                }

                secs = hour * 60 * 60;

                if (off < len && time.charAt(off++) == ':') {

                    if (off + 1 < len &&

                        isDigit(c0 = time.charAt(off++)) &&

                        isDigit(c1 = time.charAt(off++))) {

                        // minutes

                        secs += ((c0 - '0') * 10 + c1 - '0') * 60;

                        if (off < len && time.charAt(off++) == ':') {

                            if (off + 1 < len &&

                                isDigit(c0 = time.charAt(off++)) &&

                                isDigit(c1 = time.charAt(off++))) {

                                // seconds

                                secs += ((c0 - '0') * 10 + c1 - '0');

                            }

                        }

                    }

                }

                return secs * sign;

            }

            throw new IllegalArgumentException("[" + time + "]");

        }

        int parseOffset(String str) {

            int secs = parseSecs(str);

            if (Math.abs(secs) > 18 * 60 * 60) {

                throw new IllegalArgumentException(

                    "Zone offset not in valid range: -18:00 to +18:00");

            }

            return secs;

        }

        int parsePeriod(String str) {

            return parseSecs(str);

        }

        TimeDefinition parseTimeDefinition(char c) {

            switch (c) {

            case 's':

            case 'S':

                // standard time

                return TimeDefinition.STANDARD;

            case 'u':

            case 'U':

            case 'g':

            case 'G':

            case 'z':

            case 'Z':

                // UTC

                return TimeDefinition.UTC;

            case 'w':

            case 'W':

            default:

                // wall time

                return TimeDefinition.WALL;

            }

        }

    }

    /**

     * Class representing a rule line in the TZDB file.

     */

    private static class RuleLine extends MonthDayTime {

        /** The start year. */

        int startYear;

        /** The end year. */

        int endYear;

        /** The amount of savings, in seconds. */

        int savingsAmount;

        /** The text name of the zone. */

        String text;

        /**

         * Converts this to a transition rule.

         *

         * @param standardOffset  the active standard offset, not null

         * @param savingsBeforeSecs  the active savings before the transition in seconds

         * @return the transition, not null

        */

        ZoneOffsetTransitionRule toTransitionRule(ZoneOffset stdOffset, int savingsBefore) {

            // rule shared by different zones, so don't change it

            Month month = this.month;

            int dayOfMonth = this.dayOfMonth;

            DayOfWeek dayOfWeek = this.dayOfWeek;

            boolean endOfDay = this.endOfDay;

            // optimize stored format

            if (dayOfMonth < 0) {

                if (month != Month.FEBRUARY) {    // not Month.FEBRUARY

                    dayOfMonth = month.maxLength() - 6;

                }

            }

            if (endOfDay && dayOfMonth > 0 &&

                (dayOfMonth == 28 && month == Month.FEBRUARY) == false) {

                LocalDate date = LocalDate.of(2004, month, dayOfMonth).plusDays(1);  // leap-year

                month = date.getMonth();

                dayOfMonth = date.getDayOfMonth();

                if (dayOfWeek != null) {

                    dayOfWeek = dayOfWeek.plus(1);

                }

                endOfDay = false;

            }

            // build rule

            return ZoneOffsetTransitionRule.of(