from .babycode_parser import Parser
from markupsafe import Markup, escape
from pygments import highlight
from pygments.formatters import HtmlFormatter
from pygments.lexers import get_lexer_by_name
from pygments.util import ClassNotFound as PygmentsClassNotFound
import re

class BabycodeParseResult:
    def __init__(self, result, mentions=[]):
        self.result = result
        self.mentions = mentions


    def __str__(self):
        return self.result


BABYCODE_VERSION = 5

NAMED_COLORS = [
    'black', 'silver', 'gray', 'white', 'maroon', 'red',
    'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow',
    'navy', 'blue', 'teal', 'aqua', 'aliceblue', 'antiquewhite',
    'aqua', 'aquamarine', 'azure', 'beige', 'bisque', 'black',
    'blanchedalmond', 'blue', 'blueviolet', 'brown', 'burlywood', 'cadetblue',
    'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson',
    'cyan', 'aqua', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray',
    'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange',
    'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray',
    'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray',
    'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'fuchsia',
    'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'gray', 'green',
    'greenyellow', 'grey', 'gray', 'honeydew', 'hotpink', 'indianred',
    'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen',
    'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray',
    'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue',
    'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'lime', 'limegreen',
    'linen', 'magenta', 'fuchsia', 'maroon', 'mediumaquamarine', 'mediumblue',
    'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise',
    'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite',
    'navy', 'oldlace', 'olive', 'olivedrab', 'orange', 'orangered',
    'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip',
    'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'purple',
    'rebeccapurple', 'red', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon',
    'sandybrown', 'seagreen', 'seashell', 'sienna', 'silver', 'skyblue',
    'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue',
    'tan', 'teal', 'thistle', 'tomato', 'transparent', 'turquoise',
    'violet', 'wheat', 'white', 'whitesmoke', 'yellow', 'yellowgreen',
]

def is_tag(e, tag=None):
    if e is None:
        return False
    if isinstance(e, str):
        return False
    if e['type'] != 'bbcode':
        return False

    if tag is None:
        return True

    return e['name'] == tag

def is_text(e):
    return isinstance(e, str)

def tag_code(children, attr, surrounding):
    is_inline = children.find('\n') == -1
    if is_inline:
        return f"<code class=\"inline-code\">{children}</code>"
    else:
        input_code = children.strip()
        button = f"<button type=button class=\"copy-code\" value=\"{input_code}\" data-send=\"copyCode\" data-receive=\"copyCode\">Copy</button>"
        unhighlighted = f"<pre><span class=\"copy-code-container\"><span class=\"code-language-identifier\">code block</span>{button}</span><code>{input_code}</code></pre>"
        if not attr:
            return unhighlighted
        try:
            lexer = get_lexer_by_name(attr.strip())
            formatter = HtmlFormatter(nowrap=True)
            return f"<pre><span class=\"copy-code-container\"><span class=\"code-language-identifier\">{lexer.name}</span>{button}</span><code>{highlight(input_code.unescape(), lexer, formatter)}</code></pre>"
        except PygmentsClassNotFound:
            return unhighlighted

def tag_list(children):
    list_body = re.sub(r"  +\n", "<br>", children.strip())
    list_body = re.sub(r"\n\n+", "\1", list_body)
    return " ".join([f"<li>{x}</li>" for x in list_body.split("\1") if x])

def tag_color(children, attr, surrounding):
    if not attr:
        return f"[color]{children}[/color]"

    hex_re = r"^#?([0-9a-f]{6}|[0-9a-f]{3})$"
    potential_color = attr.lower().strip()

    if potential_color in NAMED_COLORS:
        return f"<span style='color: {potential_color};'>{children}</span>"

    m = re.match(hex_re, potential_color)
    if m:
        return f"<span style='color: #{m.group(1)};'>{children}</span>"

    # return just the way it was if we can't parse it
    return f"[color={attr}]{children}[/color]"

def tag_spoiler(children, attr, surrounding):
    spoiler_name = attr if attr else "Spoiler"
    content = f"<div class='accordion-content post-accordion-content hidden'>{children}</div>"
    container = f"""<div class='accordion hidden' data-receive='toggleAccordion'><div class='accordion-header'><button type='button' class='accordion-toggle' data-send='toggleAccordion'>+</button><span>{spoiler_name}</span></div>{content}</div>"""
    return container

def tag_image(children, attr, surrounding):
    img = f"<img class=\"post-image\" src=\"{attr}\" alt=\"{children}\">"
    if not is_tag(surrounding[0], 'img'):
        img = f"<div class=post-img-container>{img}"
    if not is_tag(surrounding[1], 'img'):
        img = f"{img}</div>"
    return img

TAGS = {
    "b": lambda children, attr, _: f"<strong>{children}</strong>",
    "i": lambda children, attr, _: f"<em>{children}</em>",
    "s": lambda children, attr, _: f"<del>{children}</del>",
    "u": lambda children, attr, _: f"<u>{children}</u>",

    "img": tag_image,
    "url": lambda children, attr, _: f"<a href={attr}>{children}</a>",
    "quote": lambda children, attr, _: f"<blockquote>{children}</blockquote>",
    "code": tag_code,
    "ul": lambda children, attr, _: f"<ul>{tag_list(children)}</ul>",
    "ol": lambda children, attr, _: f"<ol>{tag_list(children)}</ol>",

    "big": lambda children, attr, _: f"<span style='font-size: 2rem;'>{children}</span>",
    "small": lambda children, attr, _: f"<span style='font-size: 0.75rem;'>{children}</span>",
    "color": tag_color,

    "center": lambda children, attr, _: f"<div style='text-align: center;'>{children}</div>",
    "right": lambda children, attr, _: f"<div style='text-align: right;'>{children}</div>",

    "spoiler": tag_spoiler,
}

