# stringutil.py - utility for generic string formatting, parsing, etc.

#

#  Copyright 2005 K. Thananchayan <thananck@yahoo.com>

#  Copyright 2005-2007 Olivia Mackall <olivia@selenic.com>

#  Copyright 2006 Vadim Gelfer <vadim.gelfer@gmail.com>

#

# This software may be used and distributed according to the terms of the

# GNU General Public License version 2 or any later version.

from __future__ import annotations

import ast

import codecs

import re as remod

import textwrap

import types

import typing

from typing import (

    Optional,

    overload,

)

from ..i18n import _

from ..thirdparty import attr

# Force pytype to use the non-vendored package

if typing.TYPE_CHECKING:

    # noinspection PyPackageRequirements

    import attr

from .. import (

    encoding,

    error,

    pycompat,

)

# regex special chars pulled from https://bugs.python.org/issue29995

# which was part of Python 3.7.

_respecial = pycompat.bytestr(b'()[]{}?*+-|^$\\.&~# \t\n\r\v\f')

_regexescapemap = {ord(i): (b'\\' + i).decode('latin1') for i in _respecial}

regexbytesescapemap = {i: (b'\\' + i) for i in _respecial}

@overload

def reescape(pat: bytes) -> bytes:

    ...

@overload

def reescape(pat: str) -> str:

    ...

def reescape(pat):

    """Drop-in replacement for re.escape."""

    # NOTE: it is intentional that this works on unicodes and not

    # bytes, as it's only possible to do the escaping with

    # unicode.translate, not bytes.translate. Sigh.

    wantuni = True

    if isinstance(pat, bytes):

        wantuni = False

        pat = pat.decode('latin1')

    pat = pat.translate(_regexescapemap)

    if wantuni:

        return pat

    return pat.encode('latin1')

def pprint(o, bprefix: bool = False, indent: int = 0, level: int = 0) -> bytes:

    """Pretty print an object."""

    return b''.join(pprintgen(o, bprefix=bprefix, indent=indent, level=level))

def pprintgen(o, bprefix: bool = False, indent: int = 0, level: int = 0):

    """Pretty print an object to a generator of atoms.

    ``bprefix`` is a flag influencing whether bytestrings are preferred with

    a ``b''`` prefix.

    ``indent`` controls whether collections and nested data structures

    span multiple lines via the indentation amount in spaces. By default,

    no newlines are emitted.

    ``level`` specifies the initial indent level. Used if ``indent > 0``.

    """

    if isinstance(o, bytes):

        if bprefix:

            yield b"b'%s'" % escapestr(o)

        else:

            yield b"'%s'" % escapestr(o)

    elif isinstance(o, bytearray):

        # codecs.escape_encode() can't handle bytearray, so escapestr fails

        # without coercion.

        yield b"bytearray['%s']" % escapestr(bytes(o))

    elif isinstance(o, list):

        if not o:

            yield b'[]'

            return

        yield b'['

        if indent:

            level += 1

            yield b'\n'

            yield b' ' * (level * indent)

        for i, a in enumerate(o):

            if i + 1 < len(o):

                if indent:

                    yield b',\n'

                    yield b' ' * (level * indent)

                else:

                    yield b', '

        if indent:

            level -= 1

            yield b'\n'

            yield b' ' * (level * indent)

        yield b']'

    elif isinstance(o, dict):

        if not o:

            yield b'{}'

            return

        yield b'{'

        if indent:

            level += 1

            yield b'\n'

            yield b' ' * (level * indent)

        for i, (k, v) in enumerate(sorted(o.items())):

            yield b': '

            if i + 1 < len(o):

                if indent:

                    yield b',\n'

                    yield b' ' * (level * indent)

                else:

                    yield b', '

        if indent:

            level -= 1

            yield b'\n'

            yield b' ' * (level * indent)

        yield b'}'

    elif isinstance(o, set):

        if not o:

            yield b'set([])'

            return

        yield b'set(['

        if indent:

            level += 1

            yield b'\n'

            yield b' ' * (level * indent)

        for i, k in enumerate(sorted(o)):

            if i + 1 < len(o):

                if indent:

                    yield b',\n'

                    yield b' ' * (level * indent)

                else:

                    yield b', '

        if indent:

            level -= 1

            yield b'\n'

            yield b' ' * (level * indent)

        yield b'])'

    elif isinstance(o, tuple):

        if not o:

            yield b'()'

            return

        yield b'('

        if indent:

            level += 1

            yield b'\n'

            yield b' ' * (level * indent)

        for i, a in enumerate(o):

            if i + 1 < len(o):

                if indent:

                    yield b',\n'

                    yield b' ' * (level * indent)

                else:

                    yield b', '

        if indent:

            level -= 1

            yield b'\n'

            yield b' ' * (level * indent)

        yield b')'

    elif isinstance(o, types.GeneratorType):

        # Special case of empty generator.

        try:

            nextitem = next(o)

        except StopIteration:

            yield b'gen[]'

            return

        yield b'gen['

        if indent:

            level += 1

            yield b'\n'

            yield b' ' * (level * indent)

        last = False

        while not last:

            current = nextitem

            try:

                nextitem = next(o)

            except StopIteration:

                last = True

                current, bprefix=bprefix, indent=indent, level=level

            if not last:

                if indent:

                    yield b',\n'

                    yield b' ' * (level * indent)

                else:

                    yield b', '

        if indent:

            level -= 1

            yield b'\n'

            yield b' ' * (level * indent)

        yield b']'

    else:

        yield pycompat.byterepr(o)

