/*
 * Copyright (C) 2004-2009  Medsphere Systems Corporation
 * All rights reserved.
 *
 * This source code contains the intellectual property
 * of its copyright holder(s), and is made available
 * under a license. If you do not know the terms of
 * the license, please stop and do not read further.
 *
 * Please read LICENSES for detailed information about 
 * the license this source code file is available under. 
 * Questions should be directed to legal@medsphere.com
 *
 *
 * Licensed under AGPL v3.
 * 
 * 

 Modified by Sam Habiel to use in Scheduling GUI. Modified class licensed under LGPL.
 */


using System;
using System.Globalization;
using System.Text.RegularExpressions;

namespace IndianHealthService.ClinicalScheduling
{
	public delegate void FMDateTimeHandler (FMDateTime time);
	public delegate string FMDateStringHandler (string s);
	
	[Serializable]
	[System.Xml.Serialization.SoapType (Namespace="http://ws.medsphere.com")]
	public class FMDateTime : IComparable, ICloneable
	{
		/* public properties */
		[System.Xml.Serialization.SoapAttribute (Namespace="http://ws.medsphere.com")]
		public DateTime DateTime {
			get {
				switch (Precision) {
				case FMDateTimePrecision.YearOnly:
					return new DateTime (Year, 1, 1);
				case FMDateTimePrecision.YearMonthOnly:
					return new DateTime (Year, Month, 1);
				case FMDateTimePrecision.DateOnly:
					return new DateTime (Year, Month, Day);
				default:
					return new DateTime (Year, Month, Day, Hour, Minute, Second);
				}
			}
		}

		public int Year {
			get { return year; }
			set { year = value; }
		}

		public int Month {
			get { return month; }
			set { month = value; }
		}

		public int Day {
			get { return day; }
			set { day = value; }
		}

		public int Hour {
			get { return hour; }
			set {
				if (value > 24) {
					throw new ArgumentException ("Hour cannot be greater than 24");
				}

				hour = value % 24;
			}
		}

		public int Minute {
			get { return minute; }
			set {
				if (value > 59) {
					throw new ArgumentException ("Minute cannot be greater than 59");
				}

				minute = value;
			}
		}

		public int Second {
			get { return second; }
			set {
				if (value > 59) {
					throw new ArgumentException ("Second cannot be greater than 59");
				}

				second = value;
			}
		}

		public static FMDateTime ServerNow {
			get { return FMDateTime.Create (DateTime.Now - server_offset); }
		}

		public string RelativeFMDateString {
			get { return Raw; }
		}

		public string ShortHandString {
			get {
				if (Raw != null && date_format.IsMatch (Raw.Replace (" ", ""))) {
					return Raw;
				}
				return ToString ();
			}
		}

		public FMDateTime AtZero {
			get {
				FMDateTime d = (FMDateTime)this.Clone ();
				d.Precision = FMDateTimePrecision.DateAndTime;
				d.Hour = 0;
				d.Minute = 0;
				d.Second = 0;
				return d;
			}
		}

		public FMDateTime AtMidnight {
			get {
				FMDateTime d = (FMDateTime)this.Clone ();
				d.Precision = FMDateTimePrecision.DateAndTime;
				d.Hour = 23;
				d.Minute = 59;
				d.Second = 59;
				return d;
			}
		}

		public FMDateTime DateOnly {
			get {
				FMDateTime d = (FMDateTime)this.Clone ();
				if (Precision != FMDateTimePrecision.DateAndTime) {
					return d;
				}
				d.Precision = FMDateTimePrecision.DateOnly;
				d.Hour = d.Minute = d.Second = 0;
				return d;
			}
		}

