/*

 * 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 sun.util.calendar;

import java.io.ByteArrayInputStream;

import java.io.BufferedInputStream;

import java.io.DataInput;

import java.io.DataInputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.StreamCorruptedException;

import java.security.AccessController;

import java.security.PrivilegedAction;

import java.time.LocalDateTime;

import java.time.ZoneOffset;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Calendar;

import java.util.Collections;

import java.util.HashMap;

import java.util.List;

import java.util.Locale;

import java.util.Map;

import java.util.SimpleTimeZone;

import java.util.concurrent.ConcurrentHashMap;

import java.util.zip.CRC32;

import jdk.internal.util.StaticProperty;

import sun.security.action.GetPropertyAction;

/**

 * Loads TZDB time-zone rules for j.u.TimeZone

 * <p>

 * @since 1.8

 */

public final class ZoneInfoFile {

    /**

     * Gets all available IDs supported in the Java run-time.

     *

     * @return a set of time zone IDs.

     */

    public static String[] getZoneIds() {

        int len = regions.length + oldMappings.length;

        if (!USE_OLDMAPPING) {

            len += 3;    // EST/HST/MST not in tzdb.dat

        }

        String[] ids = Arrays.copyOf(regions, len);

        int i = regions.length;

        if (!USE_OLDMAPPING) {

            ids[i++] = "EST";

            ids[i++] = "HST";

            ids[i++] = "MST";

        }

        for (int j = 0; j < oldMappings.length; j++) {

            ids[i++] = oldMappings[j][0];

        }

        return ids;

    }

    /**

     * Gets all available IDs that have the same value as the

     * specified raw GMT offset.

     *

     * @param rawOffset  the GMT offset in milliseconds. This

     *                   value should not include any daylight saving time.

     * @return an array of time zone IDs.

     */

    public static String[] getZoneIds(int rawOffset) {

        List<String> ids = new ArrayList<>();

        for (String id : getZoneIds()) {

            ZoneInfo zi = getZoneInfo(id);

            if (zi.getRawOffset() == rawOffset) {

                ids.add(id);

            }

        }

        // It appears the "zi" implementation returns the

        // sorted list, though the specification does not

        // specify it. Keep the same behavior for better

        // compatibility.

        String[] list = ids.toArray(new String[ids.size()]);

        Arrays.sort(list);

        return list;

    }

    public static ZoneInfo getZoneInfo(String zoneId) {

        if (zoneId == null) {

            return null;

        }

        ZoneInfo zi = getZoneInfo0(zoneId);

        if (zi != null) {

            zi = (ZoneInfo)zi.clone();

            zi.setID(zoneId);

        }

        return zi;

    }

    private static ZoneInfo getZoneInfo0(String zoneId) {

        try {

            ZoneInfo zi = zones.get(zoneId);

            if (zi != null) {

                return zi;

            }

            String zid = zoneId;

            if (aliases.containsKey(zoneId)) {

                zid = aliases.get(zoneId);

            }

            int index = Arrays.binarySearch(regions, zid);

            if (index < 0) {

                return null;

            }

            byte[] bytes = ruleArray[indices[index]];

            DataInputStream dis = new DataInputStream(new ByteArrayInputStream(bytes));

            zi = getZoneInfo(dis, zid);

            zones.put(zoneId, zi);

            return zi;

        } catch (Exception ex) {

            throw new RuntimeException("Invalid binary time-zone data: TZDB:" +

                zoneId + ", version: " + versionId, ex);

        }

    }

    /**

     * Returns a Map from alias time zone IDs to their standard

     * time zone IDs.

     *

     * @return an unmodified alias mapping

     */

    public static Map<String, String> getAliasMap() {

        return Collections.unmodifiableMap(aliases);

    }

    /**

     * Gets the version of this tz data.

     *

     * @return the tzdb version

     */

    public static String getVersion() {

        return versionId;

    }

