/* -*-c-*-
 * iso8610.zkl : Do some date calculations
 * ISO 8601: Numeric representations of date and time
 *    YYYY-MM-DD
 *    Monday (1) ... Sunday (7)
 *    hh:mm:ss, 24:00 == 00:00 (00:00 is preferred)
 *    YYYYMMDDThhmmss
 *    UTC time is hh:mm:ssZ, offsets are +|-hh[:mm]
 *       12:00Z = 13:00+01:00 = 0700-0500
 * 
 *    YYYY-MM-DDThh:mm:ss 
 *       where the capital letter T is used to separate the date and time
 *       components.  Thus, for a very precise date and time, look at this:
 *       Example:  2003-04-01T13:01:02 represents one minute and two seconds
 *       after one o'clock in the afternoon of 2003-04-01.
 * 
 * http://wikipedia.org/wiki/ISO_8601
 * http://www.phys.uu.nl/~vgent/calendar/isocalendar.htm
 * 
 * Documentation is in zklManual.pdf Appendix B
 * 
 * Copyright (c) 2006, 2007, 2008 Craig Durland craigd@zenkinetic.com
 * License: The zlib/libpng License,
 * 	http://www.opensource.org/licenses/zlib-license.php
 */

AKA(Time.ISO8601); Attributes(static,noChildren);

var [const]
   TheTime  = TheVault.Time.Clock,   // TheVault needed: "class Time" (below)
   TimeDate = Import("Time.Date");

const BASIC_FORMAT    = 1;
const EXTENDED_FORMAT = 2;
const WEEK_FORMAT     = 3;


fcn init(dateString=Void)	// 8601 to Date, Repeater, or Duration
{
   if (not dateString) returnClass(DateTime());
   if (dateString[0] == "P") returnClass(Duration(dateString));
   if (dateString[0] == "R") returnClass(Repeater(dateString));
   returnClass(DateTime(dateString));
}


       /* Formats:
        *   hh:mm:ss == hhmmss
        *   hh:mm    == hhmm
        *   hh
        *   00:00 == 24:00 here, in a date means start of next day
        *   hh:mm:60 == leap second
        *   Fractional time: can only apply to most precise component (ie
        *     the last one). Use comma or dot.
        */
