package com.yami.trading.util;

import com.fasterxml.jackson.core.io.NumberInput;
import com.fasterxml.jackson.databind.util.StdDateFormat;

import java.text.*;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class STDDateformat extends DateFormat {
	/* 24-Jun-2017, tatu: Finally rewrote deserialization to use basic Regex
	 *   instead of SimpleDateFormat; partly for better concurrency, partly
	 *   for easier enforcing of specific rules. Heavy lifting done by Calendar,
	 *   anyway.
	 */
	protected final static String PATTERN_PLAIN_STR = "\\d\\d\\d\\d[-]\\d\\d[-]\\d\\d";

	/**
	 * TODO 自己加入，想加多少加多少
	 */
	protected final static String DATE_FORMAT_STR_FIRST= "yyyy-MM-dd HH:mm:ss";
	protected final static String DATE_FORMAT_STR_SECOND= "EEE MMM dd hh:mm:ss z yyyy";
	protected final static DateFormat DATE_FORMAT_FIRST;//也是同理，照葫芦画瓢
	protected final static DateFormat DATE_FORMAT_SECOND;


	protected final static Pattern PATTERN_PLAIN = Pattern.compile(PATTERN_PLAIN_STR);

	protected final static Pattern PATTERN_ISO8601;
	static {
		Pattern p = null;
		try {
			p = Pattern.compile(PATTERN_PLAIN_STR
					+"[T]\\d\\d[:]\\d\\d(?:[:]\\d\\d)?" // hours, minutes, optional seconds
					+"(\\.\\d+)?" // optional second fractions
					+"(Z|[+-]\\d\\d(?:[:]?\\d\\d)?)?" // optional timeoffset/Z
			);
		} catch (Throwable t) {
			throw new RuntimeException(t);
		}
		PATTERN_ISO8601 = p;
	}

	/**
	 * Defines a commonly used date format that conforms
	 * to ISO-8601 date formatting standard, when it includes basic undecorated
	 * timezone definition.
	 */
	public final static String DATE_FORMAT_STR_ISO8601 = "yyyy-MM-dd'T'HH:mm:ss.SSSX";

	/**
	 * ISO-8601 with just the Date part, no time: needed for error messages
	 */
	protected final static String DATE_FORMAT_STR_PLAIN = "yyyy-MM-dd";

	/**
	 * This constant defines the date format specified by
	 * RFC 1123 / RFC 822. Used for parsing via `SimpleDateFormat` as well as
	 * error messages.
	 */
	protected final static String DATE_FORMAT_STR_RFC1123 = "EEE, dd MMM yyyy HH:mm:ss zzz";

	/**
	 * For error messages we'll also need a list of all formats.
	 */
	protected final static String[] ALL_FORMATS = new String[] {
			DATE_FORMAT_STR_ISO8601,
			"yyyy-MM-dd'T'HH:mm:ss.SSS", // ISO-8601 but no timezone
			//DATE_FORMAT_STR_ISO8601_Z,
			//DATE_FORMAT_STR_ISO8601_NO_TZ,
			DATE_FORMAT_STR_RFC1123,
			DATE_FORMAT_STR_PLAIN,
			DATE_FORMAT_STR_FIRST,//把刚写的两个转换格式加入
			DATE_FORMAT_STR_SECOND
	};

	/**
	 * By default we use UTC for everything, with Jackson 2.7 and later
	 * (2.6 and earlier relied on GMT)
	 */
	protected final static TimeZone DEFAULT_TIMEZONE;
	static {
		DEFAULT_TIMEZONE = TimeZone.getTimeZone("UTC"); // since 2.7
	}

	protected final static Locale DEFAULT_LOCALE = Locale.US;

	protected final static DateFormat DATE_FORMAT_RFC1123;

	/* Let's construct "blueprint" date format instances: cannot be used
	 * as is, due to thread-safety issues, but can be used for constructing
	 * actual instances more cheaply (avoids re-parsing).
	 */
	static {
		// Another important thing: let's force use of default timezone for
		// baseline DataFormat objects
		DATE_FORMAT_RFC1123 = new SimpleDateFormat(DATE_FORMAT_STR_RFC1123, DEFAULT_LOCALE);
		DATE_FORMAT_RFC1123.setTimeZone(DEFAULT_TIMEZONE);

		DATE_FORMAT_FIRST = new SimpleDateFormat(DATE_FORMAT_STR_FIRST, DEFAULT_LOCALE);
		DATE_FORMAT_FIRST.setTimeZone(DEFAULT_TIMEZONE);
		DATE_FORMAT_SECOND = new SimpleDateFormat(DATE_FORMAT_STR_SECOND, DEFAULT_LOCALE);
		DATE_FORMAT_SECOND.setTimeZone(DEFAULT_TIMEZONE);
	}

	/**
	 * A singleton instance can be used for cloning purposes, as a blueprint of sorts.
	 */
	public final static StdDateFormat instance = new StdDateFormat();

	/**
	 * Blueprint "Calendar" instance for use during formatting. Cannot be used as is,
	 * due to thread-safety issues, but can be used for constructing actual instances
	 * more cheaply by cloning.
	 *
	 * @since 2.9.1
	 */
	protected static final Calendar CALENDAR = new GregorianCalendar(DEFAULT_TIMEZONE, DEFAULT_LOCALE);

	/**
	 * Caller may want to explicitly override timezone to use; if so,
	 * we will have non-null value here.
	 */
	protected transient TimeZone _timezone;

	protected final Locale _locale;

	/**
	 * Explicit override for leniency, if specified.
	 *<p>
	 * Cannot be `final` because {@link #setLenient(boolean)} returns
	 * `void`.
	 *
	 * @since 2.7
	 */
	protected Boolean _lenient;

	/**
	 * Lazily instantiated calendar used by this instance for serialization ({@link #format(Date)}).
	 *
	 * @since 2.9.1
	 */
	private transient Calendar _calendar;

	private transient DateFormat _formatRFC1123;

	/**
	 * Whether the TZ offset must be formatted with a colon between hours and minutes ({@code HH:mm} format)
	 *<p>
	 * Defaults to {@code true} since 2.11: earlier versions defaulted to {@code false}
	 * for backwards compatibility reasons
	 *
	 * @since 2.9.1
	 */
	private boolean _tzSerializedWithColon = true;

    /*
    /**********************************************************
    /* Life cycle, accessing singleton "standard" formats
    /**********************************************************
     */

	public STDDateformat() {
		_locale = DEFAULT_LOCALE;
	}

	@Deprecated // since 2.7
	public STDDateformat(TimeZone tz, Locale loc) {
		_timezone = tz;
		_locale = loc;
	}

	protected STDDateformat(TimeZone tz, Locale loc, Boolean lenient) {
		this(tz, loc, lenient, false);
	}

	/**
	 * @since 2.9.1
	 */
	protected STDDateformat(TimeZone tz, Locale loc, Boolean lenient,
                            boolean formatTzOffsetWithColon) {
		_timezone = tz;
		_locale = loc;
		_lenient = lenient;
		_tzSerializedWithColon = formatTzOffsetWithColon;
	}

	public static TimeZone getDefaultTimeZone() {
		return DEFAULT_TIMEZONE;
	}

	/**
	 * Method used for creating a new instance with specified timezone;
	 * if no timezone specified, defaults to the default timezone (UTC).
	 */
	public STDDateformat withTimeZone(TimeZone tz) {
		if (tz == null) {
			tz = DEFAULT_TIMEZONE;
		}
		if ((tz == _timezone) || tz.equals(_timezone)) {
			return this;
		}
		return new STDDateformat(tz, _locale, _lenient, _tzSerializedWithColon);
	}

	/**
	 * "Mutant factory" method that will return an instance that uses specified
	 * {@code Locale}:
	 * either {@code this} instance (if setting would not change), or newly
	 * constructed instance with different {@code Locale} to use.
	 */
	public STDDateformat withLocale(Locale loc) {
		if (loc.equals(_locale)) {
			return this;
		}
		return new STDDateformat(_timezone, loc, _lenient, _tzSerializedWithColon);
	}

	/**
	 * "Mutant factory" method that will return an instance that has specified leniency
	 * setting: either {@code this} instance (if setting would not change), or newly
	 * constructed instance.
	 *
	 * @since 2.9
	 */
	public STDDateformat withLenient(Boolean b) {
		if (_equals(b, _lenient)) {
			return this;
		}
		return new STDDateformat(_timezone, _locale, b, _tzSerializedWithColon);
	}

	/**
	 * "Mutant factory" method that will return an instance that has specified
	 * handling of colon when serializing timezone (timezone either written
	 * like {@code +0500} or {@code +05:00}):
	 * either {@code this} instance (if setting would not change), or newly
	 * constructed instance with desired setting for colon inclusion.
	 *<p>
	 * NOTE: does NOT affect deserialization as colon is optional accepted
	 * but not required -- put another way, either serialization is accepted
	 * by this class.
	 *
	 * @since 2.9.1
	 */
	public STDDateformat withColonInTimeZone(boolean b) {
		if (_tzSerializedWithColon == b) {
			return this;
		}
		return new STDDateformat(_timezone, _locale, _lenient, b);
	}

	@Override
	public STDDateformat clone() {
		// Although there isn't that much state to share, we do need to
		// orchestrate a bit, mostly since timezones may be changed
		return new STDDateformat(_timezone, _locale, _lenient, _tzSerializedWithColon);
	}

	/**
	 * Method for getting a non-shared DateFormat instance
	 * that uses specified timezone and can handle simple ISO-8601
	 * compliant date format.
	 *
	 * @since 2.4
	 *
	 * @deprecated Since 2.9
	 */
	@Deprecated // since 2.9
	public static DateFormat getISO8601Format(TimeZone tz, Locale loc) {
		DateFormat df = new SimpleDateFormat(DATE_FORMAT_STR_ISO8601, loc);
		df.setTimeZone(DEFAULT_TIMEZONE);
		return df;
	}

	/**
	 * Method for getting a non-shared DateFormat instance
	 * that uses specific timezone and can handle RFC-1123
	 * compliant date format.
	 *
	 * @since 2.4
	 *
	 * @deprecated Since 2.9
	 */
	@Deprecated // since 2.9
	public static DateFormat getRFC1123Format(TimeZone tz, Locale loc) {
		return _cloneFormat(DATE_FORMAT_RFC1123, DATE_FORMAT_STR_RFC1123,
				tz, loc, null);
	}

    /*
    /**********************************************************
    /* Public API, configuration
    /**********************************************************
     */

	@Override // since 2.6
	public TimeZone getTimeZone() {
		return _timezone;
	}

	@Override
	public void setTimeZone(TimeZone tz)
	{
		// DateFormats are timezone-specific (via Calendar contained),
		// so need to reset instances if timezone changes:
		if (!tz.equals(_timezone)) {
			_clearFormats();
			_timezone = tz;
		}
	}

	/**
	 * Need to override since we need to keep track of leniency locally,
	 * and not via underlying {@link Calendar} instance like base class
	 * does.
	 */
	@Override // since 2.7
	public void setLenient(boolean enabled) {
		Boolean newValue = Boolean.valueOf(enabled);
		if (!_equals(newValue, _lenient)) {
			_lenient = newValue;
			// and since leniency settings may have been used:
			_clearFormats();
		}
	}

	@Override // since 2.7
	public boolean isLenient() {
		// default is, I believe, true
		return (_lenient == null) || _lenient.booleanValue();
	}

	/**
	 * Accessor for checking whether this instance would include colon
	 * within timezone serialization or not: if {code true}, timezone offset
	 * is serialized like {@code -06:00}; if {code false} as {@code -0600}.
	 *<p>
	 * NOTE: only relevant for serialization (formatting), as deserialization
	 * (parsing) always accepts optional colon but does not require it, regardless
	 * of this setting.
	 *
	 * @return {@code true} if a colon is to be inserted between the hours and minutes
	 * of the TZ offset when serializing as String; otherwise {@code false}
	 *
	 * @since 2.9.1
	 */
	public boolean isColonIncludedInTimeZone() {
		return _tzSerializedWithColon;
	}

    /*
    /**********************************************************
    /* Public API, parsing
    /**********************************************************
     */

	@Override
	public Date parse(String dateStr) throws ParseException
	{
		dateStr = dateStr.trim();
		ParsePosition pos = new ParsePosition(0);
		Date dt = _parseDate(dateStr, pos);
		if (dt != null) {
			return dt;
		}
		StringBuilder sb = new StringBuilder();
		for (String f : ALL_FORMATS) {
			if (sb.length() > 0) {
				sb.append("\", \"");
			} else {
				sb.append('"');
			}
			sb.append(f);
		}
		sb.append('"');
		throw new ParseException
				(String.format("Cannot parse date \"%s\": not compatible with any of standard forms (%s)",
						dateStr, sb.toString()), pos.getErrorIndex());
	}

	// 24-Jun-2017, tatu: I don't think this ever gets called. So could... just not implement?
	@Override
	public Date parse(String dateStr, ParsePosition pos)
	{
		try {
			return _parseDate(dateStr, pos);
		} catch (ParseException e) {
			// may look weird but this is what `DateFormat` suggest to do...
		}
		return null;
	}

	protected Date _parseDate(String dateStr, ParsePosition pos) throws ParseException
	{
		if (looksLikeISO8601(dateStr)) { // also includes "plain"
			return parseAsISO8601(dateStr, pos);
		}
		// Also consider "stringified" simple time stamp
		int i = dateStr.length();
		while (--i >= 0) {
			char ch = dateStr.charAt(i);
			if (ch < '0' || ch > '9') {
				// 07-Aug-2013, tatu: And [databind#267] points out that negative numbers should also work
				if (i > 0 || ch != '-') {
					break;
				}
			}
		}
		if ((i < 0)
				// let's just assume negative numbers are fine (can't be RFC-1123 anyway); check length for positive
				&& (dateStr.charAt(0) == '-' || NumberInput.inLongRange(dateStr, false))) {
			return _parseDateFromLong(dateStr, pos);
		}
		// Otherwise, fall back to using RFC 1123. NOTE: call will NOT throw, just returns `null`
		return parseAsRFC1123(dateStr, pos);
	}

    /*
    /**********************************************************
    /* Public API, writing
    /**********************************************************
     */

	@Override
	public StringBuffer format(Date date, StringBuffer toAppendTo,
							   FieldPosition fieldPosition)
	{
		TimeZone tz = _timezone;
		if (tz == null) {
			tz = DEFAULT_TIMEZONE;
		}
		_format(tz, _locale, date, toAppendTo);
		return toAppendTo;
	}

	protected void _format(TimeZone tz, Locale loc, Date date,
						   StringBuffer buffer)
	{
		Calendar cal = _getCalendar(tz);
		cal.setTime(date);
		// [databind#2167]: handle range beyond [1, 9999]
		final int year = cal.get(Calendar.YEAR);

		// Assuming GregorianCalendar, special handling needed for BCE (aka BC)
		if (cal.get(Calendar.ERA) == GregorianCalendar.BC) {
			_formatBCEYear(buffer, year);
		} else {
			if (year > 9999) {
				// 22-Nov-2018, tatu: Handling beyond 4-digits is not well specified wrt ISO-8601, but
				//   it seems that plus prefix IS mandated. Padding is an open question, but since agreeement
				//   for max length would be needed, we ewould need to limit to arbitrary length
				//   like five digits (erroring out if beyond or padding to that as minimum).
				//   Instead, let's just print number out as is and let decoder try to make sense of it.
				buffer.append('+');
			}
			pad4(buffer, year);
		}
		buffer.append('-');
		pad2(buffer, cal.get(Calendar.MONTH) + 1);
		buffer.append('-');
		pad2(buffer, cal.get(Calendar.DAY_OF_MONTH));
		buffer.append('T');
		pad2(buffer, cal.get(Calendar.HOUR_OF_DAY));
		buffer.append(':');
		pad2(buffer, cal.get(Calendar.MINUTE));
		buffer.append(':');
		pad2(buffer, cal.get(Calendar.SECOND));
		buffer.append('.');
		pad3(buffer, cal.get(Calendar.MILLISECOND));

		int offset = tz.getOffset(cal.getTimeInMillis());
		if (offset != 0) {
			int hours = Math.abs((offset / (60 * 1000)) / 60);
			int minutes = Math.abs((offset / (60 * 1000)) % 60);
			buffer.append(offset < 0 ? '-' : '+');
			pad2(buffer, hours);
			if( _tzSerializedWithColon ) {
				buffer.append(':');
			}
			pad2(buffer, minutes);
		} else {
			// 24-Jun-2017, tatu: While `Z` would be conveniently short, older specs
			//   mandate use of full `+0000`
			// 06-Mar-2020, tatu: Actually statement should read "for compatibility reasons"
			//   and not standards (unless it is wrt RFC-1123). This will change in 3.0 at latest
//            formatted.append('Z');
			if( _tzSerializedWithColon ) {
				buffer.append("+00:00");
			} else {
				buffer.append("+0000");
			}
		}
	}

	protected void _formatBCEYear(StringBuffer buffer, int bceYearNoSign) {
		// Ok. First of all, BCE 1 output (given as value `1` in era BCE) needs to become
		// "+0000", but rest (from `2` up, in that era) need minus sign.
		if (bceYearNoSign == 1) {
			buffer.append("+0000");
			return;
		}
		final int isoYear = bceYearNoSign - 1;
		buffer.append('-');
		// as with CE, 4 digit variant needs padding; beyond that not (although that part is
		// open to debate, needs agreement with receiver)
		// But `pad4()` deals with "big" numbers now so:
		pad4(buffer, isoYear);
	}

	private static void pad2(StringBuffer buffer, int value) {
		int tens = value / 10;
		if (tens == 0) {
			buffer.append('0');
		} else {
			buffer.append((char) ('0' + tens));
			value -= 10 * tens;
		}
		buffer.append((char) ('0' + value));
	}

	private static void pad3(StringBuffer buffer, int value) {
		int h = value / 100;
		if (h == 0) {
			buffer.append('0');
		} else {
			buffer.append((char) ('0' + h));
			value -= (h * 100);
		}
		pad2(buffer, value);
	}

	private static void pad4(StringBuffer buffer, int value) {
		int h = value / 100;
		if (h == 0) {
			buffer.append('0').append('0');
		} else {
			if (h > 99) { // [databind#2167]: handle above 9999 correctly
				buffer.append(h);
			} else {
				pad2(buffer, h);
			}
			value -= (100 * h);
		}
		pad2(buffer, value);
	}

    /*
    /**********************************************************
    /* Std overrides
    /**********************************************************
     */

	@Override
	public String toString() {
		return String.format("DateFormat %s: (timezone: %s, locale: %s, lenient: %s)",
				getClass().getName(), _timezone, _locale, _lenient);
	}

	public String toPattern() { // same as SimpleDateFormat
		StringBuilder sb = new StringBuilder(100);
		sb.append("[one of: '")
				.append(DATE_FORMAT_STR_ISO8601)
				.append("', '")
				.append(DATE_FORMAT_STR_RFC1123)
				.append("' (")
		;
		sb.append(Boolean.FALSE.equals(_lenient) ?
				"strict" : "lenient")
				.append(")]");
		return sb.toString();
	}

	@Override // since 2.7[.2], as per [databind#1130]
	public boolean equals(Object o) {
		return (o == this);
	}

	@Override // since 2.7[.2], as per [databind#1130]
	public int hashCode() {
		return System.identityHashCode(this);
	}

    /*
    /**********************************************************
    /* Helper methods, parsing
    /**********************************************************
     */

	/**
	 * Helper method used to figure out if input looks like valid
	 * ISO-8601 string.
	 */
	protected boolean looksLikeISO8601(String dateStr)
	{
		if (dateStr.length() >= 7 // really need 10, but...
				&& Character.isDigit(dateStr.charAt(0))
				&& Character.isDigit(dateStr.charAt(3))
				&& dateStr.charAt(4) == '-'
				&& Character.isDigit(dateStr.charAt(5))
		) {
			return true;
		}
		return false;
	}

	private Date _parseDateFromLong(String longStr, ParsePosition pos) throws ParseException
	{
		long ts;
		try {
			ts = NumberInput.parseLong(longStr);
		} catch (NumberFormatException e) {
			throw new ParseException(String.format(
					"Timestamp value %s out of 64-bit value range", longStr),
					pos.getErrorIndex());
		}
		return new Date(ts);
	}

	protected Date parseAsISO8601(String dateStr, ParsePosition pos)
			throws ParseException
	{
		try {
			return _parseAsISO8601(dateStr, pos);
		} catch (IllegalArgumentException e) {
			throw new ParseException(String.format("Cannot parse date \"%s\", problem: %s",
					dateStr, e.getMessage()),
					pos.getErrorIndex());
		}
	}

	protected Date _parseAsISO8601(String dateStr, ParsePosition bogus)
			throws IllegalArgumentException, ParseException
	{
		final int totalLen = dateStr.length();
		// actually, one short-cut: if we end with "Z", must be UTC
		TimeZone tz = DEFAULT_TIMEZONE;
		if ((_timezone != null) && ('Z' != dateStr.charAt(totalLen-1))) {
			tz = _timezone;
		}
		Calendar cal = _getCalendar(tz);
		cal.clear();
		String formatStr;
		if (totalLen <= 10) {
			Matcher m = PATTERN_PLAIN.matcher(dateStr);
			if (m.matches()) {
				int year = _parse4D(dateStr, 0);
				int month = _parse2D(dateStr, 5)-1;
				int day = _parse2D(dateStr, 8);

				cal.set(year, month, day, 0, 0, 0);
				cal.set(Calendar.MILLISECOND, 0);
				return cal.getTime();
			}
			formatStr = DATE_FORMAT_STR_PLAIN;
		} else {
			Matcher m = PATTERN_ISO8601.matcher(dateStr);
			if (m.matches()) {
				// Important! START with optional time zone; otherwise Calendar will explode

				int start = m.start(2);
				int end = m.end(2);
				int len = end-start;
				if (len > 1) { // 0 -> none, 1 -> 'Z'
					// NOTE: first char is sign; then 2 digits, then optional colon, optional 2 digits
					int offsetSecs = _parse2D(dateStr, start+1) * 3600; // hours
					if (len >= 5) {
						offsetSecs += _parse2D(dateStr, end-2) * 60; // minutes
					}
					if (dateStr.charAt(start) == '-') {
						offsetSecs *= -1000;
					} else {
						offsetSecs *= 1000;
					}
					cal.set(Calendar.ZONE_OFFSET, offsetSecs);
					// 23-Jun-2017, tatu: Not sure why, but this appears to be needed too:
					cal.set(Calendar.DST_OFFSET, 0);
				}

				int year = _parse4D(dateStr, 0);
				int month = _parse2D(dateStr, 5)-1;
				int day = _parse2D(dateStr, 8);

				// So: 10 chars for date, then `T`, so starts at 11
				int hour = _parse2D(dateStr, 11);
				int minute = _parse2D(dateStr, 14);

				// Seconds are actually optional... so
				int seconds;
				if ((totalLen > 16) && dateStr.charAt(16) == ':') {
					seconds = _parse2D(dateStr, 17);
				} else {
					seconds = 0;
				}
				cal.set(year, month, day, hour, minute, seconds);

				// Optional milliseconds
				start = m.start(1) + 1;
				end = m.end(1);
				int msecs = 0;
				if (start >= end) { // no fractional
					cal.set(Calendar.MILLISECOND, 0);
				} else {
					// first char is '.', but rest....
					msecs = 0;
					final int fractLen = end-start;
					switch (fractLen) {
						default: // [databind#1745] Allow longer fractions... for now, cap at nanoseconds tho

							if (fractLen > 9) { // only allow up to nanos
								throw new ParseException(String.format(
										"Cannot parse date \"%s\": invalid fractional seconds '%s'; can use at most 9 digits",
										dateStr, m.group(1).substring(1)
								), start);
							}
							// fall through
						case 3:
							msecs += (dateStr.charAt(start+2) - '0');
						case 2:
							msecs += 10 * (dateStr.charAt(start+1) - '0');
						case 1:
							msecs += 100 * (dateStr.charAt(start) - '0');
							break;
						case 0:
							break;
					}
					cal.set(Calendar.MILLISECOND, msecs);
				}
				return cal.getTime();
			}
			formatStr = DATE_FORMAT_STR_ISO8601;
		}

		throw new ParseException
				(String.format("Cannot parse date \"%s\": while it seems to fit format '%s', parsing fails (leniency? %s)",
						dateStr, formatStr, _lenient),
						// [databind#1742]: Might be able to give actual location, some day, but for now
						//  we can't give anything more indicative
						0);
	}

	private static int _parse4D(String str, int index) {
		return (1000 * (str.charAt(index) - '0'))
				+ (100 * (str.charAt(index+1) - '0'))
				+ (10 * (str.charAt(index+2) - '0'))
				+ (str.charAt(index+3) - '0');
	}

	private static int _parse2D(String str, int index) {
		return (10 * (str.charAt(index) - '0'))
				+ (str.charAt(index+1) - '0');
	}

	protected Date parseAsRFC1123(String dateStr, ParsePosition pos)
	{
		if (_formatRFC1123 == null) {
			_formatRFC1123 = _cloneFormat(DATE_FORMAT_RFC1123, DATE_FORMAT_STR_RFC1123,
					_timezone, _locale, _lenient);
		}
		return _formatRFC1123.parse(dateStr, pos);
	}

    /*
    /**********************************************************
    /* Helper methods, other
    /**********************************************************
     */

	private final static DateFormat _cloneFormat(DateFormat df, String format,
												 TimeZone tz, Locale loc, Boolean lenient)
	{
		if (!loc.equals(DEFAULT_LOCALE)) {
			df = new SimpleDateFormat(format, loc);
			df.setTimeZone((tz == null) ? DEFAULT_TIMEZONE : tz);
		} else {
			df = (DateFormat) df.clone();
			if (tz != null) {
				df.setTimeZone(tz);
			}
		}
		if (lenient != null) {
			df.setLenient(lenient.booleanValue());
		}
		return df;
	}

	protected void _clearFormats() {
		_formatRFC1123 = null;
	}

	protected Calendar _getCalendar(TimeZone tz) {
		Calendar cal = _calendar;
		if (cal == null ) {
			_calendar = cal = (Calendar)CALENDAR.clone();
		}
		if (!cal.getTimeZone().equals(tz) ) {
			cal.setTimeZone(tz);
		}
		cal.setLenient(isLenient());
		return cal;
	}

	protected static <T> boolean _equals(T value1, T value2) {
		if (value1 == value2) {
			return true;
		}
		return (value1 != null) && value1.equals(value2);
	}
}