/*************** START iCalReader.js ******************************************************************************/

/* HEADER START

    iCalendar Reader for Javascript v. 1.1

    Parses and reads iCalendar data format.

    By Per-Kristian Nordnes (pk@yammin.com), august 2007.  

    Copyright (C) 2007 - Per Kristian Nordnes.

    All rights reserved.        

    The parsing algorithm in iCalendar.parse() is inspired by a PHP-script by Roman Ožana.

    Changelog:

      1.0 - Initial release (aug. 2007).

      1.1 - Some fixes for parsing Google iCal-data. Thanks to Emilis Dambauskas (feb. 25, 2008)

    Contents:

      Class: iCalReader() - parser object.

              Public methods:

                  * Array prepareData(String data) : set and prepare iCalendar data to read. 

                    Throws exception if invalid data.

                  * void parse() : parse the data.

                  * void sort()  : sort events in the calendar object.

                  * vCalendar getCalendar() : get the calendar object.                                                         

      Class: vCalendar() - calendar object.

              Public methods:

                  * Array<vEvent> getEvents() : get a array of the calendar events.

                  * Int getNrOfEvents() : get the number of events.                   

                  * Array<String> getPropertyNames() : get an array of the calendar's property names.

                  * PropertyMap getProperties() : get the property map object for the calendar. 

                  * 0bject getProperty(String key) : get a property value by name.

                    Throws exception if property is not found (invalidPropertyException).

                  * vEvent getEventAtIndex(int index) : get an event object at given position in calendar.                                  

      Class: vEvent()  - event object.

              Public methods:

                  * Date getStartDate() : get the starting date for the event.

                  * Date getEndDate() : get the ending date for the event.

                  * String getTimezone() : get the timezone accociated with the event.

                  * PropertyMap getRuleProperties() : get a map of rules for the event.

                  * Array<String> getPropertyNames() : get an array of available property names.

                  * Object getProperty(String key) : get an event property by name.

                    Throws exception if property is not found (invalidPropertyException).

                  * String getHtmlValue(String key) : get an string property in HTML format (\n become <br/>).

                    Throws exception if property is not found (invalidPropertyException).       

      Class: PropertyMap() - property hashmap object for vCal and vEvent.

              Public methods:

                  * Object getProperty(String) : get property value of property with key.

                  * void toString() : print an overview of the map's properties and values.

                  * boolean containsValue(Object value) : check if the property map contains a given value.

                  * boolean containsKey(String key) : check if the property map contains a given property name.

                  * int size() : the length of the property map.

      There are also several "private" methods which are used internally by the reader/parser (but available).

      Please refer to the code for overview/documentation on these.                                                                                                                         

    License:      

      You may use this script, as long as this header is kept intact.

      Released under the GNU General Public License Version 2 or later (the "GPL").

    Usage example:

      This example parses a iCalendar file and displays every property within it.

      [Begin example code]

      // Parse data

          var myTestData = [some string content of iCalendar file or stream];

          var myCalReader = new iCalReader(); // Construction of the reader object. 

          myCalReader.prepareData(myTestData); // Prepare and set the data for the parser.

          myCalReader.parse(); // Parse the data.

          myCalReader.sort(); // Sort the data.

      // Read data

          // Get the calendar properties.            

              var calendarInfo = 'Properties for calendar:\n\n';                                           

              var calendarPropertyNames = myCalReader.getCalendar().getPropertyNames(); // Get the list of availale properties.           

              for(var i=0; i<calendarPropertyNames.length; i++) { // Loop through all the properties.

                var propertyName = calendarPropertyNames[i];

                var propertyValue = myCalReader.getCalendar().getProperty(propertyName);

                calendarInfo += 'Calendar property "'+propertyName+'" has value: "'+propertyValue+'"\n';

              }

              alert(calendarInfo);

          // Get the event properties.

              alert('About to show all events and their properties...');

              var events = myCalReader.getCalendar().getEvents(); // Get all events.

              for(var i=0; i<myCalReader.getCalendar().getNrOfEvents(); i++) { // Loop through all events.

                var event = myCalReader.getCalendar().getEventAtIndex(i); // A single event.        

                // Get Javascript date for start and end time.

                var startDate = event.getStartDate();

                var endDate = event.getEndDate();

                var timeZone = event.getTimeZone();

                // Get rules.

                var rules = event.getRuleProperties();

                var eventInfo = 'Showing properties for event number '+(i+1)+'.\n\n'+

                                'This event starts '+startDate+' and ends '+endDate+'\n\n'+'Timezone is: "'+timeZone+'"\n\n'+

                                'This event have the following rules: '+rules.toString()+'\n\n';                                

                var eventPropertyNames = event.getPropertyNames(); // Get the list of available properties.         

                for(var n=0; n<eventPropertyNames.length; n++) { // Loop through all the properties.                

                  var propertyName = eventPropertyNames[n];

                  var propertyValue = event.getProperty(propertyName);

                  eventInfo += 'Property "'+propertyName+'" has value: "'+propertyValue+'"\n';                  

                }

                alert(eventInfo);

              } // End for each event.

      [End example code]    

HEADER END /*

/*************** CLASS DEFINITIONS ***************************************************************************/

 /**

 * The main object for reading and parsing iCalendar data.

 */   

