#!/usr/bin/env python

"""

A Web interface to an event calendar.

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 datetime

from imiptools.data import get_address, get_uri, uri_values

from imiptools.dates import format_datetime, get_datetime, \

                            get_datetime_item, get_end_of_day, get_start_of_day, \

                            get_start_of_next_day, get_timestamp, ends_on_same_day, \

                            to_timezone

from imiptools.period import add_day_start_points, add_empty_days, add_slots, \

                             convert_periods, get_scale, get_slots, get_spans, \

                             partition_by_day, Point

from imipweb.resource import Resource

class CalendarPage(Resource):

    "A request handler for the calendar page."

    # Request logic methods.

    def handle_newevent(self):

        """

        Handle any new event operation, creating a new event and redirecting to

        the event page for further activity.

        """

        # Handle a submitted form.

        args = self.env.get_args()

        if not args.has_key("newevent"):

            return

        # Create a new event using the available information.

        slots = args.get("slot", [])

        participants = args.get("participants", [])

        if not slots:

            return

        # Obtain the user's timezone.

        tzid = self.get_tzid()

        # Coalesce the selected slots.

        slots.sort()

        coalesced = []

        last = None

        for slot in slots:

            start, end = slot.split("-")

            start = get_datetime(start, {"TZID" : tzid})

            end = end and get_datetime(end, {"TZID" : tzid}) or get_start_of_next_day(start, tzid)

            if last:

                last_start, last_end = last

                # Merge adjacent dates and datetimes.

                if start == last_end or \

                    not isinstance(start, datetime) and \

                    get_start_of_day(last_end, tzid) == get_start_of_day(start, tzid):

                    last = last_start, end

                    continue

                # Handle datetimes within dates.

                # Datetime periods are within single days and are therefore

                # discarded.

                elif not isinstance(last_start, datetime) and \

                    get_start_of_day(start, tzid) == get_start_of_day(last_start, tzid):

                    continue

                # Add separate dates and datetimes.

                else:

                    coalesced.append(last)

            last = start, end

        if last:

            coalesced.append(last)

        # Invent a unique identifier.

        utcnow = get_timestamp()

        uid = "imip-agent-%s-%s" % (utcnow, get_address(self.user))

        # Create a calendar object and store it as a request.

        record = []

        rwrite = record.append

        # Define a single occurrence if only one coalesced slot exists.

        start, end = coalesced[0]

        start_value, start_attr = get_datetime_item(start, tzid)

        end_value, end_attr = get_datetime_item(end, tzid)

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

        rwrite(("SUMMARY", {}, "New event at %s" % utcnow))

        rwrite(("DTSTAMP", {}, utcnow))

        rwrite(("DTSTART", start_attr, start_value))

        rwrite(("DTEND", end_attr, end_value))

        rwrite(("ORGANIZER", {}, self.user))

        participants = uri_values(filter(None, participants))

        for participant in participants:

            rwrite(("ATTENDEE", {"RSVP" : "TRUE", "PARTSTAT" : "NEEDS-ACTION"}, participant))

        if self.user not in participants:

            rwrite(("ATTENDEE", {"PARTSTAT" : "ACCEPTED"}, self.user))

        # Define additional occurrences if many slots are defined.

        rdates = []

        for start, end in coalesced[1:]:

            start_value, start_attr = get_datetime_item(start, tzid)

            end_value, end_attr = get_datetime_item(end, tzid)

            rdates.append("%s/%s" % (start_value, end_value))

        if rdates:

            rwrite(("RDATE", {"VALUE" : "PERIOD", "TZID" : tzid}, rdates))

        node = ("VEVENT", {}, record)

        self.store.set_event(self.user, uid, None, node=node)

        self.store.queue_request(self.user, uid)

        # Redirect to the object (or the first of the objects), where instead of

        # attendee controls, there will be organiser controls.

        self.redirect(self.link_to(uid))

    # Page fragment methods.

    def show_requests_on_page(self):

        "Show requests for the current user."

        page = self.page

        # NOTE: This list could be more informative, but it is envisaged that

        # NOTE: the requests would be visited directly anyway.

        requests = self._get_requests()

        page.div(id="pending-requests")

        if requests:

            page.p("Pending requests:")

            page.ul()

            for uid, recurrenceid in requests:

                obj = self._get_object(uid, recurrenceid)

                if obj:

                    page.li()

                    page.a(obj.get_value("SUMMARY"), href="#request-%s-%s" % (uid, recurrenceid or ""))

                    page.li.close()

            page.ul.close()

        else:

            page.p("There are no pending requests.")

        page.div.close()

    def show_participants_on_page(self):

        "Show participants for scheduling purposes."

        page = self.page

        args = self.env.get_args()

        participants = args.get("participants", [])

        try:

            for name, value in args.items():

                if name.startswith("remove-participant-"):

                    i = int(name[len("remove-participant-"):])

                    del participants[i]

                    break

        except ValueError:

            pass

        # Trim empty participants.

        while participants and not participants[-1].strip():

            participants.pop()

        # Show any specified participants together with controls to remove and

        # add participants.

        page.div(id="participants")

        page.p("Participants for scheduling:")

        for i, participant in enumerate(participants):

            page.p()

            page.input(name="participants", type="text", value=participant)

            page.input(name="remove-participant-%d" % i, type="submit", value="Remove")

            page.p.close()

        page.p()

        page.input(name="participants", type="text")

        page.input(name="add-participant", type="submit", value="Add")

        page.p.close()

        page.div.close()

        return participants

    # Full page output methods.

    def show(self):

        "Show the calendar for the current user."

        handled = self.handle_newevent()

        self.new_page(title="Calendar")

        page = self.page

        # Form controls are used in various places on the calendar page.

        page.form(method="POST")

        self.show_requests_on_page()

        participants = self.show_participants_on_page()

        # Show a button for scheduling a new event.

        page.p(class_="controls")

        page.input(name="newevent", type="submit", value="New event", id="newevent", accesskey="N")

        page.p.close()

        # Show controls for hiding empty days and busy slots.

        # The positioning of the control, paragraph and table are important here.

        page.input(name="showdays", type="checkbox", value="show", id="showdays", accesskey="D")

        page.input(name="hidebusy", type="checkbox", value="hide", id="hidebusy", accesskey="B")

        page.p(class_="controls")

        page.label("Hide busy time periods", for_="hidebusy", class_="hidebusy enable")

        page.label("Show busy time periods", for_="hidebusy", class_="hidebusy disable")

        page.label("Show empty days", for_="showdays", class_="showdays disable")

        page.label("Hide empty days", for_="showdays", class_="showdays enable")

        page.input(name="reset", type="submit", value="Clear selections", id="reset")

        page.label("Clear selections", for_="reset", class_="reset")

        page.p.close()

        freebusy = self.store.get_freebusy(self.user)

        if not freebusy:

            page.p("No events scheduled.")

            return

        # Obtain the user's timezone.

        tzid = self.get_tzid()

        # Day view: start at the earliest known day and produce days until the

        # latest known day, perhaps with expandable sections of empty days.

        # Month view: start at the earliest known month and produce months until

        # the latest known month, perhaps with expandable sections of empty

        # months.

        # Details of users to invite to new events could be superimposed on the

        # calendar.

        # Requests are listed and linked to their tentative positions in the

        # calendar. Other participants are also shown.

        request_summary = self._get_request_summary()

        period_groups = [request_summary, freebusy]

        period_group_types = ["request", "freebusy"]

        period_group_sources = ["Pending requests", "Your schedule"]

        for i, participant in enumerate(participants):

            period_groups.append(self.store.get_freebusy_for_other(self.user, get_uri(participant)))

            period_group_types.append("freebusy-part%d" % i)

            period_group_sources.append(participant)

        groups = []

        group_columns = []

        group_types = period_group_types

        group_sources = period_group_sources

        all_points = set()

        # Obtain time point information for each group of periods.

        for periods in period_groups:

            convert_periods(periods, tzid)

            # Get the time scale with start and end points.

            scale = get_scale(periods)

            # Get the time slots for the periods.

            # Time slots are collections of Point objects with lists of active

            # periods.

            slots = get_slots(scale)

            # Add start of day time points for multi-day periods.

            add_day_start_points(slots, tzid)

            # Record the slots and all time points employed.

            groups.append(slots)

            all_points.update([point for point, active in slots])

        # Partition the groups into days.

        days = {}

        partitioned_groups = []

        partitioned_group_types = []

        partitioned_group_sources = []

        for slots, group_type, group_source in zip(groups, group_types, group_sources):

            # Propagate time points to all groups of time slots.

            add_slots(slots, all_points)

            # Count the number of columns employed by the group.

            columns = 0

            # Partition the time slots by day.

            partitioned = {}

            for day, day_slots in partition_by_day(slots).items():

                # Construct a list of time intervals within the day.

                intervals = []

                # Convert each partition to a mapping from points to active

                # periods.

                partitioned[day] = day_points = {}

                last = None

                for point, active in day_slots:

                    columns = max(columns, len(active))

                    day_points[point] = active

                    if last:

                        intervals.append((last, point))

                    last = point

                if last:

                    intervals.append((last, None))

                if not days.has_key(day):

                    days[day] = set()

                # Record the divisions or intervals within each day.

                days[day].update(intervals)

            # Only include the requests column if it provides objects.

            if group_type != "request" or columns:

                group_columns.append(columns)

                partitioned_groups.append(partitioned)

                partitioned_group_types.append(group_type)

                partitioned_group_sources.append(group_source)

        # Add empty days.

        add_empty_days(days, tzid)

        # Show the controls permitting day selection.

        self.show_calendar_day_controls(days)

        # Show the calendar itself.

        page.table(cellspacing=5, cellpadding=5, class_="calendar")

        self.show_calendar_participant_headings(partitioned_group_types, partitioned_group_sources, group_columns)

        self.show_calendar_days(days, partitioned_groups, partitioned_group_types, group_columns)

        page.table.close()

        # End the form region.

        page.form.close()

    # More page fragment methods.

    def show_calendar_day_controls(self, days):

        "Show controls for the given 'days' in the calendar."

        page = self.page

        slots = self.env.get_args().get("slot", [])

        for day in days:

            value, identifier = self._day_value_and_identifier(day)

            self._slot_selector(value, identifier, slots)

        # Generate a dynamic stylesheet to allow day selections to colour

        # specific days.

        # NOTE: The style details need to be coordinated with the static

        # NOTE: stylesheet.

        page.style(type="text/css")

        for day in days:

            daystr = format_datetime(day)

            page.add("""\