		public string FMDateString {
			get {
				switch (Precision) {
				case FMDateTimePrecision.YearOnly:
					return String.Format ("{0:000}", year - 1700);
				case FMDateTimePrecision.YearMonthOnly:
					return String.Format ("{0:000}{1:00}", year - 1700, month);
				case FMDateTimePrecision.DateOnly:
					return String.Format ("{0:000}{1:00}{2:00}", year - 1700, month, day);
				case FMDateTimePrecision.DateAndTime:
				default:
					if (second > 0) {
						return String.Format ("{0:000}{1:00}{2:00}.{3:00}{4:00}{5:00}",
								      year - 1700, month, day, hour, minute, second);
					} else {
						return String.Format ("{0:000}{1:00}{2:00}.{3:00}{4:00}",
								      year - 1700, month, day, hour, minute);
					}
				}
			}
		}

		/* public fields */
		public FMDateTimePrecision Precision;

		[NonSerialized]
		public static FMDateStringHandler ValidationMethod;

		public static FMDateTime MinValue; // 1/1/1700
		public static FMDateTime MaxValue; // 12/31/2699 12:59 PM

		/* public methods */
		static FMDateTime ()
		{
			// This is the equivalent of the FMDateTime string '0000101'
			// We do this manually to avoid parsing overhead here.
			MinValue = new FMDateTime (); // 1/1/1700
			MinValue.Hour = MinValue.Minute = MinValue.Second = 0;
			MinValue.Day = MinValue.Month = 1;
			MinValue.Year = 1700;
			MinValue.Precision = FMDateTimePrecision.DateOnly;

			// This is the equivalent of the FMDateTime string '9991231.235959'
			// We do this manually to avoid parsing overhead here.
			MaxValue = new FMDateTime (); // 12/31/2699 12:59 PM
			MaxValue.Hour = 23;
			MaxValue.Minute = 59;
			MaxValue.Second = 59;
			MaxValue.Day = 31;
			MaxValue.Month = 12;
			MaxValue.Year = 2699;
			MaxValue.Precision = FMDateTimePrecision.DateAndTime;
		}

		public FMDateTime ()
		{
		}

        public FMDateTime(DateTime d)
            : this(d, FMDateTimePrecision.DateAndTime)
        {
        }

        public FMDateTime(DateTime d, FMDateTimePrecision precision)
        {
            if (d > MaxValue.DateTime || d < MinValue.DateTime)
                return;

            this.Precision = precision;
            this.Year = d.Year;
            this.Month = d.Month;
            this.Day = d.Day;
            this.Hour = d.Hour;
            this.Minute = d.Minute;
            this.Second = d.Second;
        }
		
		public static FMDateTime Create (DateTime d, FMDateTimePrecision precision)
		{
			if (d > MaxValue.DateTime || d < MinValue.DateTime) {
				return null;
			}
			
			FMDateTime f = new FMDateTime ();
			f.Precision = precision;
			f.Year = d.Year;
			f.Month = d.Month;
			f.Day = d.Day;
			f.Hour = d.Hour;
			f.Minute = d.Minute;
			f.Second = d.Second;

			return f;
		}

		public static FMDateTime Create (DateTime d)
		{
			return Create (d, FMDateTimePrecision.DateAndTime);
		}

        /*public static string FMDate (this DateTime d)
        {
            return Create(d, FMDateTimePrecision.DateAndTime).FMDateString;
        }*/


		public static FMDateTime Parse (string str)
		{
			return Parse (str, FMDateTime.ValidationMethod);
		}