# [img] is considered block for the purposes of collapsing whitespace,
# despite being potentially inline (since the resulting <img> tag is inline, but creates a block container around itself and sibling images).
# [code] has a special case in is_inline().
INLINE_TAGS = {
    'b', 'i', 's', 'u', 'color', 'big', 'small', 'url'
}

def make_emoji(name, code):
    return f' <img class=emoji src="/static/emoji/{name}.png" alt="{name}" title=":{code}:">'

EMOJI = {
    'angry': make_emoji('angry', 'angry'),

    '(': make_emoji('frown', '('),

    'D': make_emoji('grin', 'D'),

    'imp': make_emoji('imp', 'imp'),

    'angryimp': make_emoji('impangry', 'angryimp'),
    'impangry': make_emoji('impangry', 'impangry'),

    'lobster': make_emoji('lobster', 'lobster'),

    '|': make_emoji('neutral', '|'),

    'pensive': make_emoji('pensive', 'pensive'),

    'scissors': make_emoji('scissors', 'scissors'),

    ')': make_emoji('smile', ')'),

    'smiletear': make_emoji('smiletear', 'smiletear'),
    'crytear': make_emoji('smiletear', 'crytear'),

    ',': make_emoji('sob', ','),
    'T': make_emoji('sob', 'T'),
    'cry': make_emoji('sob', 'cry'),
    'sob': make_emoji('sob', 'sob'),

    'o': make_emoji('surprised', 'o'),
    'O': make_emoji('surprised', 'O'),

    'hmm': make_emoji('think', 'hmm'),
    'think': make_emoji('think', 'think'),
    'thinking': make_emoji('think', 'thinking'),

    'P': make_emoji('tongue', 'P'),
    'p': make_emoji('tongue', 'p'),

    'weary': make_emoji('weary', 'weary'),

    ';': make_emoji('wink', ';'),
    'wink': make_emoji('wink', 'wink'),
}

TEXT_ONLY = ["code"]

def break_lines(text):
    text = re.sub(r"  +\n", "<br>", text)
    text = re.sub(r"\n\n+", "<br><br>", text)
    return text

def is_inline(e):
    if e is None:
        return False # i think

    if is_text(e):
        return True

    if is_tag(e):
        if is_tag(e, 'code'): # special case, since [code] can be inline OR block
            return '\n' not in e['children']

        return e['name'] in INLINE_TAGS

    return e['type'] != 'rule'

def make_mention(e, mentions):
    from ..models import Users
    from flask import url_for
    target_user = Users.find({'username': e['name'].lower()})
    if not target_user:
        return f"@{e['name']}"

    mention_data = {
        'mention_text': f"@{e['name']}",
        'mentioned_user_id': int(target_user.id),
        "start": e['start'],
        "end": e['end'],
    }
    if mention_data not in mentions:
        mentions.append(mention_data)

    return f"<a class='mention{' display' if target_user.has_display_name() else ''}' href='{url_for('users.page', username=target_user.username)}' title='@{target_user.username}' data-init='highlightMentions' data-username='{target_user.username}'>{'@' if not target_user.has_display_name() else ''}{target_user.get_readable_name()}</a>"

def should_collapse(text, surrounding):
    if not isinstance(text, str):
        return False

    if not text:
        return True

    if not text.strip() and '\n' not in text:
        return not is_inline(surrounding[0]) and not is_inline(surrounding[1])

    return False

def sanitize(s):
    return escape(s.strip().replace('\r\n', '\n').replace('\r', '\n'))

def babycode_to_html(s, banned_tags=[]):
    allowed_tags = set(TAGS.keys())
    if banned_tags is not None:
        for tag in banned_tags:
            allowed_tags.discard(tag)
    subj = sanitize(s)
    parser = Parser(subj)
    parser.valid_bbcode_tags = allowed_tags
    parser.bbcode_tags_only_text_children = TEXT_ONLY
    parser.mentions_allowed = '@mention' not in banned_tags
    parser.valid_emotes = EMOJI.keys()

    uncollapsed = parser.parse()
    elements = []
    for i in range(len(uncollapsed)):
        e = uncollapsed[i]
        surrounding = (
            uncollapsed[i - 1] if i-1 >= 0 else None,
            uncollapsed[i + 1] if i+1 < len(uncollapsed) else None
            )
        if not should_collapse(e, surrounding):
            elements.append(e)

    out = ""
    mentions = []
    def fold(element, nobr, surrounding):
        if isinstance(element, str):
            if nobr:
                return element
            return break_lines(element)

        match element['type']:
            case "bbcode":
                c = ""
                for i in range(len(element['children'])):
                    child = element['children'][i]
                    _surrounding = (
                        element['children'][i - 1] if i-1 >= 0 else None,
                        element['children'][i + 1] if i+1 < len(element['children']) else None
                        )
                    _nobr = element['name'] == "code" or element['name'] == "ul" or element['name'] == "ol"
                    c = c + Markup(fold(child, _nobr, _surrounding))
                res = TAGS[element['name']](c, element['attr'], surrounding)
                return res
            case "link":
                return f"<a href=\"{element['url']}\">{element['url']}</a>"
            case 'emote':
                return EMOJI[element['name']]
            case "rule":
                return "<hr>"
            case "mention":
                return make_mention(element, mentions)

    for i in range(len(elements)):
        e = elements[i]
        surrounding = (
            elements[i - 1] if i-1 >= 0 else None,
            elements[i + 1] if i+1 < len(elements) else None
            )
        out = out + fold(e, False, surrounding)
    return BabycodeParseResult(out, mentions)