/*
 * Decompiled with CFR 0.152.
 */
package javax.baja.timezone;

import com.tridium.timezone.HistoricalDstRule;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.SimpleTimeZone;
import java.util.StringTokenizer;
import java.util.TimeZone;
import javax.baja.sys.BAbsTime;
import javax.baja.sys.BMonth;
import javax.baja.sys.BTime;
import javax.baja.sys.BWeekday;
import javax.baja.timezone.BTimeZone;
import javax.baja.timezone.TimeZoneException;

/*
 * Illegal identifiers - consider using --renameillegalidents true
 */
public final class DstRule {
    public static final int UNDEFINED = -1;
    public static final short WALL_TIME = 0;
    public static final short STANDARD_TIME = 1;
    public static final short UTC_TIME = 2;
    public static final int WEEKDAY = -1;
    public static final short EXACT = 0;
    public static final short ON_OR_AFTER = 1;
    public static final short ON_OR_BEFORE = 2;
    public static final short FIRST = 0;
    public static final short SECOND = 1;
    public static final short THIRD = 2;
    public static final short FOURTH = 3;
    public static final short FIFTH = 4;
    public static final short LAST = 5;
    public static final int START = 0;
    public static final int END = 1;
    private int cacheYear;
    private int cacheBoundary;
    private BTimeZone cacheTimeZone;
    private BAbsTime cachedTime;
    private BTime timeOfDay;
    private int timeMode;
    private BMonth month;
    private int day;
    private int dayMode;
    private BWeekday weekday;
    private int week;

    public static final Object fw(int n, Object object) {
        if (n == 1103 && object != null) {
            return DstRule.makeFromHistorical((HistoricalDstRule)object);
        }
        return null;
    }

    private static final DstRule makeFromHistorical(HistoricalDstRule historicalDstRule) {
        short s = historicalDstRule.getOccursOnAnnualDate().getTheDay().getDayExpressedAs();
        short s2 = historicalDstRule.getOccursOnAnnualDate().getTheDay().getCalendarDay();
        if (s == 0 && s2 != 0) {
            return DstRule.makeExact(historicalDstRule.getOccursOnAnnualDate().getTheTimeOfDay(), historicalDstRule.getOccursOnAnnualDate().getTheTimeOfDayIsExpressedAs(), historicalDstRule.getOccursOnAnnualDate().getTheMonth(), historicalDstRule.getOccursOnAnnualDate().getTheDay().getCalendarDay());
        }
        if (s == 1 && s2 != 0) {
            return DstRule.makeOnOrAfter(historicalDstRule.getOccursOnAnnualDate().getTheTimeOfDay(), historicalDstRule.getOccursOnAnnualDate().getTheTimeOfDayIsExpressedAs(), historicalDstRule.getOccursOnAnnualDate().getTheMonth(), historicalDstRule.getOccursOnAnnualDate().getTheDay().getCalendarDay(), historicalDstRule.getOccursOnAnnualDate().getTheDay().getDayOfWeek());
        }
        if (s == 2 && s2 != 0) {
            return DstRule.makeOnOrBefore(historicalDstRule.getOccursOnAnnualDate().getTheTimeOfDay(), historicalDstRule.getOccursOnAnnualDate().getTheTimeOfDayIsExpressedAs(), historicalDstRule.getOccursOnAnnualDate().getTheMonth(), historicalDstRule.getOccursOnAnnualDate().getTheDay().getCalendarDay(), historicalDstRule.getOccursOnAnnualDate().getTheDay().getDayOfWeek());
        }
        if (s == 0 || s == 1 || s == 2 || s == 3 || s == 4 || s == 5) {
            return DstRule.makeWeekday(historicalDstRule.getOccursOnAnnualDate().getTheTimeOfDay(), historicalDstRule.getOccursOnAnnualDate().getTheTimeOfDayIsExpressedAs(), historicalDstRule.getOccursOnAnnualDate().getTheDay().getDayExpressedAs(), historicalDstRule.getOccursOnAnnualDate().getTheDay().getDayOfWeek(), historicalDstRule.getOccursOnAnnualDate().getTheMonth());
        }
        return null;
    }