def prettyrepr(o) -> bytes:

    """Pretty print a representation of a possibly-nested object"""

    lines = []

    rs = pycompat.byterepr(o)

    p0 = p1 = 0

    while p0 < len(rs):

        # '... field=<type ... field=<type ...'

        #      ~~~~~~~~~~~~~~~~

        #      p0    p1        q0    q1

        q0 = -1

        q1 = rs.find(b'<', p1 + 1)

        if q1 < 0:

            q1 = len(rs)

            # pytype: disable=wrong-arg-count

            # TODO: figure out why pytype doesn't recognize the optional start

            #  arg

        elif q1 > p1 + 1 and rs.startswith(b'=', q1 - 1):

            # pytype: enable=wrong-arg-count

            # backtrack for ' field=<'

            q0 = rs.rfind(b' ', p1 + 1, q1 - 1)

        if q0 < 0:

            q0 = q1

        else:

            q0 += 1  # skip ' '

        l = rs.count(b'<', 0, p0) - rs.count(b'>', 0, p0)

        assert l >= 0

        lines.append((l, rs[p0:q0].rstrip()))

        p0, p1 = q0, q1

    return b'\n'.join(b'  ' * l + s for l, s in lines)

def buildrepr(r) -> bytes:

    """Format an optional printable representation from unexpanded bits

    ========  =================================

    type(r)   example

    ========  =================================

    tuple     ('<not %r>', other)

    bytes     '<branch closed>'

    callable  lambda: '<branch %r>' % sorted(b)

    object    other

    ========  =================================

    """

    if r is None:

        return b''

    elif isinstance(r, tuple):

        return r[0] % pycompat.rapply(pycompat.maybebytestr, r[1:])

    elif isinstance(r, bytes):

        return r

    elif callable(r):

        return r()

    else:

        return pprint(r)

def binary(s: bytes) -> bool:

    """return true if a string is binary data"""

    return bool(s and b'\0' in s)

def _splitpattern(pattern: bytes):

    if pattern.startswith(b're:'):

        return b're', pattern[3:]

    elif pattern.startswith(b'literal:'):

        return b'literal', pattern[8:]

    return b'literal', pattern

