"""
Parse and translate an EBNF grammar into a Python parser for
the described language.
"""
# ruff: noqa: PLR0912
from __future__ import annotations

import argparse
import codecs
import importlib
import sys
from pathlib import Path

from ._version import __version__
from .exceptions import ParseException
from .ngcodegen import codegen as ngpythoncg
from .ngcodegen import objectmodel as ngobjectmodel
from .parser import GrammarGenerator
from .parserconfig import ParserConfig
from .semantics import ModelBuilderSemantics
from .util import eval_escapes

DESCRIPTION = (
    'TatSu takes a grammar'
    ' in a variation of EBNF as input, and outputs a memoizing'
    ' PEG/Packrat parser in Python.'
)


def parse_args():
    argparser = argparse.ArgumentParser(
        prog='tatsu', description=DESCRIPTION, add_help=False,
    )

    main_mode = argparser.add_mutually_exclusive_group()
    main_mode.add_argument(
        '--generate-parser',
        help='generate parser code from the grammar (default)',
        action='store_true',
    )
    main_mode.add_argument(
        '--draw',
        '-d',
        help='generate a diagram of the grammar (requires --outfile)',
        action='store_true',
    )
    main_mode.add_argument(
        '--object-model',
        '-g',
        help='generate object model from the class names given as rule arguments',
        action='store_true',
    )
    main_mode.add_argument(
        '--pretty',
        '-p',
        help='generate a prettified version of the input grammar',
        action='store_true',
    )
    main_mode.add_argument(
        '--pretty-lean',
        help='like --pretty, but without name: or ::Parameter annotations',
        action='store_true',
    )

    ebnf_opts = argparser.add_argument_group('parse-time options')
    argparser.add_argument(
        'filename',
        metavar='GRAMMAR',
        help='the filename of the TatSu grammar to parse',
    )
    ebnf_opts.add_argument(
        '--color',
        '-c',
        help='use color in traces (requires the colorama library)',
        action='store_true',
    )
    ebnf_opts.add_argument(
        '--trace',
        '-t',
        help='produce verbose parsing output',
        action='store_true',
    )

    generation_opts = argparser.add_argument_group('generation options')
    generation_opts.add_argument(
        '--no-left-recursion',
        '-l',
        help='turns left-recursion support off',
        dest='left_recursion',
        action='store_false',
        default=True,
    )
    generation_opts.add_argument(
        '--name',
        '-m',
        metavar='NAME',
        help='Name for the grammar (defaults to GRAMMAR base name)',
    )
    generation_opts.add_argument(
        '--no-nameguard',
        '-n',
        help='allow tokens that are prefixes of others',
        dest='nameguard',
        action='store_false',
        default=None,  # None allows grammar specified
    )
    generation_opts.add_argument(
        '--outfile',
        '--output',
        '-o',
        metavar='FILE',
        help='output file (default is stdout)',
    )
    generation_opts.add_argument(
        '--object-model-outfile',
        '-G',
        metavar='FILE',
        help='generate object model and save to FILE',
    )
    generation_opts.add_argument(
        '--whitespace',
        '-w',
        metavar='CHARACTERS',
        help='characters to skip during parsing (use "" to disable)',
    )

    def import_class(path):
        try:
            spath = path.rsplit('.', 1)
            module = importlib.import_module(spath[0])

            return getattr(module, spath[1])
        except Exception as e:
            raise argparse.ArgumentTypeError(
                f"Couldn't find class {path}",
            ) from e

    generation_opts.add_argument(
        '--base-type',
        metavar='CLASSPATH',
        help='class to use as base type for the object model, for example "mymodule.MyNode"',
        type=import_class,
    )

    std_args = argparser.add_argument_group('common options')
    std_args.add_argument(
        '--help', '-h', help='show this help message and exit', action='help',
    )
    std_args.add_argument(
        '--version',
        '-V',
        help='provide version information and exit',
        action='version',
        version=__version__,
    )

    args = argparser.parse_args()

    if args.draw and not args.outfile:
        argparser.error('--draw requires --outfile')

    return args


__compiled_grammar_cache = {}  # type: ignore[var-annotated]