		public static FMDateTime Parse (string str,
						FMDateStringHandler validation_method)
		{
			if (validation_method == null) {
				throw new ArgumentNullException ("You must pass in a valid validation_method");
			}

			if (str == null) {
				return null;
			}

			FMDateTime date = null;

			str = str.Trim ();
			if (str == "0" || str == String.Empty) {
				return null;
			}

			if (str.IndexOf ("@") != -1) {
				date = new FMDateTime ();

				// string has a date and time part
				string[] tokens = str.Split (new char[] {'@'}, 2);
				if (ParseDatePart (tokens[0], ref date)
 				    || ParseUsingDateTime (tokens[0], ref date)
				    || (validation_method != null
				        && ParseInternalFormat (validation_method (tokens[0]), ref date))) {
					// Its been decided that if you have an
					// invalid time part, that the entire
					// string is invalid
					if (!ParseTimePart (tokens[1], true, ref date)) {
						return null;
					}

					date.Raw = str;
					return date;
				} else {
					// Account for @0600
					date = FMDateTime.ServerNow;
					if (!ParseTimePart (tokens[1], true, ref date)) {
						return null;
					}
					return date;
				}
			}
			
			if (ParseDatePart (str, ref date)) {
				date.Raw = str;
				return date;
			}

			if (ParseTimePart (str, false, ref date)) {
				FMDateTime now = ServerNow;
				date.Year = now.Year;
				date.Month = now.Month;
				date.Day = now.Day;
				return date;
			}

			if (ParseUsingDateTime (str, ref date)) {
				return date;
			}

			if (ParseInternalFormat (str, ref date)) {
				return date;
			}

			if (validation_method != null) {
				if (ParseInternalFormat (validation_method (str), ref date)) {
					return date;
				}
				return null;
			}

			if (date == null) {
				Console.WriteLine ("WARNING: FMDateTime failed parsing '{0}'", str);
			}

			return date;
		}

		public static FMDateTime Parse (string str, FMDateTimePrecision precision)
		{
			FMDateTime date = FMDateTime.Parse (str);
			if (date != null) {
				date.Precision = precision;
			}

			return date;
		}

		public void PopulateFrom12HrTime (int hour, int minute, int second, bool is_pm)
		{
			if (hour < 12 && is_pm) {
				hour += 12;
			} else if (hour == 12 && !is_pm) {
				hour = 0;
			}

			Hour = hour;
			Minute = minute;
			Second = second;
		}

		public bool IsFutureDate
		{
			get {
				return (CompareTo (Precision, FMDateTime.ServerNow, FMDateTime.ServerNow.Precision) > 0);
			}
		}

		public bool IsPastDate
		{
			get {
				return (CompareTo (Precision, FMDateTime.ServerNow, FMDateTime.ServerNow.Precision) < 0);
			}
		}

		public static void UpdateServerNow (FMDateTime server_now)
		{
			if (server_now != null) {
				server_offset = (DateTime.Now - server_now.DateTime);
			}
		}

		public override string ToString ()
		{
			switch (Precision) {
			case FMDateTimePrecision.YearOnly:
				return DateTime.ToString ("yyyy");
			case FMDateTimePrecision.YearMonthOnly:
				return DateTime.ToString ("Y");
			case FMDateTimePrecision.DateOnly:
				return DateTime.ToString ("d");
			default:
				return DateTime.ToString ("G");
			}
		}

		public static string ToString (FMDateTime date)
		{
			if (date != null) {
				return date.ToString ();
			}
			return String.Empty;
		}

		public string ToString (string format)
		{
			return DateTime.ToString (format);
		}

		public static string ToString (FMDateTime date, string format)
		{
			if (date != null) {
				return date.ToString (format);
			}
			return String.Empty;
		}

		public string ToDateString ()
		{
			return DateTime.ToString ("d");
		}

		public static string ToDateString (FMDateTime date)
		{
			if (date != null) {
				return date.ToDateString ();
			}
			return String.Empty;
		}

		public string ToTimeString ()
		{
			return DateTime.ToString ("t");
		}

		public static string ToTimeString (FMDateTime date)
		{
			if (date != null) {
				return date.ToTimeString ();
			}
			return String.Empty;
		}

		public static string ToFMDateString (FMDateTime date)
		{
			if (date != null) {
				return date.FMDateString;
			}
			return String.Empty;
		}
				
