#!/usr/bin/python

import os
import os.path
import re
import datetime
import time

SECONDS_PER_DAY=24*60*60
iCalFolder = os.path.expanduser("~/Library/Calendars")

class ICalReader:

    def __init__(self, calendarName = None):
        self.events = []
        self.iCalFiles = os.listdir(iCalFolder)
        if calendarName:
            fullName = iCalFolder + "/" + calendarName + ".ics"
            self.iCalFiles = [fullName]
        else:
            newList = []
            for file in self.iCalFiles:
                newList.append(iCalFolder+"/"+file)
            self.iCalFiles = newList
        self.readEvents()

    def calendars(self):
        return self.iCalFiles

    def readEvents(self):
        self.events = []
        for file in self.iCalFiles:
            lines = open(file).readlines()
            inEvent = False
            eventLines = []
            for line in lines:
                stRegex = re.compile("^BEGIN:VEVENT")
                if stRegex.match(line):
                    inEvent = True
                    eventLines = []

                if inEvent:
                    eventLines.append(line)
                    enRegex = re.compile("^END:VEVENT")
                    if enRegex.match(line):
                        self.events.append(self.parseEvent(eventLines))

        return self.events

    def parseEvent(self, lines):
        event = ICalEvent()
        startDate = None
        rule = None
        endDate = None
        
        for line in lines:
            if re.compile("^SUMMARY:(.*)").match(line):
                event.summary = re.compile("^SUMMARY:(.*)").match(line).group(1)
            elif re.compile("^DTSTART;.*:(.*).*").match(line):
                startDate = self.parseDate(re.compile("^DTSTART;.*:(.*).*").match(line).group(1))
            elif re.compile("^DTEND;.*:(.*).*").match(line):
                endDate = self.parseDate(re.compile("^DTEND;.*:(.*).*").match(line).group(1))
            elif re.compile("^EXDATE.*:(.*)").match(line):
                event.addExceptionDate(parseDate(re.compile("^EXDATE.*:(.*)").match(line).group(1)))
            elif re.compile("^RRULE:(.*)").match(line):
                rule = re.compile("^RRULE:(.*)").match(line).group(1)

        event.startDate = startDate
        event.endDate = endDate
        if rule:
            event.addRecurrenceRule(rule)
        return event

    def parseDate(self, dateStr):
        year = int(dateStr[0:4])
        if year < 1970:
            year = 1970

        month = int(dateStr[4:4+2])
        day = int(dateStr[6:6+2])
        try:
            hour = int(dateStr[9:9+2])
            minute = int(dateStr[11:11+2])
        except:
            hour = 0
            minute = 0

        return datetime.datetime(year, month, day, hour, minute)

    def selectEvents(self, selectFunction):
        note = datetime.datetime.today()
        self.events.sort()
        events = filter(selectFunction, self.events)
        return events

    def todaysEvents(self, event):
        return event.startsToday()

    def tomorrowsEvents(self, event):
        return event.startsTomorrow()

    def eventsFor(self, date):
        note = datetime.datetime.today()
        self.events.sort()
        ret = []
        for event in self.events:
            if event.startsOn(date):
                ret.append(event)
        return ret


class ICalEvent:
    def __init__(self):
        self.exceptionDates = []
        self.dateSet = None

    def __str__(self):
        return self.summary

    def __eq__(self, otherEvent):
        return self.startDate == otherEvent.startDate

    def addExceptionDate(self, date):
        self.exceptionDates.append(date)

    def addRecurrenceRule(self, rule):
        self.dateSet = DateSet(self.startDate, self.endDate, rule)

    def startsToday(self):
        return self.startsOn(datetime.datetime.today())

    def startsTomorrow(self):
        tomorrow = datetime.datetime.fromtimestamp(time.time() + SECONDS_PER_DAY)
        return self.startsOn(tomorrow)

    def startsOn(self, date):
        return (self.startDate.year == date.year and
                self.startDate.month == date.month and
                self.startDate.day == date.day or
                (self.dateSet and self.dateSet.includes(date)))

    def startTime(self):
        return self.startDate

class DateSet:
    def __init__(self, startDate, endDate, rule):
        self.startDate = startDate
        self.endDate = endDate
        self.frequency = None
        self.count = None
        self.untilDate = None
        self.byMonth = None
        self.byDate = None
        self.parseRecurrenceRule(rule)
    
    def parseRecurrenceRule(self, rule):
        if re.compile("FREQ=(.*?);").match(rule) :
            self.frequency = re.compile("FREQ=(.*?);").match(rule).group(1)
		
        if re.compile("COUNT=(\d*)").match(rule) :
            self.count = int(re.compile("COUNT=(\d*)").match(rule).group(1))
		
        if re.compile("UNTIL=(.*?);").match(rule) :
            self.untilDate = DateParser.parse(re.compile("UNTIL=(.*?);").match(rule).group(1))
		
        if re.compile("INTERVAL=(\d*)").match(rule) :
            self.interval = int(re.compile("INTERVAL=(\d*)").match(rule).group(1))

        if re.compile("BYMONTH=(.*?);").match(rule) :
            self.byMonth = re.compile("BYMONTH=(.*?);").match(rule).group(1)

        if re.compile("BYDAY=(.*?);").match(rule) :
            self.byDay = re.compile("BYDAY=(.*?);").match(rule).group(1)

        
    def includes(self, date):
        if date == self.startDate:
            return True

        if self.untilDate and date > self.untilDate:
            return False

        if self.frequency == 'DAILY':
            increment = 1
            if self.interval:
                increment = self.interval
            d = self.startDate
            counter = 0
            while(d < date):
                if self.count:
                    counter += 1
                    if counter >= self.count:
                        return False

                d = d.replace(day=d.day+1)

                if (d.day == date.day and
                    d.year == date.year and
                    d.month == date.month):
                    return True
            
        elif self.frequency == 'WEEKLY':
            if self.startDate.weekday() == date.weekday():
                return True
            else:
                if self.endDate:
                    for n in range(0, self.endDate.day - self.startDate.day):
                        newDate = self.startDate.replace(day=self.startDate.day+n)
                        if newDate.weekday() == date.weekday():
                            return True

        elif self.frequency == 'MONTHLY':
            pass

        elif self.frequency == 'YEARLY':
            pass

        return False
    

if __name__ == '__main__':
    reader = ICalReader()
    print "Today"
    print "====="
    for event in reader.selectEvents(reader.todaysEvents):
        print event
    print "Tomorrow"
    print "========"
    for event in reader.selectEvents(reader.tomorrowsEvents):
        print event
    print "01/31/2003 Events"
    print "================="
    for event in reader.eventsFor(datetime.datetime.today()):
        print event