/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.tajo.util.datetime;

import com.google.common.annotations.VisibleForTesting;
import org.apache.tajo.conf.TajoConf;
import org.apache.tajo.datum.Int8Datum;
import org.apache.tajo.exception.ValueOutOfRangeException;
import org.apache.tajo.util.datetime.DateTimeConstants.DateStyle;
import org.apache.tajo.util.datetime.DateTimeConstants.DateToken;
import org.apache.tajo.util.datetime.DateTimeConstants.TokenField;

import javax.annotation.Nullable;
import java.sql.Date;
import java.sql.Time;
import java.sql.Timestamp;
import java.util.TimeZone;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;

/**
 * This Class is originated from j2date in datetime.c of PostgreSQL.
 */
public class DateTimeUtil {
  private static int MAX_FRACTION_LENGTH = 6;

  /** maximum possible number of fields in a date * string */
  private static int MAXDATEFIELDS = 25;

  public static boolean isJulianCalendar(int year, int month, int day) {
    return year <= 1752 && month <= 9 && day < 14;
  }

  public static int getCenturyOfEra(int year) {
    if (year > 0) {
      return (year - 1) / 100 + 1;
    } else if (year < 0) {
      //600BC to 501BC -> -6
      int pYear = -year;
      return -((pYear - 1) / 100 + 1);
    } else {
      return 0;
    }
  }

  public static boolean isLeapYear(int year) {
    return ((year & 3) == 0) && ((year % 100) != 0 || (year % 400) == 0);
  }

  public static int getDaysInYearMonth(int year, int month) {
    if (isLeapYear(year)) {
      return DateTimeConstants.DAY_OF_MONTH[1][month - 1];
    } else {
      return DateTimeConstants.DAY_OF_MONTH[0][month - 1];
    }
  }

  /**
   * Julian date support.
   *
   * isValidJulianDate checks the minimum date exactly, but is a bit sloppy
   * about the maximum, since it's far enough out to not be especially
   * interesting.
   * @param years
   * @param months
   * @param days
   * @return
   */
  public static boolean isValidJulianDate(int years, int months, int days) {
    return years > DateTimeConstants.JULIAN_MINYEAR || years == DateTimeConstants.JULIAN_MINYEAR &&
        months > DateTimeConstants.JULIAN_MINMONTH || months == DateTimeConstants.JULIAN_MINMONTH &&
        days >= DateTimeConstants.JULIAN_MINDAY && years < DateTimeConstants.JULIAN_MAXYEAR;
  }

  /**
   * Calendar time to Julian date conversions.
   * Julian date is commonly used in astronomical applications,
   *	since it is numerically accurate and computationally simple.
   * The algorithms here will accurately convert between Julian day
   *	and calendar date for all non-negative Julian days_full
   *	(i.e. from Nov 24, -4713 on).
   *
   * These routines will be used by other date/time packages
   * - thomas 97/02/25
   *
   * Rewritten to eliminate overflow problems. This now allows the
   * routines to work correctly for all Julian day counts from
   * 0 to 2147483647	(Nov 24, -4713 to Jun 3, 5874898) assuming
   * a 32-bit integer. Longer types should also work to the limits
   * of their precision.
   * @param year
   * @param month
   * @param day
   * @return
   */
  public static int date2j(int year, int month, int day) {
    int julian;
    int century;

    if (month > 2) {
      month += 1;
      year += 4800;
    } else {
      month += 13;
      year += 4799;
    }

    century = year / 100;
    julian = (year * 365) - 32167;
    julian += (((year / 4) - century) + (century / 4));
    julian += ((7834 * month) / 256) + day;

    return julian;
  }

  public static TimeMeta j2date(int julianDate) {
    TimeMeta tm = new TimeMeta();
    j2date(julianDate, tm);
    return tm;
  }

  /**
   * Set TimeMeta's date fields.
   * @param julianDate
   * @param tm
   */
  public static void j2date(int julianDate, TimeMeta tm) {
    long julian;
    long quad;
    long extra;
    long y;

    julian = julianDate;
    julian += 32044;
    quad = julian / 146097;
    extra = (julian - quad * 146097) * 4 + 3;
    julian += 60 + quad * 3 + extra / 146097;
    quad = julian / 1461;
    julian -= quad * 1461;
    y = julian * 4 / 1461;
    julian = ((y != 0) ? ((julian + 305) % 365) : ((julian + 306) % 366))
        + 123;
    y += quad * 4;


    tm.years = (int)(y - 4800);
    quad = julian * 2141 / 65536;
    tm.dayOfMonth = (int)(julian - 7834 * quad / 256);
    tm.monthOfYear = (int) ((quad + 10) % DateTimeConstants.MONTHS_PER_YEAR + 1);
  }

  /**
   * This method is originated from j2date in datetime.c of PostgreSQL.
   *
   * julianToDay - convert Julian date to day-of-week (0..6 == Sun..Sat)
   *
   * Note: various places use the locution julianToDay(date - 1) to produce a
   * result according to the convention 0..6 = Mon..Sun.	This is a bit of
   * a crock, but will work as long as the computation here is just a modulo.
   * @param julianDate
   * @return
   */
  public static int j2day(int julianDate) {
    long day;

    day = julianDate;

    day += 1;
    day %= 7;

    return (int) day;
  }

  /**
   * This method is originated from date2isoweek in timestamp.c of PostgreSQL.
   * Returns ISO week number of year.
   * @param year
   * @param mon
   * @param mday
   * @return
   */
  public static int date2isoweek(int year, int mon, int mday) {
    double result;
    int day0;
    int day4;
    int dayn;

    /* current day */
    dayn = date2j(year, mon, mday);

    /* fourth day of current year */
    day4 = date2j(year, 1, 4);

    /* day0 == offset to first day of week (Monday) */
    day0 = j2day(day4 - 1);

    /*
     * We need the first week containing a Thursday, otherwise this day falls
     * into the previous year for purposes of counting weeks
     */
    if (dayn < day4 - day0) {
      day4 = date2j(year - 1, 1, 4);

      /* day0 == offset to first day of week (Monday) */
      day0 = j2day(day4 - 1);
    }

    result = (dayn - (day4 - day0)) / 7 + 1;

      /*
       * Sometimes the last few days_full in a year will fall into the first week of
       * the next year, so check for this.
       */
    if (result >= 52) {
      day4 = date2j(year + 1, 1, 4);

      /* day0 == offset to first day of week (Monday) */
      day0 = j2day(day4 - 1);

      if (dayn >= day4 - day0) {
        result = (dayn - (day4 - day0)) / 7 + 1;
      }
    }

    return (int) result;
  }

  /**
   * date2isoyear()
   *
   * Returns ISO 8601 year number.
   * @param year
   * @param mon
   * @param mday
   * @return
   */
  public static int date2isoyear(int year, int mon, int mday) {
    /* current day */
    int dayn = date2j(year, mon, mday);

	  /* fourth day of current year */
    int day4 = date2j(year, 1, 4);

	  /* day0 == offset to first day of week (Monday) */
    int day0 = j2day(day4 - 1);

    /*
     * We need the first week containing a Thursday, otherwise this day falls
     * into the previous year for purposes of counting weeks
     */
    if (dayn < day4 - day0) {
      day4 = date2j(year - 1, 1, 4);

		/* day0 == offset to first day of week (Monday) */
      day0 = j2day(day4 - 1);

      year--;
    }

    double result = (dayn - (day4 - day0)) / 7 + 1;

    /*
     * Sometimes the last few days in a year will fall into the first week of
     * the next year, so check for this.
     */
    if (result >= 52) {
      day4 = date2j(year + 1, 1, 4);

		/* day0 == offset to first day of week (Monday) */
      day0 = j2day(day4 - 1);

      if (dayn >= day4 - day0) {
        year++;
      }
    }

    return year;
  }

  /**
   * Converts julian timestamp to epoch.
   * @param timestamp
   * @return
   */
  public static int julianTimeToEpoch(long timestamp) {
    long totalSecs = timestamp / DateTimeConstants.USECS_PER_SEC;
    return (int)(totalSecs + DateTimeConstants.SECS_DIFFERENCE_BETWEEN_JULIAN_AND_UNIXTIME);
  }

  /**
   * Converts julian timestamp to java timestamp.
   * @param timestamp julian time in millisecond
   * @return java time in millisecond
   */
  public static long julianTimeToJavaTime(long timestamp) {
    double totalSecs = (double)timestamp / (double)DateTimeConstants.MSECS_PER_SEC;
    return Math.round(totalSecs + DateTimeConstants.SECS_DIFFERENCE_BETWEEN_JULIAN_AND_UNIXTIME * 1000.0);
  }

  /**
   * Converts java timestamp to julian timestamp.
   * @param javaTimestamp
   * @return
   */
  public static long javaTimeToJulianTime(long javaTimestamp) {
    double totalSecs = javaTimestamp / 1000.0;
    return (long)((totalSecs -
        DateTimeConstants.SECS_DIFFERENCE_BETWEEN_JULIAN_AND_UNIXTIME) * DateTimeConstants.USECS_PER_SEC);
  }

  /**
   * Calculate the time value(hour, minute, sec, fsec)
   * If tm.TomeZone is set, the result value is adjusted.
   * @param tm
   * @return
   */
  public static long toTime(TimeMeta tm) {
    if (tm.timeZone != 0 && tm.timeZone != Integer.MAX_VALUE) {
      int timeZoneSecs = tm.timeZone;
      tm.timeZone = Integer.MAX_VALUE;
      tm.plusMillis(0 - timeZoneSecs * 1000);
    }
    return toTime(tm.hours, tm.minutes, tm.secs, tm.fsecs);
  }