		/**
		 * Compares this FMDateTime instance with given FMDateTimePrecision this_p to dt
		 * using the given FMDateTimePrecision p.
		 */ 
		public int CompareTo (FMDateTimePrecision this_p, FMDateTime dt, FMDateTimePrecision dt_p)
		{
			int r;
			FMDateTimePrecision save_this_p = Precision;
			FMDateTimePrecision save_dt_p = dt.Precision;
			Precision = this_p;
			dt.Precision = dt_p;
			r = DateTime.CompareTo (dt.DateTime);
			Precision = save_this_p;
			dt.Precision = save_dt_p;
			return r;
		}

		/**
		 * Implementation of IComparable interface.
		 */
		public int CompareTo (object o)
		{
			if (o == null) {
				return 1;
			} else if (o is FMDateTime) {
				FMDateTime f = (FMDateTime)o;
				int r = DateTime.CompareTo (f.DateTime);
				if (r == 0) {
					// special cases of DateTime comparison:
					//     1900 and January,1900 and 01/01/1900 are all 
					//         represented as 01/01/1900
					//     TODAY@0 and TODAY are both represented as TODAY@0
					// these are the cases where precision has the last word
					if (Precision < f.Precision) {
						r = -1;
					} else if (Precision > f.Precision) {
						r = 1;
					}
				}
				return r;
			} else if (o is DateTime) {
				DateTime d = (DateTime)o;
				return DateTime.CompareTo (d);
			}
			
			throw new ArgumentException ("Value is not a DateTime or FMDateTime.");
		}

		public static int Compare (FMDateTime a, FMDateTime b)
		{
			if (a == null && b == null) {
				return 0;
			} else if (a != null && b != null) {
				return a.CompareTo (b);
			/* We sort the non-null item before the null one for the mixed case */
			} else if (a == null) {
				return -1;
			} else if (b == null) {
				return 1;
			}

			// This code path really has no way of being hit.
			return 0;
		}

		public override bool Equals (object o)
		{
			if (o == null) {
				return false;
			} else if (o is FMDateTime) {
				FMDateTime f = (FMDateTime)o;

				if (f.Precision != Precision) {
					return false;
				}

				switch (Precision) {
				case FMDateTimePrecision.YearOnly:
					return Year == f.Year;
				case FMDateTimePrecision.YearMonthOnly:
					return Year == f.Year && Month == f.Month;
				case FMDateTimePrecision.DateOnly:
					return Year == f.Year && Month == f.Month && Day == f.Day;
				case FMDateTimePrecision.DateAndTime:
				default:
					return Year == f.Year && Month == f.Month && Day == f.Day
					       && Hour == f.Hour && Minute == f.Minute && Second == f.Second;
				}
			}

			throw new ArgumentException ("Value is not a FMDateTime.");
		}

		public override int GetHashCode ()
		{
			return (int)Precision + year + month + day + hour + minute + second;
		}

		/**
		 * This gets a hash code based upon the FMDateTime precision, so that
		 * an object can be stored based on DateOnly, for example, and if you
		 * try to look it up later using a different FMDateTime object that
		 * has the same date, but may have different time.  Seconds are
		 * intentionally never factored into this hash code, even for DateAndTime
		 * cases.  If you want to factor in seconds as  well, just use GetHashCode().
		 *
		 * @return   An integer hash code.
		 */
		public int GetPrecisionAwareHashCode ()
		{
			int hash_code = (int)Precision;

			switch (Precision)
			{
			case FMDateTimePrecision.YearOnly:
				hash_code += year;
				break;
			case FMDateTimePrecision.YearMonthOnly:
				hash_code += year;
				hash_code += month;
				break;
			case FMDateTimePrecision.DateOnly:
				hash_code += year;
				hash_code += month;
				hash_code += day;
				break;
			case FMDateTimePrecision.DateAndTime:
			default:
				hash_code += year;
				hash_code += month;
				hash_code += day;
				hash_code += hour;
				hash_code += minute;
				break;
			}

			return hash_code;
		}