    /**

     * Gets a ZoneInfo with the given GMT offset. The object

     * has its ID in the format of GMT{+|-}hh:mm.

     *

     * @param originalId  the given custom id (before normalized such as "GMT+9")

     * @param gmtOffset   GMT offset <em>in milliseconds</em>

     * @return a ZoneInfo constructed with the given GMT offset

     */

    public static ZoneInfo getCustomTimeZone(String originalId, int gmtOffset) {

        String id = toCustomID(gmtOffset);

        return new ZoneInfo(id, gmtOffset);

    }

    public static String toCustomID(int gmtOffset) {

        char sign;

        int offset = gmtOffset / 60000;

        if (offset >= 0) {

            sign = '+';

        } else {

            sign = '-';

            offset = -offset;

        }

        int hh = offset / 60;

        int mm = offset % 60;

        char[] buf = new char[] { 'G', 'M', 'T', sign, '0', '0', ':', '0', '0' };

        if (hh >= 10) {

            buf[4] += hh / 10;

        }

        buf[5] += hh % 10;

        if (mm != 0) {

            buf[7] += mm / 10;

            buf[8] += mm % 10;

        }

        return new String(buf);

    }

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

    private ZoneInfoFile() {

    }

    private static String versionId;

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

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

    private static byte[][] ruleArray;

    private static String[] regions;

    private static int[] indices;

    // Flag for supporting JDK backward compatible IDs, such as "EST".

    private static final boolean USE_OLDMAPPING;

    private static String[][] oldMappings = new String[][] {

        { "ACT", "Australia/Darwin" },

        { "AET", "Australia/Sydney" },

        { "AGT", "America/Argentina/Buenos_Aires" },

        { "ART", "Africa/Cairo" },

        { "AST", "America/Anchorage" },

        { "BET", "America/Sao_Paulo" },

        { "BST", "Asia/Dhaka" },

        { "CAT", "Africa/Harare" },

        { "CNT", "America/St_Johns" },

        { "CST", "America/Chicago" },

        { "CTT", "Asia/Shanghai" },

        { "EAT", "Africa/Addis_Ababa" },

        { "ECT", "Europe/Paris" },

        { "IET", "America/Indiana/Indianapolis" },

        { "IST", "Asia/Kolkata" },

        { "JST", "Asia/Tokyo" },

        { "MIT", "Pacific/Apia" },

        { "NET", "Asia/Yerevan" },

        { "NST", "Pacific/Auckland" },

        { "PLT", "Asia/Karachi" },

        { "PNT", "America/Phoenix" },

        { "PRT", "America/Puerto_Rico" },

        { "PST", "America/Los_Angeles" },

        { "SST", "Pacific/Guadalcanal" },

        { "VST", "Asia/Ho_Chi_Minh" },

    };

    static {

        String oldmapping = GetPropertyAction

                .privilegedGetProperty("sun.timezone.ids.oldmapping", "false")

                .toLowerCase(Locale.ROOT);

        USE_OLDMAPPING = (oldmapping.equals("yes") || oldmapping.equals("true"));

        AccessController.doPrivileged(new PrivilegedAction<Void>() {

            public Void run() {

                try {

                    String libDir = StaticProperty.javaHome() + File.separator + "lib";

                    try (DataInputStream dis = new DataInputStream(

                             new BufferedInputStream(new FileInputStream(

                                 new File(libDir, "tzdb.dat"))))) {

                        load(dis);

                    }

                } catch (Exception x) {

                    throw new Error(x);

                }

                return null;

            }

        });

    }

    private static void addOldMapping() {

        for (String[] alias : oldMappings) {

            aliases.put(alias[0], alias[1]);

        }

        if (USE_OLDMAPPING) {

            aliases.put("EST", "America/New_York");

            aliases.put("MST", "America/Denver");

            aliases.put("HST", "Pacific/Honolulu");

        } else {

            zones.put("EST", new ZoneInfo("EST", -18000000));

            zones.put("MST", new ZoneInfo("MST", -25200000));

            zones.put("HST", new ZoneInfo("HST", -36000000));

        }

    }