input.newevent.selector#day-%s-:checked ~ table label.day.day-%s,

input.newevent.selector#day-%s-:checked ~ table label.timepoint.day-%s {

    background-color: #5f4;

    text-decoration: underline;

}

""" % (daystr, daystr, daystr, daystr))

        page.style.close()

    def show_calendar_participant_headings(self, group_types, group_sources, group_columns):

        """

        Show headings for the participants and other scheduling contributors,

        defined by 'group_types', 'group_sources' and 'group_columns'.

        """

        page = self.page

        page.colgroup(span=1, id="columns-timeslot")

        for group_type, columns in zip(group_types, group_columns):

            page.colgroup(span=max(columns, 1), id="columns-%s" % group_type)

        page.thead()

        page.tr()

        page.th("", class_="emptyheading")

        for group_type, source, columns in zip(group_types, group_sources, group_columns):

            page.th(source,

                class_=(group_type == "request" and "requestheading" or "participantheading"),

                colspan=max(columns, 1))

        page.tr.close()

        page.thead.close()

    def show_calendar_days(self, days, partitioned_groups, partitioned_group_types, group_columns):

        """

        Show calendar days, defined by a collection of 'days', the contributing

        period information as 'partitioned_groups' (partitioned by day), the

        'partitioned_group_types' indicating the kind of contribution involved,

        and the 'group_columns' defining the number of columns in each group.

        """

        page = self.page

        # Determine the number of columns required. Where participants provide

        # no columns for events, one still needs to be provided for the

        # participant itself.

        all_columns = sum([max(columns, 1) for columns in group_columns])

        # Determine the days providing time slots.

        all_days = days.items()

        all_days.sort()

        # Produce a heading and time points for each day.

        for day, intervals in all_days:

            groups_for_day = [partitioned.get(day) for partitioned in partitioned_groups]

            is_empty = True

            for slots in groups_for_day:

                if not slots:

                    continue

                for active in slots.values():

                    if active:

                        is_empty = False

                        break

            page.thead(class_="separator%s" % (is_empty and " empty" or ""))

            page.tr()

            page.th(class_="dayheading container", colspan=all_columns+1)

            self._day_heading(day)

            page.th.close()

            page.tr.close()

            page.thead.close()

            page.tbody(class_="points%s" % (is_empty and " empty" or ""))

            self.show_calendar_points(intervals, groups_for_day, partitioned_group_types, group_columns)

            page.tbody.close()

    def show_calendar_points(self, intervals, groups, group_types, group_columns):

        """

        Show the time 'intervals' along with period information from the given

        'groups', having the indicated 'group_types', each with the number of

        columns given by 'group_columns'.

        """

        page = self.page

        # Obtain the user's timezone.

        tzid = self.get_tzid()

        # Produce a row for each interval.

        intervals = list(intervals)

        intervals.sort()

        for point, endpoint in intervals:

            continuation = point.point == get_start_of_day(point.point, tzid)

            # Some rows contain no period details and are marked as such.

            have_active = False

            have_active_request = False

            for slots, group_type in zip(groups, group_types):

                if slots and slots.get(point):

                    if group_type == "request":

                        have_active_request = True

                    else:

                        have_active = True

            # Emit properties of the time interval, where post-instant intervals

            # are also treated as busy.

            css = " ".join([

                "slot",

                (have_active or point.indicator == Point.REPEATED) and "busy" or \

                    have_active_request and "suggested" or "empty",

                continuation and "daystart" or ""

                ])

            page.tr(class_=css)

            if point.indicator == Point.PRINCIPAL:

                page.th(class_="timeslot")

                self._time_point(point, endpoint)

            else:

                page.th()

            page.th.close()

            # Obtain slots for the time point from each group.

            for columns, slots, group_type in zip(group_columns, groups, group_types):

                active = slots and slots.get(point)

                # Where no periods exist for the given time interval, generate

                # an empty cell. Where a participant provides no periods at all,

                # the colspan is adjusted to be 1, not 0.

                if not active:

                    self._empty_slot(point, endpoint, max(columns, 1))

                    continue

                slots = slots.items()

                slots.sort()

                spans = get_spans(slots)

                empty = 0

                # Show a column for each active period.

                for p in active:

                    # The period can be None, meaning an empty column.

                    if p:

                        # Flush empty slots preceding this one.

                        if empty:

                            self._empty_slot(point, endpoint, empty)

                            empty = 0

                        key = p.get_key()

                        span = spans[key]

                        # Produce a table cell only at the start of the period

                        # or when continued at the start of a day.

                        # Points defining the ends of instant events should

                        # never define the start of new events.

                        if point.indicator == Point.PRINCIPAL and (point.point == p.start or continuation):

                            has_continued = continuation and point.point != p.start

                            will_continue = not ends_on_same_day(point.point, p.end, tzid)

                            is_organiser = p.organiser == self.user

                            css = " ".join([

                                "event",

                                has_continued and "continued" or "",

                                will_continue and "continues" or "",

                                p.transp == "ORG" and "only-organising" or is_organiser and "organising" or "attending"

                                ])

                            # Only anchor the first cell of events.

                            # Need to only anchor the first period for a recurring

                            # event.

                            html_id = "%s-%s-%s" % (group_type, p.uid, p.recurrenceid or "")

                            if point.point == p.start and html_id not in self.html_ids:

                                page.td(class_=css, rowspan=span, id=html_id)

                                self.html_ids.add(html_id)

                            else:

                                page.td(class_=css, rowspan=span)

                            # Only link to events if they are not being

                            # updated by requests.

                            if not p.summary or (p.uid, p.recurrenceid) in self._get_requests() and group_type != "request":

                                page.span(p.summary or "(Participant is busy)")

                            else:

                                page.a(p.summary, href=self.link_to(p.uid, p.recurrenceid))

                            page.td.close()

                    else:

                        empty += 1

                # Pad with empty columns.

                empty = columns - len(active)

                if empty:

                    self._empty_slot(point, endpoint, empty)

            page.tr.close()

    def _day_heading(self, day):

        """

        Generate a heading for 'day' of the following form:

        <label class="day day-20150203" for="day-20150203">Tuesday, 3 February 2015</label>

        """

        page = self.page

        daystr = format_datetime(day)

        value, identifier = self._day_value_and_identifier(day)

        page.label(self.format_date(day, "full"), class_="day day-%s" % daystr, for_=identifier)

    def _time_point(self, point, endpoint):

        """

        Generate headings for the 'point' to 'endpoint' period of the following

        form:

        <label class="timepoint day-20150203" for="slot-20150203T090000-20150203T100000">09:00:00 CET</label>

        <span class="endpoint">10:00:00 CET</span>

        """

        page = self.page

        tzid = self.get_tzid()

        daystr = format_datetime(point.point.date())

        value, identifier = self._slot_value_and_identifier(point, endpoint)

        slots = self.env.get_args().get("slot", [])

        self._slot_selector(value, identifier, slots)

        page.label(self.format_time(point.point, "long"), class_="timepoint day-%s" % daystr, for_=identifier)

        page.span(self.format_time(endpoint and endpoint.point or get_end_of_day(point.point, tzid), "long"), class_="endpoint")

    def _slot_selector(self, value, identifier, slots):

        """

        Provide a timeslot control having the given 'value', employing the

        indicated HTML 'identifier', and using the given 'slots' collection

        to select any control whose 'value' is in this collection, unless the

        "reset" request parameter has been asserted.

        """

        reset = self.env.get_args().has_key("reset")

        page = self.page

        if not reset and value in slots:

            page.input(name="slot", type="checkbox", value=value, id=identifier, class_="newevent selector", checked="checked")

        else:

            page.input(name="slot", type="checkbox", value=value, id=identifier, class_="newevent selector")

    def _empty_slot(self, point, endpoint, colspan):

        """

        Show an empty slot cell for the given 'point' and 'endpoint', with the

        given 'colspan' configuring the cell's appearance.

        """

        page = self.page

        page.td(class_="empty%s" % (point.indicator == Point.PRINCIPAL and " container" or ""), colspan=colspan)

        if point.indicator == Point.PRINCIPAL: