/*

 * Copyright (c) 2000, 2011, 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.

 */

import java.util.Locale;

import sun.util.calendar.CalendarDate;

import sun.util.calendar.CalendarSystem;

import sun.util.calendar.Gregorian;

/**

 * Time class represents the "AT" field and other time related information.

 *

 * @since 1.4

 */

class Time {

    static final Gregorian gcal = CalendarSystem.getGregorianCalendar();

    // type is wall clock time

    private static final int WALL = 1;

    // type is standard time

    private static final int STD = 2;

    // type is UTC

    private static final int UTC = 3;

    // type of representing time

    private int type;

    /**

     * Time from the EPOCH in milliseconds

     */

    private long time;

    /**

     * Current time in milliseconds

     */

    private static final long currentTime = System.currentTimeMillis();

    Time() {

        time = 0L;

    }

    Time(long time) {

        this.time = time;

    }

    void setType(int type) {

        this.type = type;

    }

    long getTime() {

        return time;

    }

    int getType() {

        return type;

    }

    static long getCurrentTime() {

        return currentTime;

    }

    /**

     * @return true if the time is represented in wall-clock time.

     */

    boolean isWall() {

        return type == WALL;

    }

    /**

     * @return true if the time is represented in standard time.

     */

    boolean isSTD() {

        return type == STD;

    }

    /**

     * @return true if the time is represented in UTC time.

     */

    boolean isUTC() {

        return type == UTC;

    }

    /**

     * Converts the type to a string that represents the type in the

     * SimpleTimeZone time mode. (e.g., "SimpleTimeZone.WALL_TIME").

     * @return the converted string or null if the type is undefined.

     */

    String getTypeForSimpleTimeZone() {

        String  stz = "SimpleTimeZone.";

        if (isWall()) {

            return stz+"WALL_TIME";

        }

        else if (isSTD()) {

            return stz+"STANDARD_TIME";

        }

        else if (isUTC()) {

            return stz+"UTC_TIME";

        }

        else {

            return null;

        }

    }

    /**

     * Converts the given Gregorian calendar field values to local time.

     * Local time is represented by the amount of milliseconds from

     * January 1, 1970 0:00 GMT.

     * @param year the year value

     * @param month the Month value

     * @param day the day represented by {@link RuleDay}

     * @param save the amount of daylight time in milliseconds

     * @param gmtOffset the GMT offset in milliseconds

     * @param time the time of the day represented by {@link Time}

     * @return local time

     */

    static long getLocalTime(int year, Month month, RuleDay day, int save,

                             int gmtOffset, Time time) {

        long    t = time.getTime();

        if (time.isSTD())

            t = time.getTime() + save;

        else if (time.isUTC())

            t = time.getTime() + save + gmtOffset;

        return getLocalTime(year, month, day, t);

    }

    /**

     * Converts the given Gregorian calendar field values to local time.

     * Local time is represented by the amount of milliseconds from

     * January 1, 1970 0:00 GMT.

     * @param year the year value

     * @param month the Month value

     * @param day the day value

     * @param time the time of the day in milliseconds

     * @return local time

     */

    static long getLocalTime(int year, Month month, int day, long time) {

        CalendarDate date = gcal.newCalendarDate(null);

        date.setDate(year, month.value(), day);

        long millis = gcal.getTime(date);

        return millis + time;

    }

    /**

     * Equivalent to <code>getLocalTime(year, month, day, (long)time)</code>.

     * @param year the year value

     * @param month the Month value

     * @param day the day value

     * @param time the time of the day in milliseconds

     * @return local time

     */

    static long getLocalTime(int year, Month month, int day, int time) {

        return getLocalTime(year, month, day, (long)time);

    }

    /**

     * Equivalent to {@link #getLocalTime(int, Month, RuleDay, int)

     * getLocalTime(year, month, day, (int) time)}.

     * @param year the year value

     * @param month the Month value

     * @param day the day represented by {@link RuleDay}

     * @param time the time of the day represented by {@link Time}

     * @return local time

     */

    static long getLocalTime(int year, Month month, RuleDay day, long time) {

        return getLocalTime(year, month, day, (int) time);

    }

