#!/usr/bin/env python

from imiptools.data import get_window_end, Object

from imiptools.dates import format_datetime, get_default_timezone, to_recurrence_start

from imiptools.period import FreeBusyPeriod

from imiptools.profile import Preferences

from imip_store import FileStore, FilePublisher

import sys

def get_periods(fb, obj, tzid, window_end, only_organiser, recurrenceids):

    # Update free/busy details with the actual periods associated with the event.

    recurrenceid = format_datetime(obj.get_utc_datetime("RECURRENCE-ID")) or ""

    recurrenceids = [to_recurrence_start(r, tzid) for r in recurrenceids]

    for p in obj.get_periods_for_freebusy(tzid, window_end):

        if recurrenceid or p.start not in recurrenceids:

            fb.append(FreeBusyPeriod(

                p.start, p.end,

                obj.get_value("UID"),

                only_organiser and "ORG" or obj.get_value("TRANSP") or "OPAQUE",

                recurrenceid,

                obj.get_value("SUMMARY"),

                obj.get_value("ORGANIZER")

                ))

# Main program.

try:

    user = sys.argv[1]

    args = sys.argv[2:]

    participant = args and args[0] not in ("-n", "-s", "-v") and args[0] or user

    store_and_publish = "-s" in args

    include_needs_action = "-n" in args

    verbose = "-v" in args

except IndexError:

    print >>sys.stderr, """\

Need a user and an optional participant (if different from the user),

along with the -s option if updating the store and the published details.

"""

    sys.exit(1)

preferences = Preferences(user)

tzid = preferences.get("TZID") or get_default_timezone()

# Get the size of the free/busy window.

try:

    window_size = int(preferences.get("window_size"))

except (TypeError, ValueError):

    window_size = 100

window_end = get_window_end(tzid, window_size)

store = FileStore()

publisher = FilePublisher()

# Get all identifiers for events.

uids = store.get_events(user)

all_events = set()

for uid in uids:

    all_events.add((uid, None))

    all_events.update([(uid, recurrenceid) for recurrenceid in store.get_recurrences(user, uid)])

# Filter out cancelled events.

cancelled = store.get_cancellations(user) or []

all_events.difference_update(cancelled)

# Obtain event objects.

objs = []

for uid, recurrenceid in all_events:

    if verbose:

        print >>sys.stderr, uid, recurrenceid

    event = store.get_event(user, uid, recurrenceid)

    if event:

        objs.append(Object(event))

# Build a free/busy collection for the given user.

fb = []

for obj in objs:

    attendees = obj.get_value_map("ATTENDEE")

    organiser = obj.get_value("ORGANIZER")

    recurrenceids = store.get_recurrences(user, obj.get_value("UID"))

    for attendee, attendee_attr in attendees.items():

        # Only consider events where the stated participant actually attends.

        if attendee == participant:

            partstat = attendee_attr.get("PARTSTAT", "NEEDS-ACTION")

            if partstat not in ("DECLINED", "DELEGATED", "NEEDS-ACTION") or \

                include_needs_action and partstat == "NEEDS-ACTION":

                get_periods(fb, obj, tzid, window_end, False, recurrenceids)

            break

    # Where not attending, retain the affected periods and mark them as

    # organising periods.

    else:

        if organiser == participant:

            get_periods(fb, obj, tzid, window_end, True, recurrenceids)

fb.sort()

# Store and publish the free/busy collection.

if store_and_publish:

    if user == participant:

        store.set_freebusy(user, fb)

        publisher.set_freebusy(user, fb)

    else:

        store.set_freebusy_for_other(user, fb, participant)

else:

    for item in fb:

        print "\t".join(item.as_tuple())

# vim: tabstop=4 expandtab shiftwidth=4