#!/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_parts

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

                             get_scale, get_slots, get_spans, partition_by_day, Point

from imipweb.resource import ResourceClient

class CalendarPage(ResourceClient):

    "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()

        for key in args.keys():

            if key.startswith("newevent-"):

                i = key[len("newevent-"):]

                break

        else:

            return

        # Create a new event using the available information.

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

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

        summary = args.get("summary-%s" % i, [None])[0]

        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("-", 1) + [None])[:2]

            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)

        user_attr = self.get_user_attributes()

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

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

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

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

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

        rwrite(("ORGANIZER", user_attr, self.user))

        cn_participants = uri_parts(filter(None, participants))

        participants = []

        for cn, participant in cn_participants:

            d = {"RSVP" : "TRUE", "PARTSTAT" : "NEEDS-ACTION"}

            if cn:

                d["CN"] = cn

            rwrite(("ATTENDEE", d, participant))

            participants.append(participant)

        if self.user not in participants:

            d = {"PARTSTAT" : "ACCEPTED"}

            d.update(user_attr)

            rwrite(("ATTENDEE", d, 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, request_type 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."

        self.new_page(title="Calendar")

        page = self.page

        handled = self.handle_newevent()

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

        if not freebusy:

            page.p("No events scheduled.")

            return

        # 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()

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

            # Get the time scale with start and end points.

            scale = get_scale(periods, tzid)

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

        page.p("Select days or periods for a new event.")

        # 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 newevent-with-periods")

        page.p.close()

        # Show the calendar itself.

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

        # End the form region.

        page.form.close()

    # More page fragment methods.

    def show_calendar_day_controls(self, day):

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

        page = self.page

        daystr, dayid = self._day_value_and_identifier(day)

        # 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")

        page.add("""\

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

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

    background-color: #5f4;

    text-decoration: underline;

}

""" % (dayid, dayid, dayid, dayid))

        page.style.close()

        # Generate controls to select days.

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

        value, identifier = self._day_value_and_identifier(day)

        self._slot_selector(value, identifier, slots)

    def show_calendar_interval_controls(self, day, intervals):

        "Show controls for the intervals provided by 'day' and 'intervals'."

        page = self.page

        daystr, dayid = self._day_value_and_identifier(day)

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

        l = []

        for point, endpoint in intervals:

            timestr, timeid = self._slot_value_and_identifier(point, endpoint)

            l.append("""\

input.newevent.selector#%s:checked ~ table#region-%s th#region-%s""" % (timeid, dayid, timeid))

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

        page.add(",\n".join(l))

        page.add(""" {

    background-color: #5f4;

    text-decoration: underline;

}

""")

        page.style.close()

        # Generate controls to select time periods.

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

        last = None

        # Produce controls for the intervals/slots. Where instants in time are

        # encountered, they are merged with the following slots, permitting the

        # selection of contiguous time periods. However, the identifiers

        # employed by controls corresponding to merged periods will encode the

        # instant so that labels may reference them conveniently.

        intervals = list(intervals)

        intervals.sort()

        for point, endpoint in intervals:

            # Merge any previous slot with this one, producing a control.

            if last:

                _value, identifier = self._slot_value_and_identifier(last, last)

                value, _identifier = self._slot_value_and_identifier(last, endpoint)

                self._slot_selector(value, identifier, slots)

            # If representing an instant, hold the slot for merging.

            if endpoint and point.point == endpoint.point:

                last = point

            # If not representing an instant, produce a control.

            else:

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

                self._slot_selector(value, identifier, slots)

                last = None

        # Produce a control for any unmerged slot.

        if last:

            _value, identifier = self._slot_value_and_identifier(last, last)

            value, _identifier = self._slot_value_and_identifier(last, endpoint)

            self._slot_selector(value, identifier, slots)

    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,

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

        the 'partitioned_group_sources' indicating the origin of each group, 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.

        i = 0

        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

            daystr, dayid = self._day_value_and_identifier(day)

            # Put calendar tables within elements for quicker CSS selection.

            page.div(class_="calendar")

            # Show the controls permitting day selection as well as the controls

            # configuring the new event display.

            self.show_calendar_day_controls(day)

            self.show_calendar_interval_controls(day, intervals)

            # Show an actual table containing the day information.

            page.table(cellspacing=5, cellpadding=5, class_="calendar %s" % (is_empty and " empty" or ""), id="region-%s" % dayid)

            page.caption(class_="dayheading container separator")

            self._day_heading(day)

            page.caption.close()

            self.show_calendar_participant_headings(partitioned_group_types, partitioned_group_sources, group_columns)

            page.tbody(class_="points")

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

            page.tbody.close()

            page.table.close()

            # Show a button for scheduling a new event.

            page.p(class_="newevent-with-periods")

            page.label("Summary:")

            page.input(name="summary-%d" % i, type="text")

            page.input(name="newevent-%d" % i, type="submit", value="New event", accesskey="N")

            page.p.close()

            page.div.close()

            i += 1

    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)

            # Produce a time interval heading, spanning two rows if this point

            # represents an instant.

            if point.indicator == Point.PRINCIPAL:

                timestr, timeid = self._slot_value_and_identifier(point, endpoint)

                page.th(class_="timeslot", id="region-%s" % timeid,

                    rowspan=(endpoint and point.point == endpoint.point and 2 or 1))

                self._time_point(point, endpoint)

                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.get_start() or continuation):

                            has_continued = continuation and point.point != p.get_start()

                            will_continue = not ends_on_same_day(point.point, p.get_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",