  /**
   * Calculate the time value(hour, minute, sec, fsec)
   * @param hour
   * @param min
   * @param sec
   * @param fsec
   * @return
   */
  public static long toTime(int hour, int min, int sec, int fsec) {
    return (((((hour * DateTimeConstants.MINS_PER_HOUR) + min) *
        DateTimeConstants.SECS_PER_MINUTE) + sec) *
        DateTimeConstants.USECS_PER_SEC) + fsec;
  }

  public static long toJavaTime(int hour, int min, int sec, int fsec) {
    return toTime(hour, min, sec, fsec)/DateTimeConstants.MSECS_PER_SEC;
  }

  public static Timestamp toJavaTimestamp(TimeMeta tm, @Nullable TimeZone tz) {
    long javaTime = DateTimeUtil.julianTimeToJavaTime(DateTimeUtil.toJulianTimestamp(tm));

    if (tz != null) {
      int offset = tz.getOffset(javaTime) - TimeZone.getDefault().getOffset(javaTime);
      return new Timestamp(javaTime + offset);
    } else {
      return new Timestamp(javaTime);
    }
  }

  public static Time toJavaTime(TimeMeta tm, @Nullable TimeZone tz) {
    if (tz != null) {
      DateTimeUtil.toUserTimezone(tm, tz);
    }
    return new Time(tm.hours, tm.minutes, tm.secs);
  }

  public static Date toJavaDate(TimeMeta tm, @Nullable TimeZone tz) {
    if (tz != null) {
      DateTimeUtil.toUserTimezone(tm, tz);
    }
    return new Date(tm.years - 1900, tm.monthOfYear - 1 , tm.dayOfMonth);
  }

  /**
   * Calculate julian timestamp.
   * @param years
   * @param months
   * @param days
   * @param hours
   * @param minutes
   * @param seconds
   * @param fsec
   * @return
   */
  public static long toJulianTimestamp(
      int years, int months, int days, int hours, int minutes, int seconds, int fsec) {
    /* Julian day routines are not correct for negative Julian days_full */
    if (!isValidJulianDate(years, months, days)) {
      throw new ValueOutOfRangeException("Out of Range Julian days_full");
    }

    long numJulianDays = date2j(years, months, days) - DateTimeConstants.POSTGRES_EPOCH_JDATE;

    return toJulianTimestamp(numJulianDays, hours, minutes, seconds, fsec);
  }

  /**
   * Calculate julian timestamp.
   * @param numJulianDays
   * @param hours
   * @param minutes
   * @param seconds
   * @param fsec
   * @return
   */
  private static long toJulianTimestamp(long numJulianDays, int hours, int minutes, int seconds, int fsec) {
    long time = toTime(hours, minutes, seconds, fsec);

    long timestamp = numJulianDays * DateTimeConstants.USECS_PER_DAY + time;
      /* check for major overflow */
    if ((timestamp - time) / DateTimeConstants.USECS_PER_DAY != numJulianDays) {
      throw new RuntimeException("Out of Range of Time");
    }
      /* check for just-barely overflow (okay except time-of-day wraps) */
      /* caution: we want to allow 1999-12-31 24:00:00 */
    if ((timestamp < 0 && numJulianDays > 0) || (timestamp > 0 && numJulianDays < -1)) {
      throw new RuntimeException("Out of Range of Date");
    }

    return timestamp;
  }

  /**
   * Calculate julian timestamp.
   * If tm.TomeZone is set, the result value is adjusted.
   * @param tm
   * @return
   */
  public static long toJulianTimestamp(TimeMeta tm) {
    if (tm.timeZone != 0 && tm.timeZone != Integer.MAX_VALUE) {
      int timeZoneSecs = tm.timeZone;
      tm.timeZone = Integer.MAX_VALUE;
      tm.plusMillis(0 - timeZoneSecs * 1000);
    }
    if (tm.dayOfYear > 0) {
      return toJulianTimestamp(date2j(tm.years, 1, 1) + tm.dayOfYear - 1, tm.hours, tm.minutes, tm.secs, tm.fsecs);
    } else {
      return toJulianTimestamp(tm.years, tm.monthOfYear, tm.dayOfMonth, tm.hours, tm.minutes, tm.secs, tm.fsecs);
    }
  }

  /**
   * Set TimeMeta's field value using given julian timestamp.
   * Note that year is _not_ 1900-based, but is an explicit full value.
   * Also, month is one-based, _not_ zero-based.
   * Returns:
   *	 0 on success
   *	-1 on out of range
   *
   * If attimezone is NULL, the global timezone (including possibly brute forced
   * timezone) will be used.
   */
  public static void toJulianTimeMeta(long julianTimestamp, TimeMeta tm) {
    long date;
    long time;

    // TODO - If timezone is set, timestamp value should be adjusted here.
    time = julianTimestamp;

    // TMODULO
    date = time / DateTimeConstants.USECS_PER_DAY;
    if (date != 0) {
      time -= date * DateTimeConstants.USECS_PER_DAY;
    }
    if (time < 0) {
      time += DateTimeConstants.USECS_PER_DAY;
      date -= 1;
    }

    /* add offset to go from J2000 back to standard Julian date */
    date += DateTimeConstants.POSTGRES_EPOCH_JDATE;

    /* Julian day routine does not work for negative Julian days_full */
    if (date < 0 || date > Integer.MAX_VALUE) {
      throw new RuntimeException("Timestamp Out Of Scope");
    }

    j2date((int) date, tm);
    date2j(time, tm);
  }

  /**
   * This method is originated from dt2time in timestamp.c of PostgreSQL.
   *
   * @param julianDate
   * @return hour, min, sec, fsec
   */
  public static void date2j(long julianDate, TimeMeta tm) {
    long time = julianDate;

    tm.hours = (int) (time / DateTimeConstants.USECS_PER_HOUR);
    time -= tm.hours * DateTimeConstants.USECS_PER_HOUR;
    tm.minutes = (int) (time / DateTimeConstants.USECS_PER_MINUTE);
    time -= tm.minutes * DateTimeConstants.USECS_PER_MINUTE;
    tm.secs = (int) (time / DateTimeConstants.USECS_PER_SEC);
    tm.fsecs = (int) (time - (tm.secs * DateTimeConstants.USECS_PER_SEC));
  }

  /**
   * Decode date string which includes delimiters.
   *
   * This method is originated from DecodeDate() in datetime.c of PostgreSQL.
   * @param str The date string like '2013-12-25'.
   * @param fmask
   * @param tmaskValue
   * @param is2digits
   * @param tm
   */
  private static void decodeDate(String str, int fmask, AtomicInteger tmaskValue,  AtomicBoolean is2digits, TimeMeta tm) {

    int idx = 0;
    int nf = 0;
    TokenField type = null;
    int val = 0;

    AtomicInteger dmask = new AtomicInteger(0);
    int tmask = tmaskValue.get();
    boolean haveTextMonth = false;

    int length = str.length();
    char[] dateStr = str.toCharArray();
    String[] fields = new String[MAXDATEFIELDS];

    while(idx < length && nf < MAXDATEFIELDS) {

      /* skip field separators */
      while (idx < length && !Character.isLetterOrDigit(dateStr[idx])) {
        idx++;
      }

      if (idx == length) {
        throw new IllegalArgumentException("BAD Format: " + str);
      }

      int fieldStartIdx = idx;
      int fieldLength = idx;
      if (Character.isDigit(dateStr[idx])) {
        while (idx < length && Character.isDigit(dateStr[idx])) {
          idx++;
        }
        fieldLength = idx;
      } else if (Character.isLetterOrDigit(dateStr[idx])) {
        while (idx < length && Character.isLetterOrDigit(dateStr[idx])) {
          idx++;
        }
        fieldLength = idx;
      }

      fields[nf] = str.substring(fieldStartIdx, fieldLength);
      nf++;
    }

    /* look first for text fields, since that will be unambiguous month */
    for (int i = 0; i < nf; i++) {
      if (Character.isLetter(fields[i].charAt(0))) {
        DateToken dateToken =  DateTimeConstants.dateTokenMap.get(fields[i].toLowerCase());
        type = dateToken.getType();

        if (type == TokenField.IGNORE_DTF) {
          continue;
        }

        dmask.set(DateTimeConstants.DTK_M(type));
        switch (type) {
          case MONTH:
            tm.monthOfYear = type.getValue();
            haveTextMonth = true;
            break;

          default:
            throw new IllegalArgumentException("BAD Format: " + str);
        }
        if ((fmask & dmask.get()) != 0) {
          throw new IllegalArgumentException("BAD Format: " + str);
        }

        fmask |= dmask.get();
        tmask |= dmask.get();

			/* mark this field as being completed */
        fields[i] = null;
      }
    }

    /* now pick up remaining numeric fields */
    for (int i = 0; i < nf; i++) {
      if (fields[i] == null) {
        continue;
      }

      length = fields[i].length();
      if (length  <= 0) {
        throw new IllegalArgumentException("BAD Format: " + str);
      }

      decodeNumber(length, fields[i], haveTextMonth, fmask, dmask, tm, new AtomicLong(0), is2digits);

      if ( (fmask & dmask.get()) != 0 ) {
        throw new IllegalArgumentException("BAD Format: " + str);
      }
      fmask |= dmask.get();
      tmask |= dmask.get();
    }

    tmaskValue.set(tmask);

    if ((fmask & ~(DateTimeConstants.DTK_M(TokenField.DOY) | DateTimeConstants.DTK_M(TokenField.TZ))) != DateTimeConstants.DTK_DATE_M) {
      throw new IllegalArgumentException("BAD Format: " + str);
    }
  }

