/*

 * Copyright (c) 2003, 2004, 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.util.Locale;

import java.util.TimeZone;

/**

 * The <code>AbstractCalendar</code> class provides a framework for

 * implementing a concrete calendar system.

 *

 * <p><a name="fixed_date"></a><B>Fixed Date</B><br>

 *

 * For implementing a concrete calendar system, each calendar must

 * have the common date numbering, starting from midnight the onset of

 * Monday, January 1, 1 (Gregorian). It is called a <I>fixed date</I>

 * in this class. January 1, 1 (Gregorian) is fixed date 1. (See

 * Nachum Dershowitz and Edward M. Reingold, <I>CALENDRICAL

 * CALCULATION The Millennium Edition</I>, Section 1.2 for details.)

 *

 * @author Masayoshi Okutsu

 * @since 1.5

 */

public abstract class AbstractCalendar extends CalendarSystem {

    // The constants assume no leap seconds support.

    static final int SECOND_IN_MILLIS = 1000;

    static final int MINUTE_IN_MILLIS = SECOND_IN_MILLIS * 60;

    static final int HOUR_IN_MILLIS = MINUTE_IN_MILLIS * 60;

    static final int DAY_IN_MILLIS = HOUR_IN_MILLIS * 24;

    // The number of days between January 1, 1 and January 1, 1970 (Gregorian)

    static final int EPOCH_OFFSET = 719163;

    private Era[] eras;

    protected AbstractCalendar() {

    }

    public Era getEra(String eraName) {

        if (eras != null) {

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

                if (eras[i].equals(eraName)) {

                    return eras[i];

                }

            }

        }

