#!/usr/bin/env python

"""

Graphviz serialiser, generating content for embedding in HTML documents.

Copyright (C) 2018, 2019, 2022, 2023 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, IMAGE_FORMATS, \

                                      get_output_identifier

from moinformat.utils.links import LinkTarget

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

    input_formats = ["graphviz", "dot"]

    formats = ["html"]

    def init(self):

        self.directives = {}

    def start_block(self):

        pass

    def end_block(self):

        pass

    def directive(self, directive):

        if not self.directives.has_key(directive.key):

            self.directives[directive.key] = []

        self.directives[directive.key].append(directive.value)

    def text(self, text):

        self.process_graph(text.s)

    # Special methods for graph production.

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

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

        for key, value in attributes.items():

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

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

    def image(self, target, attributes):

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

    def object(self, target, attributes):

        self._tag("object", "data", target, 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", [])

        # Add transforms if appropriate.

        # NOTE: Maybe move this to the Graphviz class itself.

        document_index = self.metadata.get("document_index")

        if document_index and "fixlinks" not in transforms:

            transforms.insert(0, "fixlinks")

        # Determine the inline status, with only SVG being appropriate.

        inline = format == "svg" and not self.metadata.get("no_inline")

        # Non-inline graph output is stored for a known page only.

        pagename = self.metadata.get("pagename")

        if not inline:

            if not pagename:

                return

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

            identifier = get_output_identifier(text)

            attachment = "%s.%s" % (identifier, format)

            filename = self.output.get_attachment_filename(pagename, attachment)

            # Handle situations where no independent output is permitted.

            if not filename:

                return

            # Make sure that page attachments can be stored.

            self.output.ensure_attachments(pagename)

            link = self.linker.translate(LinkTarget("attachment", attachment,

                                                    pagename=pagename))

        # No filename is defined for inline output.

        else:

            filename = None

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

        graphviz.call(format, transforms, filename, self.metadata)

        # 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(link.get_target(), attributes)

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

        elif not inline:

            self.object(link.get_target(), attributes)

        # Or for inline output, emit it in the document itself.

        else:

            self.out(graphviz.get_inline_output())

serialiser = HTMLGraphvizSerialiser

# vim: tabstop=4 expandtab shiftwidth=4