class Time
{
   var 
       hour= 0,		// 0 ... 23
       min = 0,		// 0 ... 59
       sec = 0,		// 0 ... 61
       format = text;
   fcn init(h=Void,m=0,s=0)	// ("hh:mm:ss")
   {
      if (Void == h) now();	// get current time
      else if (h.isType("")) parse(h);
      else { hour = h; min = m; sec = s; }
   }
   fcn toString { return("%s(%s)".fmt(topdog.name,text())); }
   fcn now
   { 
      x,x,x,hour,min,sec := TheTime.localTime;
      return(self);
   }
   fcn text { return("%02d:%02d:%02d".fmt(hour,min,sec)); }
   fcn toAMPM
   {
      hh := hour; ampm := "AM";
      if (hh > 12) { hh -= 12; ampm = "PM"; }
      return("%02d:%02d:%02d%s".fmt(hh,min,sec,ampm));
   }
   fcn read { now(); topdog.format(); }
   fcn addHMS(h,m,s)
   {
      sec += s; min += m; hour += h;
      min += sec / 60; hour += min / 60;
      overflow := hour / 24;
      hour = hour % 24; min = min % 60; sec = sec % 60;
      return(overflow);
   }
   fcn subHMS(h,m,s)
   {
      if ((sec -= s)  < 0) { sec += 60; min  -= 1; }
      if ((min -= m)  < 0) { min += 60; hour -= 1; }
      if ((hour -= h) < 0) { hour += 24; -1 }
      else 0;
      // returns underflow
   }
   fcn add(aTime) { return(addHMS(aTime.hour,aTime.min,aTime.sec)); }
   fcn sub(aTime) { return(subHMS(aTime.hour,aTime.min,aTime.sec)); }
   fcn parse(text="")
   {
      if (not text) now();
      else hour,min,sec = textToHMS(text);
      return(self.text());
   }
   fcn textToHMS(text)
   {
      reg hh=0,mm=0,ss=0;
      if (not text)
      {
	 x,x,x,hh,mm,ss := TheTime.localTime;
	 return(hh,mm,ss);
      }
      time := text.strip() - " ";
      if (time.holds(":"))	// h:m:s, ::s, h::s, etc
      {
	 splits := time.split(":").apply(fcn(x) { (x or 0).toInt() });
	 try { hh,mm,ss = splits; } catch(IndexError) { hh,mm = splits; }
      }
      else
      {
	 try
	 {
	    hh = (time[0,2] or 0).toInt();
	    mm = (time[2,2] or 0).toInt();
	    ss = (time[4,2] or 0).toInt();
// hh = 24 --> next day
	 } catch { throw(Exception.ValueError(
	      "Time: Invalid time: %s".fmt(text))); }
      }
      if (hh < 0 or hh > 23 or mm < 0 or mm > 59 or ss < 0 or ss > 59)
	 throw(Exception.ValueError("Time: Invalid time: %s".fmt(text)));
      return(hh,mm,ss);
   }
   fcn secondsToHMS(seconds)
   {
      reg h = (seconds / 3600);
      if (seconds < 0) seconds = -seconds;
      reg m = (seconds % 3600) / 60;
      reg s = (seconds % 60);
      return(h,m,s);
   }
   fcn toSeconds { return(hour * 3600 + min * 60 + sec); }
   fcn toFloat   { return(TimeDate.toFloat(hour,min,sec)); }
}




       /* Time zones:
        *    <Time>Z == UTC, ie offset of 00
        *    <Time>+|-<Time> (no Z)
        *    <Time>+-hh:mm:ss or <Time>+-hhmmss
        *    <Time>+-hh:mm    or <Time>+-hhmm
        *    <Time>+-hh 
        */
class TimeZ(Time)	// Time with time zone
{
   var TZ=0,		// Offset from GMT, in seconds. PST == -8h
       DST=0;	// Offset for Daylight Savings Time (seconds)
   fcn init(timeString="")
   {
      Time.init();
      TZ,_,DST = TheTime.timeZone;
      TZ = -TZ;
      parse(timeString);
   }
   fcn toString { return("%s(%s)".fmt(topdog.name,text())); }
   fcn text
   {
      time := Time.text();
      if (TZ == 0) time += "Z";
      else
      {
	 h,m,s := secondsToHMS(TZ);
	 if (h >= 0) time += "+";
      	 time += "%02d".fmt(h);
	 if (m) time += ":%02d".fmt(m);
	 if (s) time += ":%02d".fmt(s);
      }
      return(time);
   }
   var format = text;
   fcn parse(text="")
   {
      re := RegExp("(.*)([Z+-])(.*)");
      if (not re.search(text)) Time.parse(text);	// just time
      else				// in the zone
      {
	 matched := re.matched;
	 Time.parse(matched[1]);
	 if (matched[2] != "Z")
	 {
	    h,m,s := textToHMS(matched[3]);
	    TZ = h * 3600 + m * 60 + s;
	    if (matched[2] == "-") TZ = -TZ;
	 }
	 else TZ = 0;
      }
      return(self.text());
   }
   fcn tzToHMS(asString=False)
   {
      reg tz = secondsToHMS(TZ);
      asString and "%+03d:%02d:%02d".fmt(tz.xplode()) or tz;
   }
   fcn shiftTZ(h,m=0,s=0) { TZ += (h*60 + m)*60 + s; self }
   fcn setTZ(h,m=0,s=0)   { TZ  = (h*60 + m)*60 + s; self }
   fcn toUTC
   {
      if (TZ == 0)  return(Time.text());
      reg tz = self.copy();
      if (TZ < 0) tz.subHMS(secondsToHMS(-TZ).xplode());
      else	  tz.addHMS(0,0,TZ);
      tz.Time.text();
   }
}

      /* YYYY
       * YYYY-MM    == YYYYMM
       * YYYY-MM-DD == YYYYMMDD
       * MM is 01 - 12
       * DD is 01 - 31
       * 
       * YYYY-Www == YYYYWww
       *   ww is 01 - 52 or 53
       *   Week 1 is the week with January 4 in it
       *     If January 1 is mon-thurs, it is week 1
       * YYYY-Www-D == YYYYWwwD
       *   D (day) is 1 (monday) - 7 (Sunday)
       * "2009-W01-1" == 2008-12-29
       * "2009-W53-7" == 2010-01-03
       * 
       * Special characters: W D
       * 
       * YYYY-DDD == YYYYDDD
       *    DDD == 001 - 366 (leap years)
       * "1981-095" == "1981-04-05"
       * 
       * Parsing:  Loose.  Missing fields are zero (year) or one.  Overflow
       * taken care of.  For example, "2006--100" is one hundred days into
       * 2006 and is converted to "2006-04-10".  For leap years:
       * "2000--100" --> "2000-04-09"
       */