    public static boolean useOldMapping() {

       return USE_OLDMAPPING;

    }

    /**

     * Loads the rules from a DateInputStream

     *

     * @param dis  the DateInputStream to load, not null

     * @throws Exception if an error occurs

     */

    private static void load(DataInputStream dis) throws ClassNotFoundException, IOException {

        if (dis.readByte() != 1) {

            throw new StreamCorruptedException("File format not recognised");

        }

        // group

        String groupId = dis.readUTF();

        if ("TZDB".equals(groupId) == false) {

            throw new StreamCorruptedException("File format not recognised");

        }

        // versions, only keep the last one

        int versionCount = dis.readShort();

        for (int i = 0; i < versionCount; i++) {

            versionId = dis.readUTF();

        }

        // regions

        int regionCount = dis.readShort();

        String[] regionArray = new String[regionCount];

        for (int i = 0; i < regionCount; i++) {

            regionArray[i] = dis.readUTF();

        }

        // rules

        int ruleCount = dis.readShort();

        ruleArray = new byte[ruleCount][];

        for (int i = 0; i < ruleCount; i++) {

            byte[] bytes = new byte[dis.readShort()];

            dis.readFully(bytes);

            ruleArray[i] = bytes;

        }

        // link version-region-rules, only keep the last version, if more than one

        for (int i = 0; i < versionCount; i++) {

            regionCount = dis.readShort();

            regions = new String[regionCount];

            indices = new int[regionCount];

            for (int j = 0; j < regionCount; j++) {

                regions[j] = regionArray[dis.readShort()];

                indices[j] = dis.readShort();

            }

        }

        // remove the following ids from the map, they

        // are exclued from the "old" ZoneInfo

        zones.remove("ROC");

        for (int i = 0; i < versionCount; i++) {

            int aliasCount = dis.readShort();

            aliases.clear();

            for (int j = 0; j < aliasCount; j++) {

                String alias = regionArray[dis.readShort()];

                String region = regionArray[dis.readShort()];

                aliases.put(alias, region);

            }

        }

        // old us time-zone names

        addOldMapping();

    }

    /////////////////////////Ser/////////////////////////////////

    public static ZoneInfo getZoneInfo(DataInput in, String zoneId) throws Exception {

        byte type = in.readByte();

        // TBD: assert ZRULES:

        int stdSize = in.readInt();

        long[] stdTrans = new long[stdSize];

        for (int i = 0; i < stdSize; i++) {

            stdTrans[i] = readEpochSec(in);

        }

        int [] stdOffsets = new int[stdSize + 1];

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

            stdOffsets[i] = readOffset(in);

        }

        int savSize = in.readInt();

        long[] savTrans = new long[savSize];

        for (int i = 0; i < savSize; i++) {

            savTrans[i] = readEpochSec(in);

        }

        int[] savOffsets = new int[savSize + 1];

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