    public static final DstRule makeExact(BTime bTime, BMonth bMonth, int n) {
        return DstRule.makeExact(bTime, 0, bMonth, n);
    }

    public static final DstRule makeExact(BTime bTime, int n, BMonth bMonth, int n2) {
        DstRule dstRule = new DstRule();
        dstRule.timeOfDay = bTime;
        dstRule.timeMode = n;
        dstRule.month = bMonth;
        dstRule.day = n2;
        dstRule.dayMode = 0;
        dstRule.weekday = null;
        dstRule.week = -1;
        return dstRule;
    }

    public static final DstRule makeWeekday(BTime bTime, int n, BWeekday bWeekday, BMonth bMonth) {
        return DstRule.makeWeekday(bTime, 0, n, bWeekday, bMonth);
    }

    public static final DstRule makeWeekday(BTime bTime, int n, int n2, BWeekday bWeekday, BMonth bMonth) {
        if (n != 0 && n != 1 && n != 2) {
            throw new IllegalArgumentException("Invalid time mode: " + n);
        }
        DstRule dstRule = new DstRule();
        dstRule.timeOfDay = bTime;
        dstRule.timeMode = n;
        dstRule.month = bMonth;
        dstRule.weekday = bWeekday;
        dstRule.week = n2;
        dstRule.day = 0;
        dstRule.dayMode = -1;
        return dstRule;
    }

    public static final DstRule makeOnOrAfter(BTime bTime, BMonth bMonth, int n, BWeekday bWeekday) {
        return DstRule.makeOnOrAfter(bTime, 0, bMonth, n, bWeekday);
    }

    public static final DstRule makeOnOrAfter(BTime bTime, int n, BMonth bMonth, int n2, BWeekday bWeekday) {
        if (n != 0 && n != 1 && n != 2) {
            throw new IllegalArgumentException("Invalid time mode: " + n);
        }
        DstRule dstRule = new DstRule();
        dstRule.timeOfDay = bTime;
        dstRule.timeMode = n;
        dstRule.month = bMonth;
        dstRule.day = n2;
        dstRule.dayMode = 1;
        dstRule.weekday = bWeekday;
        dstRule.week = -1;
        return dstRule;
    }

    public static final DstRule makeOnOrBefore(BTime bTime, BMonth bMonth, int n, BWeekday bWeekday) {
        return DstRule.makeOnOrBefore(bTime, 0, bMonth, n, bWeekday);
    }

    public static final DstRule makeOnOrBefore(BTime bTime, int n, BMonth bMonth, int n2, BWeekday bWeekday) {
        if (n != 0 && n != 1 && n != 2) {
            throw new IllegalArgumentException("Invalid time mode: " + n);
        }
        DstRule dstRule = new DstRule();
        dstRule.timeOfDay = bTime;
        dstRule.timeMode = n;
        dstRule.month = bMonth;
        dstRule.day = n2;
        dstRule.dayMode = 2;
        dstRule.weekday = bWeekday;
        dstRule.week = -1;
        return dstRule;
    }

    public final BTime getTime() {
        return this.timeOfDay;
    }

    public final int getTimeMode() {
        return this.timeMode;
    }

    public final int getWeek() {
        return this.week;
    }

    public final BWeekday getWeekday() {
        return this.weekday;
    }

    public final BMonth getMonth() {
        return this.month;
    }

    public final int getDay() {
        return this.day;
    }

    public final int getDayMode() {
        return this.dayMode;
    }

    public final synchronized BAbsTime getTime(int n, BTimeZone bTimeZone, int n2) {
        if (n2 != 0 && n2 != 1) {
            throw new IllegalArgumentException("Invalid boundary: " + n2);
        }
        if (this.cacheYear == n && bTimeZone.equals(this.cacheTimeZone) && this.cacheBoundary == n2) {
            return this.cachedTime;
        }
        this.cacheYear = n;
        this.cacheTimeZone = bTimeZone;
        this.cacheBoundary = n2;
        this.cachedTime = this.calculateTime(n, bTimeZone, n2);
        return this.cachedTime;
    }

