"""
A B A N D O N                               ,:
   A L L  H O P E                         ,' |
                                         /   :
                                      --'   /
       F O R  Y E  W H O              \/ /:/
           E N T E R  H E R E         / ://_\
                                   __/   /
                                   )'-. /
 Crude hacks lie beneath us.      ./  :\
                                    /.' '
This module includes a couple     '/'
of custom (GROAN) formatting    +
specifications and parsers      '
for them. Why did i do this?  `.
      I have no idea!      .-"-
                          (    |
                       . .-'  '.
                      ( (.   )8:
                  .'    / (_  )
                   _. :(.   )8P  `
               .  (  `-' (  `.   .
                .  :  (   .a8a)
               /_`( "a `a. )"'
           (  (/  .  ' )=='
          (   (    )  .8"   +
            (`'8a.( _(   (
         ..-. `8P    ) `  )  +
       -'   (      -ab:  )
     '    _  `    (8P"Ya
   _(    (    )b  -`.  ) +
  ( 8)  ( _.aP" _a   \( \   *
+  )/    (8P   (88    )  )
   (a:f   "     `"`


The internal representation of formatted text is much like an s-expression.

They are specified as follows:
            [directive: this is the body of text to apply it to]

The colon and the space following are important! The first space is not part
of the body, but any trailing spaces after it or at the end of the body are
included in the output.

Escaping via backslash is supported. Nesting is supported as well, but escaping
the delimiters is a bit tricky when nesting (both ends need to be escaped).
See the following examples:

[bold: this here \] is totally valid, and so is [<-TOTALLY OK this]
[bold: \[red: but both]<-CHOKE delimiters within a nest must be escaped.]

Directives are only parsed whenever the directive name is defined, and the
colon/space follow it. Thus, including [brackets like this] in a post body
will NOT require you to escape it! Even [brackets: like this] is safe, because
brackets is not a defined formatting parameter. So, any amount of unescaped brackets
may exist within the body unless they mimic a directive. To escape a valid directive,
escaping only the opening is suffiecient: \[bold: like this]. The literal body of
text outputted by that will be [bold: like this], with the backslash removed.

Just like the brackets themselves, backslashes may occur freely within bodies,
they are only removed when they occur before a valid expression.
"""

from string import punctuation
import re

colors = [
#0,   1        2        3        4       5        6       dim is not used in color api
    "red", "yellow", "green", "blue", "cyan", "magenta", "dim"
]

markup = [
    "bold", "underline", "linequote", "quote", "rainbow"
]


# quotes being references to other post_ids, like >>34 or >>0 for OP
quotes = re.compile(">>([0-9]+)")
bold = re.compile(r"(?<!\\)\*{2}(.+?)(?<!\\)\*{2}")
underline = re.compile(r"(?<!\\)_{2}(.+?)(?<!\\)_{2}")
escapes = re.compile(r"\\([*_]{2})")


def apply_directives(text):
    # is there a better way to do this? smh....
    text = quotes.sub(lambda m: "[quote: %s]" % m.group(1), text)
    text = bold.sub(lambda m: "[bold: %s]" % m.group(1), text)
    text = underline.sub(lambda m: "[underline: %s]" % m.group(1), text)
    return escapes.sub(lambda m: m.group(1), text)


def linequote_p(line):
    if not line.startswith(">"):
        return False
    _fp = line.find(" ")
    return not quotes.search(line[:_fp] if _fp != -1 else line)


def parse_segments(text, sanitize_linequotes=True):
    """
    Parse linequotes, quotes, and paragraphs into their appropriate
    representations. Paragraphs are represented as separate strings
    in the returned list, and quote-types are compiled to their
    [bracketed] representations.
    """
    result = list()
    for paragraph in re.split("\n{2,}", text):
        pg = str()
        for line in paragraph.split("\n"):
            if linequote_p(line):
                if sanitize_linequotes:
                    inner = line.replace("]", "\\]")
                else:
                    inner = apply_directives(line)
                pg += "[linequote: %s]" % inner
            else:
                pg += apply_directives(line)
            pg += "\n"
        result.append(pg.rstrip())
    return result