    /**

     * Converts the given Gregorian calendar field values to local time.

     * Local time is represented by the amount of milliseconds from

     * January 1, 1970 0:00 GMT.

     * @param year the year value

     * @param month the Month value

     * @param day the day represented by {@link RuleDay}

     * @param time the time of the day represented by {@link Time}

     * @return local time

     */

    static long getLocalTime(int year, Month month, RuleDay day, int time) {

        CalendarDate cdate = gcal.newCalendarDate(null);

        int monthValue = month.value();

        if (day.isLast()) {     // e.g., "lastSun"

            cdate.setDate(year, monthValue, 1);

            cdate.setDayOfMonth(gcal.getMonthLength(cdate));

            cdate = gcal.getNthDayOfWeek(-1, day.getDayOfWeekNum(), cdate);

        } else if (day.isLater()) { // e.g., "Sun>=1"

            cdate.setDate(year, monthValue, day.getDay());

            cdate = gcal.getNthDayOfWeek(1, day.getDayOfWeekNum(), cdate);

        } else if (day.isExact()) {

            cdate.setDate(year, monthValue, day.getDay());

        } else if (day.isEarlier()) {   // e.g., "Sun<=15"

            cdate.setDate(year, monthValue, day.getDay());

            cdate = gcal.getNthDayOfWeek(-1, day.getDayOfWeekNum(), cdate);

        } else {

            Main.panic("invalid day type: " + day);

        }

        return gcal.getTime(cdate) + time;

    }

    /**

     * Parses the given "AT" field and constructs a Time object.

     * @param the "AT" field string

     * @return the Time object

     */

    static Time parse(String time) {

        int sign;

        int index = 0;

        Time tm;

        if (time.charAt(0) == '-') {

            sign = -1;

            index++;

        } else {

            sign = 1;

        }

        int val = 0;

        int num = 0;

        int countDelim = 0;

        while (index < time.length()) {

            char c = time.charAt(index++);

            if (c == ':') {

                val = val * 60 + num;

                countDelim++;

                num = 0;

                continue;

            }

            int d = Character.digit(c, 10);

            if (d == -1) {

                --index;

                break;

            }

            num = num * 10 + d;

        }

        val = val * 60 + num;

        // convert val to second

        for (; countDelim < 2; countDelim++) {

            val *= 60;

        }

        tm = new Time((long)val * 1000 * sign);

        if (index < time.length()) {

            char c = time.charAt(index++);

            if (c == 's') {

                tm.setType(Time.STD);

            } else if (c == 'u' || c == 'g' || c == 'z') {

                tm.setType(Time.UTC);

            } else if (c == 'w') {

                tm.setType(Time.WALL);

            } else {

                Main.panic("unknown time mode: "+c);

            }

        } else {

            tm.setType(Time.WALL);

        }

        return tm;

    }

    /**

     * Converts the given milliseconds string to a "[+-]hh:mm" string.

     * @param ms the milliseconds string

     */

    static String toGMTFormat(String ms) {

        long sec = Long.parseLong(ms) / 1000;

        char sign;

        if (sec < 0) {

            sign = '-';

            sec = -sec;

        } else {

            sign = '+';

        }

        return String.format((Locale)null, "%c%02d:%02d",

                             sign, sec/3600, (sec%3600)/60);

    }

    /**

     * Converts the given millisecond value to a string for a

     * SimpleTimeZone parameter.

     * @param ms the millisecond value

     * @return the string in a human readable form

     */

    static String toFormedString(int ms) {

        StringBuilder s = new StringBuilder();

        boolean minus = false;

        if (ms < 0) {

            s.append("-");

            minus = true;

            ms = -ms;

        } else if (ms == 0) {

            return "0";

        }

        int hour = ms / (60 * 60 * 1000);

        ms %= (60 * 60 * 1000);

        int minute = ms / (60 * 1000);

        if (hour != 0) {

            if (minus && minute != 0) {

                s.append("(");

            }

            s.append(Integer.toString(hour) + "*ONE_HOUR");

        }

        if (minute != 0) {

            if (hour != 0) {

                s.append("+");

            }

            s.append(Integer.toString(minute) + "*ONE_MINUTE");

            if (minus && hour != 0) {

                s.append(")");

            }

        }

        return s.toString();

    }

}