  /**
   * Decode time string which includes delimiters.
   * Return 0 if okay, a DTERR code if not.
   *
   * Only check the lower limit on hours, since this same code can be
   * used to represent time spans.
   * @param str
   * @param fmask
   * @param range
   * @param tmask
   * @param tm
   * @param fsec
   */
  private static void decodeTime(String str, int fmask, int range,
             AtomicInteger tmask, TimeMeta tm, AtomicLong fsec) {
    StringBuilder cp = new StringBuilder();

    tmask.set(DateTimeConstants.DTK_TIME_M);

    tm.hours = strtoi(str, 0, cp);
    if (cp.charAt(0) != ':') {
      throw new IllegalArgumentException("BAD Format: " + str);
    }

    tm.minutes = strtoi(cp.toString(), 1, cp);

    if (cp.length() == 0) {
      tm.secs = 0;
      fsec.set(0);
		  /* If it's a MINUTE TO SECOND interval, take 2 fields as being mm:ss */
      if (range == (DateTimeConstants.INTERVAL_MASK(TokenField.MINUTE) | DateTimeConstants.INTERVAL_MASK(TokenField.SECOND))) {
        tm.secs = tm.minutes;
        tm.minutes = tm.hours;
        tm.hours = 0;
      }
    } else if (cp.charAt(0) == '.') {
		  /* always assume mm:ss.sss is MINUTE TO SECOND */
      parseFractionalSecond(cp, fsec);
      tm.secs = tm.minutes;
      tm.minutes = tm.hours;
      tm.hours = 0;
    }
    else if (cp.charAt(0) == ':') {
      tm.secs = strtoi(cp.toString(), 1, cp);
      if (cp.length() == 0){
        fsec.set(0);
      } else if (cp.charAt(0) == '.') {
        parseFractionalSecond(cp, fsec);
      } else{
        throw new IllegalArgumentException("BAD Format: " + str);
      }
    } else {
      throw new IllegalArgumentException("BAD Format: " + str);
    }

	/* do a sanity check */
    if (tm.hours < 0 || tm.minutes < 0 || tm.minutes > DateTimeConstants.MINS_PER_HOUR - 1 ||
        tm.secs < 0 || tm.secs > DateTimeConstants.SECS_PER_MINUTE ||
            fsec.get() < 0 ||
            fsec.get() > DateTimeConstants.USECS_PER_SEC) {
      throw new IllegalArgumentException("BAD Format: FIELD_OVERFLOW: " + str);
    }
  }

  /**
   * Parse datetime string to julian time.
   * The result is the UTC time basis.
   * @param str
   * @return
   */
  public static long toJulianTimestamp(String str) {
    TimeMeta tm = decodeDateTime(str, MAXDATEFIELDS);
    return toJulianTimestamp(tm);
  }


  /**
   * Parse datetime string to UTC-based julian time.
   * The result julian time is adjusted by local timezone.
   *
   * @param timestampStr
   * @param tz Local timezone. If it is NULL, UTC will be used by default.
   * @return UTC-based julian time
   */
  public static long toJulianTimestampWithTZ(String timestampStr, @Nullable TimeZone tz) {
    long timestamp = DateTimeUtil.toJulianTimestamp(timestampStr);
    TimeMeta tm = new TimeMeta();
    DateTimeUtil.toJulianTimeMeta(timestamp, tm);
    if (tz != null) {
      DateTimeUtil.toUTCTimezone(tm, tz);
    }
    return DateTimeUtil.toJulianTimestamp(tm);
  }

  /**
   * Parse datetime string to julian date.
   * @param dateStr
   * @return
   */
  public static int toJulianDate(String dateStr) {
    TimeMeta tm = DateTimeUtil.decodeDateTime(dateStr);
    return DateTimeUtil.date2j(tm.years, tm.monthOfYear, tm.dayOfMonth);
  }

  /**
   * Parse datetime string to julian time.
   * @param timeStr
   * @return
   */
  public static long toJulianTime(String timeStr) {
    TimeMeta tm = DateTimeUtil.decodeDateTime(timeStr);
    return DateTimeUtil.toTime(tm);
  }

  public static TimeMeta decodeDateTime(String str) {
    return decodeDateTime(str, MAXDATEFIELDS);
  }

  /**
   * Break string into tokens based on a date/time context.
   *
   * This method is originated form ParseDateTime() in datetime.c of PostgreSQL.
   *
   * @param str The input string
   * @param maxFields
   */
  public static TimeMeta decodeDateTime(String str, int maxFields) {
    int idx = 0;
    int nf = 0;
    int length = str.length();
    char [] timeStr = str.toCharArray();
    String [] fields = new String[maxFields];
    TokenField[] fieldTypes = new TokenField[maxFields];

    while (idx < length) {

      /* Ignore spaces between fields */
      if (Character.isSpaceChar(timeStr[idx])) {
        idx++;
        continue;
      }

      /* Record start of current field */
      if (nf >= maxFields) {
        throw new IllegalArgumentException("Too many fields");
      }

      int startIdx = idx;

      //January 8, 1999
      /* leading digit? then date or time */
      if (Character.isDigit(timeStr[idx])) {
        idx++;
        while (idx < length && Character.isDigit(timeStr[idx])) {
          idx++;
        }

        if (idx < length && timeStr[idx] == ':') {
          fieldTypes[nf] = TokenField.DTK_TIME;

          while (idx <length && (Character.isDigit(timeStr[idx]) || timeStr[idx] == ':' || timeStr[idx] == '.')) {
            idx++;
          }
        }

        /* date field? allow embedded text month */
        else if (idx < length && (timeStr[idx] == '-' || timeStr[idx] == '/' || timeStr[idx] == '.')) {

          /* save delimiting character to use later */
          char delim = timeStr[idx];
          idx++;

          /* second field is all digits? then no embedded text month */
          if (Character.isDigit(timeStr[idx])) {
            fieldTypes[nf] = delim == '.' ? TokenField.DTK_NUMBER : TokenField.DTK_DATE;

            while (idx < length && Character.isDigit(timeStr[idx])) {
              idx++;
            }

            /*
					   * insist that the delimiters match to get a three-field
					   * date.
					   */
            if (idx < length && timeStr[idx] == delim) {
              fieldTypes[nf] = TokenField.DTK_DATE;
              idx++;
              while (idx < length && (Character.isDigit(timeStr[idx]) || timeStr[idx] == delim)) {
                idx++;
              }
            }
          } else {
            fieldTypes[nf] = TokenField.DTK_DATE;
            while (idx < length && Character.isLetterOrDigit(timeStr[idx]) || timeStr[idx] == delim) {
              idx++;
            }
          }
        } else {
          /*
			     * otherwise, number only and will determine year, month, day, or
			     * concatenated fields later...
			    */
          fieldTypes[nf] = TokenField.DTK_NUMBER;
        }
      }

      /* Leading decimal point? Then fractional seconds... */
      else if (timeStr[idx] == '.') {
        idx++;
        while (idx < length && Character.isDigit(timeStr[idx])) {
          idx++;
          continue;
        }
        fieldTypes[nf] = TokenField.DTK_NUMBER;
      }

      // text? then date string, month, day of week, special, or timezone
      else if (Character.isLetter(timeStr[idx])) {
        boolean isDate;
        idx++;
        while (idx < length && Character.isLetter(timeStr[idx])) {
          idx++;
        }

        // Dates can have embedded '-', '/', or '.' separators.  It could
        // also be a timezone name containing embedded '/', '+', '-', '_',
        // or ':' (but '_' or ':' can't be the first punctuation). If the
        // next character is a digit or '+', we need to check whether what
        // we have so far is a recognized non-timezone keyword --- if so,
        // don't believe that this is the start of a timezone.

        isDate = false;
        if (idx < length && (timeStr[idx] == '-' || timeStr[idx] == '/' || timeStr[idx] == '.')) {
          isDate = true;
        } else if (idx < length && (timeStr[idx] == '+' || Character.isDigit(timeStr[idx]))) {
          // The original ParseDateTime handles this case. But, we currently omit this case.
          throw new IllegalArgumentException("Cannot parse this datetime field " + str.substring(startIdx, idx));
        }

        if (isDate) {
          fieldTypes[nf] = TokenField.DTK_DATE;

          do {
            idx++;
          } while (idx <length && (timeStr[idx] == '+' || timeStr[idx] == '-' || timeStr[idx] == '/' ||
              timeStr[idx] == '_' || timeStr[idx] == '.' || timeStr[idx] == ':' ||
              Character.isLetterOrDigit(timeStr[idx])));
        } else {
          fieldTypes[nf] = TokenField.DTK_STRING;
        }
      }

      // sign? then special or numeric timezone
      else if (timeStr[idx] == '+' || timeStr[idx] == '-') {
        idx++;

        // soak up leading whitespace
        while (idx < length && Character.isSpaceChar(timeStr[idx])) {
          idx++;
        }

        // numeric timezone?
        // note that "DTK_TZ" could also be a signed float or yyyy-mm */
        if (idx < length && Character.isDigit(timeStr[idx])) {
          fieldTypes[nf] = TokenField.DTK_TZ;
          idx++;

          while (idx < length && (Character.isDigit(timeStr[idx]) || timeStr[idx] == ':' || timeStr[idx] == '.' ||
              timeStr[idx] == '-')) {
            idx++;
          }
        }
        /* special? */
        else if (idx < length && Character.isLetter(timeStr[idx])) {
          fieldTypes[nf] = TokenField.DTK_SPECIAL;
          idx++;

          while (idx < length && Character.isLetter(timeStr[idx])) {
            idx++;
          }
        } else {
          throw new IllegalArgumentException("BAD Format: " + str.substring(startIdx, idx));
        }
      }
      /* ignore other punctuation but use as delimiter */
      else if (isPunctuation(timeStr[idx])) {
        idx++;
        continue;
      } else {  // otherwise, something is not right...
        throw new IllegalArgumentException("BAD datetime format: " + str.substring(startIdx, idx));
      }

      fields[nf] = str.substring(startIdx, idx);
      nf++;
    }
    return decodeDateTime(fields, fieldTypes, nf);
  }