    private final BAbsTime calculateTime(int n, BTimeZone bTimeZone, int n2) {
        GregorianCalendar gregorianCalendar = new GregorianCalendar(BTimeZone.getJavaUTCInstance());
        gregorianCalendar.clear();
        gregorianCalendar.set(1, n);
        gregorianCalendar.set(2, this.month.getOrdinal());
        if (this.dayMode == -1) {
            if (this.week == 5 || this.week == 4) {
                gregorianCalendar.set(5, BAbsTime.getDaysInMonth(n, this.month));
                gregorianCalendar.setLenient(false);
                while (gregorianCalendar.get(7) != this.weekday.getOrdinal() + 1) {
                    ((Calendar)gregorianCalendar).add(5, -1);
                }
            } else {
                int n3;
                if (this.week == 0) {
                    n3 = 1;
                } else if (this.week == 1) {
                    n3 = 8;
                } else if (this.week == 2) {
                    n3 = 15;
                } else if (this.week == 3) {
                    n3 = 22;
                } else {
                    throw new IllegalArgumentException("Invalid week: " + this.week);
                }
                gregorianCalendar.set(5, n3);
                gregorianCalendar.setLenient(false);
                while (gregorianCalendar.get(7) != this.weekday.getOrdinal() + 1) {
                    ((Calendar)gregorianCalendar).add(5, 1);
                }
            }
        } else if (this.dayMode == 0) {
            gregorianCalendar.set(5, this.day);
        } else if (this.dayMode == 1 || this.dayMode == 2) {
            gregorianCalendar.set(5, this.day);
            gregorianCalendar.setLenient(false);
            while (gregorianCalendar.get(7) != this.weekday.getOrdinal() + 1) {
                if (this.dayMode == 1) {
                    ((Calendar)gregorianCalendar).add(5, 1);
                    continue;
                }
                ((Calendar)gregorianCalendar).add(5, -1);
            }
        } else {
            throw new IllegalStateException("Cannot compute dst rule time.");
        }
        gregorianCalendar.set(11, this.timeOfDay.getHour());
        gregorianCalendar.set(12, this.timeOfDay.getMinute());
        gregorianCalendar.set(13, this.timeOfDay.getSecond());
        gregorianCalendar.set(14, this.timeOfDay.getSecond());
        if (this.timeMode == 2) {
            return BAbsTime.make(gregorianCalendar.getTimeInMillis(), bTimeZone);
        }
        if (this.timeMode == 1) {
            return BAbsTime.make(gregorianCalendar.getTimeInMillis() - (long)bTimeZone.getUtcOffset(gregorianCalendar.getTimeInMillis()), bTimeZone);
        }
        if (this.timeMode == 0) {
            long l = gregorianCalendar.getTimeInMillis() - (long)bTimeZone.getUtcOffset(gregorianCalendar.getTimeInMillis());
            if (n2 == 1) {
                l -= (long)bTimeZone.getDaylightAdjustment(gregorianCalendar.getTimeInMillis());
            }
            return BAbsTime.make(l, bTimeZone);
        }
        throw new IllegalArgumentException("Invalid time mode: " + this.timeMode);
    }

    public static final DstRule getWallTimeRule(DstRule dstRule, int n, BTimeZone bTimeZone) {
        return dstRule == null ? null : dstRule.asWallTimeRule(n, bTimeZone);
    }

    private final TimeZone getJavaTimeZone(long l) {
        if (l == 0L) {
            return BTimeZone.getJavaUTCInstance();
        }
        StringBuffer stringBuffer = new StringBuffer("GMT");
        if (l > 0L) {
            stringBuffer.append('+');
        }
        stringBuffer.append(String.valueOf(l / 3600000L));
        stringBuffer.append(":00");
        TimeZone timeZone = TimeZone.getTimeZone(stringBuffer.toString());
        if (timeZone == null) {
            return new SimpleTimeZone((int)l, stringBuffer.toString());
        }
        return timeZone;
    }

