/*

 * Copyright (c) 2012, 2013, 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 sun.util.calendar;

import java.io.ByteArrayInputStream;

import java.io.DataInput;

import java.io.DataInputStream;

import java.io.File;

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.Map.Entry;

import java.util.Objects;

import java.util.Set;

import java.util.SimpleTimeZone;

import java.util.concurrent.ConcurrentHashMap;

import java.util.zip.CRC32;

/**

 * 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.

     */

    }

    /**

     * 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<>();

            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) {

            return null;

        }

    }

    /**

     * 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() {

    }

    /**

     * 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 Map<String, String> aliases = new HashMap<>();

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

    private static final boolean USE_OLDMAPPING;

    static {

        String oldmapping = AccessController.doPrivileged(

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

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

            public Object run() {

                try {

                    String libDir = System.getProperty("java.home") + File.separator + "lib";

                        load(dis);

                    }

                } catch (Exception x) {

                    throw new Error(x);

                }

                return null;

            }

        });

    }

    private static void addOldMapping() {

        for (String[] alias : oldMappings) {

        }

        if (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();

        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();

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

            }

        }

        // 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++) {

        }

        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

    /* 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;

        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 i = 0, k = 1;

            while (i < savingsInstantTransitions.length &&

                   savingsInstantTransitions[i] < 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

                                    UTC1900,

                                    wallOffsets[i],

                                    getStandardOffset(standardTransitions, standardOffsets, UTC1900));

            }

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

                    // 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

                    // needs them in its transitions table

                    long trans_s = standardTransitions[k];

                    if (trans_s >= UTC1900) {

                        if (trans_s > trans)

                            break;

                        if (trans_s < trans) {

                            if (nOffsets + 2 >= offsets.length) {

                                offsets = Arrays.copyOf(offsets, offsets.length + 100);

                            }

                            if (nTrans + 1 >= transitions.length) {

                                transitions = Arrays.copyOf(transitions, transitions.length + 100);

                            }

                            nOffsets = addTrans(transitions, nTrans++, offsets, nOffsets,

                                                trans_s,

                                                wallOffsets[i],

                                                standardOffsets[k+1]);

                        }

                    }

                    k++;

                }

                if (nOffsets + 2 >= offsets.length) {

                    offsets = Arrays.copyOf(offsets, offsets.length + 100);

                }

                if (nTrans + 1 >= transitions.length) {

                    transitions = Arrays.copyOf(transitions, transitions.length + 100);

                }

                nOffsets = addTrans(transitions, nTrans++, offsets, nOffsets,

                                    trans,

                                    wallOffsets[i + 1],

                                    getStandardOffset(standardTransitions, standardOffsets, trans));