HtmlEquivTag('div', _FLOW_TAGS, None, html_equiv='div'), #
QuoteTag ('quote', _BLOCK_LEVEL_TAGS + ('softbr',), 'div'), #
 (only img currently needed out of the prohibited elements)
    HtmlEquivTag('pre',        _INLINE_TAGS,   None, 
        prohibited_elements=('img', 'big', 'small', 'sub', 'sup'),
        html_equiv='pre'), 
    
    #     HtmlEquivTag('code',       _INLINE_TAGS, None, 
        prohibited_elements = ('img', 'big', 'small', 'sub', 'sup'),
        html_equiv='pre', attributes={'class':'code'}),
        
    # 
    HtmlEquivTag('*', _FLOW_TAGS, 'list',
        html_equiv='li')
)

# Make a dictionary
_TAGDICT = {}
for t in _TAGS:
    if t.name != 'text':
        _TAGDICT[t.name] = t

# Make list of valid tags
_TAGNAMES = [t.name for t in _TAGS]

_EMOTICONS = {
        '0:-)': 'angel.gif',
        'O:-)':'angel.gif',
        ':angel:':'angel.gif',
        ':)':'smile.gif',
        ':(':'sad.gif',
        ':D':'grin.gif',
        ':p':'tongue.gif',
        ';)':'wink.gif',
        ':-)':'smile.gif',
        ':-(': 'sad.gif',
        ':-D': 'grin.gif',
        ':-P': 'tongue.gif',
        ':-p': 'tongue.gif',
        ':-/': 'unsure.gif',
        ':-\\': 'unsure.gif',
        ';-)': 'wink.gif',
        ':-$': 'confused.gif',
        ':-S': 'confused.gif',
        'B-)': 'cool.gif',
        ':lol:': 'lol.gif',
        ':batman:': 'batman.gif',
        ':rolleyes:': 'rolleyes.gif',
        ':icymad:': 'bluemad.gif',
        ':mad:': 'mad.gif',
        ':crying:': 'crying.gif',
        ':eek:': 'eek.gif',
        ':eyebrow:': 'eyebrow.gif',
        ':grim:': 'grim_reaper.gif',
        ':idea:': 'idea.gif',
        ':rotfl:': 'rotfl.gif',
        ':shifty:': 'shifty.gif',
        ':sleep:': 'sleep.gif',
        ':thinking:': 'thinking.gif',
        ':wave:': 'wave.gif',
        ':bow:': 'bow.gif',
        ':sheep:':  'sheep.gif',
        ':santa:':  'santaclaus.gif',
        ':anvil:': 'anvil.gif',
        ':bandit:': 'bandit.gif',
        ':chop:': 'behead.gif',
        ':biggun:': 'biggun.gif',
        ':mouthful:': 'blowingup,gif',
        ':gun:': 'bluekillsred.gif',
        ':box:': 'boxing.gif',
        ':gallows:': 'hanged.gif',
        ':jedi:': 'lightsaber1.gif',
        ':bosh:': 'mallet1.gif',
        ':saw:': 'saw.gif',
        ':stupid:': 'youarestupid.gif',
}

_EMOTICON_LIST = _EMOTICONS.keys();

###### PARSING CLASSES AND FUNCTIONS ######
class BBNode:
    """Abstract base class for a node of BBcode."""
    def __init__(self, parent):
        self.parent = parent
        self.children = []
        
    def render_children_xhtml(self):
        """Render the child nodes as XHTML"""
        return "".join([child.render_xhtml() for child in self.children])

    def render_children_bbcode(self):
        """Render the child nodes as BBCode"""
        return "".join([child.render_bbcode() for child in self.children])

class BBRootNode(BBNode):
    """Represents a root node"""
    def __init__(self, allow_inline = False):
        BBNode.__init__(self, None)
        self.children = []
        self.allow_inline = allow_inline
    
    def render_xhtml(self):
        """Render the node as XHTML"""
        return self.render_children_xhtml()

    def allows(self, tagname):
        """Returns true if the tag with 'tagname' can be added to this node"""
        if self.allow_inline:
            return tagname in _FLOW_TAGS
        else:
            # Rule for HTML BODY element
            return tagname in _BLOCK_LEVEL_TAGS

    def render_bbcode(self):
        """Render the node as correct BBCode"""
        return self.render_children_bbcode()

class BBTextNode(BBNode):
    """A text node, containing only plain text"""
    def __init__(self, parent, text):
        BBNode.__init__(self, parent)
        self.text = text
        
    def render_xhtml(self):
        """Render the node as XHTML"""
        return escape(self.text)

    def render_bbcode(self):
        return self.text

    def allows(self, tagname):
        return False      # text nodes are always leaf nodes

class BBEscapedTextNode(BBTextNode):
    def render_bbcode(self):
        return '[' + self.text + ']'

class BBTagNode(BBNode):
    def __init__(self, parent, name, parameter):
        BBNode.__init__(self, parent)
        self.bbtag = _TAGDICT[name]
        self.parameter = parameter

    def prohibited(self, tagname):
        """Return True if the element 'tagname' is prohibited by
        this node or any parent nodes"""
        if tagname in self.bbtag.prohibited_elements:
            return True
        else:
            if self.parent is None or not hasattr(self.parent, 'prohibited'):
                return False
            else:
                return self.parent.prohibited(tagname)

    def allows(self, tagname):
        """Returns true if the tag with 'tagname' can be added to this node"""
        if tagname in self.bbtag.allowed_children:
            # Check prohibited_elements of this and parent tags
            return not self.prohibited(tagname)
        else:
            return False

    def render_xhtml(self):
        """Render the node as XHTML"""
        return self.bbtag.render_node_xhtml(self)

    def render_bbcode(self):
        return self.bbtag.render_node_bbcode(self)