def stringmatcher(pattern: bytes, casesensitive: bool = True):

    """

    accepts a string, possibly starting with 're:' or 'literal:' prefix.

    returns the matcher name, pattern, and matcher function.

    missing or unknown prefixes are treated as literal matches.

    helper for tests:

    >>> def test(pattern, *tests):

    ...     kind, pattern, matcher = stringmatcher(pattern)

    ...     return (kind, pattern, [bool(matcher(t)) for t in tests])

    >>> def itest(pattern, *tests):

    ...     kind, pattern, matcher = stringmatcher(pattern, casesensitive=False)

    ...     return (kind, pattern, [bool(matcher(t)) for t in tests])

    exact matching (no prefix):

    >>> test(b'abcdefg', b'abc', b'def', b'abcdefg')

    ('literal', 'abcdefg', [False, False, True])

    regex matching ('re:' prefix)

    >>> test(b're:a.+b', b'nomatch', b'fooadef', b'fooadefbar')

    ('re', 'a.+b', [False, False, True])

    force exact matches ('literal:' prefix)

    >>> test(b'literal:re:foobar', b'foobar', b're:foobar')

    ('literal', 're:foobar', [False, True])

    unknown prefixes are ignored and treated as literals

    >>> test(b'foo:bar', b'foo', b'bar', b'foo:bar')

    ('literal', 'foo:bar', [False, False, True])

    case insensitive regex matches

    >>> itest(b're:A.+b', b'nomatch', b'fooadef', b'fooadefBar')

    ('re', 'A.+b', [False, False, True])

    case insensitive literal matches

    >>> itest(b'ABCDEFG', b'abc', b'def', b'abcdefg')

    ('literal', 'ABCDEFG', [False, False, True])

    """

    kind, pattern = _splitpattern(pattern)

    if kind == b're':

        try:

            flags = 0

            if not casesensitive:

                flags = remod.I

            regex = remod.compile(pattern, flags)

        except remod.error as e:

            raise error.ParseError(

                _(b'invalid regular expression: %s') % forcebytestr(e)

            )

        return kind, pattern, regex.search

    elif kind == b'literal':

        if casesensitive:

            match = pattern.__eq__

        else:

            ipat = encoding.lower(pattern)

            match = lambda s: ipat == encoding.lower(s)

        return kind, pattern, match

    raise error.ProgrammingError(b'unhandled pattern kind: %s' % kind)

def substringregexp(pattern: bytes, flags: int = 0):

    """Build a regexp object from a string pattern possibly starting with

    're:' or 'literal:' prefix.

    helper for tests:

    >>> def test(pattern, *tests):

    ...     regexp = substringregexp(pattern)

    ...     return [bool(regexp.search(t)) for t in tests]

    >>> def itest(pattern, *tests):

    ...     regexp = substringregexp(pattern, remod.I)

    ...     return [bool(regexp.search(t)) for t in tests]

    substring matching (no prefix):

    >>> test(b'bcde', b'abc', b'def', b'abcdefg')

    [False, False, True]

    substring pattern should be escaped:

    >>> substringregexp(b'.bc').pattern

    '\\\\.bc'

    >>> test(b'.bc', b'abc', b'def', b'abcdefg')

    [False, False, False]

    regex matching ('re:' prefix)

    >>> test(b're:a.+b', b'nomatch', b'fooadef', b'fooadefbar')

    [False, False, True]

    force substring matches ('literal:' prefix)

    >>> test(b'literal:re:foobar', b'foobar', b're:foobar')

    [False, True]

    case insensitive literal matches

    >>> itest(b'BCDE', b'abc', b'def', b'abcdefg')

    [False, False, True]

    case insensitive regex matches

    >>> itest(b're:A.+b', b'nomatch', b'fooadef', b'fooadefBar')

    [False, False, True]

    """

    kind, pattern = _splitpattern(pattern)

    if kind == b're':

        try:

            return remod.compile(pattern, flags)

        except remod.error as e:

            raise error.ParseError(

                _(b'invalid regular expression: %s') % forcebytestr(e)

            )

    elif kind == b'literal':

        return remod.compile(remod.escape(pattern), flags)

    raise error.ProgrammingError(b'unhandled pattern kind: %s' % kind)

def shortuser(user: bytes) -> bytes:

    """Return a short representation of a user name or email address."""

    f = user.find(b'@')

    if f >= 0:

        user = user[:f]

    f = user.find(b'<')

    if f >= 0:

        user = user[f + 1 :]

    f = user.find(b' ')

    if f >= 0:

        user = user[:f]

    f = user.find(b'.')

    if f >= 0:

        user = user[:f]

    return user

def emailuser(user: bytes) -> bytes:

    """Return the user portion of an email address."""

    f = user.find(b'@')

    if f >= 0:

        user = user[:f]

    f = user.find(b'<')

    if f >= 0:

        user = user[f + 1 :]

    return user

def email(author: bytes) -> bytes:

    '''get email of author.'''

    r = author.find(b'>')

    if r == -1:

        r = None

    return author[author.find(b'<') + 1 : r]

def person(author: bytes) -> bytes:

    """Returns the name before an email address,

    interpreting it as per RFC 5322