#!/usr/bin/env python

"""

Managing and presenting periods of time.

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, insort_left

from datetime import datetime, timedelta

from imiptools.dates import get_datetime, get_start_of_day, to_timezone

# Time management with datetime strings in the UTC time zone.

def can_schedule(freebusy, periods, uid, recurrenceid):

    """

    Return whether the 'freebusy' list can accommodate the given 'periods'

    employing the specified 'uid' and 'recurrenceid'.

    """

    for conflict in have_conflict(freebusy, periods, True):

        start, end, found_uid, found_transp, found_recurrenceid = conflict[:5]

        if found_uid != uid and found_recurrenceid != recurrenceid:

            return False

    return True

def have_conflict(freebusy, periods, get_conflicts=False):

    """

    Return whether any period in 'freebusy' overlaps with the given 'periods',

    returning a collection of such overlapping periods if 'get_conflicts' is

    set to a true value.

    """

    conflicts = []

    for start, end in periods:

        overlapping = period_overlaps(freebusy, (start, end), get_conflicts)

        if overlapping:

            if get_conflicts:

                conflicts += overlapping

            else:

                return True

    if get_conflicts:

        return conflicts

    else:

        return False

def insert_period(freebusy, period):

    "Insert into 'freebusy' the given 'period'."

    insort_left(freebusy, period)

def remove_period(freebusy, uid, recurrenceid=None):

    """

    Remove from 'freebusy' all periods associated with 'uid' and 'recurrenceid'

    (which if omitted causes the "parent" object's periods to be referenced).

    """

    i = 0

    while i < len(freebusy):

        t = freebusy[i]

        if len(t) >= 5 and t[2] == uid and t[4] == recurrenceid:

            del freebusy[i]

        else:

            i += 1

def remove_additional_periods(freebusy, uid, recurrenceids=None):

    """

    Remove from 'freebusy' all periods associated with 'uid' having a

    recurrence identifier indicating an additional or modified period.

    If 'recurrenceids' is specified, remove all periods associated with 'uid'

    that do not have a recurrence identifier in the given list.

    """

    i = 0

    while i < len(freebusy):

        t = freebusy[i]

        if len(t) >= 5 and t[2] == uid and t[4] and (

            recurrenceids is None or

            recurrenceids is not None and t[4] not in recurrenceids

            ):

            del freebusy[i]

        else:

            i += 1

def remove_affected_period(freebusy, uid, recurrenceid):

    """

    Remove from 'freebusy' a period associated with 'uid' that provides an

    occurrence starting at the given 'recurrenceid', where the recurrence

    identifier is used to provide an alternative time period whilst also acting

    as a reference to the originally-defined occurrence.

    """

    found = bisect_left(freebusy, (recurrenceid,))

    while found < len(freebusy):

        start, end, _uid, transp, _recurrenceid = freebusy[found][:5]

        # Stop looking if the start no longer matches the recurrence identifier.

        if start != recurrenceid:

            return

        # If the period belongs to the parent object, remove it and return.

        if not _recurrenceid and uid == _uid:

            del freebusy[found]

            break

        # Otherwise, keep looking for a matching period.

        found += 1

def get_overlapping(freebusy, period):

    """

    Return the indexes in 'freebusy' providing periods overlapping with

    'period'.

    """

    dtstart, dtend = period[:2]

    found = bisect_left(freebusy, (dtstart, dtend))

    # Find earlier overlapping periods.

    start = found

    while start > 0 and freebusy[start - 1][1] > dtstart:

        start -= 1

    # Find later overlapping periods.

    end = found

    while end < len(freebusy) and (dtend is None or freebusy[end][0] < dtend):

        end += 1

    return start, end

def period_overlaps(freebusy, period, get_periods=False):

    """

    Return whether any period in 'freebusy' overlaps with the given 'period',

    returning a collection of overlapping periods if 'get_periods' is set to a

    true value.

    """

    start, end = get_overlapping(freebusy, period)

    if get_periods:

        return freebusy[start:end]

    else:

        return start != end

def remove_overlapping(freebusy, period):

    "Remove from 'freebusy' all periods overlapping with 'period'."

    start, end = get_overlapping(freebusy, period)

    if start != end:

        del freebusy[start:end]

def replace_overlapping(freebusy, period, replacements):

    """

    Replace existing periods in 'freebusy' within the given 'period', using the

    given 'replacements'.

    """

    remove_overlapping(freebusy, period)

    for replacement in replacements:

        insert_period(freebusy, replacement)

# Period layout mostly with datetime objects.

def convert_periods(periods, tzid):

    "Convert 'periods' to use datetime objects employing the given 'tzid'."

    l = []

    for t in periods:

        start, end = t[:2]

        # NOTE: This only really works if the datetimes are UTC already.

        # NOTE: Since the periods should originate from the free/busy data,

        # NOTE: and since that data should employ UTC times, this should not be

        # NOTE: an immediate problem.

        start = get_datetime(start)

        end = get_datetime(end)

        start = isinstance(start, datetime) and to_timezone(start, tzid) or get_start_of_day(start, tzid)

        end = isinstance(end, datetime) and to_timezone(end, tzid) or get_start_of_day(end, tzid)

        l.append((start, end) + tuple(t[2:]))

    return l

def get_scale(periods):

    """

    Return an ordered time scale from the given list 'periods', with the first

    two elements of each tuple being start and end times.

    The given 'tzid' is used to make sure that the times are defined according

    to the chosen time zone.

    The returned scale is a mapping from time to (starting, ending) tuples,

    where starting and ending are collections of tuples from 'periods'.

    """

    scale = {}

    for t in periods:

        start, end = t[:2]

        # Add a point and this event to the starting list.

        if not scale.has_key(start):

            scale[start] = [], []

        scale[start][0].append(t)

        # Add a point and this event to the ending list.

        if not scale.has_key(end):

            scale[end] = [], []

        scale[end][1].append(t)

    return scale

def get_slots(scale):

    """

    Return an ordered list of time slots from the given 'scale'.

    Each slot is a tuple containing a point in time for the start of the slot,

    together with a list of parallel event tuples, each tuple containing the

    original details of an event.

    """

    slots = []

    active = []

    points = scale.items()

    points.sort()

    for point, (starting, ending) in points:

        # Discard all active events ending at or before this start time.

        # Free up the position in the active list.

        for t in ending:

            i = active.index(t)

            active[i] = None

        # For each event starting at the current point, fill any newly-vacated

        # position or add to the end of the active list.

        for t in starting:

            try:

                i = active.index(None)

                active[i] = t

            except ValueError:

                active.append(t)

        # Discard vacant positions from the end of the active list.

        while active and active[-1] is None:

            active.pop()

        slots.append((point, active[:]))

    return slots

def add_day_start_points(slots, tzid):

    """

    Introduce into the 'slots' any day start points required by multi-day

    periods. The 'tzid' is required to make sure that appropriate time zones

    are chosen and not necessarily those provided by the existing time points.

    """

    new_slots = []

    current_date = None

    previously_active = []

    for point, active in slots:

        start_of_day = get_start_of_day(point, tzid)

        this_date = point.date()

        # For each new day, add a slot for the start of the day where periods

        # are active and where no such slot already exists.

        if this_date != current_date:

            current_date = this_date

            # Add any continuing periods.

            if point != start_of_day:

                new_slots.append((start_of_day, previously_active))

        # Add the currently active periods at this point in time.

        previously_active = active

    for t in new_slots:

        insort_left(slots, t)

def add_slots(slots, points):

    """

    Introduce into the 'slots' entries for those in 'points' that are not

    already present, propagating active periods from time points preceding

    those added.

    """

    new_slots = []

    for point in points:

        i = bisect_left(slots, (point, None))

        if i < len(slots) and slots[i][0] == point:

            continue

        new_slots.append((point, i > 0 and slots[i-1][1] or []))

    for t in new_slots:

        insort_left(slots, t)

def partition_by_day(slots):

    """

    Return a mapping from dates to time points provided by 'slots'.

    """

    d = {}

    for point, value in slots:

        day = point.date()

        if not d.has_key(day):

            d[day] = []

        d[day].append((point, value))

    return d

def add_empty_days(days, tzid):

    "Add empty days to 'days' between busy days."

    last_day = None

    all_days = days.keys()

    all_days.sort()

    for day in all_days:

        if last_day:

            empty_day = last_day + timedelta(1)

            while empty_day < day:

                days[empty_day] = [(get_start_of_day(empty_day, tzid), None)]

                empty_day += timedelta(1)

        last_day = day 

def get_spans(slots):

    "Inspect the given 'slots', returning a mapping of event uids to spans."

    points = [point for point, active in slots]

    spans = {}

    for point, active in slots:

        for t in active:

            if t and len(t) >= 2:

                start, end, uid, recurrenceid, summary, organiser, key = get_freebusy_details(t)

                try:

                    start_slot = points.index(start)

                except ValueError:

                    start_slot = 0

                try:

                    end_slot = points.index(end)

                except ValueError:

                    end_slot = len(slots)

                spans[key] = end_slot - start_slot

    return spans

def get_freebusy_details(t):

    """

    Return a tuple of the form (start, end, uid, recurrenceid, summary,

    organiser, key) from 't'.

    """

    # Handle both complete free/busy details...

    if len(t) >= 7:

        start, end, uid, transp, recurrenceid, summary, organiser = t[:7]

        key = uid, recurrenceid

    # ...and published details without specific event details.

    else:

        start, end = t[:2]

        uid = None

        recurrenceid = None

        summary = None

        organiser = None

        key = (start, end)

    return start, end, uid, recurrenceid, summary, organiser, key

def update_freebusy(freebusy, periods, transp, uid, recurrenceid, summary, organiser):

    """

    Update the free/busy details with the given 'periods', 'transp' setting,

    'uid' plus 'recurrenceid' and 'summary' and 'organiser' details.

    """

    remove_period(freebusy, uid, recurrenceid)

    for start, end in periods:

        insert_period(freebusy, (start, end, uid, transp, recurrenceid, summary, organiser))

# vim: tabstop=4 expandtab shiftwidth=4