//Determine the difference between users local time and Pacific
notz=new Date('Mar 03, 2008 17:00:23');
tz=new Date('Mon, 03 Mar 2008 17:00:23 -0800');
var df_tz_diff=notz.valueOf()-tz.valueOf();

Array.prototype.exists = function (x) {
    for (var i = 0; i < this.length; i++) {
        if (this[i] == x) return true;
    }
    return false;
}

Date.prototype.formatDate = function (input,time) {
    // formatDate :
    // a PHP date like function, for formatting date strings
    // See: http://www.php.net/date
    //
    // input : format string
    // time : epoch time (seconds, and optional)
    //
    // if time is not passed, formatting is based on 
    // the current "this" date object's set time.
    //
    // supported:
    // a, A, B, d, D, F, g, G, h, H, i, j, l (lowercase L), L, 
    // m, M, n, O, r, s, S, t, U, w, W, y, Y, z
    //
    // unsupported:
    // I (capital i), T, Z    

    var switches =    ["a", "A", "B", "d", "D", "F", "g", "G", "h", "H", 
                       "i", "j", "l", "L", "m", "M", "n", "O", "r", "s", 
                       "S", "t", "T", "U", "w", "W", "y", "Y", "z"];
    var daysLong =    ["Sunday", "Monday", "Tuesday", "Wednesday", 
                       "Thursday", "Friday", "Saturday"];
    var olddaysShort =   ["Sun", "Mon", "Tue", "Wed", 
                       "Thu", "Fri", "Sat"];
    var daysShort =   ["SUN", "MON", "TUE", "WED", 
                       "THU", "FRI", "SAT"];
    var titlemonthsShort = ["Jan.", "Feb.", "Mar.", "Apr.",
                       "May", "Jun.", "Jul.", "Aug.", "Sep.",
                       "Oct.", "Nov.", "Dec."];
    var monthsShort = ["JAN", "FEB", "MAR", "APR",
                       "MAY", "JUN", "JUL", "AUG", "SEP",
                       "OCT", "NOV", "DEC"];
    var monthsLong =  ["January", "February", "March", "April",
                       "May", "June", "July", "August", "September",
                       "October", "November", "December"];
    var daysSuffix = ["st", "nd", "rd", "th", "th", "th", "th", // 1st - 7th
                      "th", "th", "th", "th", "th", "th", "th", // 8th - 14th
                      "th", "th", "th", "th", "th", "th", "st", // 15th - 21st
                      "nd", "rd", "th", "th", "th", "th", "th", // 22nd - 28th
                      "th", "th", "st"];                        // 29th - 31st

    function a() {
        // Lowercase Ante meridiem and Post meridiem
        return self.getHours() > 11? "pm" : "am";
    }
    function A() {
        // Uppercase Ante meridiem and Post meridiem
        // return self.getHours() > 11? "PM" : "AM";
        return self.getHours() > 11? "P" : "A";
    }

    function B(){
        // Swatch internet time. code simply grabbed from ppk,
        // since I was feeling lazy:
        // http://www.xs4all.nl/~ppk/js/beat.html
        var off = (self.getTimezoneOffset() + 60)*60;
        var theSeconds = (self.getHours() * 3600) + 
                         (self.getMinutes() * 60) + 
                          self.getSeconds() + off;
        var beat = Math.floor(theSeconds/86.4);
        if (beat > 1000) beat -= 1000;
        if (beat < 0) beat += 1000;
        if ((""+beat).length == 1) beat = "00"+beat;
        if ((""+beat).length == 2) beat = "0"+beat;
        return beat;
    }
    
    function d() {
        // Day of the month, 2 digits with leading zeros
        return new String(self.getDate()).length == 1?
        "0"+self.getDate() : self.getDate();
    }
    function D() {
        // A textual representation of a day, three letters
        return daysShort[self.getDay()];
    }
    function F() {
        // A full textual representation of a month
        return monthsLong[self.getMonth()];
    }
    function g() {
        // 12-hour format of an hour without leading zeros
        hours= self.getHours() > 12? self.getHours()-12 : self.getHours();
        if (hours==0) 
           hours=12;
        return hours;
    }
    function G() {
        // 24-hour format of an hour without leading zeros
        return self.getHours();
    }
    function h() {
        // 12-hour format of an hour with leading zeros
        if (self.getHours() > 12) {
          var s = new String(self.getHours()-12);
          return s.length == 1?
          "0"+ (self.getHours()-12) : self.getHours()-12;
        } else { 
          var s = new String(self.getHours());
          return s.length == 1?
          "0"+self.getHours() : self.getHours();
        }  
    }
    function H() {
        // 24-hour format of an hour with leading zeros
        return new String(self.getHours()).length == 1?
        "0"+self.getHours() : self.getHours();
    }
    function i() {
        // Minutes with leading zeros
        return new String(self.getMinutes()).length == 1? 
        "0"+self.getMinutes() : self.getMinutes(); 
    }
    function j() {
        // Day of the month without leading zeros
        return self.getDate();
    }    
    function l() {
        // A full textual representation of the day of the week
        return daysLong[self.getDay()];
    }
    function L() {
        // leap year or not. 1 if leap year, 0 if not.
        // the logic should match iso's 8601 standard.
        var y_ = Y();
        if (         
            (y_ % 4 == 0 && y_ % 100 != 0) ||
            (y_ % 4 == 0 && y_ % 100 == 0 && y_ % 400 == 0)
            ) {
            return 1;
        } else {
            return 0;
        }
    }
    function m() {
        // Numeric representation of a month, with leading zeros
        return self.getMonth() < 9?
        "0"+(self.getMonth()+1) : 
        self.getMonth()+1;
    }
    function M() {
        // A short textual representation of a month, three letters
        return monthsShort[self.getMonth()];
    }
    function n() {
        // Numeric representation of a month, without leading zeros
        return self.getMonth()+1;
    }
    function O() {
        // Difference to Greenwich time (GMT) in hours
        var os = Math.abs(self.getTimezoneOffset());
        var h = ""+Math.floor(os/60);
        var m = ""+(os%60);
        h.length == 1? h = "0"+h:1;
        m.length == 1? m = "0"+m:1;
        return self.getTimezoneOffset() < 0 ? "+"+h+m : "-"+h+m;
    }
    function r() {
        // RFC 822 formatted date
        var r; // result
        //  Thu    ,     21          Dec         2000
        r = D() + ", " + j() + " " + M() + " " + Y() +
        //        16     :    01     :    07          +0200
            " " + H() + ":" + i() + ":" + s() + " " + O();
        return r;
    }
    function S() {
        // English ordinal suffix for the day of the month, 2 characters
        return daysSuffix[self.getDate()-1];
    }
    function s() {
        // Seconds, with leading zeros
        return new String(self.getSeconds()).length == 1?
        "0"+self.getSeconds() : self.getSeconds();
    }
    function t() {

        // thanks to Matt Bannon for some much needed code-fixes here!
        var daysinmonths = [null,31,28,31,30,31,30,31,31,30,31,30,31];
        if (L()==1 && n()==2) return 29; // leap day
        return daysinmonths[n()];
    }
    
    function T() {
        // A short textual representation of a month, three letters, title case
        return titlemonthsShort[self.getMonth()];
    }
    
    function U() {
        // Seconds since the Unix Epoch (January 1 1970 00:00:00 GMT)
        return Math.round(self.getTime()/1000);
    }
    function W() {
        // Weeknumber, as per ISO specification:
        // http://www.cl.cam.ac.uk/~mgk25/iso-time.html
        
        // if the day is three days before newyears eve,
        // there's a chance it's "week 1" of next year.
        // here we check for that.
        var beforeNY = 364+L() - z();
        var afterNY  = z();
        var weekday = w()!=0?w()-1:6; // makes sunday (0), into 6.
        if (beforeNY <= 2 && weekday <= 2-beforeNY) {
            return 1;
        }
        // similarly, if the day is within threedays of newyears
        // there's a chance it belongs in the old year.
        var ny = new Date("January 1 " + Y() + " 00:00:00");
        var nyDay = ny.getDay()!=0?ny.getDay()-1:6;
        if (
            (afterNY <= 2) && 
            (nyDay >=4)  && 
            (afterNY >= (6-nyDay))
            ) {
            // Since I'm not sure we can just always return 53,
            // i call the function here again, using the last day
            // of the previous year, as the date, and then just
            // return that week.
            var prevNY = new Date("December 31 " + (Y()-1) + " 00:00:00");
            return prevNY.formatDate("W");
        }
        
        // week 1, is the week that has the first thursday in it.
        // note that this value is not zero index.
        if (nyDay <= 3) {
            // first day of the year fell on a thursday, or earlier.
            return 1 + Math.floor( ( z() + nyDay ) / 7 );
        } else {
            // first day of the year fell on a friday, or later.
            return 1 + Math.floor( ( z() - ( 7 - nyDay ) ) / 7 );
        }
    }
    function w() {
        // Numeric representation of the day of the week
        return self.getDay();
    }
    
    function Y() {
        // A full numeric representation of a year, 4 digits

        // we first check, if getFullYear is supported. if it
        // is, we just use that. ppks code is nice, but wont
        // work with dates outside 1900-2038, or something like that
        if (self.getFullYear) {
            var newDate = new Date("January 1 2001 00:00:00 +0000");
            var x = newDate .getFullYear();
            if (x == 2001) {              
                // i trust the method now
                return self.getFullYear();
            }
        }
        // else, do this:
        // codes thanks to ppk:
        // http://www.xs4all.nl/~ppk/js/introdate.html
        var x = self.getYear();
        var y = x % 100;
        y += (y < 38) ? 2000 : 1900;
        return y;
    }
    function y() {
        // A two-digit representation of a year
        var y = Y()+"";
        return y.substring(y.length-2,y.length);
    }
    function z() {
        // The day of the year, zero indexed! 0 through 366
        var t = new Date("January 1 " + Y() + " 00:00:00");
        var diff = self.getTime() - t.getTime();
        return Math.floor(diff/1000/60/60/24);
    }
        
    var self = this;
    if (time) {
        // save time
        var prevTime = self.getTime();
        self.setTime(time);
    }
    
    var ia = input.split("");
    var ij = 0;
    while (ia[ij]) {
        if (ia[ij] == "\\") {
            // this is our way of allowing users to escape stuff
            ia.splice(ij,1);
        } else {
            if (switches.exists(ia[ij])) {
                ia[ij] = eval(ia[ij] + "()");
            }
        }
        ij++;
    }
    // reset time, back to what it was
    if (prevTime) {
        self.setTime(prevTime);
    }
    return ia.join("");
}

