# vim: set filencoding=utf8
"""
Exchange Commands

@author: Mike Crute (mcrute@gmail.com)
@date: November 10, 2008

This is a set of classes that starts to define a set of classes for
fetching data using Exchange's WebDAV API. This is still pretty
development code but it does the trick. Watch out, it doesn't consider
many corner cases.
"""

import xml.etree.cElementTree as ElementTree
import dateutil.parser as date_parser

from httplib import HTTPSConnection
from string import Template
from datetime import datetime, timedelta
from icalendar import Calendar, Event as _Event, Alarm
from exchange import ExchangeException, EST


class ExchangeCommand(object):
    """
    Base class for Exchange commands. This really shouldn't be constructed
    directly but should be subclassed to do useful things.
    """

    #: Base URL for Exchange commands.
    BASE_URL = Template("/exchange/${username}/${method}")

    #: Basic headers that are required for all requests
    BASE_HEADERS = {
       "Content-Type": 'text/xml; charset="UTF-8"',
       "Depth": "0",
       "Translate": "f",
       }

    def __init__(self, session):
        self.server = session.server
        self.session = session

    def _get_xml(self, **kwargs):
        """
        Try to get an XML response from the server.
        @return: ElementTree response
        """
        kwargs["username"] = self.session.username

        xml = self._get_query(**kwargs)
        url = self.BASE_URL.substitute({ "username": self.session.username,
                                         "method": self.exchange_method })
        query = Template(xml).substitute(kwargs)
        send_headers = self.BASE_HEADERS.copy()
        send_headers['Cookie'] = self.session.token

        conn = HTTPSConnection(self.server)
        conn.request(self.dav_method.upper(), url, query, headers=send_headers)
        resp = conn.getresponse()

        if int(resp.status) > 299 or int(resp.status) < 200:
            raise ExchangeException("%s %s" % (resp.status, resp.reason))

        return ElementTree.fromstring(resp.read())

    def _get_query(self, **kwargs):
        """
        Build up the XML query for the server. Mostly just does a lot
        of template substitutions, also does a little bit of elementtree
        magic to to build the XML query.
        """
        declaration = ElementTree.ProcessingInstruction("xml", 'version="1.0"')

        request = ElementTree.Element("g:searchrequest", { "xmlns:g": "DAV:" })
        query = ElementTree.SubElement(request, "g:sql")
        query.text = Template(self.sql).substitute(kwargs)

        output = ElementTree.tostring(declaration)
        output += ElementTree.tostring(request)

        return output


class Event(_Event):

    def add_alarm(self, alarm_offset):
        alarm = Alarm()
        alarm.add("action", "DISPLAY")
        alarm.add("description", "REMINDER")
        alarm.add("trigger", timedelta(minutes=alarm_offset))
        self.add_component(alarm)

    def _get_element_text(self, element, key):
        value = element.find(key)

        if hasattr(value, 'text'):
            return value.text

    def add_text(self, element, key, add_as=None):
        value = self._get_element_text(element, key)

        add_as = key if not add_as else add_as
        self.add(add_as, value)

    def add_date(self, element, key, add_as=None):
        value = date_parser.parse(self._get_element_text(element, key))

        add_as = key if not add_as else add_as
        self.add(add_as, value)


class FetchCalendar(ExchangeCommand):
    exchange_method = "calendar"
    dav_method = "search"

    sql = """
        SELECT
            PidLidAllAttendeesString                 AS attendees,
            "urn:schemas:calendar:location"          AS location,
            "urn:schemas:calendar:organizer"         AS organizer,
            "urn:schemas:calendar:meetingstatus"     AS status,
            "urn:schemas:httpmail:normalizedsubject" AS subject,
            "urn:schemas:calendar:dtstart"           AS start_date,
            "urn:schemas:calendar:dtend"             AS end_date,
            "urn:schemas:calendar:timezone"          AS timezone_info,
            "urn:schemas:httpmail:textdescription"   AS description
        FROM
            Scope('SHALLOW TRAVERSAL OF "/exchange/${username}/calendar/"')
        WHERE
            NOT "urn:schemas:calendar:instancetype" = 1
            AND "DAV:contentclass" = 'urn:content-classes:appointment'
        ORDER BY
            "urn:schemas:calendar:dtstart" ASC
        """

    def execute(self, alarms=True, alarm_offset=15, **kwargs):
        exchange_xml = self._get_xml(**kwargs)
        calendar = Calendar()

        for item in exchange_xml.getchildren():
            item = item.find("{DAV:}propstat").find("{DAV:}prop")

            event = Event()
            event.add_text(item, 'subject', add_as='summary')
            event.add_text(item, 'location')
            event.add_text(item, 'description')
            event.add_date(item, 'start_date', add_as='dtstart')
            event.add_date(item, 'end_date', add_as='dtend')

            # TODO: Handle timezone_info
            # TODO: Handle alarms. Previous implementation didn't work

            calendar.add_component(event)

        return calendar