# Copyright (C) 2020 Red Hat Inc.
#
# Authors:
#  Eduardo Habkost <ehabkost@redhat.com>
#
# This work is licensed under the terms of the GNU GPL, version 2.  See
# the COPYING file in the top-level directory.
"""Helpers for creation of regular expressions"""
import re

import logging
logger = logging.getLogger(__name__)
DBG = logger.debug
INFO = logger.info
WARN = logger.warning

def S(*regexps) -> str:
    """Just a shortcut to concatenate multiple regexps more easily"""
    return ''.join(regexps)

def P(*regexps, name=None, capture=False, repeat='') -> str:
    """Just add parenthesis around regexp(s), with optional name or repeat suffix"""
    s = S(*regexps)
    if name:
        return f'(?P<{name}>{s}){repeat}'
    elif capture:
        return f'({s}){repeat}'
    else:
        return f'(?:{s}){repeat}'

def NAMED(name, *regexps) -> str:
    """Make named group using <P<name>...) syntax

    >>> NAMED('mygroup', 'xyz', 'abc')
    '(?P<mygroup>xyzabc)'
    """
    return P(*regexps, name=name)

def OR(*regexps, **kwargs) -> str:
    """Build (a|b|c) regexp"""
    return P('|'.join(regexps), **kwargs)

def M(*regexps, n='*', name=None) -> str:
    """Add repetition qualifier to regexp(s)

    >>> M('a', 'b')
    '(?:ab)*'
    >>> M('a' , 'b', n='+')
    '(?:ab)+'
    >>> M('a' , 'b', n='{2,3}', name='name')
    '(?P<name>(?:ab){2,3})'
    """
    r = P(*regexps, repeat=n)
    if name:
        r = NAMED(name, r)
    return r

# helper to make parenthesis optional around regexp
OPTIONAL_PARS = lambda R: OR(S(r'\(\s*', R, r'\s*\)'), R)
def test_optional_pars():
    r = OPTIONAL_PARS('abc')+'$'
    assert re.match(r, 'abc')
    assert re.match(r, '(abc)')
    assert not re.match(r, '(abcd)')
    assert not re.match(r, '(abc')
    assert not re.match(r, 'abc)')


# this disables the MULTILINE flag, so it will match at the
# beginning of the file:
RE_FILE_BEGIN = r'(?-m:^)'

# C primitives:

SP = r'\s*'

RE_COMMENT = r'//[^\n]*$|/\*([^*]|\*[^/])*\*/'
RE_COMMENTS = M(RE_COMMENT + SP)

RE_IDENTIFIER = r'[a-zA-Z_][a-zA-Z0-9_]*(?![a-zA-Z0-9])'
RE_STRING = r'\"([^\"\\]|\\[a-z\"])*\"'
RE_NUMBER = r'[0-9]+|0x[0-9a-fA-F]+'

# space or escaped newlines:
CPP_SPACE = OR(r'\s', r'\\\n', repeat='+')

RE_PATH = '[a-zA-Z0-9/_.-]+'

RE_INCLUDEPATH = OR(S(r'\"', RE_PATH, r'\"'),
                    S(r'<', RE_PATH, r'>'))

RE_INCLUDE = S(r'^[ \t]*#[ \t]*include[ \t]+', NAMED('includepath', RE_INCLUDEPATH), r'[ \t]*\n')
RE_SIMPLEDEFINE = S(r'^[ \t]*#[ \t]*define[ \t]+', RE_IDENTIFIER, r'[ \t]*\n')

RE_STRUCT_TYPE = S(r'struct\s+', RE_IDENTIFIER)
RE_TYPE = OR(RE_IDENTIFIER, RE_STRUCT_TYPE)

RE_MACRO_CONCAT = M(S(OR(RE_IDENTIFIER, RE_STRING), SP), n='{2,}')

RE_SIMPLE_VALUE = OR(RE_IDENTIFIER, RE_STRING, RE_NUMBER)

RE_FUN_CALL = S(RE_IDENTIFIER, r'\s*\(\s*', RE_SIMPLE_VALUE, r'\s*\)')
RE_SIZEOF = S(r'sizeof\s*\(\s*', NAMED('sizeoftype', RE_TYPE), r'\s*\)')

RE_ADDRESS = S(r'&\s*', RE_IDENTIFIER)

RE_ARRAY_ITEM = S(r'{\s*', NAMED('arrayitem', M(RE_SIMPLE_VALUE, n='?')), r'\s*}\s*,?')
RE_ARRAY_CAST = S(r'\(\s*', RE_IDENTIFIER, r'\s*\[\s*\]\)')
RE_ARRAY_ITEMS = M(S(RE_ARRAY_ITEM, SP))
RE_ARRAY = S(M(RE_ARRAY_CAST, n='?'), r'\s*{\s*',
             NAMED('arrayitems', RE_ARRAY_ITEMS),
             r'}')

# NOTE: this covers a very small subset of valid expressions

RE_EXPRESSION = OR(RE_SIZEOF, RE_FUN_CALL, RE_MACRO_CONCAT, RE_SIMPLE_VALUE,
                   RE_ARRAY, RE_ADDRESS)