    public final DstRule asWallTimeRule(int n, BTimeZone bTimeZone) {
        GregorianCalendar gregorianCalendar;
        block57: {
            block56: {
                if (this.getTimeMode() == 0) {
                    return this;
                }
                if (this.getTimeMode() == 1 && n == 0) {
                    DstRule dstRule = new DstRule();
                    dstRule.timeOfDay = this.timeOfDay;
                    dstRule.timeMode = 0;
                    dstRule.month = this.month;
                    dstRule.day = this.day;
                    dstRule.dayMode = this.dayMode;
                    dstRule.weekday = this.weekday;
                    dstRule.week = this.week;
                    return dstRule;
                }
                gregorianCalendar = this.getTimeMode() == 2 ? new GregorianCalendar(BTimeZone.getJavaUTCInstance()) : new GregorianCalendar(this.getJavaTimeZone(bTimeZone.getUtcOffset()));
                int n2 = gregorianCalendar.get(1);
                gregorianCalendar.clear();
                gregorianCalendar.set(1, n2);
                gregorianCalendar.set(2, this.getMonth().getOrdinal());
                gregorianCalendar.setLenient(false);
                if (this.getDayMode() != -1) break block56;
                switch (this.getWeek()) {
                    case 0: {
                        gregorianCalendar.set(5, 1);
                        while (gregorianCalendar.get(7) != this.getWeekday().getOrdinal() + 1) {
                            ((Calendar)gregorianCalendar).add(5, 1);
                        }
                        break block57;
                    }
                    case 1: {
                        gregorianCalendar.set(5, 8);
                        while (gregorianCalendar.get(7) != this.getWeekday().getOrdinal() + 1) {
                            ((Calendar)gregorianCalendar).add(5, 1);
                        }
                        break block57;
                    }
                    case 2: {
                        gregorianCalendar.set(5, 15);
                        while (gregorianCalendar.get(7) != this.getWeekday().getOrdinal() + 1) {
                            ((Calendar)gregorianCalendar).add(5, 1);
                        }
                        break block57;
                    }
                    case 3: {
                        gregorianCalendar.set(5, 22);
                        while (gregorianCalendar.get(7) != this.getWeekday().getOrdinal() + 1) {
                            ((Calendar)gregorianCalendar).add(5, 1);
                        }
                        break block57;
                    }
                    case 4: 
                    case 5: {
                        gregorianCalendar.set(5, ((Calendar)gregorianCalendar).getActualMaximum(5));
                        while (gregorianCalendar.get(7) != this.getWeekday().getOrdinal() + 1) {
                            ((Calendar)gregorianCalendar).add(5, -1);
                        }
                        break block57;
                    }
                }
                break block57;
            }
            switch (this.getDayMode()) {
                case 0: {
                    gregorianCalendar.set(5, this.getDay());
                    break;
                }
                case 1: {
                    gregorianCalendar.set(5, this.getDay());
                    while (gregorianCalendar.get(7) != this.getWeekday().getOrdinal() + 1) {
                        ((Calendar)gregorianCalendar).add(5, 1);
                    }
                    break;
                }
                case 2: {
                    gregorianCalendar.set(5, this.getDay());
                    while (gregorianCalendar.get(7) != this.getWeekday().getOrdinal() + 1) {
                        ((Calendar)gregorianCalendar).add(5, -1);
                    }
                    break;
                }
            }
        }
        gregorianCalendar.set(11, this.getTime().getHour());
        gregorianCalendar.set(12, this.getTime().getMinute());
        gregorianCalendar.set(13, this.getTime().getSecond());
        gregorianCalendar.set(14, this.getTime().getMillisecond());
        int n3 = gregorianCalendar.get(5);
        int n4 = 0;
        if (1 <= n3 && n3 < 8) {
            n4 = 0;
        } else if (8 <= n3 && n3 < 15) {
            n4 = 1;
        } else if (15 <= n3 && n3 < 22) {
            n4 = 2;
        } else if (22 <= n3 && n3 < 29) {
            if (this.getWeek() != -1) {
                if (this.getWeek() == 5) {
                    n4 = 5;
                } else if (this.getWeek() == 3) {
                    n4 = 3;
                }
            } else {
                n4 = ((Calendar)gregorianCalendar).getActualMaximum(5) <= 28 ? 5 : (n3 + 7 > ((Calendar)gregorianCalendar).getActualMaximum(5) ? 5 : 3);
            }
        } else if (29 <= n3 && n3 < 32) {
            n4 = 5;
        }
        BMonth bMonth = BMonth.make(gregorianCalendar.get(2));
        long l = 0L;
        if (this.getTimeMode() == 1) {
            l = gregorianCalendar.getTime().getTime() + (long)bTimeZone.getDaylightAdjustment(gregorianCalendar.getTime().getTime());
        } else {
            l = gregorianCalendar.getTime().getTime() + (long)bTimeZone.getUtcOffset(gregorianCalendar.getTime().getTime());
            if (n == 1) {
                l += (long)bTimeZone.getDaylightAdjustment(gregorianCalendar.getTime().getTime());
            }
        }
        gregorianCalendar.setTimeInMillis(l);
        int n5 = gregorianCalendar.get(5);
        BWeekday bWeekday = BWeekday.make(gregorianCalendar.get(7) - 1);
        int n6 = 0;
        if (1 <= n5 && n5 < 8) {
            n6 = 0;
        } else if (8 <= n5 && n5 < 15) {
            n6 = 1;
        } else if (15 <= n5 && n5 < 22) {
            n6 = 2;
        } else if (22 <= n5 && n5 < 29) {
            n6 = ((Calendar)gregorianCalendar).getActualMaximum(5) <= 28 ? 5 : (n5 + 7 > ((Calendar)gregorianCalendar).getActualMaximum(5) ? 5 : 3);
        } else if (29 <= n5 && n5 < 32) {
            n6 = 5;
        }
        BMonth bMonth2 = BMonth.make(gregorianCalendar.get(2));
        if (n3 != n5) {
            if (!bMonth.equals(bMonth2)) {
                return null;
            }
            if (this.getDayMode() != 0) {
                if (this.getDayMode() == 1) {
                    return null;
                }
                if (this.getDayMode() == 2) {
                    return null;
                }
                if (n6 != n4) {
                    return null;
                }
                return null;
            }
        }
        if (this.getDayMode() == -1) {
            return DstRule.makeWeekday(BTime.make(gregorianCalendar.get(11), gregorianCalendar.get(12), gregorianCalendar.get(13), gregorianCalendar.get(14)), 0, n6, bWeekday, bMonth2);
        }
        if (this.getDayMode() == 0) {
            return DstRule.makeExact(BTime.make(gregorianCalendar.get(11), gregorianCalendar.get(12), gregorianCalendar.get(13), gregorianCalendar.get(14)), 0, bMonth2, n5);
        }
        if (this.getDayMode() == 2) {
            return DstRule.makeOnOrBefore(BTime.make(gregorianCalendar.get(11), gregorianCalendar.get(12), gregorianCalendar.get(13), gregorianCalendar.get(14)), 0, this.month, this.day, this.weekday);
        }
        return DstRule.makeOnOrAfter(BTime.make(gregorianCalendar.get(11), gregorianCalendar.get(12), gregorianCalendar.get(13), gregorianCalendar.get(14)), 0, this.month, this.day, this.weekday);
    }

