#!/usr/bin/env python

"""

Construct free/busy records for a user, either recording that user's own

availability schedule or the schedule of another user (using details provided

when scheduling events with that user).

Copyright (C) 2014, 2015 Paul Boddie <paul@boddie.org.uk>

This program is free software; you can redistribute it and/or modify it under

the terms of the GNU General Public License as published by the Free Software

Foundation; either version 3 of the License, or (at your option) any later

version.

This program is distributed in the hope that it will be useful, but WITHOUT

ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more

details.

You should have received a copy of the GNU General Public License along with

this program.  If not, see <http://www.gnu.org/licenses/>.

"""

from os.path import split

import sys

# Find the modules.

try:

    import imiptools

except ImportError:

    parent = split(split(__file__)[0])[0]

    if split(parent)[1] == "imip-agent":

        sys.path.append(parent)

from codecs import getwriter

from imiptools.client import Client

from imiptools.data import get_window_end, Object

from imiptools.dates import get_default_timezone, to_utc_datetime

from imiptools.period import insert_period

from imip_store import FileStore, FilePublisher

def make_freebusy(client, participant, store_and_publish, include_needs_action,

    reset_updated_list, verbose):

    """

    Using the given 'client' representing a user, make free/busy details for the

    records of the user, generating details for 'participant' if not indicated

    as None; otherwise, generating free/busy details concerning the given user.

    If 'store_and_publish' is set, the stored details will be updated;

    otherwise, the details will be written to standard output.

    If 'include_needs_action' is set, details of objects whose participation

    status is set to "NEEDS-ACTION" for the participant will be included in the

    details.

    If 'reset_updated_list' is set, all objects will be inspected for periods;

    otherwise, only those in the stored free/busy providers file will be

    inspected.

    If 'verbose' is set, messages will be written to standard error.

    """

    user = client.user

    store = client.get_store()

    publisher = client.get_publisher()

    preferences = client.get_preferences()

    participant = participant or 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)

    # Get identifiers for uncancelled events either from a list of events

    # providing free/busy periods at the end of the given time window, or from

    # a list of all events.

    all_events = not reset_updated_list and store.get_freebusy_providers(user, window_end)

    if not all_events:

        all_events = store.get_all_events(user)

        fb = []

    # With providers of additional periods, append to the existing collection.

    else:

        if user == participant:

            fb = store.get_freebusy(user)

        else:

            fb = store.get_freebusy_for_other(user, participant)

    # 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.

    for obj in objs:

        partstat = obj.get_participation_status(participant)

        recurrenceids = not obj.get_recurrenceid() and store.get_recurrences(user, obj.get_uid())

        if obj.get_participation(partstat, include_needs_action):

            for p in obj.get_active_periods(recurrenceids, tzid, window_end):

                fbp = obj.get_freebusy_period(p, partstat == "ORG")

                insert_period(fb, fbp)

    # Store and publish the free/busy collection.

    if store_and_publish:

        if user == participant:

            store.set_freebusy(user, fb)

            if client.is_sharing() and client.is_publishing():

                publisher.set_freebusy(user, fb)

            # Update the list of objects providing periods on future occasions.

            store.set_freebusy_providers(user, to_utc_datetime(window_end, tzid),

                [obj for obj in objs if obj.possibly_active_from(window_end, tzid)])

        else:

            store.set_freebusy_for_other(user, fb, participant)

    # Alternatively, just write the collection to standard output.

    else:

        f = getwriter("utf-8")(sys.stdout)

        for item in fb:

            print >>f, "\t".join(item.as_tuple(strings_only=True))

# Main program.

if __name__ == "__main__":

    # Interpret the command line arguments.

    participants = []

    args = []

    store_dir = []

    publishing_dir = []

    preferences_dir = []

    ignored = []

    # Collect user details first, switching to other arguments when encountering

    # switches.

    l = participants

    for arg in sys.argv[1:]:

        if arg in ("-n", "-s", "-v", "-r"):

            args.append(arg)

            l = ignored

        elif arg == "-S":

            l = store_dir

        elif arg == "-P":

            l = publishing_dir

        elif arg == "-p":

            l = preferences_dir

        else:

            l.append(arg)

    try:

        user = participants[0]

    except IndexError:

        print >>sys.stderr, """\

Usage: %s <user> [ <other user> ] <options>

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.

Specify -n to include objects with PARTSTAT of NEEDS-ACTION.

Specify -r to inspect all objects, not just those expected to provide details.

Specify -v for additional messages on standard error.

General options:

-S  indicate the store directory location

-P  indicate the publishing directory location

-p  indicate the preferences directory location

""" % split(sys.argv[0])[1]

        sys.exit(1)

    # Define any other participant of interest plus options.

    participant = participants[1:] and participants[1] or None

    store_and_publish = "-s" in args

    include_needs_action = "-n" in args

    reset_updated_list = "-r" in args

    verbose = "-v" in args

    # Override defaults if indicated.

    store_dir = store_dir and store_dir[0] or None

    publishing_dir = publishing_dir and publishing_dir[0] or None

    preferences_dir = preferences_dir and preferences_dir[0] or None

    # Obtain store-related objects.

    store = FileStore(store_dir)

    publisher = FilePublisher(publishing_dir)

    # Obtain a list of users for processing.

    if user in ("*", "all"):

        users = store.get_users()

    else:

        users = [user]

    # Process the given users.

    for user in users:

        if verbose:

            print >>sys.stderr, user

        make_freebusy(

            Client(user, None, store, publisher, preferences_dir), participant,

            store_and_publish, include_needs_action, reset_updated_list, verbose)

# vim: tabstop=4 expandtab shiftwidth=4