		public object Clone ()
		{
			FMDateTime d = new FMDateTime ();
			d.Precision = Precision;
			d.Year = year;
			d.Month = month;
			d.Day = day;
			d.Hour = hour;
			d.Minute = minute;
			d.Second = second;
			return d;
		}
	
		public static bool operator == (FMDateTime a, FMDateTime b)
		{
			object obj_a = (object)a;
			object obj_b = (object)b;

			if (obj_a == null && obj_b == null) {
				return true;
			} else if (obj_a != null && obj_b != null) {
				return a.Equals (b);
			} else {
				return false;
			}
		}

		public static bool operator != (FMDateTime a, FMDateTime b)
		{
			return !(a == b);
		}

		public static bool operator > (FMDateTime a, FMDateTime b)
		{
			if (a == null) {
				throw new ArgumentException ("Left hand argument to comparison cannot be null.");
			}

			return (a.CompareTo (b) > 0);
		}

		public static bool operator >= (FMDateTime a, FMDateTime b)
		{
			if (a == null) {
				throw new ArgumentException ("Left hand argument to comparison cannot be null.");
			}

			return (a.CompareTo (b) >= 0);
		}

		public static bool operator < (FMDateTime a, FMDateTime b)
		{
			if (a == null) {
				throw new ArgumentException ("Left hand argument to comparison cannot be null.");
			}

			return (a.CompareTo (b) < 0);
		}

		public static bool operator <= (FMDateTime a, FMDateTime b)
		{
			if (a == null) {
				throw new ArgumentException ("Left hand argument to comparison cannot be null.");
			}

			return (a.CompareTo (b) <= 0);
		}

		public static implicit operator FMDateTime (DateTime d)
		{
			return FMDateTime.Create (d);
		}

		/* protected properties */
		protected string Raw;
		
		/* private properties */
		private static Calendar CurrentCalendar {
			get { return CultureInfo.CurrentCulture.Calendar; }
		}

		/* private fields */
		private int year, month, day, hour, minute, second;

		// We do this here so we can lazy load the compiled regexes.
		private static Regex internal_format {
			get {
				if (priv_internal_format == null) {
					priv_internal_format = new Regex (@"^(\d{3})(\d{2})?(\d{2})?(\.(\d{1,2})?(\d{1,2})?(\d{1,2})?)?$", RegexOptions.IgnoreCase | RegexOptions.Compiled);
				}
				
				return priv_internal_format;
			}
		}
		private static Regex priv_internal_format;

		private static Regex date_format {
			get {
				if (priv_date_format == null) {
					priv_date_format = new Regex (@"^(t(oday)?|n(ow)?)(([+-])(\d+)(w)?)?$", RegexOptions.IgnoreCase | RegexOptions.Compiled);
				}
				
				return priv_date_format;
			}
		}
		private static Regex priv_date_format;

		private static Regex time_format {
			get {
				if (priv_time_format == null) {
					priv_time_format = new Regex (@"^(\d{1,2})(:(\d{2}))?(:(\d{2}))?(\s*)(AM|PM)?$", RegexOptions.IgnoreCase | RegexOptions.Compiled);
				}
				
				return priv_time_format;
			}
		}
		private static Regex priv_time_format;

		private static TimeSpan server_offset = new TimeSpan ();

