#!/usr/bin/env python

"""

Interpretation of vCalendar content.

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 bisect import bisect_left

from datetime import datetime, timedelta

from email.mime.text import MIMEText

from imiptools.dates import format_datetime, get_datetime, get_duration, \

                            get_freebusy_period, get_period, to_datetime, \

                            to_timezone, to_utc_datetime

from imiptools.period import Period, period_overlaps

from pytz import timezone

from vCalendar import iterwrite, parse, ParseError, to_dict, to_node

from vRecurrence import get_parameters, get_rule

import email.utils

try:

    from cStringIO import StringIO

except ImportError:

    from StringIO import StringIO

class Object:

    "Access to calendar structures."

    def __init__(self, fragment):

        self.objtype, (self.details, self.attr) = fragment.items()[0]

    def get_items(self, name, all=True):

        return get_items(self.details, name, all)

    def get_item(self, name):

        return get_item(self.details, name)

    def get_value_map(self, name):

        return get_value_map(self.details, name)

    def get_values(self, name, all=True):

        return get_values(self.details, name, all)

    def get_value(self, name):

        return get_value(self.details, name)

    def get_utc_datetime(self, name):

        return get_utc_datetime(self.details, name)

    def get_date_values(self, name, tzid=None):

        items = get_date_value_items(self.details, name, tzid)

        return items and [value for value, attr in items]

    def get_date_value_items(self, name, tzid=None):

        return get_date_value_items(self.details, name, tzid)

    def get_datetime(self, name):

        dt, attr = get_datetime_item(self.details, name)

        return dt

    def get_datetime_item(self, name):

        return get_datetime_item(self.details, name)

    def get_duration(self, name):

        return get_duration(self.get_value(name))

    def to_node(self):

        return to_node({self.objtype : [(self.details, self.attr)]})

    def to_part(self, method):

        return to_part(method, [self.to_node()])

    # Direct access to the structure.

    def has_key(self, name):

        return self.details.has_key(name)

    def __getitem__(self, name):

        return self.details[name]

    def __setitem__(self, name, value):

        self.details[name] = value

    def __delitem__(self, name):

        del self.details[name]

    # Computed results.

    def has_recurrence(self, tzid, recurrence):

        recurrences = [p.start for p in get_periods(self, tzid, recurrence, inclusive=True)]

        return recurrence in recurrences

    def get_periods(self, tzid, end):

        return get_periods(self, tzid, end)

    def get_periods_for_freebusy(self, tzid, end):

        periods = self.get_periods(tzid, end)

        return get_periods_for_freebusy(self, periods, tzid)

    def get_tzid(self):

        dtstart, dtstart_attr = self.get_datetime_item("DTSTART")

        dtend, dtend_attr = self.get_datetime_item("DTEND")

        return get_tzid(dtstart_attr, dtend_attr)

# Construction and serialisation.

def make_calendar(nodes, method=None):

    """

    Return a complete calendar node wrapping the given 'nodes' and employing the

    given 'method', if indicated.

    """

    return ("VCALENDAR", {},

            (method and [("METHOD", {}, method)] or []) +

            [("VERSION", {}, "2.0")] +

            nodes

           )

def make_freebusy(freebusy, uid, organiser, organiser_attr=None, attendee=None,

    attendee_attr=None, dtstart=None, dtend=None):

    """

    Return a calendar node defining the free/busy details described in the given

    'freebusy' list, employing the given 'uid', for the given 'organiser' and

    optional 'organiser_attr', with the optional 'attendee' providing recipient

    details together with the optional 'attendee_attr'.

    The result will be constrained to the 'dtstart' and 'dtend' period if these

    parameters are given.

    """

    record = []

    rwrite = record.append

    rwrite(("ORGANIZER", organiser_attr or {}, organiser))

    if attendee:

        rwrite(("ATTENDEE", attendee_attr or {}, attendee)) 

    rwrite(("UID", {}, uid))

    if freebusy:

        # Get a constrained view if start and end limits are specified.

        periods = dtstart and dtend and \

            period_overlaps(freebusy, Period(dtstart, dtend), True) or \

            freebusy

        # Write the limits of the resource.

        rwrite(("DTSTART", {"VALUE" : "DATE-TIME"}, periods[0].start))

        rwrite(("DTEND", {"VALUE" : "DATE-TIME"}, periods[-1].end))

        for p in periods:

            if p.transp == "OPAQUE":

                rwrite(("FREEBUSY", {"FBTYPE" : "BUSY"}, "/".join([p.start, p.end])))

    return ("VFREEBUSY", {}, record)

def parse_object(f, encoding, objtype=None):

    """

    Parse the iTIP content from 'f' having the given 'encoding'. If 'objtype' is

    given, only objects of that type will be returned. Otherwise, the root of

    the content will be returned as a dictionary with a single key indicating

    the object type.

    Return None if the content was not readable or suitable.

    """

    try:

        try:

            doctype, attrs, elements = obj = parse(f, encoding=encoding)

            if objtype and doctype == objtype:

                return to_dict(obj)[objtype][0]

            elif not objtype:

                return to_dict(obj)

        finally:

            f.close()

    # NOTE: Handle parse errors properly.

    except (ParseError, ValueError):

        pass

    return None

def to_part(method, calendar):

    """

    Write using the given 'method', the 'calendar' details to a MIME

    text/calendar part.

    """

    encoding = "utf-8"

    out = StringIO()

    try:

        to_stream(out, make_calendar(calendar, method), encoding)

        part = MIMEText(out.getvalue(), "calendar", encoding)

        part.set_param("method", method)

        return part

    finally:

        out.close()

def to_stream(out, fragment, encoding="utf-8"):

    iterwrite(out, encoding=encoding).append(fragment)

# Structure access functions.

def get_items(d, name, all=True):

    """

    Get all items from 'd' for the given 'name', returning single items if

    'all' is specified and set to a false value and if only one value is

    present for the name. Return None if no items are found for the name or if

    many items are found but 'all' is set to a false value.

    """

    if d.has_key(name):

        items = d[name]

        if all:

            return items

        elif len(items) == 1:

            return items[0]

        else:

            return None

    else:

        return None

def get_item(d, name):

    return get_items(d, name, False)

def get_value_map(d, name):

    """

    Return a dictionary for all items in 'd' having the given 'name'. The

    dictionary will map values for the name to any attributes or qualifiers

    that may have been present.

    """

    items = get_items(d, name)

    if items:

        return dict(items)

    else:

        return {}

def values_from_items(items):

    return map(lambda x: x[0], items)

def get_values(d, name, all=True):

    if d.has_key(name):

        items = d[name]

        if not all and len(items) == 1:

            return items[0][0]

        else:

            return values_from_items(items)

    else:

        return None

def get_value(d, name):

    return get_values(d, name, False)

def get_date_value_items(d, name, tzid=None):

    """

    Obtain items from 'd' having the given 'name', where a single item yields

    potentially many values. Return a list of tuples of the form (value,

    attributes) where the attributes have been given for the property in 'd'.

    """

    items = get_items(d, name)

    if items:

        all_items = []

        for item in items:

            values, attr = item

            if not attr.has_key("TZID") and tzid:

                attr["TZID"] = tzid

            if not isinstance(values, list):

                values = [values]

            for value in values:

                all_items.append((get_datetime(value, attr) or get_period(value, attr), attr))

        return all_items

    else:

        return None

def get_utc_datetime(d, name):

    t = get_datetime_item(d, name)

    if not t:

        return None

    else:

        dt, attr = t

        return to_utc_datetime(dt)

def get_datetime_item(d, name):

    t = get_item(d, name)

    if not t:

        return None

    else:

        value, attr = t

        return get_datetime(value, attr), attr

def get_addresses(values):

    return [address for name, address in email.utils.getaddresses(values)]

def get_address(value):

    value = value.lower()

    return value.startswith("mailto:") and value[7:] or value

def get_uri(value):

    return value.lower().startswith("mailto:") and value.lower() or ":" in value and value or "mailto:%s" % value.lower()

uri_value = get_uri

def uri_values(values):

    return map(get_uri, values)

def uri_dict(d):

    return dict([(get_uri(key), value) for key, value in d.items()])

def uri_item(item):

    return get_uri(item[0]), item[1]

def uri_items(items):

    return [(get_uri(value), attr) for value, attr in items]

# Operations on structure data.

def is_new_object(old_sequence, new_sequence, old_dtstamp, new_dtstamp, partstat_set):

    """

    Return for the given 'old_sequence' and 'new_sequence', 'old_dtstamp' and

    'new_dtstamp', and the 'partstat_set' indication, whether the object

    providing the new information is really newer than the object providing the

    old information.

    """

    have_sequence = old_sequence is not None and new_sequence is not None

    is_same_sequence = have_sequence and int(new_sequence) == int(old_sequence)

    have_dtstamp = old_dtstamp and new_dtstamp

    is_old_dtstamp = have_dtstamp and new_dtstamp < old_dtstamp or old_dtstamp and not new_dtstamp

    is_old_sequence = have_sequence and (

        int(new_sequence) < int(old_sequence) or

        is_same_sequence and is_old_dtstamp

        )

    return is_same_sequence and partstat_set or not is_old_sequence

# NOTE: Need to expose the 100 day window for recurring events in the

# NOTE: configuration.

def get_window_end(tzid, window_size=100):

    return to_timezone(datetime.now(), tzid) + timedelta(window_size)

def get_tzid(dtstart_attr, dtend_attr):

    return dtstart_attr.get("TZID") or dtend_attr.get("TZID")

class RecurringPeriod(Period):

    "A period with origin information from the object."

    def __init__(self, start, end, origin, start_attr=None, end_attr=None):

        Period.__init__(self, start, end)

        self.origin = origin

        self.start_attr = start_attr

        self.end_attr = end_attr

    def as_tuple(self):

        return self.start, self.end, self.origin, self.start_attr, self.end_attr

    def __repr__(self):

        return "RecurringPeriod(%r, %r, %r, %r, %r)" % (self.start, self.end, self.origin, self.start_attr, self.end_attr)

def get_periods(obj, tzid, window_end, inclusive=False):

    """

    Return periods for the given object 'obj', confining materialised periods

    to before the given 'window_end' datetime. If 'inclusive' is set to a true

    value, any period occurring at the 'window_end' will be included.

    """

    rrule = obj.get_value("RRULE")

    # Use localised datetimes.

    dtstart, dtstart_attr = obj.get_datetime_item("DTSTART")

    if obj.has_key("DTEND"):

        dtend, dtend_attr = obj.get_datetime_item("DTEND")

        duration = dtend - dtstart

    elif obj.has_key("DURATION"):

        duration = obj.get_duration("DURATION")

        dtend = dtstart + duration

        dtend_attr = dtstart_attr

    else:

        dtend, dtend_attr = dtstart, dtstart_attr

    tzid = get_tzid(dtstart_attr, dtend_attr) or tzid

    if not rrule:

        periods = [RecurringPeriod(dtstart, dtend, "DTSTART", dtstart_attr, dtend_attr)]

    else:

        # Recurrence rules create multiple instances to be checked.

        # Conflicts may only be assessed within a period defined by policy

        # for the agent, with instances outside that period being considered

        # unchecked.

        selector = get_rule(dtstart, rrule)

        parameters = get_parameters(rrule)

        periods = []

        for start in selector.materialise(dtstart, window_end, parameters.get("COUNT"), parameters.get("BYSETPOS"), inclusive):

            start = to_timezone(datetime(*start), tzid)

            end = start + duration

            periods.append(RecurringPeriod(start, end, "RRULE"))

    # Add recurrence dates.

    rdates = obj.get_date_value_items("RDATE", tzid)

    if rdates:

        for rdate, rdate_attr in rdates:

            if isinstance(rdate, tuple):

                periods.append(RecurringPeriod(rdate[0], rdate[1], "RDATE", rdate_attr))

            else:

                periods.append(RecurringPeriod(rdate, rdate + duration, "RDATE", rdate_attr))

    # Return a sorted list of the periods.

    periods.sort(cmp=compare_periods(tzid))

    # Exclude exception dates.

    exdates = obj.get_date_values("EXDATE", tzid)

    if exdates:

        for exdate in exdates:

            if isinstance(exdate, tuple):

                period = Period(exdate[0], exdate[1])

            else:

                period = Period(exdate, exdate + duration)

            i = bisect_left(periods, period)

            while i < len(periods) and periods[i] == period:

                del periods[i]

    return periods

class compare_periods:

    "Compare periods for exception date purposes."

    def __init__(self, tzid):

        self.tzid = tzid

    def __call__(self, first, second):

        return cmp(

            (to_datetime(first.start, self.tzid), to_datetime(first.end, self.tzid)),

            (to_datetime(second.start, self.tzid), to_datetime(second.end, self.tzid))

            )

def get_periods_for_freebusy(obj, periods, tzid):

    """

    Get free/busy-compliant periods employed by 'obj' from the given 'periods',

    using the indicated 'tzid' to convert dates to datetimes.

    """

    start, start_attr = obj.get_datetime_item("DTSTART")

    if obj.has_key("DTEND"):

        end, end_attr = obj.get_datetime_item("DTEND")

    elif obj.has_key("DURATION"):

        duration = obj.get_duration("DURATION")

        end = start + duration

    else:

        end, end_attr = start, start_attr

    tzid = get_tzid(start_attr, end_attr) or tzid

    l = []

    for p in periods:

        start, end = get_freebusy_period(p.start, p.end, tzid)

        start, end = [to_timezone(x, "UTC") for x in start, end]

        # Create a new period for free/busy purposes with the converted

        # datetime information.

        l.append(p.__class__(

            *((format_datetime(start), format_datetime(end)) + p.as_tuple()[2:])

            ))

    return l

# vim: tabstop=4 expandtab shiftwidth=4