class Date
{
   	// Shit - constructor needs to set defaults so "Date" doesn't puke
   var year=2008,	// YYYY
       month=3,		// 1 ... 12
       day=12,		// 1 ... 31
       dayInWeek,	// 1 ... 7, 1 is Monday
       dayInYear,	// 1 ... 366
       ;
   fcn init(y,m=1,d=1)	// (or ISO Date string)
   {
      if (vm.numArgs == 0) now();	// get current time
      else if (y.isType("")) parse(y);
      else
      {
	 year = y; month = m; day = d;
	 _adjust();
      }
   }
   fcn toString { return("%s(%s)".fmt(topdog.name,text())); }
   fcn now
   {
      year,month,day = TheTime.localTime;
      _adjust();
      return(self);
   }
   fcn _adjust
   {
      dayInWeek = TimeDate.weekDay(year,month,day);
      dayInYear = TimeDate.nthDayInYear(year,month,day);
   }
   fcn isLeapYear { return(TimeDate.isLeapYear(year)); }
   fcn text       { "%04d-%02d-%02d".fmt(year,month,day); }
   fcn pretty     { TimeDate.prettyDay(year,month,day); }
   fcn weekText
   {
      Y,W := whichWeek();
      return("%04d-W%02d-%d".fmt(Y,W,dayInWeek));
   }
   var format = text;
	/* Week format
	 * 2008-12-29 is written "2009-W01-1", 2008W01 is 2007-12-31
	 * 2009-12-31 is 2009-W53-4, 2009W01 is 2008-12-29
	 * 2010-01-03 is written "2009-W53-7", 2010W01 is 2010-01-04
	 * 2006-W52-7 (or in its most compact form 2006W527) is the Sunday
	 *    of the 52nd week of 2006
	 * 2006 December 31
	 */
   fcn whichWeek	// return the year & week Date is in
   {
		// first Monday is last year or this year 
      Y := year;
      firstMonday := Date(TimeDate.week01(year).xplode());
      W := 1; weeksInYear := TimeDate.weeksInYear(year);
      if (firstMonday.year < year)	// eg 2008 W1 is in 2007
      {
	 // if W1 is last year, we can only be W01 or W52, W53
	 // and month is 12 or 01
	 if (dayInYear < 7) W = 1;
	 else if (dayInYear >= 7 * weeksInYear) { W = 1; Y += 1; }
	 else W = weeksInYear;
      }
      else	// W1 is in this year
      {
	 n := firstMonday;
	 if (month == 1 and day < n.day)
	    W = TimeDate.weeksInYear(Y -= 1);
	 else
	 {
	    while (n.month != month) { n.addDays(7); W += 1; }
	    W += (day - n.day) / 7;
	    if (W > weeksInYear) { W = 1; Y += 1; }
//	    else if (W == weeksInYear) Y -= 1;
	 }
      }
      return(Y,W);
   }
   fcn nthDay { return(TimeDate.nthDayInYear(year,month,day)); }

	/* "Normalize" a date: check for overflow in D M and adjust as needed
	 * Be careful, because of leap years, you have to have to add days,
	 * normalize, add months, normalize, etc
	 */
   fcn normalize
   {
      do	// repeat until no overflow in any fields
      {
	 overflow := False;      
	 days := TimeDate.daysInMonth(year,month);
	 if (day > days)
	 {
	    day -= days;
	    month += 1;
	    overflow = True;
	 }
	 if (month > 12)
	 {
	    month -= 12;
	    year += 1;
	    overflow = True;
	 }
      } while (overflow);
   }
   fcn addDays(days)
   {
      if (days == 0) return(self);
      if (days < 0)  return(subDays(-days));

      numDays := days;
#if 0
      while (True)	// years
      {
	 daysLeftInYear = 
	    TimeDate.daysInYear(year) - TimeDate.nthDayInYear(year,month,day);
	 if (numDays < daysLeftInYear) break;
	 year += 1; month = TimeDate.January; day = 1;
	 numDays -= daysLeftInYear;
      }
      if (numDays > 0)
      {
	 while (True)	// months
	 {
	    daysLeftInMonth = 	// might be 0
		TimeDate.daysInMonth(year,month) - day;
	    if (numDays <= daysLeftInMonth) break;
	    month += 1; day = 1;
	    numDays -= daysLeftInMonth + 1;
	 }
      }
#endif
      day += numDays;
      normalize();
      _adjust();
      return(self);
   }
   fcn subDays(days)
   {
      if (days == 0) return(self);
      if (days < 0)  return(addDays(-days));

      numDays := days;
      while (True)	// years
      {
	 nthDay := TimeDate.nthDayInYear(year,month,day);
	 if (numDays < nthDay) break;		// stay in the current year
		// last day of previous year
	 year += 1; month = TimeDate.December; day = 31;
	 numDays -= nthDay;
      }
      if (numDays > 0)
      {
	 while (True)	// months
	 {
	    if (numDays < day) break;	// stay in current month
	    numDays -= day;
		// last day of previous month
	    day = TimeDate.daysInMonth(year,month -= 1);
	 }
      }
       day -= numDays;	// days
      normalize();
      _adjust();
      return(self);
   }
   	/* OK, what do you do when you add a month to 10-31? November only
	 * has 30 days, truncate or roll into December?
	 * For now, stay inside of month
	 */
   fcn addMonths(months)
   {
      if (months == 0) return(self);
      if (months < 0)  return(subMonths(-months));
      month += months;
      if (month > TimeDate.December)
      {
	 year += month / 13;
	 month = (month - 1)%12 + 1;
      }
      maxDays := TimeDate.daysInMonth(year,month);
      if (day > maxDays) day = maxDays;
      normalize();
      return(self);
   }
   fcn subMonths(months)
   {
      if (months == 0) return(self);
      if (months < 0)  return(addMonths(-months));
      month -= months;
      if (month < TimeDate.January)
      {
	 year += (month - 12) / 12;
	 month = month % 12 + 12;
      }
      maxDays := TimeDate.daysInMonth(year,month);
      if (day > maxDays) day = maxDays;
      normalize();
      return(self);
   }
   fcn addYears(years)
   {
      year += years;
      return(self);
   }
   fcn addYMD(years,months,days)
   {
      addDays(days); addMonths(months); addYears(years);
      return(self);
   }
   fcn subYMD(years,months,days)	// --> self
   {
      subDays(days); subMonths(months); addYears(-years);
      return(self);
   }
   fcn add(x)
   {
      if (x.isInstanceOf(self)) addYMD(x.year,x.month,x.day);
      else throw(Exception.TypeError("Date.add: no can do with %s".fmt(x)));
      return(self);
   }
   fcn parse(text)	// --> modifies self?!?
   {
      year = 2000; month = day = 1;
      if (not text) now();
      else if (text.holds("D"))
      {
	 
      }
      else if (text.holds("W"))
      {
	 x := text.split("W");
	 if (year = x.pop(0))
	 {
	    if (year[-1] == "-") year = year[0,-1].toInt();	// 2000-W
	    else		 year = year.toInt();		// "2000W..."
	 }
	 else year = TheTime.localTime[0];		// "W..."
	 x = x.pop() - "-";
	 weeks := x[0,2].toInt();
	 if (weeks < 1 or weeks > 53) throw(
	    Exception.ValueError("Date: week range: "+text));
	 d := x[2,1].toInt() or 1;	// Monday ... Sunday
	 if (d < 1 or d > 7) throw(
	    Exception.ValueError("Date: weekday range: "+text));
	 year,month,day = TimeDate.week01(year);
	 day += (weeks - 1) * 7;
	 normalize();		// had better be a Monday
	 day += d - 1;
      }
      else
      {
	 if (text.holds("-"))
	 {
	    x := text.split("-");
	    try
	    {
	       year  = x.pop(0).toInt();
	       month = x.pop(0).toInt();
	       day   = x.pop(0).toInt();
	    } catch(IndexError) {}
	 }
	 else
	 {
	    year  = (text[0,4] or 2000).toInt();
	    month = (text[4,2] or 1).toInt();
	    day   = (text[6,2] or 1).toInt();
	 }
	 if (month == 0) month = 1;
	 if (day   == 0) day   = 1;
      }
      normalize();	// or bitch if out of range?
      _adjust();
      return(self.text());
   }
}

    /* <date>
     * <date>T<time>
     * "" or Void
     */
