#!/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, \

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

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

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

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

        # configuring the new event display.

        self.show_calendar_day_controls(days)

        self.show_calendar_interval_controls(days)

        # Show a button for scheduling a new event.

        page.p(class_="controls")

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

        page.span("Select days or periods for a new event.", class_="newevent-no-periods")

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

        page.p.close()

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

        l = []

        for day in days:

            daystr, dayid = self._day_value_and_identifier(day)

            l.append("""\

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

input.newevent.selector#%s:checked ~ table label.timepoint.day-%s""" % (dayid, daystr, dayid, daystr))

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

        page.add(""" {

    background-color: #5f4;

    text-decoration: underline;

}

""")

        page.style.close()

    def show_calendar_interval_controls(self, days):

        "Show controls for the intervals provided by 'days'."

        page = self.page

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

        for day, intervals in days.items():

            for point, endpoint in intervals:

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

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

        l = []; l2 = []; l3 = []

        for day, intervals in days.items():

            for point, endpoint in intervals:

                daystr, dayid = self._day_value_and_identifier(day)

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

                l.append("""\

input.newevent.selector#%s:checked ~ p .newevent-no-periods,

input.newevent.selector#%s:checked ~ p .newevent-no-periods""" % (dayid, timeid))

                l2.append("""\

input.newevent.selector#%s:checked ~ p .newevent-with-periods,

input.newevent.selector#%s:checked ~ p .newevent-with-periods""" % (dayid, timeid))

                l3.append("""\

input.newevent.selector#%s:checked ~ table label.timepoint[for=%s]""" % (timeid, timeid))

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

        page.add(""" {

    display: none;

}""")

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

        page.add(""" {

    display: inline;

}

""")

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

        page.add(""" {

    background-color: #5f4;

    text-decoration: underline;

}

""")

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

                                ])

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

                                group_type != "request" and self._have_request(p.uid, p.recurrenceid, None, True):

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

                            # Link to counter-proposals.

                            elif group_type == "request" and self._have_request(p.uid, p.recurrenceid, "COUNTER", True):

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

                            # Link to requests and events (including ones for

                            # which counter-proposals exist).

                            else:

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

                            page.td.close()

                    else:

                        empty += 1