  /**
   * Fetch a fractional-second value with suitable error checking
   * @param cp
   * @param fsec
   */
  public static void parseFractionalSecond(StringBuilder cp, AtomicLong fsec) {
	  /* Caller should always pass the start of the fraction part */
    double frac = strtod(cp.toString(), 1, cp);
    fsec.set(Math.round(frac * 1000000));
  }

  /**
   * Interpret string as a numeric timezone.
   *
   * Return 0 if okay (and set *tzp), a DTERR code if not okay.
   *
   * NB: this must *not* ereport on failure; see commands/variable.c.
   * @param str
   * @param tz
   */
  public static void decodeTimezone(String str, AtomicInteger tz) {
    int min = 0;
    int sec = 0;
    StringBuilder sb = new StringBuilder();

    int strIndex = 0;
	  /* leading character must be "+" or "-" */
    if (str.charAt(strIndex) != '+' && str.charAt(strIndex) != '-') {
      throw new IllegalArgumentException("BAD Format: " + str);
    }
    int hr = strtoi(str, 1, sb);

	  /* explicit delimiter? */
    if (sb.length() > 0 && sb.charAt(0) == ':') {
      min = strtoi(sb.toString(), 1, sb);
      if (sb.charAt(0) == ':') {
        sec = strtoi(sb.toString(), 1, sb);
      }
    }
	  /* otherwise, might have run things together... */
    else if (sb.length() == 0 && str.length() > 3) {
      min = hr % 100;
      hr = hr / 100;
		/* we could, but don't, support a run-together hhmmss format */
    } else {
      min = 0;
    }
	  /* Range-check the values; see notes in datatype/timestamp.h */
    if (hr < 0 || hr > DateTimeConstants.MAX_TZDISP_HOUR) {
      throw new IllegalArgumentException("BAD Format: TZDISP_OVERFLOW: " + str);
    }
    if (min < 0 || min >= DateTimeConstants.MINS_PER_HOUR) {
      throw new IllegalArgumentException("BAD Format: TZDISP_OVERFLOW: " + str);
    }
    if (sec < 0 || sec >= DateTimeConstants.SECS_PER_MINUTE) {
      throw new IllegalArgumentException("BAD Format: TZDISP_OVERFLOW: " + str);
    }

    int tzValue = (hr * DateTimeConstants.MINS_PER_HOUR + min) * DateTimeConstants.SECS_PER_MINUTE + sec;
    if (str.charAt(strIndex) == '-') {
      tzValue = -tzValue;
    }
    tz.set(tzValue);
  }

  /**
   * Interpret plain numeric field as a date value in context.
   * @param flen
   * @param str
   * @param haveTextMonth
   * @param fmask
   * @param tmaskValue
   * @param tm
   * @param fsec
   * @param is2digits
   */
  private static void decodeNumber(int flen, String str, boolean haveTextMonth, int fmask,
               AtomicInteger tmaskValue, TimeMeta tm, AtomicLong fsec, AtomicBoolean is2digits) {
    int	val;
    StringBuilder cp = new StringBuilder();

    int tmask = 0;
    tmaskValue.set(tmask);

    val = strtoi(str, 0, cp);
    if (cp.toString().equals(str)) {
      throw new IllegalArgumentException("BAD Format: " + str);
    }

    if (cp.length() > 0 && cp.charAt(0) == '.') {
		/*
		 * More than two digits before decimal point? Then could be a date or
		 * a run-together time: 2001.360 20011225 040506.789
		 */
      if (cp.length() - str.length() > 2) {
        decodeNumberField(flen, str,
            (fmask | DateTimeConstants.DTK_DATE_M),
            tmaskValue, tm,
            fsec, is2digits);
        return;
      }
      parseFractionalSecond(cp, fsec);
    }

  	// Special case for day of year
    if (flen == 3 && (fmask & DateTimeConstants.DTK_DATE_M) == DateTimeConstants.DTK_M(TokenField.YEAR) &&
        val >= 1 && val <= 366) {
      tmaskValue.set((DateTimeConstants.DTK_M(TokenField.DOY) |
          DateTimeConstants.DTK_M(TokenField.MONTH) |
          DateTimeConstants.DTK_M(TokenField.DAY)));
      tm.dayOfYear = val;
		  // tm_mon and tm_mday can't actually be set yet ...
      return;
    }

	  /* Switch based on what we have so far */
    int checkValue = fmask & DateTimeConstants.DTK_DATE_M;
    if (checkValue == 0) {
			/*
			 * Nothing so far; make a decision about what we think the input
			 * is.	There used to be lots of heuristics here, but the
			 * consensus now is to be paranoid.  It *must* be either
			 * YYYY-MM-DD (with a more-than-two-digit year field), or the
			 * field order defined by DateOrder.
			 */
      if (flen >= 3 || TajoConf.getDateOrder() == DateTimeConstants.DATEORDER_YMD) {
        tmaskValue.set(DateTimeConstants.DTK_M(TokenField.YEAR));
        tm.years = val;
      } else if (TajoConf.getDateOrder() == DateTimeConstants.DATEORDER_DMY) {
        tmaskValue.set(DateTimeConstants.DTK_M(TokenField.DAY));
        tm.dayOfMonth = val;
      } else {
        tmaskValue.set(DateTimeConstants.DTK_M(TokenField.MONTH));
        tm.monthOfYear = val;
      }
    } else if (checkValue == (DateTimeConstants.DTK_M(TokenField.YEAR))) {
			/* Must be at second field of YY-MM-DD */
      tmaskValue.set(DateTimeConstants.DTK_M(TokenField.MONTH));
      tm.monthOfYear = val;
    } else if (checkValue == (DateTimeConstants.DTK_M(TokenField.MONTH))) {
      if (haveTextMonth) {
				/*
				 * We are at the first numeric field of a date that included a
				 * textual month name.	We want to support the variants
				 * MON-DD-YYYY, DD-MON-YYYY, and YYYY-MON-DD as unambiguous
				 * inputs.	We will also accept MON-DD-YY or DD-MON-YY in
				 * either DMY or MDY modes, as well as YY-MON-DD in YMD mode.
				 */
        if (flen >= 3 || TajoConf.getDateOrder() == DateTimeConstants.DATEORDER_YMD) {
          tmaskValue.set(DateTimeConstants.DTK_M(TokenField.YEAR));
          tm.years = val;
        } else {
          tmaskValue.set(DateTimeConstants.DTK_M(TokenField.DAY));
          tm.dayOfMonth = val;
        }
      } else {
				/* Must be at second field of MM-DD-YY */
        tmaskValue.set(DateTimeConstants.DTK_M(TokenField.DAY));
        tm.dayOfMonth = val;
      }
    } else if (checkValue == (DateTimeConstants.DTK_M(TokenField.YEAR) | DateTimeConstants.DTK_M(TokenField.MONTH))) {
      if (haveTextMonth) {
				/* Need to accept DD-MON-YYYY even in YMD mode */
        if (flen >= 3 && is2digits.get()) {
					/* Guess that first numeric field is day was wrong */
          tmaskValue.set(DateTimeConstants.DTK_M(TokenField.DAY));		/* YEAR is already set */
          tm.dayOfMonth = tm.years;
          tm.years = val;
          is2digits.set(false);
        } else {
          tmaskValue.set(DateTimeConstants.DTK_M(TokenField.DAY));
          tm.dayOfMonth = val;
        }
      } else {
				/* Must be at third field of YY-MM-DD */
        tmaskValue.set(DateTimeConstants.DTK_M(TokenField.DAY));
        tm.dayOfMonth = val;
      }
    } else if (checkValue == DateTimeConstants.DTK_M(TokenField.DAY)) {
			/* Must be at second field of DD-MM-YY */
      tmaskValue.set(DateTimeConstants.DTK_M(TokenField.MONTH));
      tm.monthOfYear = val;
    } else if (checkValue == (DateTimeConstants.DTK_M(TokenField.MONTH) | DateTimeConstants.DTK_M(TokenField.DAY))) {
			/* Must be at third field of DD-MM-YY or MM-DD-YY */
      tmaskValue.set(DateTimeConstants.DTK_M(TokenField.YEAR));
      tm.years = val;
    } else if (checkValue == (DateTimeConstants.DTK_M(TokenField.YEAR) | DateTimeConstants.DTK_M(TokenField.MONTH) | DateTimeConstants.DTK_M(TokenField.DAY))) {
			/* we have all the date, so it must be a time field */
      decodeNumberField(flen, str, fmask,
          tmaskValue, tm,
          fsec, is2digits);
      return;

    } else {
      throw new IllegalArgumentException("BAD Format: " + str);
    }

	/*
	 * When processing a year field, mark it for adjustment if it's only one
	 * or two digits.
	 */
    if (tmaskValue.get() == DateTimeConstants.DTK_M(TokenField.YEAR)) {
      is2digits.set(flen <= 2);
    }
  }