class DateTime(Date,TimeZ)
{
   fcn init(dateString = "")
   {
      Date.init(); TimeZ.init();
      parse(dateString);
   }
   fcn toString { return("%s(%s)".fmt(topdog.name,text())); }
   fcn text { return("%s T %s".fmt(Date.format(),TimeZ.text())); }
   var format = text;
   fcn ctime
   {
      return("%s %s %d %02d:%02d:%02d %d".fmt(TimeDate.dayName(dayInWeek)[0,3],
	TimeDate.monthName(month)[0,3],day,hour,min,sec,year));
   }
   fcn pretty(ampm=False)
   {
      h := hour;
      aorp := if (ampm) { if (h > 12) { h -= 12; "PM" } else "AM" }
	     else "";;

      "%02d:%02d:%02d%s ".fmt(h,min,sec,aorp) +
         TimeDate.prettyDay(year,month,day);
   }
   fcn add(x)
   {
      if (x.isInstanceOf(Time))
      {
	 overflow := Time.add(x);
	 Date.addYMD(0,0,overflow);
      }
      else if (x.isInstanceOf(Date)) Date.add(x);
      else if (x.isInstanceOf(DateTime))
      {
	 days := x.days + Time.add(x.Time);
	 Date.addYMD(x.year,x.month,days);
      }
      else if (x.isInstanceOf(Duration))
      {
	 days := x.D + Time.addHMS(x.HH,x.MM,x.SS);
	 Date.addYMD(x.Y,x.M,days);
      }
      else throw(Exception.TypeError("DateTime.add: no can do with %s".fmt(x)));
      return(self);
   }
   fcn sub(x)
   {
      if (x.isInstanceOf(DateTime))
      {
//	 days = x.days + Time.sub(x.Time);
days := 0;
	 Date.subYMD(x.year,x.month,days);
      }
      else throw(Exception.TypeError("DateTime.add: no can do with %s".fmt(x)));
      return(self);
   }
   fcn parse(text="")
   {
      if (text.holds("T"))
      {
	 date,time := text.split("T");
	 Date.parse(date); TimeZ.parse(time);
      }
      else { Date.parse(text); TimeZ.parse(); }
      return(self.text());
   }
}


   /* A span of time
    *   P nnY nnM nnD T nnH nn M nnS or 
    *   P nnY nnW nnD T nnH nn M nnS 
    *   P<date>T<time>
    *   Special characters: P Y M W D T H S
    *   P[YYYY]-[MM]-[DD]T[hh]:[mm]:[ss]
    * "P3Y6M4DT12H30M0S" defines a period of three years, six months, four
    * days, twelve hours, thirty minutes, and zero seconds. 
    */
