#!/usr/bin/env python

"""

Common resource functionality for Web calendar clients.

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.client import Client

from imiptools.data import get_uri, get_window_end, Object, uri_values

from imiptools.dates import format_datetime, format_time

from imiptools.period import FreeBusyPeriod, \

                             remove_period, remove_affected_period, update_freebusy

from imipweb.env import CGIEnvironment

import babel.dates

import imip_store

import markup

class Resource(Client):

    "A Web application resource and calendar client."

    def __init__(self, resource=None):

        self.encoding = "utf-8"

        self.env = CGIEnvironment(self.encoding)

        user = self.env.get_user()

        Client.__init__(self, user and get_uri(user) or None)

        self.locale = None

        self.requests = None

        self.out = resource and resource.out or self.env.get_output()

        self.page = resource and resource.page or markup.page()

        self.html_ids = None

        self.store = imip_store.FileStore()

        self.objects = {}

        try:

            self.publisher = imip_store.FilePublisher()

        except OSError:

            self.publisher = None

    # Presentation methods.

    def new_page(self, title):

        self.page.init(title=title, charset=self.encoding, css=self.env.new_url("styles.css"))

        self.html_ids = set()

    def status(self, code, message):

        self.header("Status", "%s %s" % (code, message))

    def header(self, header, value):

        print >>self.out, "%s: %s" % (header, value)

    def no_user(self):

        self.status(403, "Forbidden")

        self.new_page(title="Forbidden")

        self.page.p("You are not logged in and thus cannot access scheduling requests.")

    def no_page(self):

        self.status(404, "Not Found")

        self.new_page(title="Not Found")

        self.page.p("No page is provided at the given address.")

    def redirect(self, url):

        self.status(302, "Redirect")

        self.header("Location", url)

        self.new_page(title="Redirect")

        self.page.p("Redirecting to: %s" % url)

    def link_to(self, uid, recurrenceid=None):

        if recurrenceid:

            return self.env.new_url("/".join([uid, recurrenceid]))

        else:

            return self.env.new_url(uid)

    # Access to objects.

    def _suffixed_name(self, name, index=None):

        return index is not None and "%s-%d" % (name, index) or name

    def _simple_suffixed_name(self, name, suffix, index=None):

        return index is not None and "%s-%s" % (name, suffix) or name

    def _get_identifiers(self, path_info):

        parts = path_info.lstrip("/").split("/")

        if len(parts) == 1:

            return parts[0], None

        else:

            return parts[:2]

    def _get_object(self, uid, recurrenceid=None):

        if self.objects.has_key((uid, recurrenceid)):

            return self.objects[(uid, recurrenceid)]

        fragment = uid and self.store.get_event(self.user, uid, recurrenceid) or None

        obj = self.objects[(uid, recurrenceid)] = fragment and Object(fragment)

        return obj

    def _get_recurrences(self, uid):

        return self.store.get_recurrences(self.user, uid)

    def _get_requests(self):

        if self.requests is None:

            cancellations = self.store.get_cancellations(self.user)

            requests = set(self.store.get_requests(self.user))

            self.requests = requests.difference(cancellations)

        return self.requests

    def _get_request_summary(self):

        summary = []

        for uid, recurrenceid in self._get_requests():

            obj = self._get_object(uid, recurrenceid)

            if obj:

                periods = obj.get_periods_for_freebusy(self.get_tzid(), self.get_window_end())

                recurrenceids = self._get_recurrences(uid)

                # Convert the periods to more substantial free/busy items.

                for p in periods:

                    # Subtract any recurrences from the free/busy details of a

                    # parent object.

                    if recurrenceid or p.start not in recurrenceids:

                        summary.append(

                            FreeBusyPeriod(

                                p.start, p.end, uid,

                                obj.get_value("TRANSP"),

                                recurrenceid,

                                obj.get_value("SUMMARY"),

                                obj.get_value("ORGANIZER")

                                ))

        return summary

    # Preference methods.

    def get_user_locale(self):

        if not self.locale:

            self.locale = self.get_preferences().get("LANG", "en")

        return self.locale

    # Prettyprinting of dates and times.

    def format_date(self, dt, format):

        return self._format_datetime(babel.dates.format_date, dt, format)

    def format_time(self, dt, format):

        return self._format_datetime(babel.dates.format_time, dt, format)

    def format_datetime(self, dt, format):

        return self._format_datetime(

            isinstance(dt, datetime) and babel.dates.format_datetime or babel.dates.format_date,

            dt, format)

    def _format_datetime(self, fn, dt, format):

        return fn(dt, format=format, locale=self.get_user_locale())

    # Data management methods.

    def remove_request(self, uid, recurrenceid=None):

        return self.store.dequeue_request(self.user, uid, recurrenceid)

    def remove_event(self, uid, recurrenceid=None):

        return self.store.remove_event(self.user, uid, recurrenceid)

    def update_freebusy(self, uid, recurrenceid, obj):

        """

        Update stored free/busy details for the event with the given 'uid' and

        'recurrenceid' having a representation of 'obj'.

        """

        is_only_organiser = self.user not in uri_values(obj.get_values("ATTENDEE"))

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

        update_freebusy(freebusy,

            obj.get_periods_for_freebusy(self.get_tzid(), self.get_window_end()),

            is_only_organiser and "ORG" or obj.get_value("TRANSP"),

            uid, recurrenceid,

            obj.get_value("SUMMARY"),

            obj.get_value("ORGANIZER"))

        # Subtract any recurrences from the free/busy details of a parent

        # object.

        for recurrenceid in self._get_recurrences(uid):

            remove_affected_period(freebusy, uid, recurrenceid)

        self.store.set_freebusy(self.user, freebusy)

        if self.publisher:

            self.publisher.set_freebusy(self.user, freebusy)

    def remove_from_freebusy(self, uid, recurrenceid=None):

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

        remove_period(freebusy, uid, recurrenceid)

        self.store.set_freebusy(self.user, freebusy)

# vim: tabstop=4 expandtab shiftwidth=4