#

# The role of the verbatim parser is to encode properly from UTF-8 verbatim

# text to valid latin-1 text. Two goals must be met:

#

# - Just encode the characters, but don't escape latex characters like in normal

#   text. This is why a dedicated latex encoder is used.

# - When the characters are translated to macros, escape the whole sequence

#   to allow tex execute the macro embedded in verbatim text.

# - When the escape sequence is required, update the listing environment options

#   if necessary.

#

import re

from io import open

from dbtexmf.dblatex.texcodec import TexCodec

from dbtexmf.dblatex.texcodec import tex_handler_counter

from dbtexmf.dblatex.rawparse import RawUtfParser

class VerbCodec(TexCodec):

    def __init__(self, pre, post, errors="verbtex",

                 input_encoding="utf8", output_encoding="latin-1"):

        self.pre = pre

        self.post = post

        self.output_encoding = output_encoding

        TexCodec.__init__(self, input_encoding, output_encoding,

                          errors=errors, pre=pre, post=post)

    def decode(self, text):

        global tex_handler_counter

        ntext = TexCodec.decode(self, text)

        if self.output_encoding != "utf8":

            return ntext

        # Funnily listings cannot handle unicode characters greater than 255.

        # The loop just escapes them by wrapping with 
 and <post> and

        # emulates the corresponding encoding exception

        text = ""

        n = tex_handler_counter[self._errors]

        for c in ntext:

            if ord(c) > 255:

                c = self.pre + c + self.post

                n += 1

            text += c

        tex_handler_counter[self._errors] = n

        return text

class VerbParser:

    def __init__(self, output_encoding="latin-1"):

        # The listing environment can be different from 'lstlisting'

        # but the rule is that it must begin with 'lst'

        self.start_re = re.compile(br"\\begin{lst[^}]*}")

        self.stop_re = re.compile(br"\\end{lst[^}]*}")

        self.esc_re = re.compile(br"escapeinside={([^}]*)}{([^}]*)}")

        self.block = b""

        self.encoding = output_encoding

        self.default_esc_start = b"<:"

        self.default_esc_stop = b":>"

        self.default_codec = VerbCodec(self.default_esc_start,

                                       self.default_esc_stop,

                                       output_encoding=output_encoding)

    def parse(self, line):

        if not(self.block):

            m = self.start_re.search(line)

            if not(m):

                return line

            else:

                return self.parse_begin(line, m)

        else:

            m = self.stop_re.search(line)

            if not(m):

                return self.block_grow(line)

            else:

                return self.parse_end(line, m)

    def parse_begin(self, line, m):

        preblock = line[:m.start()]

        self.command = line[m.start():m.end()]

        line = line[m.end():]

        # By default, no escape sequence defined yet

        self.esc_start = b""

        self.esc_stop = b""

        self.options = b""

        # If there are some options, look for escape specs

        if line[0] == b"[":

            e = line.find(b"]")+1

            self.options = line[:e]

            line = line[e:]

            m = self.esc_re.search(self.options)

            if m:

                self.esc_start = m.group(1)

                self.esc_stop = m.group(2)

        self.block_grow(line)

        return preblock

    def parse_end(self, line, m):

        self.block_grow(line[:m.start()])

        # The block is complete, find out the codec with escape sequence

        c = self.get_codec()

        c.clear_errors()

        # Now, parse/encode the block

        p = RawUtfParser(codec=c)

        text = p.parse(self.block)

        # Add the escape option if necessary

        if not(self.esc_start) and c.get_errors() != 0:

            escopt = b"escapeinside={%s}{%s}" % (c.pre, c.post)

            if self.options:

                if self.options[-2] != ",":

                    escopt = b"," + escopt

                self.options = self.options[:-1] + escopt + "]"

            else:

                self.options = b"[" + escopt + b"]"

        block = self.command + self.options + text + line[m.start():]

        self.block = b""

        return block

    def block_grow(self, line):

        self.block += line

        return b""

    def get_codec(self):

        # Something already specified

        if (self.esc_start):

            if self.esc_start != self.default_esc_start:

                return VerbCodec(self.esc_start, self.esc_stop,

                                 b"verbtex" + self.esc_start,

                                 output_encoding=self.encoding)

            else:

                return self.default_codec

        # Find the starting escape sequence that does not occur in verbatim text

        s = self.default_esc_start

        iter = 0

        i = self.block.find(s)

        while (i != -1):

            s = b"<" + bytes(iter) + b":"

            i = self.block.find(s)

            iter += 1

        # By luck the default is enough

        if (s == self.default_esc_start):

            return self.default_codec

        return VerbCodec(s, self.default_esc_stop, b"verbtex" + s,

                         output_encoding=self.encoding)

if __name__ == "__main__":

    import sys

    v = VerbParser()

    buf = getattr(sys.stdout, "buffer", sys.stdout)

    f = open(sys.argv[1], "rb")

    for line in f:

        text = v.parse(line)

        if text:

            buf.write(text)