class Duration
{
   var Y,M,D, HH,MM,SS;
   fcn init(text="PT")
   {
      Y=M=D = HH=MM=SS = 0;
      parse(text);
   }
   fcn parse(text)
   {
      if (text[0] != "P")
	 throw(Exception.ValueError("Duration: Missing P: %s".fmt(text)));
      text = text[1,*] - " ";
      reg datePart = text, timePart = "";
      if (text.holds("T")) datePart, timePart = text.split("T");
      reg W;
      Y,M,W,D,_,_ = parsePart(datePart,RegExp(0'|(\d*)([YMWD])|));
      D += W * 7;
      _,MM,_,_,HH,SS = parsePart(timePart,RegExp(0'|(\d*)([HMS])|));
      return(self.text());
   }
   fcn parsePart(text,re)
   {
      reg Y,M,W,D,H,S;
      Y = M = W = D = H = S = 0;
      while (True)
      {
	 if (not text) return(Y,M,W,D,H,S);

	 reg matched;
	 if (re.search(text))
	 {
	    matched = re.matched;
	    nn := matched[1].toInt();
	    switch(matched[2])
	    {
	       case("Y") { Y = nn; }	// year
	       case("M") { M = nn; }	// month or minute
	       case("W") { W = nn; }	// week
	       case("D") { D = nn; }	// day
	       case("H") { H = nn; }	// hour
	       case("S") { S = nn; }	// seconds
	    }
	 }
	 else throw(Exception.ValueError(
	    "Duration: PnnYnnMnnDTnnHnnMnnS: %s".fmt(text)));

	 text = text[matched[0].sum(),*];
      } // while
   }
   fcn text
   {
      return("P %dY %dM %dD T %dH %dM %dS".fmt(Y,M,D,HH,MM,SS));
   }
   fcn format(format = EXTENDED_FORMAT)
   {
      return(text() - " ");
   }
}

    /* Time interval:
     *    <begin>/<end>
     *    <begin>/<duration>
     *    <duration>/<end>
     *    <duration>
     */
class Interval
{
   var begin, duration;
   fcn text { return("%s / %s".fmt(begin.text(), duration.text())); }
   fcn format(format = EXTENDED_FORMAT)
   {
      t := text();
      if (format == BASIC_FORMAT) return(t - " ");
      return(t);
   }
   fcn init(text)
   {
      begin = DateTime(); duration = Duration();
      if (text.holds("/"))
      {
	 one,two := text.split("/");
	 if (one[0] == "P")	// <duration>/<end>
	 {
	    throw(Exception.NotImplementedError("Interval: <duration>/<end>"));
	 }
	 else		// <begin>/<end> or <begin>/<duration>
	 {
	    begin.parse(one); 
	    if (two[0] == "P") duration.parse(two);	// <begin>/<duration>
	    else 		// <begin>/<end>
	    {
	       endDate := DateTime(two).sub(begin);
	       throw(Exception.NotImplementedError("Interval: <begin>/<end>"));
	    }
	 }
      }
      else duration.parse(text);	// <duration>
   }
   fcn next
   {
      begin.add(duration);
   }
   fcn contains		// is date in this interval?
   {
      
   }
}

    /* Repeating intervals:
     *   Rnn/<interval>
     *   R/<interval> == unbounded
     */
class Repeater(Interval)
{
   var N;	// N == Void == unbounded
   fcn init(text)
   {
      re := RegExp(0'|R(\d*)/(.+)|);
      if (not re.search(text)) throw(Exception.ValueError(
         "Repeating interval: Invalid value: %s".fmt(text)));
      matched := re.matched;
      N = matched[1];
      if (N == "") N = Void; else N = N.toInt();
      Interval.init(matched[2]);
   }
   fcn text
   {
      t := ""; if (N != -1) t += N;
      return("R%s / %s".fmt(t,Interval.text()));
   }
   fcn format(format = EXTENDED_FORMAT)
   {
      t := text();
      if (format == BASIC_FORMAT) return(t - " :-");
      return(t - " ");
   }
   fcn read
   {
      if (N != Void and N < 1) throw(Exception.TheEnd);
      Interval.next(); N -= 1;
      return(begin);
   }
   fcn walker { return(Walker(self,False)); }
}