		/* private methods */
		private static bool ParseDatePart (string str, ref FMDateTime date)
		{
			FMDateTime orig_date = date;
		
			string clean = str.Replace (" ", "");

			// see if it matches (t|today|now) +/- some number
			if (!date_format.IsMatch (clean)) {
				return false;
			}

			Match m = date_format.Match (clean);
			if (m != null) {
				if (date == null) {
					date = new FMDateTime ();
				}

				// be safe about dates like T-99999999
				try {
					int modifier = 0;
					if (m.Groups[5].Value != String.Empty) {
						int sign_bit = 1;
						if (m.Groups[5].Value == "-") {
							sign_bit = -1;
						}
						
						// Convert will bomb if the modifier
						// won't fit into an int (it's invalid
						// anyway)
						modifier = sign_bit * Convert.ToInt32 (m.Groups[6].Value);
					}

					DateTime dt = ServerNow.DateTime;
					if (m.Groups[7].Value.ToLower () == "w") {
						dt = CurrentCalendar.AddWeeks (dt, modifier);
					} else {
						dt = CurrentCalendar.AddDays (dt, modifier);
					}

					date.Day = dt.Day;
					date.Month = dt.Month;
					date.Year = dt.Year;

					if (m.Groups[1].Value.ToLower ().StartsWith ("n")) {
						date.Precision = FMDateTimePrecision.DateAndTime;
						date.Hour = dt.Hour;
						date.Minute = dt.Minute;
						date.Second = dt.Second;
					} else {
						date.Precision = FMDateTimePrecision.DateOnly;
						date.Hour = date.Minute = date.Second = 0;
					}
				} catch {
					date = orig_date;
					return false;
				}

				return true;
			}

			date = orig_date;
			return false;
		}

		private static bool ParseTimePart (string str, bool try_int_parse, ref FMDateTime date)
		{
            int time;
			str = str.ToUpper ();
			if (str == "NOON") {
				if (date == null) {
					date = new FMDateTime ();
				}
			
				date.Hour = 12;
				date.Minute = date.Second = 0;
				
				date.Precision = FMDateTimePrecision.DateAndTime;

				return true;
			} else if (str == "MID" || str == "MIDNIGHT") {
				if (date == null) {
					date = new FMDateTime ();
				}
			
				date.Hour = 23;
				date.Minute = 59;
				date.Second = 59;

				date.Precision = FMDateTimePrecision.DateAndTime;

				return true;
			} else if (time_format.IsMatch (str)) {
				Match m = time_format.Match (str);
				if (m == null) {
					return false;
				}

				int hour, minute, second;
                int.TryParse(m.Groups[1].Value, out hour);
				int.TryParse(m.Groups[3].Value, out minute);
				int.TryParse(m.Groups[5].Value, out second);

				if (m.Groups[7].Value == "PM") {
					hour += 12;
				}

				if (hour == 24 && minute == 0 && second == 0) {
					hour = 23;
					minute = second = 59;
				}

				if (!ValidateTime (hour, minute, second)) {
					return false;
				}

				if (date == null) {
					date = new FMDateTime ();
				}

				date.Hour = hour;
				date.Minute = minute;
				date.Second = second;
				date.Precision = FMDateTimePrecision.DateAndTime;

				return true;
			} else if (try_int_parse && int.TryParse(str, out time)) {

				int hour, minute, second;
				if (time <= 2359) {
					hour = time / 100;
					minute = time - (hour * 100);
					second = 0;
				} else if (time <= 235959) {
					hour = time / 10000;
					minute = (time - (hour * 10000)) / 100;
					second = time - ((time / 100) * 100);
				} else {
					return false;
				}
				
				if (hour == 24 && minute == 0 && second == 0) {
					hour = 23;
					minute = second = 59;
				}

				if (!ValidateTime (hour, minute, second)) {
					return false;
				}

				if (date == null) {
					date = new FMDateTime ();
				}
				
				date.Hour = hour;
				date.Minute = minute;
				date.Second = second;
				date.Precision = FMDateTimePrecision.DateAndTime;

				return true;
			}
			
			return false;
		}

