#!/usr/bin/env python

"""

Date processing functions.

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 datetime import date, datetime, timedelta

from os.path import exists

from pytz import timezone, UnknownTimeZoneError

import re

# iCalendar date and datetime parsing (from DateSupport in MoinSupport).

_date_icalendar_regexp_str = ur'(?P<year>[0-9]{4})(?P<month>[0-9]{2})(?P<day>[0-9]{2})'

date_icalendar_regexp_str = _date_icalendar_regexp_str + '$'

datetime_icalendar_regexp_str = _date_icalendar_regexp_str + \

    ur'(?:' \

    ur'T(?P<hour>[0-2][0-9])(?P<minute>[0-5][0-9])(?P<second>[0-6][0-9])' \

    ur'(?P<utc>Z)?' \

    ur')?$'

_duration_time_icalendar_regexp_str = \

    ur'T' \

    ur'(?:' \

    ur'([0-9]+H)(?:([0-9]+M)([0-9]+S)?)?' \

    ur'|' \

    ur'([0-9]+M)([0-9]+S)?' \

    ur'|' \

    ur'([0-9]+S)' \

    ur')'

duration_icalendar_regexp_str = ur'P' \

    ur'(?:' \

    ur'([0-9]+W)' \

    ur'|' \

    ur'(?:%s)' \

    ur'|' \

    ur'([0-9]+D)(?:%s)?' \

    ur')$' % (_duration_time_icalendar_regexp_str, _duration_time_icalendar_regexp_str)

match_date_icalendar = re.compile(date_icalendar_regexp_str, re.UNICODE).match

match_datetime_icalendar = re.compile(datetime_icalendar_regexp_str, re.UNICODE).match

match_duration_icalendar = re.compile(duration_icalendar_regexp_str, re.UNICODE).match

def to_utc_datetime(dt, date_tzid=None):

    """

    Return a datetime corresponding to 'dt' in the UTC time zone. If 'date_tzid'

    is specified, dates are converted to datetimes using the time zone

    information; otherwise, dates remain unconverted.

    """

    if not dt:

        return None

    elif isinstance(dt, datetime):

        return to_timezone(dt, "UTC")

    elif date_tzid:

        return to_timezone(to_datetime(dt, date_tzid), "UTC")

    else:

        return dt

def get_default_timezone():

    "Return the system time regime."

    filename = "/etc/timezone"

    if exists(filename):

        f = open(filename)

        try:

            return f.read().strip()

        finally:

            f.close()

    else:

        return None

def to_timezone(dt, name):

    """

    Return a datetime corresponding to 'dt' in the time regime having the given

    'name'.

    """

    try:

        tz = name and timezone(name) or None

    except UnknownTimeZoneError:

        tz = None

    return to_tz(dt, tz)

def to_tz(dt, tz):

    "Return a datetime corresponding to 'dt' employing the pytz.timezone 'tz'."

    if tz is not None and isinstance(dt, datetime):

        if not dt.tzinfo:

            return tz.localize(dt)

        else:

            return dt.astimezone(tz)

    else:

        return dt

def format_datetime(dt):

    "Format 'dt' as an iCalendar-compatible string."

    if not dt:

        return None

    elif isinstance(dt, datetime):

        if dt.tzname() == "UTC":

            return dt.strftime("%Y%m%dT%H%M%SZ")

        else:

            return dt.strftime("%Y%m%dT%H%M%S")

    else:

        return dt.strftime("%Y%m%d")

def format_time(dt):

    "Format the time portion of 'dt' as an iCalendar-compatible string."

    if not dt:

        return None

    elif isinstance(dt, datetime):

        if dt.tzname() == "UTC":

            return dt.strftime("%H%M%SZ")

        else:

            return dt.strftime("%H%M%S")

    else:

        return None

def get_datetime_attributes(dt, tzid=None):

    "Return attributes for 'dt' and 'tzid'."

    if isinstance(dt, datetime):

        attr = {"VALUE" : "DATE-TIME"}

        if tzid:

            attr["TZID"] = tzid

        return attr

    else:

        return {"VALUE" : "DATE"}

    return {}

def get_period_attributes(tzid=None):

    "Return attributes for 'tzid'."

    attr = {"VALUE" : "PERIOD"}

    if tzid:

        attr["TZID"] = tzid

    return attr

def get_datetime_item(dt, tzid=None):

    "Return an iCalendar-compatible string and attributes for 'dt' and 'tzid'."

    if not dt:

        return None, None

    dt = to_timezone(dt, tzid)

    value = format_datetime(dt)

    attr = get_datetime_attributes(dt, tzid)

    return value, attr

def get_period_item(start, end, tzid=None):

    """

    Return an iCalendar-compatible string and attributes for 'start', 'end' and

    'tzid'.

    """

    start = start and to_timezone(start, tzid)

    end = end and to_timezone(end, tzid)

    start_value = start and format_datetime(start) or None

    end_value = end and format_datetime(end) or None

    if start and end:

        attr = get_period_attributes(tzid)

        return "%s/%s" % (start_value, end_value), attr

    elif start:

        attr = get_datetime_attributes(start, tzid)

        return start_value, attr

    else:

        return None, None

def get_datetime(value, attr=None):

    """

    Return a datetime object from the given 'value' in iCalendar format, using

    the 'attr' mapping (if specified) to control the conversion.

    """

    if not value:

        return None

    if len(value) > 9 and (not attr or attr.get("VALUE") in (None, "DATE-TIME")):

        m = match_datetime_icalendar(value)

        if m:

            year, month, day, hour, minute, second = map(m.group, [

                "year", "month", "day", "hour", "minute", "second"

                ])

            if hour and minute and second:

                dt = datetime(

                    int(year), int(month), int(day), int(hour), int(minute), int(second)

                    )

                # Impose the indicated timezone.

                # NOTE: This needs an ambiguity policy for DST changes.

                return to_timezone(dt, m.group("utc") and "UTC" or attr and attr.get("TZID") or None)

        return None

    # Permit dates even if the VALUE is not set to DATE.

    if not attr or attr.get("VALUE") in (None, "DATE"):

        m = match_date_icalendar(value)

        if m:

            year, month, day = map(m.group, ["year", "month", "day"])

            return date(int(year), int(month), int(day))

    return None

def get_period(value, attr=None):

    """

    Return a tuple of the form (start, end) for the given 'value' in iCalendar

    format, using the 'attr' mapping (if specified) to control the conversion.

    """

    if not value or attr and attr.get("VALUE") != "PERIOD":

        return None

    t = value.split("/")

    if len(t) != 2:

        return None

    dtattr = {}

    if attr:

        dtattr.update(attr)

        if dtattr.has_key("VALUE"):

            del dtattr["VALUE"]

    start = get_datetime(t[0], dtattr)

    if t[1].startswith("P"):

        end = start + get_duration(t[1])

    else:

        end = get_datetime(t[1], dtattr)

    return start, end

def get_duration(value):

    "Return a duration for the given 'value'."

    if not value:

        return None

    m = match_duration_icalendar(value)

    if m:

        weeks, days, hours, minutes, seconds = 0, 0, 0, 0, 0

        for s in m.groups():

            if not s: continue

            if s[-1] == "W": weeks += int(s[:-1])

            elif s[-1] == "D": days += int(s[:-1])

            elif s[-1] == "H": hours += int(s[:-1])

            elif s[-1] == "M": minutes += int(s[:-1])

            elif s[-1] == "S": seconds += int(s[:-1])

        return timedelta(

            int(weeks) * 7 + int(days),

            (int(hours) * 60 + int(minutes)) * 60 + int(seconds)

            )

    else:

        return None

def to_date(dt):

    "Return the date of 'dt'."

    return date(dt.year, dt.month, dt.day)

def to_datetime(dt, tzid):

    """

    Return a datetime for 'dt', using the start of day for dates, and using the

    'tzid' for the conversion.

    """

    if isinstance(dt, datetime):

        return dt

    else:

        return get_start_of_day(dt, tzid)

def get_start_of_day(dt, tzid):

    """

    Get the start of the day in which 'dt' is positioned, using the given 'tzid'

    to obtain a datetime in the appropriate time zone. Where time zone

    transitions occur within a day, the zone of 'dt' may not be the eventual

    zone of the returned object.

    """

    start = datetime(dt.year, dt.month, dt.day, 0, 0)

    return to_timezone(start, tzid)

def get_end_of_day(dt, tzid):

    """

    Get the end of the day in which 'dt' is positioned, using the given 'tzid'

    to obtain a datetime in the appropriate time zone. Where time zone

    transitions occur within a day, the zone of 'dt' may not be the eventual

    zone of the returned object.

    """

    return get_start_of_day(dt + timedelta(1), tzid)

def get_start_of_next_day(dt, tzid):

    """

    Get the start of the day after the day in which 'dt' is positioned. This

    function is intended to extend either dates or datetimes to the end of a

    day for the purpose of generating a missing end date or datetime for an

    event.

    If 'dt' is a date and not a datetime, a plain date object for the next day

    will be returned.

    If 'dt' is a datetime, the given 'tzid' is used to obtain a datetime in the

    appropriate time zone. Where time zone transitions occur within a day, the

    zone of 'dt' may not be the eventual zone of the returned object.

    """

    if isinstance(dt, datetime):

        return get_end_of_day(dt, tzid)

    else:

        return dt + timedelta(1)

def ends_on_same_day(dt, end, tzid):

    """

    Return whether 'dt' ends on the same day as 'end', testing the date

    components of 'dt' and 'end' against each other, but also testing whether

    'end' is the actual end of the day in which 'dt' is positioned.

    Since time zone transitions may occur within a day, 'tzid' is required to

    determine the end of the day in which 'dt' is positioned, using the zone

    appropriate at that point in time, not necessarily the zone applying to

    'dt'.

    """

    return (

        to_timezone(dt, tzid).date() == to_timezone(end, tzid).date() or

        end == get_end_of_day(dt, tzid)

        )

def get_timestamp():

    "Return the current time as an iCalendar-compatible string."

    return format_datetime(to_timezone(datetime.utcnow(), "UTC"))

def get_freebusy_period(start, end, tzid):

    """

    For the given 'start' datetime, together with the given 'end' datetime, and

    given a 'tzid' either from the datetimes or provided for the user, return a

    (start, end) tuple containing datetimes in the UTC time zone, where dates

    are converted to points in time so that each day has a specific start and

    end point defined in UTC.

    """

    start = to_utc_datetime(start, tzid)

    end = to_utc_datetime(end, tzid)

    return start, end

def to_recurrence_start(recurrenceid, tzid):

    """

    Return 'recurrenceid' in a form suitable for comparison with free/busy start

    datetimes, using 'tzid' to convert recurrence identifiers that are dates.

    """

    return format_datetime(to_utc_datetime(get_datetime(recurrenceid), tzid))

def end_date_to_calendar(dt):

    """

    Change end dates to refer to the iCalendar "next day" dates, not the actual

    dates.

    """

    if not isinstance(dt, datetime):

        return dt + timedelta(1)

    else:

        return dt

def end_date_from_calendar(dt):

    """

    Change end dates to refer to the actual dates, not the iCalendar "next day"

    dates.

    """

    if not isinstance(dt, datetime):

        return dt - timedelta(1)

    else:

        return dt

# vim: tabstop=4 expandtab shiftwidth=4