class BBCodeParser:
    def __init__(self, root_allows_inline = False):
        self.root_allows_inline = root_allows_inline

    def push_text_node(self, text, escaped=False):
        """Add a text node to the current node"""
        # escaped=True for text that has been wrapped in extra []
        # to stop interpretation as bbcode
        
        if escaped:
            text_class = BBEscapedTextNode
        else:
            text_class = BBTextNode

        if not self.current_node.allows('text'):
            # e.g. text after [list] but before [*] or after [quote].
            # Only get here if BBRootNode or BBTagNode is current
            if len(text.strip()) == 0:
                # Whitespace, append anyway
                self.current_node.children.append(text_class(self.current_node, text))
            else:
                if self.current_node.allows('div'):
                    self.current_node.children.append(BBTagNode(self.current_node, 'div',''))
                    self.descend()
                else:
                    self.ascend()
                self.push_text_node(text)
        else:
            self.current_node.children.append(text_class(self.current_node, text))
            # text nodes are never open, do don't bother descending

    def descend(self):
        """Move to the last child of the current node"""
        self.current_node = self.current_node.children[-1]

    def ascend(self):
        """Move to the parent node of the current node"""
        # This usually closes the node, since parsing
        # will add nodes to the end of self.children
        self.current_node = self.current_node.parent

    def push_tag_node(self, name, parameter):
        """Add a BBTagNode of name 'name' onto the tree"""
        if not self.current_node.allows(name):
            new_tag = _TAGDICT[name]
            if new_tag.discardable:
                return
            elif (self.current_node == self.root_node or \
                self.current_node.bbtag.name in _BLOCK_LEVEL_TAGS) and\
                not new_tag.implicit_tag is None:
                
                # E.g. [*] inside root, or [*] inside [quote]
                # or inline inside root
                # Add an implicit tag if possible
                self.push_tag_node(new_tag.implicit_tag, '')
                self.push_tag_node(name, parameter)
            else:
                # e.g. block level in inline etc. - traverse up the tree
                self.current_node = self.current_node.parent
                self.push_tag_node(name, parameter) # recursive call
        else:
            node = BBTagNode(self.current_node, name, parameter)
            self.current_node.children.append(node)
            if not node.bbtag.self_closing:
                self.descend()

    def close_tag_node(self, name):
        """Pop the stack back to the first node with the 
        specified tag name, and 'close' that node."""
        temp_node = self.current_node
        while True:
            if temp_node == self.root_node:
                # Give up, effectively discarding the closing tag
                break
            if hasattr(temp_node, 'bbtag'):
                if temp_node.bbtag.name == name:
                    # found it
                    self.current_node = temp_node
                    self.ascend()
                    break
            temp_node = temp_node.parent
            continue

    def _prepare(self, bbcode):
        # Replace newlines with 'soft' brs
        bbcode = bbcode.replace("\n", '[softbr]')
        
        # Replace emoticons with context-sensitive emoticon tags
        for emoticon in _EMOTICON_LIST:
            bbcode = bbcode.replace(emoticon, 
                '[emoticon]' + emoticon + '[/emoticon]')
        return bbcode

    def parse(self, bbcode):
        """Parse the bbcode into a tree of elements"""        
        self.root_node = BBRootNode(self.root_allows_inline)
        self.current_node = self.root_node
        bbcode = self._prepare(bbcode)
        pos = 0
        while pos < len(bbcode):
            match = _BBTAG_REGEXP.search(bbcode, pos)
            if not match is None:
                # push all text up to the start of the match

                self.push_text_node(bbcode[pos:match.start()])
                
                # push the tag itself
                tagname = match.groups()[0]
                parameter = match.groups()[2]
                wholematch = match.group()
                if wholematch.startswith('[[') and wholematch.endswith(']]'):
                    # escaping mechanism
                    self.push_text_node(wholematch[1:-1], escaped=True)
                else:
                    if not parameter is None and len(parameter) > 0:
                        parameter = parameter[1:] # strip the equals
                    if tagname in _TAGNAMES:
                        # genuine tag
                        if wholematch.startswith('[['):
                            # in case of "[[tag]blah":
                            self.push_text_node('[')
                        # push it
                        if wholematch.startswith('[/'):
                            # closing
                            self.close_tag_node(tagname)
                        else:
                            # opening
                            self.push_tag_node(tagname, parameter)
                        if wholematch.endswith(']]'):
                            # in case of "[tag]]":
                            self.push_text_node(']')
                    else:
                        # non-genuine tag, treat as literal
                        self.push_text_node(wholematch)
                pos = match.end()
            else:
                # push all remaining text
                self.push_text_node(bbcode[pos:])
                pos = len(bbcode)
        
    def render_xhtml(self):
        """Render the parsed tree as XHTML"""
        return self.root_node.render_xhtml()
        
    def render_bbcode(self):
        """Render the parsed tree as corrected BBCode"""
        return self.root_node.render_bbcode()

def bb2xhtml(bbcode, root_allows_inline = False):
    "Render bbcode as XHTML"
    parser = BBCodeParser(root_allows_inline)
    parser.parse(bbcode)
    return parser.render_xhtml()
    
def correct(bbcode):
    "Renders corrected bbcode"
    parser = BBCodeParser(True)
    parser.parse(bbcode)
    return parser.render_bbcode()

def to_html(text):
    return bb2xhtml( text, False )

def name():
    return "bbcode"

def quote(text, url):
    return "[quote]\n%s\n[/quote]\n" % text