def compile(
    grammar,
    name=None,
    semantics=None,
    asmodel=False,
    config: ParserConfig | None = None,
    **settings,
):
    cache = __compiled_grammar_cache

    key = (name, grammar, id(semantics))
    if key in cache:
        model = cache[key]
    else:
        gen = GrammarGenerator(name, config=config, **settings)
        model = cache[key] = gen.parse(grammar, config=config, **settings)

    if semantics is not None:
        model.semantics = semantics
    elif asmodel:
        model.semantics = ModelBuilderSemantics()

    return model


def parse(
    grammar,
    input,
    start=None,
    name=None,
    semantics=None,
    asmodel=False,
    config: ParserConfig | None = None,
    **settings,
):
    model = compile(
        grammar,
        name=name,
        semantics=semantics,
        asmodel=asmodel,
        config=config,
        **settings,
    )
    return model.parse(
        input, start=start, semantics=semantics, config=config, **settings,
    )


def to_python_sourcecode(
    grammar,
    name=None,
    filename=None,
    config: ParserConfig | None = None,
    **settings,
):
    model = compile(
        grammar, name=name, filename=filename, config=config, **settings,
    )
    return ngpythoncg(model)


def to_python_model(
    grammar,
    name=None,
    filename=None,
    base_type=None,
    config: ParserConfig | None = None,
    **settings,
):
    model = compile(
        grammar, name=name, filename=filename, config=config, **settings,
    )
    return ngobjectmodel.modelgen(model, base_type=base_type)


# for backwards compatibility. Use `compile()` instead
def genmodel(
    name=None,
    grammar=None,
    semantics=None,
    config: ParserConfig | None = None,
    **settings,
):
    if grammar is None:
        raise ParseException('grammar is None')

    return compile(
        grammar, name=name, semantics=semantics, config=config, **settings,
    )


def gencode(
    name=None,
    grammar=None,
    trace=False,
    filename=None,
    codegen=ngpythoncg,
    config: ParserConfig | None = None,
    **settings,
):
    model = compile(
        grammar,
        name=name,
        filename=filename,
        trace=trace,
        config=config,
        **settings,
    )
    return codegen(model)


def prepare_for_output(filename):
    if filename:
        filename = Path(filename)
        if filename.is_file():
            filename.unlink()
        dirname = filename.parent
        if dirname.exists():
            dirname.mkdir(parents=True, exist_ok=True)


def save(filename, content):
    with codecs.open(filename, 'w', encoding='utf-8') as f:
        f.write(content)


def main():
    args = parse_args()

    if args.whitespace:
        args.whitespace = eval_escapes(args.whitespace)

    outfile = args.outfile
    prepare_for_output(outfile)
    prepare_for_output(args.object_model_outfile)

    grammar = codecs.open(args.filename, encoding='utf-8').read()

    try:
        model = compile(
            grammar,
            args.name,
            trace=args.trace,
            filename=args.filename,
            colorize=args.color,
        )
        model.whitespace = args.whitespace
        model.nameguard = args.nameguard
        model.left_recursion = args.left_recursion

        if args.draw:
            from tatsu import diagrams

            diagrams.draw(outfile, model)
        else:
            if args.pretty:
                result = model.pretty()
            elif args.pretty_lean:
                result = model.pretty_lean()
            elif args.object_model:
                result = ngobjectmodel.modelgen(model, base_type=args.base_type)
            else:
                result = ngpythoncg(model)

            if outfile:
                save(outfile, result)
            else:
                print(result)

        # if requested, always save it
        if args.object_model_outfile:
            save(
                args.object_model_outfile,
                ngobjectmodel.modelgen(model, base_type=args.base_type),
            )

        print('-' * 72, file=sys.stderr)
        print(
            f'{len(grammar.split()):12,d}  lines in grammar', file=sys.stderr,
        )
        print(f'{len(model.rules):12,d}  rules in grammar', file=sys.stderr)
        print(f'{model.nodecount():12,d}  nodes in AST', file=sys.stderr)
    except ParseException as e:
        print(e, file=sys.stderr)
        sys.exit(1)


if __name__ == '__main__':
    main()