    public static final DstRule asWeekdayRule(DstRule dstRule) throws TimeZoneException {
        if (dstRule == null) {
            return dstRule;
        }
        if (dstRule.getDayMode() == -1) {
            return dstRule;
        }
        if (dstRule.getDayMode() == 0) {
            throw new TimeZoneException("Can't convert rule from exact to nth weekday");
        }
        int n = dstRule.getDay();
        int n2 = 0;
        if (dstRule.getDayMode() == 1) {
            switch (n) {
                case 1: {
                    n2 = 0;
                    break;
                }
                case 8: {
                    n2 = 1;
                    break;
                }
                case 15: {
                    n2 = 2;
                    break;
                }
                case 22: {
                    n2 = 3;
                    break;
                }
                case 29: {
                    n2 = 5;
                    break;
                }
                default: {
                    throw new TimeZoneException("Day = " + n + ". Can not accurately convert from ON_OR_AFTER to NTH day");
                }
            }
        }
        if (dstRule.getDayMode() == 2) {
            switch (n) {
                case 7: {
                    n2 = 0;
                    break;
                }
                case 14: {
                    n2 = 1;
                    break;
                }
                case 21: {
                    n2 = 2;
                    break;
                }
                case 28: {
                    n2 = 3;
                    break;
                }
                default: {
                    throw new TimeZoneException("Day = " + n + ". Can not accurately convert from ON_OR_BEFORE to NTH day");
                }
            }
        }
        return DstRule.makeWeekday(dstRule.getTime(), dstRule.getTimeMode(), n2, dstRule.getWeekday(), dstRule.getMonth());
    }