//KCRW Custom Functions
var fd_days=["SAT","SUN","MON","TUE","WED","THU","FRI","SAT"];

function fdCalculateDiff(notz,tz)
{
   // Calculate the difference in miliseconds between the local time
   // and the sever time.  The trick is comparing a date with a timezone
   // agains a date without a timezone.
   var refnotz=new Date(notz);
   var reftz=new Date(tz);
   var diff=refnotz.valueOf() - reftz.valueOf();
   return diff;
}

function fdDateWithOffset(thedate)
{
  retdate=new Date(thedate.valueOf() + df_tz_diff );
  return retdate;
}

function dayindex(day)
{
   for(d=0;d<fd_days.length;d++)
      if ( day == fd_days[d] )
      {
         return d;
      }
}

function inGroup(start,thegroupings,day)
{
   //MON, TUE, etc.
   startDay=start.formatDate(day);
   //A : A or P (am, pm)
   startA=start.formatDate('A');
   //g : 12 hour format of an hour without leading 0's
    startH=start.formatDate('g');
   //i : 30 (Minutes)
   startM=start.formatDate('i');
   var groupings_length=thegroupings.length;
   // determine the index of the current date
   currentDayIndex=dayindex(startDay);
   //loop through groups
   for(g=0;g<groupings_length;g++)
   {
     group=thegroupings[g];
     glength=group.length;
     prevDay=group[glength-1][0].formatDate(day);
     prevDayIndexPlus=dayindex(prevDay)+1;
     prevTime=group[glength-1][0].formatDate('Gi');
     currTime=start.formatDate('Gi');
     //alert(prevDay + ' == ' + fd_days[currentDayIndex+1] +' : ' + prevTime + '==' + currTime);
     if( fd_days[prevDayIndexPlus] == fd_days[currentDayIndex] && currTime ==  prevTime )
     {
        // found a match, return the index in groupings to push date to
        return g;
     }
   }
   return -1;
}

