r"""
Parses ascii escape sequences into marked up strings

>>> r = peel_off_esc_code('Amore')
>>> r == ('', {'csi': '\x1b', 'command': 'A', 'seq': '\x1bA'}, 'more')
True
>>> r = peel_off_esc_code('[2Astuff')
>>> r == ('', {'csi': '\x1b[', 'seq': '\x1b[2A', 'intermed': '', 'private': '', 'command': 'A', 'numbers': [2]}, 'stuff')
True
"""

from typing import (
    Text,
    List,
    Mapping,
    Union,
    Tuple,
    Match,
    cast,
    Dict,
    Any,
    Optional,
    NewType,
)

import re

from .termformatconstants import (
    FG_NUMBER_TO_COLOR,
    BG_NUMBER_TO_COLOR,
    NUMBER_TO_STYLE,
    RESET_ALL,
    RESET_FG,
    RESET_BG,
    STYLES,
)


Token = Dict[str, Union[Text, List[int]]]


def remove_ansi(s):
    # type: (Text) -> Text
    return re.sub(r"(\x9B|\x1B\[)[0-?]*[ -\/]*[@-~]", "", s)


def parse(s):
    # type: (Text) -> List[Union[Text, Dict[str, Union[str, bool, None]]]]
    r"""
    Returns a list of strings or format dictionaries to describe the strings.

    May raise a ValueError if it can't be parsed.

    >>> parse(">>> []")
    ['>>> []']
    >>> parse("\x1b[33m[\x1b[39m\x1b[33m]\x1b[39m\x1b[33m[\x1b[39m\x1b[33m]\x1b[39m\x1b[33m[\x1b[39m\x1b[33m]\x1b[39m\x1b[33m[\x1b[39m")
    [{'fg': 'yellow'}, '[', {'fg': None}, {'fg': 'yellow'}, ']', {'fg': None}, {'fg': 'yellow'}, '[', {'fg': None}, {'fg': 'yellow'}, ']', {'fg': None}, {'fg': 'yellow'}, '[', {'fg': None}, {'fg': 'yellow'}, ']', {'fg': None}, {'fg': 'yellow'}, '[', {'fg': None}]
    """
    stuff = []  # type: List[Union[Text, Dict[str, Union[str, bool, None]]]]
    rest = s
    while True:
        front, token, rest = peel_off_esc_code(rest)
        if front:
            stuff.append(front)
        if token:
            try:
                tok = token_type(token)
                if tok:
                    stuff.extend(tok)
            except ValueError:
                raise ValueError(
                    "Can't parse escape sequence: %r %r %r %r"
                    % (s, repr(front), token, repr(rest))
                )
        if not rest:
            break
    return stuff


def peel_off_esc_code(s):
    # type: (Text) -> Tuple[Text, Optional[Token], Text]
    r"""Returns processed text, the next token, and unprocessed text

    >>> front, d, rest = peel_off_esc_code('some[2Astuff')
    >>> front, rest
    ('some', 'stuff')
    >>> d == {'numbers': [2], 'command': 'A', 'intermed': '', 'private': '', 'csi': '\x1b[', 'seq': '\x1b[2A'}
    True
    """
    # fmt: off
    p = r"""(?P<front>.*?)
            (?P<seq>
                (?P<csi>
                    (?:[]\[)
                    |
                    ["""+'\x9b' + r"""])
                (?P<private>)
                (?P<numbers>
                    (?:\d+;)*
                    (?:\d+)?)
                (?P<intermed>""" + '[\x20-\x2f]*)' + r"""
                (?P<command>""" + '[\x40-\x7e]))' + r"""
            (?P<rest>.*)"""
    # fmt: on
    m1 = re.match(p, s, re.VERBOSE)  # multibyte esc seq
    m2 = re.match(
        "(?P<front>.*?)(?P<seq>(?P<csi>)(?P<command>[\x40-\x5f]))(?P<rest>.*)", s
    )  # 2 byte escape sequence
    m = None  # Optional[Match[str]]
    if m1 and m2:
        m = m1 if len(m1.groupdict()["front"]) <= len(m2.groupdict()["front"]) else m2
        # choose the match which has less processed text in order to get the
        # first escape sequence
    elif m1:
        m = m1
    elif m2:
        m = m2
    else:
        m = None

    if m:
        d = m.groupdict()  # type: Dict[str, Any]
        del d["front"]
        del d["rest"]
        if "numbers" in d and all(d["numbers"].split(";")):
            d["numbers"] = [int(x) for x in d["numbers"].split(";")]

        return m.groupdict()["front"], cast(Token, d), m.groupdict()["rest"]
    else:
        return s, None, ""


def token_type(info):
    # type: (Token) -> Optional[List[Dict[Text, Union[Text, bool, None]]]]

    if info["command"] == "m":
        # The default action for ESC[m is to act like ESC[0m
        # Ref: https://en.wikipedia.org/wiki/ANSI_escape_code#CSI_codes
        values = cast(List[int], info["numbers"]) if len(info["numbers"]) else [0]
        tokens = []  # type: List[Dict[str, Union[Text, bool, None]]]
        # fmt: off
        for value in values:
            if value in FG_NUMBER_TO_COLOR: tokens.append({'fg':FG_NUMBER_TO_COLOR[value]})
            if value in BG_NUMBER_TO_COLOR: tokens.append({'bg':BG_NUMBER_TO_COLOR[value]})
            if value in NUMBER_TO_STYLE: tokens.append({NUMBER_TO_STYLE[value]:True})
            if value == RESET_ALL: tokens.append(dict({k: None for k in STYLES}, **{'fg':None, 'bg':None}))
            if value == RESET_FG: tokens.append({'fg':None})
            if value == RESET_BG: tokens.append({'bg':None})
        # fmt: on

        if tokens:
            return tokens
        else:
            raise ValueError("Can't parse escape seq %r" % info)
    elif info["command"] == "H":  # fix for bpython #76
        return [{}]
    return None


if __name__ == "__main__":
    import doctest

    doctest.testmod()
    # print(peel_off_esc_code('[2Astuff'))
    # print(peel_off_esc_code('Amore'))
    print(repr(parse("[31mstuff is the best[32myay")))