def sequential_expressions(string):
    """
    Takes a string, sexpifies it, and returns a list of lists
    who contain tuples. Each list of tuples represents a paragraph.
    Within each paragraph, [0] is either None or a markup directive,
    and [1] is the body of text to which it applies. This representation
    is very easy to handle for a client. It semi-supports nesting:
    eg, the expression [red: this [blue: is [green: mixed]]] will
    return [("red", "this "), ("blue", "is "), ("green", "mixed")],
    but this cannot effectively express an input like
    [bold: [red: bolded colors.]], in which case the innermost
    expression will take precedence. For the input:
        "[bold: [red: this] is some shit [green: it cant handle]]"
    you get:
    [('red', 'this'), ('bold', ' is some shit '), ('green', 'it cant handle')]
    """
    # abandon all hope ye who enter here
    directives = colors + markup
    result = list()
    for paragraph in parse_segments(string):
        stack = [[None, str()]]
        skip_iters = 0
        nest = [None]
        escaped = False
        for index, char in enumerate(paragraph):
            if skip_iters:
                skip_iters -= 1
                continue

            if not escaped and char == "[":
                directive = paragraph[index+1:paragraph.find(": ", index+1)]
                open_p = directive in directives
            else:
                open_p = False
            clsd_p = not escaped and nest[-1] != None and char == "]"

            # dont splice other directives into linequotes: that is far
            # too confusing for the client to determine where to put line
            # breaks
            if open_p and nest[-1] != "linequote":
                stack.append([directive, str()])
                nest.append(directive)
                skip_iters += len(directive) + 2

            elif clsd_p:
                nest.pop()
                stack.append([nest[-1], str()])

            else:
                escaped = char == "\\"
                try:
                    n = paragraph[index + 1]
                except IndexError:
                    n = " "
                if not (escaped and n in "[]"):
                    stack[-1][1] += char
        # filter out unused bodies, eg ["red", ""]
        result.append([(directive, body) for directive, body in stack if body])
    return result


def apply_formatting(msg_obj, formatter):
    """
    Receives a messages object from a thread and returns it with
    all the message bodies passed through FORMATTER. Not all
    formatting functions have to return a string. Refer to the
    documentation for each formatter.
    """
    for x, obj in enumerate(msg_obj):
        if not msg_obj[x].get("send_raw"):
            msg_obj[x]["body"] = formatter(obj["body"])
    return msg_obj


def raw(text):
    """
    Just return the message in the same state that it was submitted.
    """
    return text


def strip(text):
    """
    Returns the text with all formatting directives removed.
    Not to be confused with `raw`.
    """
    pass # me the bong im boutta smash tha bish



def entities(text):
    """
    Returns a tuple where [0] is raw text and [1] is documentation
    """
    # once someone asked me if i wanted a life
    # and i said
    pass



def html(text):
    """
    Returns messages in html format, after being sent through markdown.
    Color directives are given as:
      <span color="{COLOR}" style="color: {COLOR};">content</span>

    Directives may be nested. If you don't have access to a fully featured
    and compliant html renderer in your client, you should use one of the
    simpler directives like strip, indice, or raw.
    """
    return "where is your god now"


# and this is drunk too
def map_html(match):
    return """
    If there is a place you got to go
    I am the one you need to know
    I'm the Map!
    I'm the Map!
    I'm the Map!

    If there is a place you got to get
    I can get you there I bet
    I'm the Map!
    I'm the Map!
    I'm the Map!

    I'm the Map!

    I'm the Map!
    I'm the Map!

    I'm the Map!
    I'm the Map!
    I'm the Map!

    I'm the Map!
    I'm the Map!
    I'm the Map!
    """