# -*- coding: iso-8859-1 -*-

"""

    MoinMoin - SendMessage Action

    @copyright: 2012, 2013 by Paul Boddie <paul@boddie.org.uk>

    @license: GNU GPL (v2 or later), see COPYING.txt for details.

"""

from MoinMoin.action import ActionBase, AttachFile

from MoinMoin.formatter import text_html

from MoinMoin.log import getLogger

from MoinMoin.Page import Page

from MoinMoin import config

from MoinMessage import GPG, MoinMessageError, Message, sendMessage

from MoinSupport import *

from MoinMoin.wikiutil import escape, MimeType, parseQueryString, \

                              taintfilename, getInterwikiHomePage

from email.mime.base import MIMEBase

from email.mime.image import MIMEImage

from email.mime.multipart import MIMEMultipart

from email.mime.text import MIMEText

from os.path import abspath, exists, join

import urllib

try:

    from MoinMoin.web import static

    htdocs = abspath(join(static.__file__, "htdocs"))

except ImportError:

    htdocs = None

Dependencies = []

def get_htdocs(request):

    "Use the 'request' to find the htdocs directory."

    global htdocs

    if not htdocs:

        htdocs_in_cfg = getattr(request.cfg, "moinmessage_static_files", None)

        if htdocs_in_cfg and exists(htdocs_in_cfg):

            htdocs = htdocs_in_cfg

            return htdocs

        htdocs_in_data = abspath(join(request.cfg.data_dir, "../htdocs"))

        if exists(htdocs_in_data):

            htdocs = htdocs_in_data

            return htdocs

    return htdocs

class SendMessage(ActionBase, ActionSupport):

    "An action that can send a message to another site."

    def get_form_html(self, buttons_html):

        "Present an interface for message sending."

        _ = self._

        request = self.request

        form = self.get_form()

        message = form.get("message", [""])[0]

        recipient = form.get("recipient", [""])[0]

        format = form.get("format", ["wiki"])[0]

        preview = form.get("preview")

        queue = form.get("queue")

        # Get a list of potential recipients.

        recipients = self.get_recipients()

        # Prepare the recipients list, selecting the specified recipients.

        recipients_list = []

        if recipients:

            recipients_list += self.get_option_list(recipient, recipients) or []

        recipients_list.sort()

        # Prepare any preview.

        parser_cls = getParserClass(request, format)

        request.formatter.setPage(self.page)

        preview_output = preview and formatText(message, request, request.formatter, inhibit_p=False, parser_cls=parser_cls) or ""

        # Fill in the fields and labels.

        d = {

            "buttons_html"          : buttons_html,

            "format_label"          : escape(_("Message format")),

            "format"                : escattr(format),

            "recipient_label"       : escape(_("Recipient")),

            "recipients_list"       : "\n".join(recipients_list),

            "message_label"         : escape(_("Message text")),

            "message_default"       : escape(message),

            "preview_label"         : escattr(_("Preview message")),

            "preview_output"        : preview_output,

            "queue_label"           : escape(_("Queue message for sending")),

            "queue_checked"         : queue and 'checked="checked" ' or "",

            }

        # Prepare the output HTML.

        html = '''

<table>

    <tr>

        <td class="label"><label>%(recipient_label)s</label></td>

        <td>

            <select name="recipient">

                %(recipients_list)s

            </select>

        </td>

    </tr>

    <tr>

        <td class="label"><label>%(format_label)s</label></td>

        <td>

            <input name="format" type="text" value="%(format)s" size="20" />

        </td>

    </tr>

    <tr>

        <td class="label"><label>%(message_label)s</label></td>

        <td>

            <textarea name="message" cols="60" rows="10">%(message_default)s</textarea>

        </td>

    </tr>

    <tr>

        <td></td>

        <td class="buttons">

            <input name="preview" type="submit" value="%(preview_label)s" />

        </td>

    </tr>

    <tr>

        <td></td>

        <td class="moinmessage-preview">

%(preview_output)s

        </td>

    </tr>

    <tr>

        <td class="label"><label>%(queue_label)s</label></td>

        <td>

            <input name="queue" type="checkbox" value="true" %(queue_checked)s/>

        </td>

    <tr>

        <td></td>

        <td class="buttons">

            %(buttons_html)s

        </td>

    </tr>

</table>''' % d

        return html

    def do_action(self):

        "Attempt to send the message."

        _ = self._

        request = self.request

        form = self.get_form()

        text = form.get("message", [None])[0]

        recipient = form.get("recipient", [None])[0]

        format = form.get("format", ["wiki"])[0]

        queue = form.get("queue")

        if not text:

            return 0, _("A message must be given.")

        if not recipient:

            return 0, _("A recipient must be given.")

        homedir = self.get_homedir()

        if not homedir:

            return 0, _("MoinMessage has not been set up: a GPG homedir is not defined.")

        gpg = GPG(homedir)

        # Construct a message from the request.

        message = Message()

        container = MIMEMultipart("related")

        container["Update-Action"] = "store"

        container["To"] = recipient

        # Add the message body and any attachments.

        parser_cls = getParserClass(request, format)

        # Determine whether alternative output types are produced and, if so,

        # bundle them in a multipart/alternative part.

        output_types = getParserOutputTypes(parser_cls)

        if len(output_types) > 1:

            alternatives = MIMEMultipart("alternative")

            container.attach(alternatives)

        else:

            alternatives = container

        # Produce each of the representations.

        for output_type in output_types:

            # HTML must be processed to identify attachments.

            if output_type == "text/html":

                fmt = OutgoingHTMLFormatter(request)

                fmt.setPage(request.page)

                body = formatText(text, request, fmt, inhibit_p=False, parser_cls=parser_cls)

            else:

                body = formatTextForOutputType(text, request, parser_cls, output_type)

            maintype, subtype = output_type.split("/", 1)

            if maintype == "text":

                part = MIMEText(body.encode("utf-8"), subtype, "utf-8")

            else:

                part = MIMEBase(maintype, subtype)

                part.set_payload(body)

            alternatives.attach(part)

        # Produce any identified attachments.

        for pos, (path, filename) in enumerate(fmt.attachments):

            # Obtain the attachment content.

            f = open(path, "rb")

            try:

                body = f.read()

            finally:

                f.close()

            # Determine the attachment type.

            mimetype = MimeType(filename=filename)

            # NOTE: Support a limited set of explicit part types for now.

            if mimetype.major == "image":

                part = MIMEImage(body, mimetype.minor, **mimetype.params)

            elif mimetype.major == "text":

                part = MIMEText(body, mimetype.minor, mimetype.charset, **mimetype.params)

            else:

                part = MIMEApplication(body, mimetype.minor, **mimetype.params)

            # Label the attachment and include it in the message.

            part["Content-ID"] = "attachment%d" % pos

            container.attach(part)

        message.add_update(container)

        # Get the sender details for signing messages.

        # This is not the same as the details for authenticating users in the

        # PostMessage action since the fingerprints refer to public keys.

        signing_users = self.get_signing_users()

        signer = signing_users and signing_users.get(request.user.name)

        # Get the recipient details.

        recipients = self.get_recipients()

        if not recipients:

            return 0, _("No recipients page is defined for MoinMessage.")

        recipient_details = recipients.get(recipient)

        if not recipient_details:

            return 0, _("The specified recipient is not present in the list of known contacts.")

        parameters = parseDictEntry(recipient_details, ("fingerprint",))

        if not parameters.has_key("page") and not parameters.has_key("url"):

            return 0, _("The recipient details are missing a location for sent messages.")

        if parameters.has_key("url") and not parameters.has_key("fingerprint"):

            return 0, _("The recipient details are missing a fingerprint for sending messages.")

        # Sign, encrypt and send the message.

        message = message.get_payload()

        if not queue and parameters.has_key("url"):

            try:

                if signer:

                    message = gpg.signMessage(message, signer)

                message = gpg.encryptMessage(message, parameters["fingerprint"])

                sendMessage(message, parameters["url"])

            except MoinMessageError, exc:

                return 0, "%s: %s" % (_("The message could not be prepared and sent"), exc)

        # Or queue the message on the specified page.

        elif parameters.has_key("page"):

            page = Page(request, parameters["page"])

            outbox = ItemStore(page, "messages", "message-locks")

            outbox.append(message.as_string())

        # Or queue the message in a special outbox.

        else:

            outbox = ItemStore(request.page, "outgoing-messages", "outgoing-message-locks")

            outbox.append(message.as_string())

        return 1, _("Message sent!")

    def get_homedir(self):

        "Locate the GPG home directory."

        return getattr(self.request.cfg, "moinmessage_gpg_homedir")

    def get_recipients(self):

        """

        Return the recipients dictionary by first obtaining the page in which it

        is stored. This page may either be a subpage of the user's home page, if

        stored on this wiki, or it may be relative to the site root.

        The name of the subpage is defined by the configuration setting

        'moinmessage_gpg_recipients_page', which if absent is set to

        "MoinMessageRecipientsDict".

        """

        request = self.request

        subpage = getattr(request.cfg, "moinmessage_gpg_recipients_page", "MoinMessageRecipientsDict")

        homedetails = getInterwikiHomePage(request)

        if homedetails:

            homewiki, homepage = homedetails

            if homewiki == "Self":

                recipients = getWikiDict("%s/%s" % (homepage, subpage), request)

                if recipients:

                    return recipients

        return getWikiDict(subpage, request)

    def get_signing_users(self):

        return getWikiDict(

            getattr(self.request.cfg, "moinmessage_gpg_signing_users_page", "MoinMessageSigningUserDict"),

            self.request)