  /**
   * Interpret numeric string as a concatenated date or time field.
   *
   * Use the context of previously decoded fields to help with
   * the interpretation.
   * @param len
   * @param str
   * @param fmask
   * @param tmaskValue
   * @param tm
   * @param fsec
   * @param is2digits
   * @return
   */
  static TokenField decodeNumberField(int len, String str, int fmask,
                    AtomicInteger tmaskValue, TimeMeta tm, AtomicLong fsec, AtomicBoolean is2digits) {
    /*
     * Have a decimal point? Then this is a date or something with a seconds
     * field...
     */
    int index = str.indexOf('.');

    if (index >= 0) {
      String cp = str.substring(index + 1);
		/*
		 * Can we use ParseFractionalSecond here?  Not clear whether trailing
		 * junk should be rejected ...
		 */
      double frac = strtod(cp, 0, null);
      fsec.set(Math.round(frac * 1000000));
		  /* Now truncate off the fraction for further processing */
      len = str.length();
    }
	  /* No decimal point and no complete date yet? */
    else if ((fmask & DateTimeConstants.DTK_DATE_M) != DateTimeConstants.DTK_DATE_M) {
		  /* yyyymmdd? */
      if (len == 8) {
        tmaskValue.set(DateTimeConstants.DTK_DATE_M);

        tm.dayOfMonth = Integer.parseInt(str.substring(6));
        tm.monthOfYear = Integer.parseInt(str.substring(4, 6));
        tm.years = Integer.parseInt(str.substring(0, 4));

        return TokenField.DTK_DATE;
      }
		  /* yymmdd? */
      else if (len == 6) {
        tmaskValue.set(DateTimeConstants.DTK_DATE_M);
        tm.dayOfMonth = Integer.parseInt(str.substring(4));
        tm.monthOfYear = Integer.parseInt(str.substring(2, 4));
        tm.years = Integer.parseInt(str.substring(0, 2));
        is2digits.set(true);

        return TokenField.DTK_DATE;
      }
    }

	  /* not all time fields are specified? */
    if ((fmask & DateTimeConstants.DTK_TIME_M) != DateTimeConstants.DTK_TIME_M) {
		  /* hhmmss */
      if (len == 6) {
        tmaskValue.set(DateTimeConstants.DTK_TIME_M);
        tm.secs = Integer.parseInt(str.substring(4));
        tm.minutes = Integer.parseInt(str.substring(2, 4));
        tm.hours = Integer.parseInt(str.substring(0, 2));

        return TokenField.DTK_TIME;
      }
		  /* hhmm? */
      else if (len == 4) {
        tmaskValue.set(DateTimeConstants.DTK_TIME_M);
        tm.secs = 0;
        tm.minutes = Integer.parseInt(str.substring(2, 4));
        tm.hours = Integer.parseInt(str.substring(0, 2));

        return TokenField.DTK_TIME;
      }
    }

    throw new IllegalArgumentException("BAD Format: " + str);
  }

