content: package tim.prune.data;
  
  import java.text.DateFormat;
  import java.text.ParsePosition;
  import java.text.SimpleDateFormat;
  import java.util.Calendar;
  import java.util.Date;
  import java.util.TimeZone;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  
  /**
   * Class to hold a UTC-based timestamp, for example of a track point.
   * When the selected timezone changes, this timestamp will keep its
   * numerical value but the date and time will change accordingly.
   */
  public class TimestampUtc extends Timestamp
  {
  	private final boolean _valid;
  	private final long _milliseconds;
  	private final String _text;
  
  	private static final DateFormat ISO_8601_FORMAT_NOZ = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
  	private static DateFormat[] ALL_DATE_FORMATS = null;
  	private static Calendar CALENDAR = null;
  	private static final Pattern ISO8601_FRACTIONAL_PATTERN
  		= Pattern.compile("(\\d{4})-(\\d{2})-(\\d{2})T(\\d{2}):(\\d{2}):(\\d{2})(?:[.,](\\d{1,3}))?(Z|[+-]\\d{2}(?::?\\d{2})?)?");
  		//                    year     month     day T  hour    minute    sec             millisec   Z or +/-  hours  :   minutes
  	private static final Pattern GENERAL_TIMESTAMP_PATTERN
  		= Pattern.compile("(\\d{4})\\D(\\d{2})\\D(\\d{2})\\D(\\d{2})\\D(\\d{2})\\D(\\d{2})");
  	private static long SECS_SINCE_1970 = 0L;
  	private static long SECS_SINCE_GARTRIP = 0L;
  	private static long MSECS_SINCE_1970 = 0L;
  	private static long MSECS_SINCE_1990 = 0L;
  	private static long TWENTY_YEARS_IN_SECS = 0L;
  	private static final long GARTRIP_OFFSET = 631065600L;
  
  	/** Identifier for the parsing strategy to use */
  	private enum ParseType
  	{
  		NONE,
  		ISO8601_FRACTIONAL,
  		LONG,
  		FIXED_FORMAT0,
  		FIXED_FORMAT1,
  		FIXED_FORMAT2,
  		FIXED_FORMAT3,
  		FIXED_FORMAT4,
  		FIXED_FORMAT5,
  		FIXED_FORMAT6,
  		FIXED_FORMAT7,
  		FIXED_FORMAT8,
  		GENERAL_STRING
  	}
  
  	/** Array of parse types to loop through (first one is changed to last successful type) */
  	private static final ParseType[] ALL_PARSE_TYPES = {ParseType.NONE, ParseType.ISO8601_FRACTIONAL, ParseType.LONG,
  		ParseType.FIXED_FORMAT0, ParseType.FIXED_FORMAT1, ParseType.FIXED_FORMAT2, ParseType.FIXED_FORMAT3,
  		ParseType.FIXED_FORMAT4, ParseType.FIXED_FORMAT5, ParseType.FIXED_FORMAT6, ParseType.FIXED_FORMAT7,
  		ParseType.FIXED_FORMAT8, ParseType.GENERAL_STRING};
  
  	// Static block to initialise offsets
  	static
  	{
  		CALENDAR = Calendar.getInstance();
  		TimeZone gmtZone = TimeZone.getTimeZone("GMT");
  		CALENDAR.setTimeZone(gmtZone);
  		MSECS_SINCE_1970 = CALENDAR.getTimeInMillis();
  		SECS_SINCE_1970 = MSECS_SINCE_1970 / 1000L;
  		SECS_SINCE_GARTRIP = SECS_SINCE_1970 - GARTRIP_OFFSET;
  		CALENDAR.add(Calendar.YEAR, -20);
  		MSECS_SINCE_1990 = CALENDAR.getTimeInMillis();
  		TWENTY_YEARS_IN_SECS = (MSECS_SINCE_1970 - MSECS_SINCE_1990) / 1000L;
  		// Date formats
  		ALL_DATE_FORMATS = new DateFormat[]
  		{
  			DEFAULT_DATETIME_FORMAT,
  			new SimpleDateFormat("EEE MMM dd HH:mm:ss yyyy"),
  			new SimpleDateFormat("HH:mm:ss dd MMM yyyy"),
  			new SimpleDateFormat("dd MMM yyyy HH:mm:ss"),
  			new SimpleDateFormat("dd-MMM-yyyy HH:mm:ss"),
  			new SimpleDateFormat("yyyy MMM dd HH:mm:ss"),
  			new SimpleDateFormat("MMM dd, yyyy hh:mm:ss aa"),
  			ISO_8601_FORMAT, ISO_8601_FORMAT_NOZ
  		};
  		for (DateFormat df : ALL_DATE_FORMATS)
  		{
  			df.setLenient(false);
  			df.setTimeZone(gmtZone);
  		}
  	}
  
  
  	/**
  	 * Constructor
  	 * @param inString String containing timestamp
  	 */
  	public TimestampUtc(String inString)
  	{
  		String text = null;
  		long millis = 0L;
  		if (inString != null && !inString.equals(""))
  		{
  			// Try each of the parse types in turn
  			for (ParseType type : ALL_PARSE_TYPES)
  			{
  				Long parsedMillis = parseString(inString, type);
  				if (parsedMillis != null)
  				{
  					ALL_PARSE_TYPES[0] = type;
  					text = inString;
  					millis = parsedMillis;
  					break;
  				}
  			}
  		}
  		_text = text;
  		_milliseconds = millis;
  		_valid = (_text != null);
  	}
  
  	/**
  	 * Try to parse the given string in the specified way
  	 * @param inString String to parse
  	 * @param inType parse type to use
  	 * @return milliseconds if parse was successful, otherwise false
  	 */
  	private static Long parseString(String inString, ParseType inType)
  	{
  		if (inString == null || inString.equals("")) {
  			return null;
  		}
  		switch (inType)
  		{
  			case NONE:
  				return null;
  			case LONG:
  				// Try to parse into a long
  				try
  				{
  					long rawValue = Long.parseLong(inString.trim());
  					return getMilliseconds(rawValue);
  				}
  				catch (NumberFormatException ignored) {}
  				break;
  
  			case ISO8601_FRACTIONAL:
  				final Matcher fmatcher = ISO8601_FRACTIONAL_PATTERN.matcher(inString);
  				if (fmatcher.matches())
  				{
  					try {
  						return getMilliseconds(Integer.parseInt(fmatcher.group(1)), // year
  							Integer.parseInt(fmatcher.group(2)), // month
  							Integer.parseInt(fmatcher.group(3)), // day
  							Integer.parseInt(fmatcher.group(4)), // hour
  							Integer.parseInt(fmatcher.group(5)), // minute
  							Integer.parseInt(fmatcher.group(6)), // second
  							fmatcher.group(7),                   // fractional seconds
  							fmatcher.group(8));                  // timezone, if any
  					}
  					catch (NumberFormatException ignored) {}
  				}
  				break;
  
  			case FIXED_FORMAT0: return parseString(inString, ALL_DATE_FORMATS[0]);
  			case FIXED_FORMAT1: return parseString(inString, ALL_DATE_FORMATS[1]);
  			case FIXED_FORMAT2: return parseString(inString, ALL_DATE_FORMATS[2]);
  			case FIXED_FORMAT3: return parseString(inString, ALL_DATE_FORMATS[3]);
  			case FIXED_FORMAT4: return parseString(inString, ALL_DATE_FORMATS[4]);
  			case FIXED_FORMAT5: return parseString(inString, ALL_DATE_FORMATS[5]);
  			case FIXED_FORMAT6: return parseString(inString, ALL_DATE_FORMATS[6]);
  			case FIXED_FORMAT7: return parseString(inString, ALL_DATE_FORMATS[7]);
  			case FIXED_FORMAT8: return parseString(inString, ALL_DATE_FORMATS[8]);
  
  			case GENERAL_STRING:
  				if (inString.length() == 19)
  				{
  					final Matcher matcher = GENERAL_TIMESTAMP_PATTERN.matcher(inString);
  					if (matcher.matches())
  					{
  						try {
  							return getMilliseconds(Integer.parseInt(matcher.group(1)),
  								Integer.parseInt(matcher.group(2)),
  								Integer.parseInt(matcher.group(3)),
  								Integer.parseInt(matcher.group(4)),
  								Integer.parseInt(matcher.group(5)),
  								Integer.parseInt(matcher.group(6)),
  								null, null); // no fractions of a second and no timezone
  						}
  						catch (NumberFormatException ignored) {} // parse shouldn't fail if matcher matched
  					}
  				}
  				break;
  		}
  		return null;
  	}
  
  
  	/**
  	 * Try to parse the given string with the given date format
  	 * @param inString String to parse
  	 * @param inDateFormat Date format to use
  	 * @return milliseconds if successful
  	 */
  	private static Long parseString(String inString, DateFormat inDateFormat)
  	{
  		ParsePosition pPos = new ParsePosition(0);
  		Date date = inDateFormat.parse(inString, pPos);
  		if (date != null && inString.length() == pPos.getIndex()) // require use of _all_ the string, not just the beginning
  		{
  			CALENDAR.setTime(date);
  			return CALENDAR.getTimeInMillis();
  		}
  		return null;
  	}
  
  
  	/**
  	 * Constructor giving millis
  	 * @param inMillis milliseconds since 1970
  	 */
  	public TimestampUtc(long inMillis)
  	{
  		_milliseconds = inMillis;
  		_text = null;
  		_valid = true;
  	}
  
  
  	/**
  	 * Convert the given timestamp parameters into a number of milliseconds
  	 * @param inYear year
  	 * @param inMonth month, beginning with 1
  	 * @param inDay day of month, beginning with 1
  	 * @param inHour hour of day, 0-24
  	 * @param inMinute minute
  	 * @param inSecond seconds
  	 * @param inFraction fractions of a second
  	 * @param inTimezone timezone, if any
  	 * @return number of milliseconds
  	 */
  	private static long getMilliseconds(int inYear, int inMonth, int inDay,
  		int inHour, int inMinute, int inSecond, String inFraction, String inTimezone)
  	{
  		Calendar cal = Calendar.getInstance();
  		// Timezone, if any
  		if (inTimezone == null || inTimezone.equals("") || inTimezone.equals("Z")) {
  			// No timezone, use zulu
  			cal.setTimeZone(TimeZone.getTimeZone("GMT"));
  		}
  		else {
  			// Timezone specified, pass to calendar
  			cal.setTimeZone(TimeZone.getTimeZone("GMT" + inTimezone));
  		}
  		cal.set(Calendar.YEAR, inYear);
  		cal.set(Calendar.MONTH, inMonth - 1);
  		cal.set(Calendar.DAY_OF_MONTH, inDay);
  		cal.set(Calendar.HOUR_OF_DAY, inHour);
  		cal.set(Calendar.MINUTE, inMinute);
  		cal.set(Calendar.SECOND, inSecond);
  		int millis = 0;
  		if (inFraction != null)
  		{
  			try {
  				int frac = Integer.parseInt(inFraction);
  				final int fracLen = inFraction.length();
  				switch (fracLen) {
  					case 1: millis = frac * 100; break;
  					case 2: millis = frac * 10;  break;
  					case 3: millis = frac;       break;
  				}
  			}
  			catch (NumberFormatException nfe) {} // ignore errors, millis stay at 0
  		}
  		cal.set(Calendar.MILLISECOND, millis);
  		return cal.getTimeInMillis();
  	}
  
  	/**
  	 * Convert the given long parameters into a number of milliseconds
  	 * @param inRawValue long value representing seconds / milliseconds
  	 * @return number of milliseconds
  	 */
  	private static long getMilliseconds(long inRawValue)
  	{
  		// check for each format possibility and pick nearest
  		long diff1 = Math.abs(SECS_SINCE_1970 - inRawValue);
  		long diff2 = Math.abs(MSECS_SINCE_1970 - inRawValue);
  		long diff3 = Math.abs(MSECS_SINCE_1990 - inRawValue);
  		long diff4 = Math.abs(SECS_SINCE_GARTRIP - inRawValue);
  
  		// Start off with "seconds since 1970" format
  		long smallestDiff = diff1;
  		long millis = inRawValue * 1000;
  		// Now check millis since 1970
  		if (diff2 < smallestDiff)
  		{
  			// milliseconds since 1970
  			millis = inRawValue;
  			smallestDiff = diff2;
  		}
  		// Now millis since 1990
  		if (diff3 < smallestDiff)
  		{
  			// milliseconds since 1990
  			millis = inRawValue + TWENTY_YEARS_IN_SECS * 1000L;
  			smallestDiff = diff3;
  		}
  		// Lastly, check gartrip offset
  		if (diff4 < smallestDiff)
  		{
  			// seconds since gartrip offset
  			millis = (inRawValue + GARTRIP_OFFSET) * 1000L;
  		}
  		return millis;
  	}
  
  	/**
  	 * @return true if timestamp is valid
  	 */
  	public boolean isValid() {
  		return _valid;
  	}
  
  	/**
  	 * @return true if the timestamp has non-zero milliseconds
  	 */
  	protected boolean hasMilliseconds() {
  		return isValid() && (_milliseconds % 1000L) > 0;
  	}
  
  	/**
  	 * @return the milliseconds according to the given timezone
  	 */
  	public long getMilliseconds(TimeZone inZone) {
  		return _milliseconds;
  	}
  
  	/**
  	 * Add the given number of milliseconds offset
  	 * @param inOffset number of milliseconds to add/subtract
  	 * @return new timestamp, offset from this one
  	 */
  	public Timestamp addOffsetMilliseconds(long inOffset) {
  		return new TimestampUtc(_milliseconds + inOffset);
  	}
  
  	/**
  	 * Add the given number of seconds offset
  	 * @param inOffset number of seconds to add/subtract
  	 * @return new timestamp, offset from this one
  	 */
  	public Timestamp addOffsetSeconds(long inOffset) {
  		return addOffsetMilliseconds(inOffset * 1000L);
  	}
  
  	/**
  	 * @param inFormat format of timestamp
  	 * @param inTimezone timezone to use
  	 * @return Description of timestamp in required format
  	 */
  	public String getText(Format inFormat, TimeZone inTimezone)
  	{
  		// Use the cached text if possible
  		if (isValid()
  			&& _text != null
  			&& inFormat == Format.ORIGINAL)
  		{
  			return _text;
  		}
  
  		// Nothing cached, so use the regular one
  		return super.getText(inFormat, inTimezone);
  	}
  
  	/** @return a string describing the interpolated timestamp between two existing ones */
  	public static String interpolate(Timestamp inStartStamp, Timestamp inEndStamp, double inFrac)
  	{
  		if (inStartStamp == null || !inStartStamp.isValid()
  			|| inEndStamp == null || !inEndStamp.isValid()
  			|| inEndStamp.isBefore(inStartStamp))
  		{
  			return "";
  		}
  		TimeZone utcZone = TimeZone.getTimeZone("UTC");
  		final long startMillis = inStartStamp.getMilliseconds(utcZone);
  		final long endMillis = inEndStamp.getMilliseconds(utcZone);
  		final long middleMillis = startMillis + (long) (inFrac * (endMillis - startMillis));
  		TimestampUtc result = new TimestampUtc(middleMillis);
  		return result.getText(Format.ISO8601, utcZone);
  	}
  
  	/**
  	 * Utility method for formatting dates / times
  	 * @param inFormat formatter object
  	 * @param inTimezone timezone to use
  	 * @return formatted String
  	 */
  	protected String format(DateFormat inFormat, TimeZone inTimezone)
  	{
  		synchronized(CALENDAR)
  		{
  			CALENDAR.setTimeZone(TimeZone.getTimeZone("GMT"));
  			inFormat.setTimeZone(inTimezone == null ? TimeZone.getTimeZone("GMT") : inTimezone);
  
  			CALENDAR.setTimeInMillis(_milliseconds);
  			return inFormat.format(CALENDAR.getTime());
  		}
  	}
  
  	/**
  	 * @return a Calendar object representing this timestamp
  	 */
  	public Calendar getCalendar(TimeZone inZone)
  	{
  		Calendar cal = Calendar.getInstance();
  		cal.setTimeZone(TimeZone.getTimeZone("GMT"));
  		cal.setTimeInMillis(_milliseconds);
  		return cal;
  	}
  }
  