#!/usr/bin/env python

"""

Graphviz serialiser, generating content for embedding in HTML documents.

Copyright (C) 2018 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 moinformat.serialisers.common import Serialiser, escape_attr, escape_text

from moinformat.utils.graphviz import Graphviz, GraphvizError, IMAGE_FORMATS, \

                                      get_output_identifier

# Utility functions.

def select_keys(d, keys):

    "Select from 'd' the given 'keys'."

    if not d:

        return []

    out = {}

    for key in keys:

        if d.has_key(key):

            out[key] = d[key]

    return out

# The serialiser class.

class HTMLGraphvizSerialiser(Serialiser):

    "Serialisation of Graphviz regions."

    def init(self):

        self.directives = {}

    def start_block(self):

        pass

    def end_block(self):

        pass

    def directive(self, key, value):

        if not self.directives.has_key(key):

            self.directives[key] = []

        self.directives[key].append(value)

    def text(self, text):

        self.process_graph(text)

    # Special methods for graph production.

    def _tag(self, tagname, attrname, filename, attributes, closing):

        l = ["%s='%s'" % (attrname, escape_attr(filename))]

        for key, value in attributes.items():

            l.append("%s='%s'" % (key, value))

        self.out("<%s %s%s>" % (tagname, " ".join(l), closing and " /"))

    def image(self, filename, attributes):

        self._tag("img", "src", filename, attributes, True)

    def object(self, filename, attributes):

        self._tag("object", "data", filename, attributes, False)

        self.out("</object>")

    def raw(self, text):

        self.out(text)

    # Graph output preparation.

    def process_graph(self, text):

        "Process the graph 'text' using the known directives."

        filter = self.directives.get("filter", ["dot"])[0]

        format = self.directives.get("format", ["svg"])[0]

        transforms = self.directives.get("transform", [])

        # Get an identifier and usable filename to store the output.

        identifier = get_output_identifier(text)

        filename = self.output.get_filename(identifier)

        # Permit imagemaps only for image formats.

        if format in IMAGE_FORMATS:

            cmapx = self.directives.has_key("cmapx")

        # Configure Graphviz and invoke it.

        graphviz = Graphviz(filter, text, identifier)

        graphviz.call(format, transforms, filename)

        # Obtain any metadata.

        attributes = select_keys(graphviz.get_metadata(), ["width", "height"])

        # For image output, create a file directly and reference it.

        if format in IMAGE_FORMATS:

            # Produce, embed and reference an imagemap if requested.

            if cmapx:

                graphviz.call("cmapx")

                mapid = graphviz.get_metadata().get("id")

                if mapid:

                    self.raw(graphviz.get_output())

                    attributes["usemap"] = "#%s" % im_attributes["id"]

            self.image(filename, attributes)

        # For other output, create a file and embed the object.

        else:

            self.object(filename, attributes)

serialiser = HTMLGraphvizSerialiser

# vim: tabstop=4 expandtab shiftwidth=4