  private static TimeMeta decodeDateTime(String[] fields, TokenField[] fieldTypes, int nf) {
    int	fmask = 0;
    AtomicInteger tmask = new AtomicInteger(0);
    int type;

    /* "prefix type" for ISO y2001m02d04 format */
    TokenField ptype = null;

    boolean		haveTextMonth = false;
    boolean		isjulian = false;
    AtomicBoolean is2digits = new AtomicBoolean(false);
    boolean		bc = false;

    int tzp = Integer.MAX_VALUE;
    String namedTimeZone = null;

    StringBuilder sb = new StringBuilder();
    // We'll insist on at least all of the date fields, but initialize the
    // remaining fields in case they are not set later...
    TokenField dtype = TokenField.DTK_DATE;
    TokenField mer = null;

    TimeMeta tm = new TimeMeta();
    TimeMeta cur_tm = new TimeMeta();

    AtomicLong fsec = new AtomicLong();
    AtomicInteger tz = new AtomicInteger(Integer.MAX_VALUE);

    // don't know daylight savings time status apriori */
    tm.isDST = false;

    for (int i = 0; i < nf; i++) {
      if (fieldTypes[i] == null) {
        continue;
      }
      switch (fieldTypes[i]) {
        case DTK_DATE:
          /***
           * Integral julian day with attached time zone?
           * All other forms with JD will be separated into
           * distinct fields, so we handle just this case here.
           ***/
          if (ptype == TokenField.DTK_JULIAN) {
            int			val;

            if (tzp == Integer.MAX_VALUE) {
              throw new IllegalArgumentException("BAD Format: " + fields[i]);
            }

            val = strtoi(fields[i], 0, sb);

            date2j(val, tm);
            isjulian = true;

					  /* Get the time zone from the end of the string */
            decodeTimezone(sb.toString(), tz);

            tmask.set(DateTimeConstants.DTK_DATE_M | DateTimeConstants.DTK_TIME_M | DateTimeConstants.DTK_M(TokenField.TZ));
            ptype = null;
            break;
          }
          /***
           * Already have a date? Then this might be a time zone name
           * with embedded punctuation (e.g. "America/New_York") or a
           * run-together time with trailing time zone (e.g. hhmmss-zz).
           * - thomas 2001-12-25
           *
           * We consider it a time zone if we already have month & day.
           * This is to allow the form "mmm dd hhmmss tz year", which
           * we've historically accepted.
           ***/
          else if (ptype != null ||
              ((fmask & (DateTimeConstants.DTK_M(TokenField.MONTH) | DateTimeConstants.DTK_M(TokenField.DAY))) ==
                  (DateTimeConstants.DTK_M(TokenField.MONTH) | DateTimeConstants.DTK_M(TokenField.DAY))))
          {
					/* No time zone accepted? Then quit... */
            if (tzp == Integer.MAX_VALUE) {
              throw new IllegalArgumentException("BAD Format: " + fields[i]);
            }

            if (Character.isDigit(fields[i].charAt(0)) || ptype != null) {
              if (ptype != null) {
							  /* Sanity check; should not fail this test */
                if (ptype != TokenField.DTK_TIME) {
                  throw new IllegalArgumentException("BAD Format: " + fields[i]);
                }
                ptype = null;
              }

						/*
						 * Starts with a digit but we already have a time
						 * field? Then we are in trouble with a date and time
						 * already...
						 */
              if ((fmask & DateTimeConstants.DTK_TIME_M) == DateTimeConstants.DTK_TIME_M) {
                throw new IllegalArgumentException("BAD Format: " + fields[i]);
              }

              int index = fields[i].indexOf("-");
              if (index < 0) {
                throw new IllegalArgumentException("BAD Format: " + fields[i]);
              }

						  /* Get the time zone from the end of the string */
              decodeTimezone(fields[i].substring(index + 1), tz);

              /*
               * Then read the rest of the field as a concatenated
               * time
               */
              decodeNumberField(fields[i].length(), fields[i],
                  fmask,
                  tmask, tm,
                  fsec, is2digits);

              /*
               * modify tmask after returning from
               * DecodeNumberField()
               */
              tmask.set(tmask.get() | DateTimeConstants.DTK_M(TokenField.TZ));
            }
            else {
              namedTimeZone = pg_tzset(fields[i]);
              if (namedTimeZone == null) {
							/*
							 * We should return an error code instead of
							 * ereport'ing directly, but then there is no way
							 * to report the bad time zone name.
							 */
                throw new IllegalArgumentException("BAD Format: time zone \"%s\" not recognized: " + fields[i]);
              }
						  /* we'll apply the zone setting below */
              tmask.set(DateTimeConstants.DTK_M(TokenField.TZ));
            }
          } else {
            decodeDate(fields[i], fmask, tmask, is2digits, tm);
          }
          break;

        case DTK_TIME:
          decodeTime(fields[i], (fmask | DateTimeConstants.DTK_DATE_M),
              DateTimeConstants.INTERVAL_FULL_RANGE,
              tmask, tm, fsec);
          break;

        case DTK_TZ: {
          decodeTimezone(fields[i], tz);
          tmask.set(DateTimeConstants.DTK_M(TokenField.TZ));
          break;
        }

        case DTK_NUMBER:

          /*
           * Was this an "ISO date" with embedded field labels? An
           * example is "y2001m02d04" - thomas 2001-02-04
           */
          if (ptype != null) {
            int val = strtoi(fields[i], 0, sb);

            /*
             * only a few kinds are allowed to have an embedded
             * decimal
             */
            if (sb.length() == 0) {
              continue;
            }
            if (sb.charAt(0) == '.') {
              switch (ptype) {
                case DTK_JULIAN:
                case DTK_TIME:
                case DTK_SECOND:
                  break;
                default:
                  throw new IllegalArgumentException("BAD Format: " + fields[i]);
              }
            } else {
              throw new IllegalArgumentException("BAD Format: " + fields[i]);
            }
            switch (ptype) {
              case DTK_YEAR:
                tm.years = val;
                tmask.set(DateTimeConstants.DTK_M(TokenField.YEAR));
                break;

              case DTK_MONTH:

                /*
                 * already have a month and hour? then assume
                 * minutes
                 */
                if ((fmask & DateTimeConstants.DTK_M(TokenField.MONTH)) != 0 &&
                    (fmask & DateTimeConstants.DTK_M(TokenField.HOUR)) != 0) {
                  tm.minutes = val;
                  tmask.set(DateTimeConstants.DTK_M(TokenField.MINUTE));
                }
                else {
                  tm.monthOfYear = val;
                  tmask.set(DateTimeConstants.DTK_M(TokenField.MONTH));
                }
                break;

              case DTK_DAY:
                tm.dayOfMonth = val;
                tmask.set(DateTimeConstants.DTK_M(TokenField.DAY));
                break;

              case DTK_HOUR:
                tm.hours = val;
                tmask.set(DateTimeConstants.DTK_M(TokenField.HOUR));
                break;

              case DTK_MINUTE:
                tm.minutes = val;
                tmask.set(DateTimeConstants.DTK_M(TokenField.MINUTE));
                break;

              case DTK_SECOND:
                tm.secs = val;
                tmask.set(DateTimeConstants.DTK_M(TokenField.SECOND));
                if (sb.charAt(0) == '.') {
                  parseFractionalSecond(sb, fsec);
                  tmask.set(DateTimeConstants.DTK_ALL_SECS_M);
                }
                break;
              case DTK_TZ:
                tmask.set(DateTimeConstants.DTK_M(TokenField.TZ));
                decodeTimezone(fields[i], tz);
                break;

              case DTK_JULIAN:
							  /* previous field was a label for "julian date" */
                if (val < 0) {
                  throw new IllegalArgumentException("BAD Format: FIELD_OVERFLOW: " + fields[i]);
                }
                tmask.set(DateTimeConstants.DTK_DATE_M);
                date2j(val, tm);
                isjulian = true;

							  /* fractional Julian Day? */
                if (sb.charAt(0) == '.') {
                  double time = strtod(sb.toString(), 0, sb);

                  time *= DateTimeConstants.USECS_PER_DAY;
                  date2j((long)time, tm);
                  tmask.set(tmask.get() | DateTimeConstants.DTK_TIME_M);
                }
                break;

              case DTK_TIME:
							/* previous field was "t" for ISO time */
                decodeNumberField(fields[i].length(), fields[i],
                    (fmask | DateTimeConstants.DTK_DATE_M),
                    tmask, tm,
                    fsec, is2digits);
                if (tmask.get() != DateTimeConstants.DTK_TIME_M) {
                  throw new IllegalArgumentException("BAD Format: FIELD_OVERFLOW: " + fields[i]);
                }
                break;

              default:
                throw new IllegalArgumentException("BAD Format: " + fields[i]);
            }

            ptype = null;
            dtype = TokenField.DTK_DATE;
          } else {
            int flen = fields[i].length();
            int index = fields[i].indexOf(".");
            String cp = null;
            if (index > 0) {
              cp = fields[i].substring(index + 1);
            }

					  /* Embedded decimal and no date yet? */
            if (cp != null && ((fmask & DateTimeConstants.DTK_DATE_M) == 0 )) {
              decodeDate(fields[i], fmask,
                  tmask, is2digits, tm);
            }
					  /* embedded decimal and several digits before? */
            else if (cp != null && flen - cp.length() > 2) {
						/*
						 * Interpret as a concatenated date or time Set the
						 * type field to allow decoding other fields later.
						 * Example: 20011223 or 040506
						 */
              decodeNumberField(flen, fields[i], fmask,
                  tmask, tm,
                  fsec, is2digits);
            }
            else if (flen > 4) {
              decodeNumberField(flen, fields[i], fmask,
                  tmask, tm,
                  fsec, is2digits);
            }
					  /* otherwise it is a single date/time field... */
            else {
              decodeNumber(flen, fields[i],
                  haveTextMonth, fmask,
                  tmask, tm,
                  fsec, is2digits);
            }
          }
          break;
        case DTK_STRING:
        case DTK_SPECIAL:
          DateToken dateToken =  DateTimeConstants.dateTokenMap.get(fields[i].toLowerCase());
          if (dateToken == null) {
            throw new IllegalArgumentException("BAD Format: " + fields[i]);
          }
          tmask.set(DateTimeConstants.DTK_M(dateToken.getType()));
          switch (dateToken.getType()) {
            case RESERV:
              switch(dateToken.getValueType()) {
                case DTK_CURRENT:
                  throw new IllegalArgumentException("BAD Format: date/time value \"current\" is no longer supported" + fields[i]);

                case DTK_NOW:
                  tmask.set(DateTimeConstants.DTK_DATE_M | DateTimeConstants.DTK_TIME_M | DateTimeConstants.DTK_M(TokenField.TZ));
                  dtype = TokenField.DTK_DATE;
                  date2j(javaTimeToJulianTime(System.currentTimeMillis()), tm);
                  break;

                case DTK_YESTERDAY:
                  tmask.set(DateTimeConstants.DTK_DATE_M);
                  dtype = TokenField.DTK_DATE;
                  date2j(javaTimeToJulianTime(System.currentTimeMillis()), tm);
                  tm.plusDays(-1);
                  break;

                case DTK_TODAY:
                  tmask.set(DateTimeConstants.DTK_DATE_M);
                  dtype = TokenField.DTK_DATE;
                  date2j(javaTimeToJulianTime(System.currentTimeMillis()), cur_tm);
                  tm.years = cur_tm.years;
                  tm.monthOfYear = cur_tm.monthOfYear;
                  tm.dayOfMonth = cur_tm.dayOfMonth;
                  break;

                case DTK_TOMORROW:
                  tmask.set(DateTimeConstants.DTK_DATE_M);
                  dtype = TokenField.DTK_DATE;
                  date2j(javaTimeToJulianTime(System.currentTimeMillis()), tm);
                  tm.plusDays(1);
                  break;

                case DTK_ZULU:
                  tmask.set(DateTimeConstants.DTK_TIME_M | DateTimeConstants.DTK_M(TokenField.TZ));
                  dtype = TokenField.DTK_DATE;
                  tm.hours = 0;
                  tm.minutes = 0;
                  tm.secs = 0;
                  break;

                default:
                  dtype = dateToken.getValueType();
              }
              break;

            case MONTH:
              /*
               * already have a (numeric) month? then see if we can
               * substitute...
               */
              if ((fmask & DateTimeConstants.DTK_M(TokenField.MONTH)) != 0 && !haveTextMonth &&
                  (fmask & DateTimeConstants.DTK_M(TokenField.DAY)) == 0 &&
                  tm.monthOfYear >= 1 && tm.monthOfYear <= 31) {
                tm.dayOfMonth = tm.monthOfYear;
                tmask.set(DateTimeConstants.DTK_M(TokenField.DAY));
              }
              haveTextMonth = true;
              tm.monthOfYear = dateToken.getValue();
              break;

            case DTZMOD:

						/*
						 * daylight savings time modifier (solves "MET DST"
						 * syntax)
						 */
              tmask.set(tmask.get() | DateTimeConstants.DTK_M(TokenField.DTZ));
              tm.isDST = true;
              if (tzp == Integer.MAX_VALUE) {
                throw new IllegalArgumentException("BAD Format: " + fields[i]);
              }
              tzp += dateToken.getValue() * DateTimeConstants.MINS_PER_HOUR;
              break;

            case DTZ:

						/*
						 * set mask for TZ here _or_ check for DTZ later when
						 * getting default timezone
						 */
              tmask.set(tmask.get() | DateTimeConstants.DTK_M(TokenField.TZ));
              tm.isDST = true;
              if (tzp == Integer.MAX_VALUE) {
                throw new IllegalArgumentException("BAD Format: " + fields[i]);
              }
              tzp = dateToken.getValue() * DateTimeConstants.MINS_PER_HOUR;
              break;

            case TZ:
              tm.isDST = false;
              if (tzp == Integer.MAX_VALUE) {
                throw new IllegalArgumentException("BAD Format: " + fields[i]);
              }
              tzp = dateToken.getValue() * DateTimeConstants.MINS_PER_HOUR;
              break;

            case IGNORE_DTF:
              break;

            case AMPM:
              mer = dateToken.getValueType();
              break;

            case ADBC:
              bc = (dateToken.getValueType() == TokenField.BC);
              break;

            case DOW:
              tm.dayOfWeek = dateToken.getValue();
              break;

            case UNITS:
              tmask.set(0);
              ptype = dateToken.getValueType();
              break;

            case ISOTIME:

						/*
						 * This is a filler field "t" indicating that the next
						 * field is time. Try to verify that this is sensible.
						 */
              tmask.set(0);

						/* No preceding date? Then quit... */
              if ((fmask & DateTimeConstants.DTK_DATE_M) != DateTimeConstants.DTK_DATE_M) {
                throw new IllegalArgumentException("BAD Format: " + fields[i]);
              }

              /***
               * We will need one of the following fields:
               *	DTK_NUMBER should be hhmmss.fff
               *	DTK_TIME should be hh:mm:ss.fff
               *	DTK_DATE should be hhmmss-zz
               ***/
              if (i >= nf - 1 ||
                  (fieldTypes[i + 1] != TokenField.DTK_NUMBER &&
                      fieldTypes[i + 1] != TokenField.DTK_TIME &&
                      fieldTypes[i + 1] != TokenField.DTK_DATE)) {
                throw new IllegalArgumentException("BAD Format: " + fields[i]);
              }

              ptype = dateToken.getValueType();
              break;

            case UNKNOWN_FIELD:

						/*
						 * Before giving up and declaring error, check to see
						 * if it is an all-alpha timezone name.
						 */
              namedTimeZone = pg_tzset(fields[i]);
              if (namedTimeZone == null) {
                throw new IllegalArgumentException("BAD Format: " + fields[i]);
              }
						/* we'll apply the zone setting below */
              tmask.set(DateTimeConstants.DTK_M(TokenField.TZ));
              break;

            default:
              throw new IllegalArgumentException("BAD Format: " + fields[i]);
          }
          break;
      }
      if ((tmask.get() & fmask) != 0) {
        throw new IllegalArgumentException("BAD Format: " + fields[i]);
      }
      fmask |= tmask.get();
    }   /* end loop over fields */

    tm.fsecs = fsec.intValue();
    tm.timeZone = tz.get();
    /* do final checking/adjustment of Y/M/D fields */
    validateDate(fmask, isjulian, is2digits.get(), bc, tm);

	  /* handle AM/PM */
    if (mer != null && mer != TokenField.HR24 && tm.hours > DateTimeConstants.HOURS_PER_DAY / 2) {
      throw new IllegalArgumentException("BAD Format: overflow hour: " + tm.hours);
    }
    if (mer != null && mer == TokenField.AM && tm.hours == DateTimeConstants.HOURS_PER_DAY / 2) {
      tm.hours = 0;
    } else if (mer != null && mer == TokenField.PM && tm.hours != DateTimeConstants.HOURS_PER_DAY / 2) {
      tm.hours += DateTimeConstants.HOURS_PER_DAY / 2;
    }
	  /* do additional checking for full date specs... */
    if (dtype == TokenField.DTK_DATE) {
      if ((fmask & DateTimeConstants.DTK_DATE_M) != DateTimeConstants.DTK_DATE_M) {
        if ((fmask & DateTimeConstants.DTK_TIME_M) == DateTimeConstants.DTK_TIME_M) {
          return tm;
        }
        throw new IllegalArgumentException("BAD Format: " + tm);
      }

		/*
		 * If we had a full timezone spec, compute the offset (we could not do
		 * it before, because we need the date to resolve DST status).
		 */
      if (namedTimeZone != null) {
			/* daylight savings time modifier disallowed with full TZ */
        if ( (fmask & DateTimeConstants.DTK_M(TokenField.DTZMOD)) != 0 ) {
          throw new IllegalArgumentException("BAD Format: " + tm);
        }
      }
    }

    return tm;
  }