		private static bool ParseUsingDateTime (string str, ref FMDateTime date)
		{
			// we need to use DateTime.Parse to allow
			// roundtripping of our ToString () methods

			// LAMESPEC: There isn't any way to find out whether a
			// DateTime contains a time part, or just a date part
			// after calling Parse, so we have to specifically call
			// ParseExact on a few known formats
			try {
				string[] formats = new string[] {
					"yyyy"
				};
				
				DateTime d = DateTime.ParseExact (str, formats, null,
				                                  DateTimeStyles.AllowWhiteSpaces);
				if (date == null) {
					date = new FMDateTime ();
				}
				                                  
				date.Year = d.Year;
				date.Precision = FMDateTimePrecision.YearOnly;
				return true;
			} catch (FormatException) {
			}

			try {
				string[] formats = new string[] {
					"Y"
				};
				
				DateTime d = DateTime.ParseExact (str, formats, null,
				                                  DateTimeStyles.AllowWhiteSpaces);
				if (date == null) {
					date = new FMDateTime ();
				}
				
				date.Year = d.Year;
				date.Month = d.Month;
				date.Precision = FMDateTimePrecision.YearMonthOnly;
				return true;
			} catch (FormatException) {
			}

			try {
				string[] formats = new string[] {
					"d", "MM/dd/yy"
				};
				
				DateTime d = DateTime.ParseExact (str, formats, null,
				                                  DateTimeStyles.AllowWhiteSpaces);
				if (date == null) {
					date = new FMDateTime ();
				}
				
				date.Year = d.Year;
				date.Month = d.Month;
				date.Day = d.Day;
				date.Precision = FMDateTimePrecision.DateOnly;
				return true;
			} catch (FormatException) {
			}

			try {
				string[] formats = new string[] {
					"g", "G", "MM/dd/yy hh:mm tt",
					"MM/dd/yy h:mm tt"
				};
				
				DateTime d = DateTime.ParseExact (str, formats, null,
				                                  DateTimeStyles.AllowWhiteSpaces);
				if (date == null) {
					date = new FMDateTime ();
				}
				
				date.Year = d.Year;
				date.Month = d.Month;
				date.Day = d.Day;

				date.Hour = d.Hour;
				date.Minute = d.Minute;
				date.Second = d.Second;

				date.Precision = FMDateTimePrecision.DateAndTime;
				return true;
			} catch (FormatException) {
			}
		
			/* XXX: Disabiling this for now, since it sucks incredibly
			// first try parsing date & time
			try {
				string[] date_time_formats = new string[] {
					"dddd*, MMMM* dd, yyyy HH*:mm* tt*", "f",
					"dddd*, MMMM* dd, yyyy HH*:mm*:ss* tt*", "F",
					"MM/dd/yyyy HH*:mm* tt*", "g",
					"MM/dd/yyyy HH*:mm*:ss* tt*", "G",
					"dddd*, MMMM* dd, yyyy HH*:mm*:ss* tt*", "U"
				};

				DateTime d = DateTime.ParseExact (str, date_time_formats, null,
				                                  DateTimeStyles.AllowWhiteSpaces);
				date.Year = d.Year;
				date.Month = d.Month;
				date.Day = d.Day;
				date.Hour = d.Hour;
				date.Minute = d.Minute;
				date.Second = d.Second;
				date.Precision = FMDateTimePrecision.DateAndTime;
				return true;
			} catch { }
			
			// fall back on just parsing a date
			try {
				string[] date_formats = new string[] {
					"d", "D", "m", "M", "y", "Y"
				};

				DateTime d = DateTime.ParseExact (str, date_formats, null,
				                                  DateTimeStyles.AllowWhiteSpaces);
				date.Year = d.Year;
				date.Month = d.Month;
				date.Day = d.Day;
				date.Precision = FMDateTimePrecision.DateOnly;
				return true;
			} catch { }
			
			// if nothing else, try a couple of time formats
			try {
				string[] time_formats = new string[] {
					"HH*:mm* tt*", "t",
					"HH*:mm*:ss* tt*", "T"
				};

				DateTime d = DateTime.ParseExact (str, time_formats, null,
				                                  DateTimeStyles.AllowWhiteSpaces);
				date = FMDateTime.ServerNow;
				date.Hour = d.Hour;
				date.Minute = d.Minute;
				date.Second = d.Second;
				date.Precision = FMDateTimePrecision.DateAndTime;
				return true;
			} catch { }
			*/

			return false;
		}

		private static bool ParseInternalFormat (string str, ref FMDateTime date)
		{
			FMDateTime orig_date = date;
		
			if (internal_format.IsMatch (str)) {
				Match m = internal_format.Match (str);
				if (m != null && m.Groups.Count == 8) {
					int year, month, day, hour, minute, second;

					int.TryParse(m.Groups[1].Value, out year);
					year += 1700;

					int.TryParse(m.Groups[2].Value, out month);
					int.TryParse(m.Groups[3].Value, out day);
					int.TryParse(m.Groups[5].Value, out hour);
                    int.TryParse(m.Groups[6].Value, out minute);
                    int.TryParse(m.Groups[7].Value, out second);

					// 1 digit hours apparently have just
					// had the trailing 0 dropped.  Go figure.
					if (m.Groups[5].Value.Length == 1) {
						hour *= 10;
					}

					// 1 digit minutes do too
					if (m.Groups[6].Value.Length == 1) {
						minute *= 10;
					}

					// 1 digit seconds aren't to be left out
					if (m.Groups[7].Value.Length == 1) {
						second *= 10;
					}

					if (!ValidateYear (year)) {
						return false;
					}

					if (date == null) {
						date = new FMDateTime ();
					}
					
					date.Year = year;

					date.Precision = FMDateTimePrecision.YearOnly;
					if (m.Groups[5].Value != String.Empty
					    && month > 0 && day > 0 && hour > 0) {
						if (!ValidateDate (year, month, day)
						    || !ValidateTime (hour, minute, second)) {
							date = orig_date;
							return false;
						}

						date.Month = month;
						date.Day = day;
						date.Hour = hour;
						date.Minute = minute;
						date.Second = second;

						date.Precision = FMDateTimePrecision.DateAndTime;
					} else if (m.Groups[3].Value != String.Empty
					           && month > 0 && day > 0) {
						if (!ValidateDate (year, month, day)) {
							date = orig_date;
							return false;
						}

						date.Month = month;
						date.Day = day;

						date.Precision = FMDateTimePrecision.DateOnly;
					} else if (m.Groups[2].Value != String.Empty
					           && month > 0) {
						if (!ValidateYearMonth (year, month)) {
							date = orig_date;
							return false;
						}

						date.Month = month;

						date.Precision = FMDateTimePrecision.YearMonthOnly;
					}

					return true;
				}
			}

			return false;
		}

		private static bool ValidateYear (int year)
		{
			// Sadly, we can't use MaxValue and MinValue due to
			// this function being used in the
			// parsing and initialization of those values
			if (year < 1700 || year > 2699) {
				return false;
			}
			
			return true;
		}

		private static bool ValidateYearMonth (int year, int month)
		{
			if (!ValidateYear (year)) {
				return false;
			}

			int num_months = CurrentCalendar.GetMonthsInYear (year);
			if (month < 1 || month > num_months) {
				return false;
			}
			
			return true;
		}

		private static bool ValidateDate (int year, int month, int day)
		{
			if (!ValidateYearMonth (year, month)) {
				return false;
			}

			int num_days = CurrentCalendar.GetDaysInMonth (year, month);
			if (day < 1 || day > num_days) {
				return false;
			}

			return true;
		}

		private static bool ValidateTime (int hour, int minute, int second)
		{
			if (hour < 0 || hour > 24) {
				return false;
			}

			if (minute < 0 || minute > 59) {
				return false;
			}

			if (second < 0 || second > 59) {
				return false;
			}

			if (hour == 24 && (minute > 0 || second > 0)) {
				return false;
			}

			return true;
		}
	}

	public enum FMDateTimePrecision {
		YearOnly,
		YearMonthOnly,
		DateOnly,
		DateAndTime
	}
}