    public static final boolean equals(DstRule dstRule, DstRule dstRule2) {
        if (dstRule == null) {
            boolean bl = false;
            if (dstRule2 == null) {
                bl = true;
            }
            return bl;
        }
        if (dstRule2 == null) {
            return false;
        }
        boolean bl = false;
        if (dstRule.timeOfDay.equals(dstRule2.timeOfDay) && dstRule.timeMode == dstRule2.timeMode && dstRule.month.equals(dstRule2.month) && dstRule.day == dstRule2.day && dstRule.dayMode == dstRule2.dayMode && dstRule.weekday == dstRule2.weekday && dstRule.week == dstRule2.week) {
            bl = true;
        }
        return bl;
    }

    public static final boolean isEquivalent(DstRule dstRule, DstRule dstRule2, BTimeZone bTimeZone, int n) {
        if (dstRule == null) {
            boolean bl = false;
            if (dstRule2 == null) {
                bl = true;
            }
            return bl;
        }
        if (dstRule == dstRule2) {
            return true;
        }
        DstRule dstRule3 = null;
        DstRule dstRule4 = null;
        try {
            dstRule3 = DstRule.asWeekdayRule(dstRule);
        }
        catch (TimeZoneException timeZoneException) {
            dstRule3 = dstRule;
        }
        try {
            dstRule4 = DstRule.asWeekdayRule(dstRule2);
        }
        catch (TimeZoneException timeZoneException) {
            dstRule4 = dstRule2;
        }
        int n2 = dstRule3.week;
        int n3 = dstRule4.week;
        if (n2 == 4) {
            n2 = 5;
        }
        if (n3 == 4) {
            n3 = 5;
        }
        if (dstRule3.month.equals(dstRule4.month) && dstRule3.day == dstRule4.day && dstRule3.dayMode == dstRule4.dayMode && dstRule3.weekday == dstRule4.weekday && n2 == n3) {
            if (dstRule3.timeMode == dstRule4.timeMode && dstRule3.timeOfDay.equals(dstRule4.timeOfDay)) {
                return true;
            }
            dstRule3 = dstRule3.asWallTimeRule(n, bTimeZone);
            dstRule4 = dstRule4.asWallTimeRule(n, bTimeZone);
            boolean bl = false;
            if (dstRule3 != null && dstRule4 != null && dstRule3.timeOfDay.equals(dstRule4.timeOfDay)) {
                bl = true;
            }
            return bl;
        }
        return false;
    }

    public final boolean equals(Object object) {
        boolean bl = false;
        if (object instanceof DstRule && DstRule.equals(this, (DstRule)object)) {
            bl = true;
        }
        return bl;
    }

    public final boolean isEquivalent(DstRule dstRule, BTimeZone bTimeZone, int n) {
        return DstRule.isEquivalent(this, dstRule, bTimeZone, n);
    }

    public final void encode(DataOutput dataOutput) throws IOException {
        this.timeOfDay.encode(dataOutput);
        dataOutput.writeInt(this.timeMode);
        this.month.encode(dataOutput);
        dataOutput.writeInt(this.day);
        dataOutput.writeInt(this.dayMode);
        boolean bl = false;
        if (this.weekday != null) {
            bl = true;
        }
        dataOutput.writeBoolean(bl);
        if (this.weekday != null) {
            this.weekday.encode(dataOutput);
        }
        dataOutput.writeInt(this.week);
    }

    public static final DstRule decode(DataInput dataInput) throws IOException {
        DstRule dstRule = new DstRule();
        dstRule.timeOfDay = (BTime)BTime.DEFAULT.decode(dataInput);
        dstRule.timeMode = dataInput.readInt();
        dstRule.month = (BMonth)BMonth.january.decode(dataInput);
        dstRule.day = dataInput.readInt();
        dstRule.dayMode = dataInput.readInt();
        if (dataInput.readBoolean()) {
            dstRule.weekday = (BWeekday)BWeekday.sunday.decode(dataInput);
        }
        dstRule.week = dataInput.readInt();
        return dstRule;
    }

