"""
Maven2 Site Plugin APT(almost plain text) document tree Writer.
"""

__docformat__ = 'reStructuredText'

import sys
import os
import os.path
import time
import re
import docutils
from docutils import frontend, nodes, utils, writers, languages
from docutils.transforms import writer_aux


class Writer(writers.Writer):

    supported = ('apt')
    """Formats this writer supports."""

    settings_defaults = {'output_encoding_error_handler': 'xmlcharrefreplace'}

    relative_path_settings = ('stylesheet_path',)

    config_section = 'm2apt writer'
    config_section_dependencies = ('writers',)

    def get_transforms(self):
        #return writers.Writer.get_transforms(self) + [writer_aux.Admonitions]
        return writers.Writer.get_transforms(self)

    def __init__(self):
        writers.Writer.__init__(self)
        #self.translator_class = HTMLTranslator
        self.translator_class = Maven2AptTranslator
        self.title = ""

    def translate(self):
        self.visitor = visitor = self.translator_class(self.document)
        self.document.walkabout(visitor)

        self.output = ''.join(getattr(visitor, 'text'))

        # for development
        self.output = self.output.encode('big5')


class Maven2AptTranslator(nodes.GenericNodeVisitor):

    def __init__(self, document):
        nodes.NodeVisitor.__init__(self, document)
        self.text = []
        self.__in_section = False
        self.__in_title = False
        self.__in_note = False
        self.__in_literal_block = False
        self.__after_topic = False
        self.__bullet_list = False
        self.__enumerated_list = False
        self.__list_item_count = 0
        self.__ref_table = {}

        self.__indent_count = 1

    def indentString(self):
        ind = ''
        for i in range(self.__indent_count):
            ind += "\t"
        return ind

    def appendLn(self, str = ""):
        self.append(str+"\n")

    def append(self, str = ''):
        self.text.append(str)

    def appendNodeLn(self, node, encoding = None):
        self.appendNode(node, encoding, True)

    def appendNode(self, node, encoding = None, newLine = False):
        text = node.astext()
        if newLine:
            text += "\n"
        self.text.append(text)

    def default_visit(self, node):
        print node.__class__
        pass

    def default_departure(self, node):
        print "L: ", node.__class__
        pass

    def depart_topic(self, node):
        self.__after_topic = True

    def visit_section(self, node):
        self.__in_section = True

    def depart_section(self, node):
        self.__in_section = False

    def visit_paragraph(self, node):
        self.__indent_count += 1

    def depart_paragraph(self, node):
        self.__indent_count -= 1
        self.appendLn("")
        self.appendLn("")

    def visit_bullet_list(self, node):
        self.__indent_count += 1
        self.__bullet_list = True

    def depart_bullet_list(self, node):
        self.__indent_count -= 1
        self.__bullet_list = False

    def visit_enumerated_list(self, node):
        self.__indent_count += 1
        self.__enumerated_list = True

    def depart_enumerated_list(self, node):
        self.__indent_count -= 1
        self.__enumerated_list = False
        self.__list_item_count = 0

    def visit_list_item(self, node):
        if self.__after_topic and not self.__in_title:
            if self.__enumerated_list:
                self.__list_item_count += 1
                self.append(self.indentString())
                self.append(" [[%s]] " % (self.__list_item_count))

            if self.__bullet_list:
                self.append(self.indentString())
                self.append(" * ")

    def depart_list_item(self, node):
        self.appendLn("")

    def visit_Text(self, node):
        if self.__ref_table.has_key(node.astext()):
            self.append("{{{%s}%s}}" % (self.__ref_table[node.astext()], node.astext()))
            return

        if self.__in_literal_block:
            self.appendNode(node)
            return

        if self.__in_note:
            for i in node.astext().split("[\r\n]+"):
                self.append(" " + i)
            # this return is important. prevent node text from re-printing
            return

        if self.__after_topic and not self.__in_title:
            self.append(self.indentString())
            for i in node.astext().split("[\r\n]+"):
                self.append(" " + i)

    def visit_title(self, node):
        self.__in_title = True

        if self.__in_section:
            self.appendLn()
            self.appendLn()
            self.appendNodeLn(node)
            self.appendLn()

    def depart_title(self, node):
        self.__in_title = False

    def visit_strong(self, node):
        self.append(' <<')

    def depart_strong(self, node):
        self.append('>>')

    def visit_emphasis(self, node):
        self.append(' <')

    def depart_emphasis(self, node):
        self.append('>')

    def visit_note(self, node):
        self.__in_note = True
        self.appendLn("")
        self.append(self.indentString())
        self.append("[NOTE] ")

    def depart_note(self, node):
        self.__in_note = False

    def visit_literal_block(self, node):
        self.__in_literal_block = True
        self.appendLn("")
        self.appendLn("+-----------------------------------------+")

    def depart_literal_block(self, node):
        self.__in_literal_block = False
        self.appendLn("")
        self.appendLn("+-----------------------------------------+")

    def visit_reference(self, node):
        name = None
        uri = None

        for k, v in node.attlist():
            if k == "name":
                name = v
            if k == "refuri":
                uri = v
        if uri is not None:
            self.__ref_table[name] = uri
        pass