function fdTimeAirings(datearray,endarray,dayformat)
{
  var currentDate='';
  var outstr='';
  for(y=0;y<datearray.length;y++)
  {
    start=new Date(datearray[y]);
    start=fdDateWithOffset(start);
    end=new Date(endarray[y]);
    end=fdDateWithOffset(end);
    startA=start.formatDate('A');
    startM=start.formatDate('i');
    startH=start.formatDate('g');
    endA=end.formatDate('A');
    endM=end.formatDate('i');
    endH=end.formatDate('g');
    // get the start date
    startDate=start.formatDate(dayformat);
    //Put the same start dates on the same linke
    if (startDate == currentDate) {
       ;// skip the addition of the date string
    }
    else {
       // New date?  start a new line
       if( y != 0)
         outstr=outstr+'<br />'
       outstr=outstr+startDate;
       currentDate=startDate;
    }
    outstr=outstr+', ' + startH ;
    outstr=outstr + ':' + startM;
    if( startA != endA )
       outstr=outstr + startA;
    outstr=outstr + '-' + endH;
    outstr=outstr + ':' + endM;
    outstr=outstr + endA;
  }
  return outstr;
} 

function fdTimeSchedule(datearray,endarray,dayformat,hourformat,day)
{
  var outstr='';
  //This keeps track of the last date processed
  var previousDayIndex=-1;
  var currentDayIndex=-2;
  var previousStartEndTime='';
  var inloop=0;
  var groupings=[];
  var group=[];
  
  //Loop through the dates, these should already be sorted by date
  for(y=0;y<datearray.length;y++)
  {
    glength=group.length
    start=new Date(datearray[y]);
    start=fdDateWithOffset(start); 
    end=new Date(endarray[y]);
    end=fdDateWithOffset(end); 
  
    // Groupings is a list of lists of dates/times that are sequential
    // e.g. Mon-Fri 11:00A-2:00P
  
    // Find the index of the group in groupings to append this to
    x=inGroup(start,groupings,day); // -1 return means no match 
    if(x != -1)
    {
      //we found a match
      groupings[x].push([start,end]);
      continue;
    }
    // Create a new group
    groupings.push([ [start,end] ]);
  }
  
  //Now we loop through each group in groupings, and format the text
  for(y=0;y<groupings.length;y++)
  {
    group=groupings[y]
    if(group.length==1) //Only one date
    {
      start=group[0][0];
      end=group[0][1];
      outstr=outstr+start.formatDate(day + ' ' + hourformat)  + '-';
      outstr=outstr + end.formatDate(hourformat) + ', ';
      continue;
    }
    else // more than one sequential Date
    {
      start=group[0][0];
      end=group[group.length-1][0];
      endtime=group[0][1];
      outstr=outstr + start.formatDate(day) + '-' + end.formatDate(day);
      outstr=outstr + ' ' + start.formatDate(hourformat) + '-' + endtime.formatDate(hourformat) + ', '
    }
  }
  // get rid of last ', '
  //document.write(outstr.substring(0,outstr.length-2));
  return outstr.substring(0,outstr.length-2);
}