function iCalReader() {

	this.data = null; // Holds the iCalendar input data.

	this.calendar = new vCalendar(); // The VCALENDAR object.

	this.eventCount = -1; // Tracks the number of events in the calendar.

	this.lastKey = null;	// Reference to last proccessed key (property).

}

  // Class methods

  iCalReader.prototype = {

  /**

   * Prepares and sets the data for the parser.

   * @input calendar file data (string).

   * @throws invalidCalendarException

   * @return prepared data (array of lines)       

   */     

      prepareData: function(data) {

        // Fix for malformed Mozilla VCALENDAR syntax.

      	this.data = data.replace(/[\r\n]{1,} ([:;])/g, '$1');

      	// Make array of all the lines.

        this.data = this.data.split(/\r?\n/);                

        // Is it really a VCALENDAR?

        if(this.data[0].indexOf('BEGIN:VCALENDAR') == -1) {

          throw('invalidCalendarException');

        }

      	return this.data;

      },

	/**

	 * Method that does the actual parsing.

	 */   	

      parse: function() {

      	this.calendar = new vCalendar();

        // Loop through all lines and analyze them.

      	for(var i=0; i<this.data.length; i++) {

    			var line = this.data[i];

  			 // Get possible key/value for line.

  				var values = this.returnKeyValue(line);

  				key = values[0];

  				value = values[1];

  				switch(line) {	

  					// It's a new event.

  					case 'BEGIN:VEVENT':

  						this.eventCount++;

  						type = 'VEVENT';

  						break;

  					// It's a calendar property.

  					case 'BEGIN:VCALENDAR':

  					case 'BEGIN:DAYLIGHT':

  					case 'BEGIN:VTIMEZONE':

  					case 'BEGIN:STANDARD':

  						type = value;

  						break;

  					// It's the end of the calendar property or event.

  					case 'END:VEVENT':

  					case 'END:VCALENDAR':

  					case 'END:DAYLIGHT':

  					case 'END:VTIMEZONE':

  					case 'END:STANDARD':

  						type = 'VCALENDAR';

  						break;

  					// Add data to the calendar or event.

  					default:

  						this.addToCalendar(type, key, value);

  						break;

  				}				

        } 

      },

  /**

   * Adds data to the calendar object from the parser.

   * @input type of current item in parsing queue.

   * @input key (name) of item property.

   * @input value of item property.                     

   */     

      addToCalendar: function(type, key, value) {    

        // Make a new event if we are not proccessing a current one and type is VEVENT.

        if(type == 'VEVENT') {        

          try {

            var event = this.calendar.getEventAtIndex(this.eventCount);

          } catch(e) {

            var event = new vEvent();

            this.calendar.addEvent(event);

          }

        }    

        // If no key, add the current value to currently proccessing property's value.

    		if (key == false) {

    			key = this.lastKey;

    			var oldValue;

    			switch(type) {

    				case 'VEVENT':

    			      oldValue = this.calendar.getEventAtIndex(this.eventCount).getProperty(key); 			 

                value = oldValue+this.trimStart(value);

                break;

    			}

    		}

    		// Convert calendar date properties to javascript date.

    		if ((key == 'DTSTAMP') || (key == 'LAST-MODIFIED') || (key == 'CREATED')) {

    		    value = this.toDate(value);

        } 

        // Convert event date properties to own detailed mapping.

    		if (key.indexOf('DTSTART') > -1 || key.indexOf('DTEND') > -1|| key.indexOf('ALTDTSTART') > -1) {

    		    var dateArray = this.toDateProperties(key,value);

    		    key = dateArray[0];

    		    value = dateArray[1];

        }

    		// Parse any rules for item.

        if (key == 'RRULE' ) {

          value = this.makeRuleProperties(value);

        }

        // Add the data.    

        switch(type) {

          // It's an event. Add property and value to event.

    			case 'VEVENT': 

            this.calendar.getEventAtIndex(this.eventCount).setProperty(key,value);

            break;

    			// It's a calendar's property. 

    			default:

    				this.calendar.setProperty(key,value);

    				break;

    		}

        // Reference last proccessed key.

        this.lastKey = key;

    	},

  /**

   * Make rule property map.

   * @input string RRULE-string.

   * @return PropertyMap of rules.   

   */     

      makeRuleProperties: function(value) {      

        var ruledata = value.split(';');

        var rule = new PropertyMap();

        for(var r in ruledata) {

            var data = ruledata[r].split('=');

            rule.put(data[0], data[1]);

        }

        return rule;

      },    	

  /**

   * Parse a VEVENT type date to a own property map object.

   * @input string property name (like "DTSTART;TZID=Europe/Oslo")

   * @input string property value (like "20070719T220000").       

   * @return array(string DTSTART or DTEND, PropertyMap{ property JSDATE = [Date], property TZID = [string] } )   

   */     

      toDateProperties: function(key,value) {

          var dtProperty = new PropertyMap();

          dtProperty.put('TZID', 'Undefined'); // Default in case we don't find any timezone data.

          // Convert time to JS-date and make property.

          dtProperty.put('JSDATE', this.toDate(value));

          // Get date info from key value.

          var dtInfo = key.split(';');

          key = dtInfo[0]; // Shorten the key to read DTSTART or DTEND not "DTSTART;TZID=Europe/Oslo".

          dtProperty.put(key, value);

          if(typeof(dtInfo[1]) != 'undefined') { // Timezone is specified.

            // Get timezone.

            var tzInfo = dtInfo[1].split('=');

            var timezoneValue = tzInfo[1];

            dtProperty.put('TZID', timezoneValue);

        		return new Array(key,dtProperty);          

          } else {

            // Try get the calendar default TZ.

            try { dtProperty.put('TZID', this.calendar.getProperty('TZID')); } catch(e) {}

            try { dtProperty.put('TZID', this.calendar.getProperty('X-WR-TIMEZONE')); } catch(e) {}            

            return new Array(key,dtProperty);

        	}

      },

  /**

   * Convert a iCal type timestamp to Javascript date.

   * @input calendar type date string.

   * @return javascript date object.

   * @throws invalidDateException.     

   */     

      toDate: function(dateString) {

        dateString = dateString.replace('T', '');

        dateString = dateString.replace('Z', '');

        var pattern = /([0-9]{4})([0-9]{2})([0-9]{2})([0-9]{0,2})([0-9]{0,2})([0-9]{0,2})/; 

        try {

          var dArr = pattern.exec(dateString);

          var calDate = new Date();

          var months = (dArr[2][0] == '0') ? dArr[2][1] : dArr[2];

          months = parseInt(months)-1;

          var days = (dArr[3][0] == '0') ? dArr[3][1] : dArr[3];

          days = parseInt(days);

          var hours = (dArr[4][0] == '0') ? dArr[4][1] : dArr[4];

          hours = hours == '' ? '0' : hours;

          hours = parseInt(hours);

          var minutes = (dArr[5][0] == '0') ? dArr[5][1] : dArr[5];

          minutes = minutes == '' ? '0' : minutes;

          minutes = parseInt(minutes);

          var seconds = (dArr[6][0] == '0') ? dArr[6][1] : dArr[6];

          seconds = seconds == '' ? '0' : seconds;

          seconds = parseInt(seconds);

          calDate.setFullYear(dArr[1]);

          calDate.setMonth(months);

          calDate.setDate(days);

          calDate.setHours(hours);

          calDate.setMinutes(minutes);

          calDate.setSeconds(seconds);

        } catch(e) {

          throw('invalidDateException');

        }

        return calDate;

      },

  /**

   * Returns a possible value/key-set of a calendar data line.

   * @input calendar data line (string).

   * @return array of key,value.       

   */     

    	returnKeyValue: function(line) {    

        // Regex for VCALENDAR syntax. Match letters in uppercase in the beginning

        // of the line followed by VCALENDAR-type operator and value.

        var pattern = /^([A-Z]+[^:]+)[:]([\w\W]*)/;

        var matches = pattern.exec(line);

        if(matches) {

              return matches.splice(1,2);

        }

        // No key found, just return value.

        return new Array(false,line);

    	},

  /**

   * Trims the beginning of string one whitespace character.

   * @input string to trim.

   * @return trimmed string.          

   */     

      trimStart: function(str) {

        str=str.replace(/^\s{0,1}(.*)/, '$1');

        return str;

      },            

	/**

	 * Get the calendar object for the reader.

	 * @return vCalendar object.    	 

	 */   	

    	getCalendar: function() {

    		return this.calendar;

    	},

  /**

   * Sorts the calendar events by time desc.   

   *

   */

      sort: function(){

        this.calendar.sort();

      }     

}

/**

 * Object to hold the calendar propterties.

 */   

function vCalendar() {

    this.vEvents = new Array();

    this.properties = new PropertyMap();

}

    // Class methods

  vCalendar.prototype = {

  /**

   * Gets the event array.

   * @return array of event objects.       

   */     

      getEvents: function() {

        return this.vEvents;

      },

  /**

   * Gets the properties hashmap.

   * @return PropertyMap.       

   */     

      getProperties: function() {

        return this.properties;

      },

  /**

   * Get the number of events.

   * @return number   

   */        

      getNrOfEvents: function() {

        return this.vEvents.length;

      },

  /**

   * Sorts the array of events by time desc.   

   *

   */

      sort: function(){

        this.vEvents = this.vEvents.sort(this.sortByDate);

      },        

  /**

   * Get list of available properties for the calendar.

   * @return array of strings.       

   */     

      getPropertyNames: function() {

        return this.properties.keys();

      },

  /**

   * Get an event at a given index.

   * @input int index.

   * @return vEvent event.              

   */

      getEventAtIndex: function(index) {

        var evt = this.vEvents[index];

        if(typeof(evt) == 'undefined') {

          throw('eventNotFoundException');

        }

        return this.vEvents[index];

      },

  /**

   * Get value of a given property.

   * @input string property name.

   * @return object value.         

   */

      getProperty: function(property) {  

        try {

          return this.properties.get(property);      

        } catch(e) {

          throw(e); 

        }

      },

  /**

   * Adds a vEvent object to the event array.

   * @input vEvent event.       

   */

      addEvent: function(vEvent) {

        this.vEvents.push(vEvent);

      },

  /**

   * Set a property to the calendar.

   * @input string property name.

   * @input object value.              

   */

      setProperty: function(property, value) {

        if(typeof(property) == 'string' && property != null && property != '') {      

          this.properties.put(property,value);

        } else {

          throw('invalidKeyNameException');

        }

      },

  /**

   * Sorting method for the events.

   *

   */

      sortByDate: function(a, b) {

          var x = a.getStartDate();

          var y = b.getStartDate();

          return ((x < y) ? -1 : ((x > y) ? 1 : 0));

      }      

  }

/**

 * Object to hold the VEVENT propterties.

 */   

function vEvent() {

  this.properties = new PropertyMap();

}

  // Class methods

  vEvent.prototype = {

    /**

     * Get start time for event.

     * @return Date start.         

     */

        getStartDate: function() {

           var dt = this.getProperty('DTSTART');

           return dt.get('JSDATE');

        },

    /**

     * Get start time for event.

     * @return Date start.         

     */

        getAltStartDate: function() {

           var dt = this.getProperty('ALTDTSTART');

           return dt.get('JSDATE');

        },

    /**

     * Get end time for event.

     * @return Date end.              

     */

        getEndDate: function() {

           var dt = this.getProperty('DTEND');

           return dt.get('JSDATE');

        },

    /**

     * Get timezone for event.

     * @return string timezone.              

     */

        getTimeZone: function() {