"""
EPython is a code-transformer that translates a statically typed subset of
Python syntax into an extension of Python for a particular backend.

The .epy file is first compiled into an AST
The AST is validated to ensure it uses only the allowed subset of Python
The AST is then fed to a transformer specific to the backend.

"""
import argparse
import ast
import os.path

from epython import __version__
from .validate import validate

# See https://greentreesnakes.readthedocs.io/en/latest/nodes.html

_registry = {}

def register_func(name_or_func):
    if isinstance(name_or_func, str):
        name = name_or_func
        func = None
    else:
        func = name_or_func
        name = func.__name__
    if func is None:
        def decorator(new_func):
            _registry[name] = new_func
            return new_func
        return decorator
    else:
        _registry[name] = func
        return func

# A transformation function needs to take as agruments
#  ast: the validated ast of the code
#  filename: the name to generate the artefacts
#
# It returns the PATH (or URL) of the created artefact

@register_func('cpython')
def transform(ast, name):
    return name + '.so'

# @register_func
# def pypy(mine):
#     return mine

def main():
    find_backends()
    parser = argparse.ArgumentParser(prog='epython',
            description="Compile statically typed subset of Python to a backend.")
    parser.add_argument("file")
    parser.add_argument("--backend", default="cpython")
    parser.add_argument("--name", default="none")
    parser.add_argument("--version", action='version',
                        version='%(prog)s ' + __version__)
    args = parser.parse_args()

    if args.name == 'none':
        name = os.path.splitext(args.file)[0]
    else:
        name = args.name

    with open(args.file) as fi:
        source = fi.read()

    code = ast.parse(source, name, 'exec', type_comments=True)
    result = validate(code)
    if result is not None:
        raise result[0](result[1])

    try:
        transformer = _registry[args.backend]
    except KeyError:
        raise RuntimeError(f"There is no epython backend registered for {args.backend}.")

    output = transformer(code, name)

    from .cython_backend import CythonGenerator
    translator = CythonGenerator()
    print(translator.visit(code))


# importing the backend should be sufficient to call the decorator(s)
# that registers the function in _registry which is why the
# dictionary created here is not returned or seemingly unused.
def find_backends():
    import importlib
    import pkgutil

    # importing the module registers the function.
    discovered_plugins = {
        name: importlib.import_module(name)
        for finder, name, ispkg in pkgutil.iter_modules()
                if name.startswith('epython-')
    }

    if len(discovered_plugins) > len(_registry):
        print("Registry: ")
        print(_registry)
        print("\n\nPlugin Modules Found: ")
        print(discovered_plugins)
        raise (ValueError, "The number of Plugin Modules Found is larger "
               "than the number of transformations successfully registered.")


if __name__ == "__main__":
    code = main()