  private static String pg_tzset(String str) {
    //TODO implements logic
    return null;
  }

  /**
   * Check valid year/month/day values, handle BC and DOY cases
   * Return 0 if okay, a DTERR code if not.
   * @param fmask
   * @param isjulian
   * @param is2digits
   * @param bc
   * @param tm
   * @return
   */
  private static int validateDate(int fmask, boolean isjulian, boolean is2digits, boolean bc, TimeMeta tm) {
    if ( (fmask & DateTimeConstants.DTK_M(TokenField.YEAR)) != 0 ) {
      if (isjulian) {
			/* tm_year is correct and should not be touched */
      } else if (bc) {
			  /* there is no year zero in AD/BC notation */
        if (tm.years <= 0) {
          throw new IllegalArgumentException("BAD Format: year overflow:" + tm.years);
        }
			  /* internally, we represent 1 BC as year zero, 2 BC as -1, etc */
        tm.years = -(tm.years - 1);
      }
      else if (is2digits) {
			  /* process 1 or 2-digit input as 1970-2069 AD, allow '0' and '00' */
        if (tm.years < 0) { /* just paranoia */
          throw new IllegalArgumentException("BAD Format: year overflow:" + tm.years);
        }
        if (tm.years < 70) {
          tm.years += 2000;
        } else if (tm.years < 100) {
          tm.years += 1900;
        }
      }
      else {
			  /* there is no year zero in AD/BC notation */
        if (tm.years <= 0) {
          throw new IllegalArgumentException("BAD Format: year overflow:" + tm.years);
        }
      }
    }

	  /* now that we have correct year, decode DOY */
    if ( (fmask & DateTimeConstants.DTK_M(TokenField.DOY)) != 0 ) {
      j2date(date2j(tm.years, 1, 1) + tm.dayOfYear - 1, tm);
    }

	  /* check for valid month */
    if ( (fmask & DateTimeConstants.DTK_M(TokenField.MONTH)) != 0 ) {
      if (tm.monthOfYear < 1 || tm.monthOfYear > DateTimeConstants.MONTHS_PER_YEAR) {
        throw new IllegalArgumentException("BAD Format: month overflow:" + tm.monthOfYear);
      }
    }

	  /* minimal check for valid day */
    if ( (fmask & DateTimeConstants.DTK_M(TokenField.DAY)) != 0 ) {
      if (tm.dayOfMonth < 1 || tm.dayOfMonth > 31) {
        throw new IllegalArgumentException("BAD Format: day overflow:" + tm.dayOfMonth);
      }
    }

    if ((fmask & DateTimeConstants.DTK_DATE_M) == DateTimeConstants.DTK_DATE_M) {
		/*
		 * Check for valid day of month, now that we know for sure the month
		 * and year.  Note we don't use MD_FIELD_OVERFLOW here, since it seems
		 * unlikely that "Feb 29" is a YMD-order error.
		 */
      boolean leapYear = isLeapYear(tm.years);
      if (tm.dayOfMonth > DateTimeConstants.DAY_OF_MONTH[leapYear ? 1: 0][tm.monthOfYear - 1])
        throw new IllegalArgumentException("BAD Format: day overflow:" + tm.dayOfMonth);
    }

    return 0;
  }

  public static int strtoi(String str, int startIndex, StringBuilder sb) {
    sb.setLength(0);
    char[] chars = str.toCharArray();

    int index = startIndex;
    for (; index < chars.length; index++) {
      if (!Character.isDigit(chars[index])) {
        break;
      }
    }

    int val = index == startIndex ? 0 : Integer.parseInt(str.substring(startIndex, index));
    sb.append(chars, index, chars.length - index);

    return val;
  }

  public static long strtol(String str, int startIndex, StringBuilder sb) {
    sb.setLength(0);
    char[] chars = str.toCharArray();

    int index = startIndex;
    for (; index < chars.length; index++) {
      if (!Character.isDigit(chars[index])) {
        break;
      }
    }

    long val = index == startIndex ? 0 : Long.parseLong(str.substring(startIndex, index));
    sb.append(chars, index, chars.length - index);

    return val;
  }

  public static double strtod(String str, int strIndex, StringBuilder sb) {
    if (sb != null) {
      sb.setLength(0);
    }
    char[] chars = str.toCharArray();

    int index = strIndex;
    for (; index < chars.length; index++) {
      if (!Character.isDigit(chars[index])) {
        break;
      }
    }

    double val = Double.parseDouble(str.substring(0, index));
    if (sb != null) {
      sb.append(chars, index, chars.length - index);
    }
    return val;
  }

  /**
   * Check whether it is a punctuation character or not.
   * @param c The character to be checked
   * @return True if it is a punctuation character. Otherwise, false.
   */
  public static boolean isPunctuation(char c) {
    return ((c >= '!' && c <= '/') ||
        (c >= ':' && c <= '@') ||
        (c >= '[' && c <= '`') ||
        (c >= '{' && c <= '~'));
  }

  public static String toString(TimeMeta tm) {
    return encodeDateTime(tm, DateStyle.ISO_DATES);
  }

  /**
   * Encode date and time interpreted as local time.
   *
   * tm and fsec are the value to encode, print_tz determines whether to include
   * a time zone (the difference between timestamp and timestamptz types), tz is
   * the numeric time zone offset, tzn is the textual time zone, which if
   * specified will be used instead of tz by some styles, style is the date
   * style, str is where to write the output.
   *
   * Supported date styles:
   *	Postgres - day mon hh:mm:ss yyyy tz
   *	SQL - mm/dd/yyyy hh:mm:ss.ss tz
   *	ISO - yyyy-mm-dd hh:mm:ss+/-tz
   *	German - dd.mm.yyyy hh:mm:ss tz
   *	XSD - yyyy-mm-ddThh:mm:ss.ss+/-tz
   *
   * This method is originated from EncodeDateTime of datetime.c of PostgreSQL.
   * @param tm
   * @param style
   * @return
   */
  public static String encodeDateTime(TimeMeta tm, DateStyle style) {

    StringBuilder sb = new StringBuilder();
    switch (style) {

      case ISO_DATES:
      case XSO_DATES:
        if (style == DateTimeConstants.DateStyle.ISO_DATES) {
          sb.append(String.format("%04d-%02d-%02d %02d:%02d:",
              (tm.years > 0) ? tm.years : -(tm.years - 1),
              tm.monthOfYear, tm.dayOfMonth, tm.hours, tm.minutes));
        } else {
          sb.append(String.format("%04d-%02d-%02dT%02d:%02d:",
              (tm.years > 0) ? tm.years : -(tm.years - 1),
              tm.monthOfYear, tm.dayOfMonth, tm.hours, tm.minutes));
        }

        appendSecondsToEncodeOutput(sb, tm.secs, tm.fsecs, 6, true);
        if (tm.timeZone != 0 && tm.timeZone != Integer.MAX_VALUE) {
          sb.append(getDisplayTimeZoneOffset(tm.timeZone));
        }
        if (tm.years <= 0) {
          sb.append(" BC");
        }
        break;

      case SQL_DATES:
        // Compatible with Oracle/Ingres date formats

    }

    return sb.toString();
  }

  public static String encodeDate(TimeMeta tm, DateStyle style) {
    return encodeDate(tm.years, tm.monthOfYear, tm.dayOfMonth, style);
  }