    public final String encodeToString() throws IOException {
        StringBuffer stringBuffer = new StringBuffer(128);
        stringBuffer.append(this.timeOfDay.encodeToString());
        stringBuffer.append(',');
        stringBuffer.append(DstRule.encodeTimeMode(this.timeMode));
        stringBuffer.append(',');
        stringBuffer.append(this.month.encodeToString());
        stringBuffer.append(',');
        stringBuffer.append(this.day);
        stringBuffer.append(',');
        stringBuffer.append(DstRule.encodeDayMode(this.dayMode));
        stringBuffer.append(',');
        stringBuffer.append(this.weekday == null ? "null" : this.weekday.encodeToString());
        stringBuffer.append(',');
        stringBuffer.append(DstRule.encodeWeek(this.week));
        return stringBuffer.toString();
    }

    public static final DstRule decodeFromString(String string) throws IOException {
        StringTokenizer stringTokenizer = new StringTokenizer(string, ",");
        DstRule dstRule = new DstRule();
        dstRule.timeOfDay = (BTime)BTime.DEFAULT.decodeFromString(stringTokenizer.nextToken());
        dstRule.timeMode = DstRule.decodeTimeMode(stringTokenizer.nextToken());
        dstRule.month = (BMonth)BMonth.january.decodeFromString(stringTokenizer.nextToken());
        dstRule.day = Integer.parseInt(stringTokenizer.nextToken());
        dstRule.dayMode = DstRule.decodeDayMode(stringTokenizer.nextToken());
        String string2 = stringTokenizer.nextToken();
        if (!string2.equals("null")) {
            dstRule.weekday = (BWeekday)BWeekday.sunday.decodeFromString(string2);
        }
        dstRule.week = DstRule.decodeWeek(stringTokenizer.nextToken());
        return dstRule;
    }

    public static final String encodeDayMode(int n) {
        switch (n) {
            case -1: {
                return "undefined";
            }
            case 0: {
                return "exact";
            }
            case 2: {
                return "on or before";
            }
            case 1: {
                return "on or after";
            }
        }
        return "invalid: " + n;
    }

    public static final int decodeDayMode(String string) {
        if (string.equals("undefined")) {
            return -1;
        }
        if (string.equals("exact")) {
            return 0;
        }
        if (string.equals("on or before")) {
            return 2;
        }
        if (string.equals("on or after")) {
            return 1;
        }
        return -1;
    }

    public static final String encodeWeek(int n) {
        switch (n) {
            case 0: {
                return "first";
            }
            case 1: {
                return "second";
            }
            case 2: {
                return "third";
            }
            case 3: {
                return "fourth";
            }
            case 4: {
                return "fifth";
            }
            case 5: {
                return "last";
            }
            case -1: {
                return "undefined";
            }
        }
        throw new IllegalArgumentException("Invalid week specification: " + n);
    }

    public static final int decodeWeek(String string) {
        if (string.equals("first")) {
            return 0;
        }
        if (string.equals("second")) {
            return 1;
        }
        if (string.equals("third")) {
            return 2;
        }
        if (string.equals("fourth")) {
            return 3;
        }
        if (string.equals("fifth")) {
            return 4;
        }
        if (string.equals("last")) {
            return 5;
        }
        if (string.equals("undefined")) {
            return -1;
        }
        throw new IllegalArgumentException("Invalid week specification: " + string);
    }

    public static final String encodeTimeMode(int n) {
        switch (n) {
            case 0: {
                return "wall";
            }
            case 1: {
                return "standard";
            }
            case 2: {
                return "utc";
            }
        }
        return "invalid: " + n;
    }

    public static final int decodeTimeMode(String string) {
        if (string.equals("wall")) {
            return 0;
        }
        if (string.equals("standard")) {
            return 1;
        }
        if (string.equals("utc")) {
            return 2;
        }
        return -1;
    }

    private final /* synthetic */ void this() {
        this.cacheYear = -1;
        this.cacheBoundary = -1;
    }

    private DstRule() {
        this.this();
    }
}