# Special message formatters.

def unquoteWikinameURL(url, charset=config.charset):

    """

    The inverse of wikiutil.quoteWikinameURL, returning the page name referenced

    by the given 'url', with the page name assumed to be encoded using the given

    'charset' (or default charset if omitted).

    """

    return unicode(urllib.unquote(url), encoding=charset)

def getAttachmentFromURL(url, request):

    """

    Return a (full path, attachment filename) tuple for the attachment

    referenced by the given 'url', using the 'request' to interpret the

    structure of 'url'.

    If 'url' does not refer to an attachment on this wiki, None is returned.

    """

    # Detect static resources.

    htdocs_dir = get_htdocs(request)

    if htdocs_dir:

        prefix = request.cfg.url_prefix_static

        # Normalise the 

        if not prefix.endswith("/"):

            prefix += "/"

        if url.startswith(prefix):

            filename = url[len(prefix):]

            # Obtain the resource path.

            path = abspath(join(htdocs_dir, filename))

            if exists(path):

                return path, taintfilename(filename)

    # Detect attachments and other resources.

    script = request.getScriptname()

    # Normalise the URL.

    if not script.endswith("/"):

        script += "/"

    # Reject URLs outside the wiki.

    if not url.startswith(script):

        return None

    path = url[len(script):].lstrip("/")

    try:

        qpagename, qs = path.split("?", 1)

    except ValueError:

        qpagename = path

        qs = None

    pagename = unquoteWikinameURL(qpagename)

    qs = qs and parseQueryString(qs) or {}

    filename = qs.get("target") or qs.get("drawing")

    filename = taintfilename(filename)

    # Obtain the attachment path.

    path = AttachFile.getFilename(request, pagename, filename)

    return path, filename

class OutgoingHTMLFormatter(text_html.Formatter):

    """

    Handle outgoing HTML content by identifying attachments and rewriting their

    locations. References to bundled attachments are done using RFC 2111:

    https://tools.ietf.org/html/rfc2111

    Messages employing references between parts are meant to comply with RFC

    2387:

    https://tools.ietf.org/html/rfc2387

    """

    def __init__(self, request, **kw):

        text_html.Formatter.__init__(self, request, **kw)

        self.attachments = []

    def add_attachment(self, location):

        details = getAttachmentFromURL(location, self.request)

        if details:

            pos = len(self.attachments)

            self.attachments.append(details)

            return "cid:attachment%d" % pos

        else:

            return None

    def image(self, src=None, **kw):

        src = src or kw.get("src")

        ref = src and self.add_attachment(src)

        return text_html.Formatter.image(self, ref or src, **kw)

    def transclusion(self, on, **kw):

        if on:

            data = kw.get("data")

            kw["data"] = data and self.add_attachment(data)

        return text_html.Formatter.transclusion(self, on, **kw)

# Action function.

def execute(pagename, request):

    SendMessage(pagename, request).render()

# vim: tabstop=4 expandtab shiftwidth=4