  public static String encodeDate(int years, int monthOfYear, int dayOfMonth, DateStyle style) {
    StringBuilder sb = new StringBuilder();
    switch (style) {
      case ISO_DATES:
      case XSO_DATES:
      case SQL_DATES:
        // Compatible with Oracle/Ingres date formats
      default:
        sb.append(String.format("%04d-%02d-%02d",
            (years > 0) ? years : -(years - 1),
            monthOfYear, dayOfMonth));
    }

    return sb.toString();
  }

  public static String encodeTime(TimeMeta tm, DateStyle style) {
    StringBuilder sb = new StringBuilder();
    switch (style) {

      case ISO_DATES:
      case XSO_DATES:
      case SQL_DATES:
        // Compatible with Oracle/Ingres date formats
      default :
        sb.append(String.format("%02d:%02d:", tm.hours, tm.minutes));
        appendSecondsToEncodeOutput(sb, tm.secs, tm.fsecs, 6, true);
        if (tm.timeZone != 0 && tm.timeZone != Integer.MAX_VALUE) {
          sb.append(getDisplayTimeZoneOffset(tm.timeZone));
        }
        break;
    }

    return sb.toString();
  }

  /**
   * Append sections and fractional seconds (if any) at *cp.
   * precision is the max number of fraction digits, fillzeros says to
   * pad to two integral-seconds digits.
   * Note that any sign is stripped from the input seconds values.
   *
   * This method is originated form AppendSeconds in datetime.c of PostgreSQL.
   */
  public static void appendSecondsToEncodeOutput(
      StringBuilder sb, int sec, int fsec, int precision, boolean fillzeros) {
    if (fsec == 0) {
      if (fillzeros)
        sb.append(String.format("%02d", Math.abs(sec)));
      else
        sb.append(String.format("%d", Math.abs(sec)));
    } else {
      if (fillzeros) {
        sb.append(String.format("%02d", Math.abs(sec)));
      } else {
        sb.append(String.format("%d", Math.abs(sec)));
      }

      if (precision > MAX_FRACTION_LENGTH) {
        precision = MAX_FRACTION_LENGTH;
      }

      if (precision > 0) {
        char[] fracChars = String.valueOf(fsec).toCharArray();
        char[] resultChars = new char[MAX_FRACTION_LENGTH];

        int numFillZero = MAX_FRACTION_LENGTH - fracChars.length;
        for (int i = 0, fracIdx = 0; i < MAX_FRACTION_LENGTH; i++) {
          if (i < numFillZero) {
            resultChars[i] = '0';
          } else {
            resultChars[i] = fracChars[fracIdx];
            fracIdx++;
          }
        }
        sb.append(".").append(resultChars, 0, precision);
      }
      trimTrailingZeros(sb);
    }
  }

  /**
   * ... resulting from printing numbers with full precision.
   *
   * Before Postgres 8.4, this always left at least 2 fractional digits,
   * but conversations on the lists suggest this isn't desired
   * since showing '0.10' is misleading with values of precision(1).
   *
   * This method is originated form AppendSeconds in datetime.c of PostgreSQL.
   * @param sb
   */
  public static void trimTrailingZeros(StringBuilder sb) {
    int len = sb.length();
    while (len > 1 && sb.charAt(len - 1) == '0' && sb.charAt(len - 2) != '.') {
      len--;
      sb.setLength(len);
    }
  }

  /**
   * Return the Julian day which corresponds to the first day (Monday) of the given ISO 8601 year and week.
   * Julian days_full are used to convert between ISO week dates and Gregorian dates.
   *
   * This method is originated form AppendSeconds in timestamp.c of PostgreSQL.
   * @param year
   * @param week
   * @return
   */
  public static int isoweek2j(int year, int week) {
	  /* fourth day of current year */
    int day4 = date2j(year, 1, 4);

	  /* day0 == offset to first day of week (Monday) */
    int day0 = j2day(day4 - 1);

    return ((week - 1) * 7) + (day4 - day0);
  }

  /**
   * Convert ISO week of year number to date.
   * The year field must be specified with the ISO year!
   * karel 2000/08/07
   *
   * This method is originated form AppendSeconds in timestamp.c of PostgreSQL.
   * @param woy
   * @param tm
   */
  public static void isoweek2date(int woy, TimeMeta tm) {
    j2date(isoweek2j(tm.years, woy), tm);
  }

  /**
   * Convert an ISO 8601 week date (ISO year, ISO week) into a Gregorian date.
   * Gregorian day of week sent so weekday strings can be supplied.
   * Populates year, mon, and mday with the correct Gregorian values.
   * year must be passed in as the ISO year.
   *
   * This method is originated form AppendSeconds in timestamp.c of PostgreSQL.
   * @param isoweek
   * @param wday
   * @param tm
   */
  public static void isoweekdate2date(int isoweek, int wday, TimeMeta tm) {
    int jday;
    jday = isoweek2j(tm.years, isoweek);
	  /* convert Gregorian week start (Sunday=1) to ISO week start (Monday=1) */
    if (wday > 1) {
      jday += wday - 2;
    } else {
      jday += 6;
    }
    j2date(jday, tm);
  }

  /**
   * Returns the ISO 8601 day-of-year, given a Gregorian year, month and day.
   * Possible return values are 1 through 371 (364 in non-leap years).
   * @param year
   * @param mon
   * @param mday
   * @return
   */
  public static int date2isoyearday(int year, int mon, int mday) {
    return date2j(year, mon, mday) - isoweek2j(date2isoyear(year, mon, mday), 1) + 1;
  }

  public static void toUserTimezone(TimeMeta tm, TimeZone timeZone) {
    tm.convertToLocalTime(timeZone);
  }

  public static void toUTCTimezone(TimeMeta tm, TimeZone timeZone) {
    tm.convertToUTC(timeZone);
  }

  @VisibleForTesting
  public static String getDisplayTimeZoneOffset(TimeZone timeZone, boolean dst) {
    return getDisplayTimeZoneOffset((timeZone.getRawOffset() + (dst ? timeZone.getDSTSavings() : 0)) / 1000);
  }

  public static String getDisplayTimeZoneOffset(int totalSecs) {
    if (totalSecs == 0) {
      return "";
    }
    int minutes = Math.abs(totalSecs) / DateTimeConstants.SECS_PER_MINUTE;
    int hours = minutes / DateTimeConstants.MINS_PER_HOUR;
    minutes = minutes - hours * DateTimeConstants.MINS_PER_HOUR;

    StringBuilder sb = new StringBuilder();
    sb.append(totalSecs > 0 ? "+" : "-").append(String.format("%02d", hours));

    if (minutes > 0) {
      sb.append(":").append(String.format("%02d", minutes));
    }

    return sb.toString();
  }

  public static long getDay(TimeMeta dateTime) {
    return julianTimeToJavaTime(toJulianTimestamp(dateTime.years, dateTime.monthOfYear, dateTime.dayOfMonth,
        0, 0, 0, 0)) * DateTimeConstants.USECS_PER_MSEC;
  }

  public static long getHour(TimeMeta dateTime) {
    return julianTimeToJavaTime(toJulianTimestamp(dateTime.years, dateTime.monthOfYear, dateTime.dayOfMonth,
        dateTime.hours, 0, 0, 0)) * DateTimeConstants.USECS_PER_MSEC;
  }

  public static long getMinute(TimeMeta dateTime) {
    return julianTimeToJavaTime(toJulianTimestamp(dateTime.years, dateTime.monthOfYear, dateTime.dayOfMonth,
        dateTime.hours, dateTime.minutes, 0, 0)) * DateTimeConstants.USECS_PER_MSEC;
  }

  public static long getSecond(TimeMeta dateTime) {
    return julianTimeToJavaTime(toJulianTimestamp(dateTime.years, dateTime.monthOfYear, dateTime.dayOfMonth,
        dateTime.hours, dateTime.minutes, dateTime.secs, 0)) * DateTimeConstants.USECS_PER_MSEC;
  }

  public static long getMonth(TimeMeta dateTime) {
    return julianTimeToJavaTime(toJulianTimestamp(dateTime.years, dateTime.monthOfYear, 1, 0, 0, 0, 0)) *
        DateTimeConstants.USECS_PER_MSEC;
  }

  public static long getDayOfWeek(TimeMeta dateTime, int weekday) {    
    if (weekday < 1 || weekday > 7) {
      throw new RuntimeException("Weekday is out of range. Actual : " + weekday);
    }
    
    int week = date2isoweek(dateTime.years, dateTime.monthOfYear, dateTime.dayOfMonth);
    int jday = isoweek2j(dateTime.years, week);

    jday += (weekday - 1);
    
    jday -=  DateTimeConstants.POSTGRES_EPOCH_JDATE;

    return julianTimeToJavaTime(toJulianTimestamp(jday, 0, 0, 0, 0)) * DateTimeConstants.USECS_PER_MSEC;
  }

  public static long getYear(TimeMeta dateTime) {
    return julianTimeToJavaTime(toJulianTimestamp(dateTime.years, 1, 1, 0, 0, 0, 0)) *
        DateTimeConstants.USECS_PER_MSEC;
  }

  public static TimeMeta getUTCDateTime(Int8Datum int8Datum){
    return getUTCDateTime(int8Datum.asInt8());
  }

  public static TimeMeta getUTCDateTime(long time) {
    long usecs = time % DateTimeConstants.USECS_PER_MSEC;
    long julianTimestamp = javaTimeToJulianTime(time / DateTimeConstants.USECS_PER_MSEC);
    TimeMeta tm = new TimeMeta();

    julianTimestamp += usecs;
    toJulianTimeMeta(julianTimestamp, tm);
    return tm;
  }

}