            savOffsets[i] = readOffset(in);

        }

        int ruleSize = in.readByte();

        ZoneOffsetTransitionRule[] rules = new ZoneOffsetTransitionRule[ruleSize];

        for (int i = 0; i < ruleSize; i++) {

            rules[i] = new ZoneOffsetTransitionRule(in);

        }

        return getZoneInfo(zoneId, stdTrans, stdOffsets, savTrans, savOffsets, rules);

    }

    public static int readOffset(DataInput in) throws IOException {

        int offsetByte = in.readByte();

        return offsetByte == 127 ? in.readInt() : offsetByte * 900;

    }

    static long readEpochSec(DataInput in) throws IOException {

        int hiByte = in.readByte() & 255;

        if (hiByte == 255) {

            return in.readLong();

        } else {

            int midByte = in.readByte() & 255;

            int loByte = in.readByte() & 255;

            long tot = ((hiByte << 16) + (midByte << 8) + loByte);

            return (tot * 900) - 4575744000L;

        }

    }

    /////////////////////////ZoneRules --> ZoneInfo/////////////////////////////////

    // ZoneInfo starts with UTC1900

    private static final long UTC1900 = -2208988800L;

    // ZoneInfo ends with   UTC2037

    // LocalDateTime.of(2038, 1, 1, 0, 0, 0).toEpochSecond(ZoneOffset.UTC) - 1;

    private static final long UTC2037 = 2145916799L;

    // ZoneInfo has an ending entry for 2037, this need to be offset by

    // a "rawOffset"

    // LocalDateTime.of(2037, 1, 1, 0, 0, 0).toEpochSecond(ZoneOffset.UTC));

    private static final long LDT2037 = 2114380800L;

    //Current time. Used to determine future GMToffset transitions

    private static final long CURRT = System.currentTimeMillis()/1000;

    /* Get a ZoneInfo instance.

     *

     * @param standardTransitions  the standard transitions, not null

     * @param standardOffsets  the standard offsets, not null

     * @param savingsInstantTransitions  the standard transitions, not null

     * @param wallOffsets  the wall offsets, not null

     * @param lastRules  the recurring last rules, size 15 or less, not null

     */

    private static ZoneInfo getZoneInfo(String zoneId,

                                        long[] standardTransitions,

                                        int[] standardOffsets,

                                        long[] savingsInstantTransitions,

                                        int[] wallOffsets,

                                        ZoneOffsetTransitionRule[] lastRules) {

        int rawOffset = 0;

        int dstSavings = 0;

        int checksum = 0;

        int[] params = null;

        boolean willGMTOffsetChange = false;

        // rawOffset, pick the last one

        if (standardTransitions.length > 0) {

            rawOffset = standardOffsets[standardOffsets.length - 1] * 1000;

            willGMTOffsetChange = standardTransitions[standardTransitions.length - 1] > CURRT;

        }

        else

            rawOffset = standardOffsets[0] * 1000;

        // transitions, offsets;

        long[] transitions = null;

        int[]  offsets = null;

        int    nOffsets = 0;

        int    nTrans = 0;

        if (savingsInstantTransitions.length != 0) {

            transitions = new long[250];

            offsets = new int[100];    // TBD: ZoneInfo actually can't handle

                                       // offsets.length > 16 (4-bit index limit)

            // last year in trans table

            // It should not matter to use before or after offset for year

            int lastyear = getYear(savingsInstantTransitions[savingsInstantTransitions.length - 1],

                                   wallOffsets[savingsInstantTransitions.length - 1]);

            int i = 0, k = 1;

            while (i < savingsInstantTransitions.length &&

                   savingsInstantTransitions[i] < UTC1900) {

                i++;     // skip any date before UTC1900

            }

            if (i < savingsInstantTransitions.length) {

                // javazic writes the last GMT offset into index 0!

                if (i < savingsInstantTransitions.length) {

                    offsets[0] = standardOffsets[standardOffsets.length - 1] * 1000;

                    nOffsets = 1;

                }

                // ZoneInfo has a beginning entry for 1900.

                // Only add it if this is not the only one in table

                nOffsets = addTrans(transitions, nTrans++,

                                    offsets, nOffsets,

                                    UTC1900,

                                    wallOffsets[i],

                                    getStandardOffset(standardTransitions, standardOffsets, UTC1900));

            }

            for (; i < savingsInstantTransitions.length; i++) {

                long trans = savingsInstantTransitions[i];

                if (trans > UTC2037) {

                    // no trans beyond LASTYEAR

                    lastyear = LASTYEAR;

                    break;

                }

                while (k < standardTransitions.length) {

                    // some standard offset transitions don't exist in

                    // savingInstantTrans, if the offset "change" doesn't

                    // really change the "effectiveWallOffset". For example

                    // the 1999/2000 pair in Zone Arg/Buenos_Aires, in which

                    // the daylightsaving "happened" but it actually does

                    // not result in the timezone switch. ZoneInfo however

                    // needs them in its transitions table

                    long trans_s = standardTransitions[k];

                    if (trans_s >= UTC1900) {

                        if (trans_s > trans)

                            break;

                        if (trans_s < trans) {