        return null;

    }

    public Era[] getEras() {

        Era[] e = null;

        if (eras != null) {

            e = new Era[eras.length];

            System.arraycopy(eras, 0, e, 0, eras.length);

        }

        return e;

    }

    public void setEra(CalendarDate date, String eraName) {

        if (eras == null) {

            return; // should report an error???

        }

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

            Era e = eras[i];

            if (e != null && e.getName().equals(eraName)) {

                date.setEra(e);

                return;

            }

        }

        throw new IllegalArgumentException("unknown era name: " + eraName);

    }

    protected void setEras(Era[] eras) {

        this.eras = eras;

    }

    public CalendarDate getCalendarDate() {

        return getCalendarDate(System.currentTimeMillis(), newCalendarDate());

    }

    public CalendarDate getCalendarDate(long millis) {

        return getCalendarDate(millis, newCalendarDate());

    }

    public CalendarDate getCalendarDate(long millis, TimeZone zone) {

        CalendarDate date = newCalendarDate(zone);

        return getCalendarDate(millis, date);

    }

    public CalendarDate getCalendarDate(long millis, CalendarDate date) {

        int ms = 0;             // time of day

        int zoneOffset = 0;

        int saving = 0;

        long days = 0;          // fixed date

        // adjust to local time if `date' has time zone.

        TimeZone zi = date.getZone();

        if (zi != null) {

            int[] offsets = new int[2];

            if (zi instanceof ZoneInfo) {

                zoneOffset = ((ZoneInfo)zi).getOffsets(millis, offsets);

            } else {

                zoneOffset = zi.getOffset(millis);

                offsets[0] = zi.getRawOffset();

                offsets[1] = zoneOffset - offsets[0];

            }

            // We need to calculate the given millis and time zone

            // offset separately for java.util.GregorianCalendar

            // compatibility. (i.e., millis + zoneOffset could cause

            // overflow or underflow, which must be avoided.) Usually

            // days should be 0 and ms is in the range of -13:00 to

            // +14:00. However, we need to deal with extreme cases.

            days = zoneOffset / DAY_IN_MILLIS;

            ms = zoneOffset % DAY_IN_MILLIS;

            saving = offsets[1];

        }

        date.setZoneOffset(zoneOffset);

        date.setDaylightSaving(saving);

        days += millis / DAY_IN_MILLIS;

        ms += (int) (millis % DAY_IN_MILLIS);

        if (ms >= DAY_IN_MILLIS) {

            // at most ms is (DAY_IN_MILLIS - 1) * 2.

            ms -= DAY_IN_MILLIS;

            ++days;

        } else {

            // at most ms is (1 - DAY_IN_MILLIS) * 2. Adding one

            // DAY_IN_MILLIS results in still negative.

            while (ms < 0) {

                ms += DAY_IN_MILLIS;

                --days;

            }

        }

        // convert to fixed date (offset from Jan. 1, 1 (Gregorian))

        days += EPOCH_OFFSET;

        // calculate date fields from the fixed date

        getCalendarDateFromFixedDate(date, days);

        // calculate time fields from the time of day

        setTimeOfDay(date, ms);

        date.setLeapYear(isLeapYear(date));

        date.setNormalized(true);

        return date;

    }

    public long getTime(CalendarDate date) {

        long gd = getFixedDate(date);

        long ms = (gd - EPOCH_OFFSET) * DAY_IN_MILLIS + getTimeOfDay(date);

        int zoneOffset = 0;

        TimeZone zi = date.getZone();

        if (zi != null) {

            if (date.isNormalized()) {

                return ms - date.getZoneOffset();

            }

            // adjust time zone and daylight saving

            int[] offsets = new int[2];

            if (date.isStandardTime()) {

                // 1) 2:30am during starting-DST transition is

                //    intrepreted as 2:30am ST

                // 2) 5:00pm during DST is still interpreted as 5:00pm ST

                // 3) 1:30am during ending-DST transition is interpreted

                //    as 1:30am ST (after transition)

                if (zi instanceof ZoneInfo) {

                    ((ZoneInfo)zi).getOffsetsByStandard(ms, offsets);

                    zoneOffset = offsets[0];

                } else {

                    zoneOffset = zi.getOffset(ms - zi.getRawOffset());

                }

            } else {

                // 1) 2:30am during starting-DST transition is

                //    intrepreted as 3:30am DT

                // 2) 5:00pm during DST is intrepreted as 5:00pm DT

                // 3) 1:30am during ending-DST transition is interpreted

                //    as 1:30am DT/0:30am ST (before transition)

                if (zi instanceof ZoneInfo) {

                    zoneOffset = ((ZoneInfo)zi).getOffsetsByWall(ms, offsets);

                } else {

                    zoneOffset = zi.getOffset(ms - zi.getRawOffset());

                }

            }

        }

        ms -= zoneOffset;

        getCalendarDate(ms, date);

        return ms;

    }

    protected long getTimeOfDay(CalendarDate date) {

        long fraction = date.getTimeOfDay();

        if (fraction != CalendarDate.TIME_UNDEFINED) {

            return fraction;

        }

        fraction = getTimeOfDayValue(date);

        date.setTimeOfDay(fraction);

        return fraction;

    }

    public long getTimeOfDayValue(CalendarDate date) {

        long fraction = date.getHours();

        fraction *= 60;

        fraction += date.getMinutes();

        fraction *= 60;

        fraction += date.getSeconds();

        fraction *= 1000;

        fraction += date.getMillis();

        return fraction;

    }

    public CalendarDate setTimeOfDay(CalendarDate cdate, int fraction) {

        if (fraction < 0) {

            throw new IllegalArgumentException();

        }

        boolean normalizedState = cdate.isNormalized();

        int time = fraction;

        int hours = time / HOUR_IN_MILLIS;

        time %= HOUR_IN_MILLIS;

        int minutes = time / MINUTE_IN_MILLIS;

        time %= MINUTE_IN_MILLIS;

        int seconds = time / SECOND_IN_MILLIS;

        time %= SECOND_IN_MILLIS;

        cdate.setHours(hours);

        cdate.setMinutes(minutes);

        cdate.setSeconds(seconds);

        cdate.setMillis(time);

        cdate.setTimeOfDay(fraction);

        if (hours < 24 && normalizedState) {

            // If this time of day setting doesn't affect the date,

            // then restore the normalized state.

            cdate.setNormalized(normalizedState);

        }

        return cdate;

    }

    /**

     * Returns 7 in this default implementation.

     *

     * @return 7

     */

    public int getWeekLength() {

        return 7;

    }

    protected abstract boolean isLeapYear(CalendarDate date);

    public CalendarDate getNthDayOfWeek(int nth, int dayOfWeek, CalendarDate date) {

        CalendarDate ndate = (CalendarDate) date.clone();

        normalize(ndate);

        long fd = getFixedDate(ndate);

        long nfd;

        if (nth > 0) {

            nfd = 7 * nth + getDayOfWeekDateBefore(fd, dayOfWeek);

        } else {

            nfd = 7 * nth + getDayOfWeekDateAfter(fd, dayOfWeek);

        }

        getCalendarDateFromFixedDate(ndate, nfd);

        return ndate;

    }

    /**

     * Returns a date of the given day of week before the given fixed

     * date.

     *

     * @param fixedDate the fixed date

     * @param dayOfWeek the day of week

     * @return the calculated date

     */

    static long getDayOfWeekDateBefore(long fixedDate, int dayOfWeek) {

        return getDayOfWeekDateOnOrBefore(fixedDate - 1, dayOfWeek);

    }

    /**

     * Returns a date of the given day of week that is closest to and

     * after the given fixed date.

     *

     * @param fixedDate the fixed date

     * @param dayOfWeek the day of week

     * @return the calculated date

     */

    static long getDayOfWeekDateAfter(long fixedDate, int dayOfWeek) {

        return getDayOfWeekDateOnOrBefore(fixedDate + 7, dayOfWeek);

    }

    /**

     * Returns a date of the given day of week on or before the given fixed

     * date.

     *

     * @param fixedDate the fixed date

     * @param dayOfWeek the day of week

     * @return the calculated date

     */

    // public for java.util.GregorianCalendar

    public static long getDayOfWeekDateOnOrBefore(long fixedDate, int dayOfWeek) {

        long fd = fixedDate - (dayOfWeek - 1);

        if (fd >= 0) {

            return fixedDate - (fd % 7);

        }

        return fixedDate - CalendarUtils.mod(fd, 7);

    }

    /**

     * Returns the fixed date calculated with the specified calendar

     * date. If the specified date is not normalized, its date fields

     * are normalized.

     *

     * @param date a <code>CalendarDate</code> with which the fixed

     * date is calculated

     * @return the calculated fixed date

     * @see AbstractCalendar.html#fixed_date

     */

    protected abstract long getFixedDate(CalendarDate date);

    /**

     * Calculates calendar fields from the specified fixed date. This

     * method stores the calculated calendar field values in the specified

     * <code>CalendarDate</code>.

     *

     * @param date a <code>CalendarDate</code> to stored the

     * calculated calendar fields.

     * @param fixedDate a fixed date to calculate calendar fields

     * @see AbstractCalendar.html#fixed_date

     */

    protected abstract void getCalendarDateFromFixedDate(CalendarDate date,

                                                         long fixedDate);

    public boolean validateTime(CalendarDate date) {

        int t = date.getHours();

        if (t < 0 || t >= 24) {

            return false;

        }

        t = date.getMinutes();

        if (t < 0 || t >= 60) {

            return false;

        }

        t = date.getSeconds();

        // TODO: Leap second support.

        if (t < 0 || t >= 60) {

            return false;

        }

        t = date.getMillis();

        if (t < 0 || t >= 1000) {

            return false;

        }

        return true;

    }

    int normalizeTime(CalendarDate date) {

        long fraction = getTimeOfDay(date);

        long days = 0;

        if (fraction >= DAY_IN_MILLIS) {

            days = fraction / DAY_IN_MILLIS;

            fraction %= DAY_IN_MILLIS;

        } else if (fraction < 0) {

            days = CalendarUtils.floorDivide(fraction, DAY_IN_MILLIS);

            if (days != 0) {

                fraction -= DAY_IN_MILLIS * days; // mod(fraction, DAY_IN_MILLIS)

            }

        }

        if (days != 0) {

            date.setTimeOfDay(fraction);

        }

        date.setMillis((int)(fraction % 1000));

        fraction /= 1000;

        date.setSeconds((int)(fraction % 60));

        fraction /= 60;

        date.setMinutes((int)(fraction % 60));

        date.setHours((int)(fraction / 60));

        return (int)days;

    }

}