import glob

import io

import os

import sys

import importlib.metadata

import argparse

import traceback

import json

import subprocess

import re

import tempfile

import email.parser

import pathlib

import zipfile

from pyproject_requirements_txt import convert_requirements_txt

from pyproject_wheel import parse_config_settings_args

# Some valid Python version specifiers are not supported.

# Allow only the forms we know we can handle.

VERSION_RE = re.compile(r'[a-zA-Z0-9.-]+(\.\*)?')

class EndPass(Exception):

    """End current pass of generating requirements"""

# nb: we don't use functools.partial to be able to use pytest's capsys

# see https://github.com/pytest-dev/pytest/issues/8900

def print_err(*args, **kwargs):

    kwargs.setdefault('file', sys.stderr)

    print(*args, **kwargs)

try:

    from packaging.requirements import Requirement, InvalidRequirement

    from packaging.utils import canonicalize_name

except ImportError as e:

    print_err('Import error:', e)

    # already echoed by the %pyproject_buildrequires macro

    sys.exit(0)

# uses packaging, needs to be imported after packaging is verified to be present

from pyproject_convert import convert

def guess_reason_for_invalid_requirement(requirement_str):

    if ':' in requirement_str:

        message = (

            'It might be an URL. '

            '%pyproject_buildrequires cannot handle all URL-based requirements. '

            'Add PackageName@ (see PEP 508) to the URL to at least require any version of PackageName.'

        )

        if '@' in requirement_str:

            message += ' (but note that URLs might not work well with other features)'

        return message

    if '/' in requirement_str:

        return (

            'It might be a local path. '

            '%pyproject_buildrequires cannot handle local paths as requirements. '

            'Use an URL with PackageName@ (see PEP 508) to at least require any version of PackageName.'

        )

    # No more ideas

    return None

class Requirements:

    """Requirement gatherer. The macro will eventually print out output_lines."""

    def __init__(self, get_installed_version, extras=None,

                 generate_extras=False, python3_pkgversion='3', config_settings=None):

        self.get_installed_version = get_installed_version

        self.output_lines = []

        self.extras = set()

        if extras:

            for extra in extras:

                self.add_extras(*extra.split(','))

        self.missing_requirements = False

        self.ignored_alien_requirements = []

        self.generate_extras = generate_extras

        self.python3_pkgversion = python3_pkgversion

        self.config_settings = config_settings

    def add_extras(self, *extras):

        self.extras |= set(e.strip() for e in extras)

    @property

    def marker_envs(self):

        if self.extras:

            return [{'extra': e} for e in sorted(self.extras)]

        return [{'extra': ''}]

    def evaluate_all_environments(self, requirement):

        for marker_env in self.marker_envs:

            if requirement.marker.evaluate(environment=marker_env):

                return True

        return False

    def add(self, requirement_str, *, package_name=None, source=None):

        """Output a Python-style requirement string as RPM dep"""

        print_err(f'Handling {requirement_str} from {source}')

        try:

            requirement = Requirement(requirement_str)

        except InvalidRequirement:

            hint = guess_reason_for_invalid_requirement(requirement_str)

            message = f'Requirement {requirement_str!r} from {source} is invalid.'

            if hint:

                message += f' Hint: {hint}'

            raise ValueError(message)

        if requirement.url:

            print_err(

                f'WARNING: Simplifying {requirement_str!r} to {requirement.name!r}.'

            )

        name = canonicalize_name(requirement.name)

        if (requirement.marker is not None and

                not self.evaluate_all_environments(requirement)):

            print_err(f'Ignoring alien requirement:', requirement_str)

            self.ignored_alien_requirements.append(requirement_str)

            return

        # Handle self-referencing requirements

        if package_name and canonicalize_name(package_name) == name:

            # Self-referential extras need to be handled specially

            if requirement.extras:

                if not (requirement.extras <= self.extras):  # only handle it if needed

                    # let all further requirements know we want those extras

                    self.add_extras(*requirement.extras)

                    # re-add all of the alien requirements ignored in the past

                    # they might no longer be alien now

                    self.readd_ignored_alien_requirements(package_name=package_name)

            else:

                print_err(f'Ignoring self-referential requirement without extras:', requirement_str)

            return

        # We need to always accept pre-releases as satisfying the requirement

        # Otherwise e.g. installed cffi version 1.15.0rc2 won't even satisfy the requirement for "cffi"

        # https://bugzilla.redhat.com/show_bug.cgi?id=2014639#c3

        requirement.specifier.prereleases = True

        try:

            # TODO: check if requirements with extras are satisfied

            installed = self.get_installed_version(requirement.name)

        except importlib.metadata.PackageNotFoundError:

            print_err(f'Requirement not satisfied: {requirement_str}')

            installed = None

        if installed and installed in requirement.specifier:

            print_err(f'Requirement satisfied: {requirement_str}')

            print_err(f'   (installed: {requirement.name} {installed})')

            if requirement.extras:

                print_err(f'   (extras are currently not checked)')

        else:

            self.missing_requirements = True

        if self.generate_extras:

            extra_names = [f'{name}[{extra.lower()}]' for extra in sorted(requirement.extras)]

        else:

            extra_names = []

        for name in [name] + extra_names:

            together = []

            for specifier in sorted(

                requirement.specifier,

                key=lambda s: (s.operator, s.version),

            ):

                if not VERSION_RE.fullmatch(str(specifier.version)):

                    raise ValueError(

                        f'Unknown character in version: {specifier.version}. '

                        + '(This might be a bug in pyproject-rpm-macros.)',

                    )

                together.append(convert(python3dist(name, python3_pkgversion=self.python3_pkgversion),

                                        specifier.operator, specifier.version))

            if len(together) == 0:

                dep = python3dist(name, python3_pkgversion=self.python3_pkgversion)

                self.output_lines.append(dep)

            elif len(together) == 1:

                self.output_lines.append(together[0])

            else:

                self.output_lines.append(f"({' with '.join(together)})")

    def check(self, *, source=None):

        """End current pass if any unsatisfied dependencies were output"""

        if self.missing_requirements:

            print_err(f'Exiting dependency generation pass: {source}')

            raise EndPass(source)

    def extend(self, requirement_strs, **kwargs):

        """add() several requirements"""

        for req_str in requirement_strs:

            self.add(req_str, **kwargs)

    def readd_ignored_alien_requirements(self, **kwargs):

        """add() previously ignored alien requirements again."""

        requirements, self.ignored_alien_requirements = self.ignored_alien_requirements, []

        kwargs.setdefault('source', 'Previously ignored alien requirements')

        self.extend(requirements, **kwargs)

def toml_load(opened_binary_file):

    try:

        # tomllib is in the standard library since 3.11.0b1

        import tomllib

    except ImportError:

        try:

            import tomli as tomllib

        except ImportError as e:

            print_err('Import error:', e)

            # already echoed by the %pyproject_buildrequires macro

            sys.exit(0)

    return tomllib.load(opened_binary_file)

def get_backend(requirements):

    try:

        f = open('pyproject.toml', 'rb')

    except FileNotFoundError:

        pyproject_data = {}

    else:

        with f:

            pyproject_data = toml_load(f)

    buildsystem_data = pyproject_data.get('build-system', {})

    requirements.extend(

        buildsystem_data.get('requires', ()),

        source='build-system.requires',

    )

    backend_name = buildsystem_data.get('build-backend')

    if not backend_name:

        # https://www.python.org/dev/peps/pep-0517/:

        # If the pyproject.toml file is absent, or the build-backend key is

        # missing, the source tree is not using this specification, and tools

        # should revert to the legacy behaviour of running setup.py

        # (either directly, or by implicitly invoking the [following] backend).

        # If setup.py is also not present program will mimick pip's behavior

        # and end with an error.

        if not os.path.exists('setup.py'):

            raise FileNotFoundError('File "setup.py" not found for legacy project.')

        backend_name = 'setuptools.build_meta:__legacy__'

        # Note: For projects without pyproject.toml, this was already echoed

        # by the %pyproject_buildrequires macro, but this also handles cases

        # with pyproject.toml without a specified build backend.

        # If the default requirements change, also change them in the macro!

        requirements.add('setuptools >= 40.8', source='default build backend')

        requirements.add('wheel', source='default build backend')

    requirements.check(source='build backend')

    backend_path = buildsystem_data.get('backend-path')

    if backend_path:

        # PEP 517 example shows the path as a list, but some projects don't follow that

        if isinstance(backend_path, str):

            backend_path = [backend_path]

        sys.path = backend_path + sys.path

    module_name, _, object_name = backend_name.partition(":")

    backend_module = importlib.import_module(module_name)

    if object_name:

        return getattr(backend_module, object_name)

    return backend_module

def generate_build_requirements(backend, requirements):

    get_requires = getattr(backend, 'get_requires_for_build_wheel', None)

    if get_requires:

        new_reqs = get_requires(config_settings=requirements.config_settings)

        requirements.extend(new_reqs, source='get_requires_for_build_wheel')

        requirements.check(source='get_requires_for_build_wheel')

def parse_metadata_file(metadata_file):

    return email.parser.Parser().parse(metadata_file, headersonly=True)

def requires_from_parsed_metadata_file(message):

    return {k: message.get_all(k, ()) for k in ('Requires', 'Requires-Dist')}

def package_name_from_parsed_metadata_file(message):

    return message.get('name')

def package_name_and_requires_from_metadata_file(metadata_file):

    message = parse_metadata_file(metadata_file)

    package_name = package_name_from_parsed_metadata_file(message)

    requires = requires_from_parsed_metadata_file(message)

    return package_name, requires

def generate_run_requirements_hook(backend, requirements):

    hook_name = 'prepare_metadata_for_build_wheel'

    prepare_metadata = getattr(backend, hook_name, None)

    if not prepare_metadata:

        raise ValueError(

            'The build backend cannot provide build metadata '

            '(incl. runtime requirements) before build. '

            'Use the provisional -w flag to build the wheel and parse the metadata from it, '

            'or use the -R flag not to generate runtime dependencies.'

        )

    dir_basename = prepare_metadata('.', config_settings=requirements.config_settings)

    with open(dir_basename + '/METADATA') as metadata_file:

        name, requires = package_name_and_requires_from_metadata_file(metadata_file)

        for key, req in requires.items():

            requirements.extend(req,

                                package_name=name,

                                source=f'hook generated metadata: {key} ({name})')

def find_built_wheel(wheeldir):

    wheels = glob.glob(os.path.join(wheeldir, '*.whl'))

    if not wheels:

        return None

    if len(wheels) > 1:

        raise RuntimeError('Found multiple wheels in %{_pyproject_wheeldir}, '

                           'this is not supported with %pyproject_buildrequires -w.')

    return wheels[0]

def generate_run_requirements_wheel(backend, requirements, wheeldir):

    # Reuse the wheel from the previous round of %pyproject_buildrequires (if it exists)

    wheel = find_built_wheel(wheeldir)

    if not wheel:

        import pyproject_wheel

        returncode = pyproject_wheel.build_wheel(

            wheeldir=wheeldir,

            stdout=sys.stderr,

            config_settings=requirements.config_settings,

        )

        if returncode != 0:

            raise RuntimeError('Failed to build the wheel for %pyproject_buildrequires -w.')

        wheel = find_built_wheel(wheeldir)

    if not wheel:

        raise RuntimeError('Cannot locate the built wheel for %pyproject_buildrequires -w.')

    print_err(f'Reading metadata from {wheel}')

    with zipfile.ZipFile(wheel) as wheelfile:

        for name in wheelfile.namelist():

            if name.count('/') == 1 and name.endswith('.dist-info/METADATA'):

                with io.TextIOWrapper(wheelfile.open(name), encoding='utf-8') as metadata_file:

                    name, requires = package_name_and_requires_from_metadata_file(metadata_file)

                    for key, req in requires.items():

                        requirements.extend(req,

                                            package_name=name,

                                            source=f'built wheel metadata: {key} ({name})')

                break

        else:

            raise RuntimeError('Could not find *.dist-info/METADATA in built wheel.')

def generate_run_requirements(backend, requirements, *, build_wheel, wheeldir):

    if build_wheel:

        generate_run_requirements_wheel(backend, requirements, wheeldir)

    else:

        generate_run_requirements_hook(backend, requirements)

def generate_tox_requirements(toxenv, requirements):

    toxenv = ','.join(toxenv)

    requirements.add('tox-current-env >= 0.0.6', source='tox itself')

    requirements.check(source='tox itself')

    with tempfile.NamedTemporaryFile('r') as deps, \

        tempfile.NamedTemporaryFile('r') as extras, \

            tempfile.NamedTemporaryFile('r') as provision:

        r = subprocess.run(

            [sys.executable, '-m', 'tox',

             '--print-deps-to', deps.name,

             '--print-extras-to', extras.name,

             '--no-provision', provision.name,

             '-q', '-r', '-e', toxenv],

            check=False,

            encoding='utf-8',

            stdout=subprocess.PIPE,

            stderr=subprocess.STDOUT,

        )

        if r.stdout:

            print_err(r.stdout, end='')

        provision_content = provision.read()

        if provision_content and r.returncode != 0:

            provision_requires = json.loads(provision_content)

            if 'minversion' in provision_requires:

                requirements.add(f'tox >= {provision_requires["minversion"]}',

                                 source='tox provision (minversion)')

            if 'requires' in provision_requires:

                requirements.extend(provision_requires["requires"],

                                    source='tox provision (requires)')

            requirements.check(source='tox provision')  # this terminates the script

            raise RuntimeError(

                'Dependencies requested by tox provisioning appear installed, '

                'but tox disagreed.')

        else:

            r.check_returncode()

        deplines = deps.read().splitlines()

        packages = convert_requirements_txt(deplines)

        requirements.add_extras(*extras.read().splitlines())

        requirements.extend(packages,

                            source=f'tox --print-deps-only: {toxenv}')

def python3dist(name, op=None, version=None, python3_pkgversion="3"):

    prefix = f"python{python3_pkgversion}dist"

    if op is None:

        if version is not None:

            raise AssertionError('op and version go together')

        return f'{prefix}({name})'

    else:

        return f'{prefix}({name}) {op} {version}'

def generate_requires(

    *, include_runtime=False, build_wheel=False, wheeldir=None, toxenv=None, extras=None,

    get_installed_version=importlib.metadata.version,  # for dep injection

    generate_extras=False, python3_pkgversion="3", requirement_files=None, use_build_system=True,

    output, config_settings=None,

):

    """Generate the BuildRequires for the project in the current directory

    The generated BuildRequires are written to the provided output.

    This is the main Python entry point.

    """

    requirements = Requirements(

        get_installed_version, extras=extras or [],

        generate_extras=generate_extras,

        python3_pkgversion=python3_pkgversion,

        config_settings=config_settings,

    )

    try:

        if (include_runtime or toxenv) and not use_build_system:

            raise ValueError('-N option cannot be used in combination with -r, -e, -t, -x options')

        if requirement_files:

            for req_file in requirement_files:

                requirements.extend(

                    convert_requirements_txt(req_file, pathlib.Path(req_file.name)),

                    source=f'requirements file {req_file.name}'

                )

            requirements.check(source='all requirements files')

        if use_build_system:

            backend = get_backend(requirements)

            generate_build_requirements(backend, requirements)

        if toxenv:

            include_runtime = True

            generate_tox_requirements(toxenv, requirements)

        if include_runtime:

            generate_run_requirements(backend, requirements, build_wheel=build_wheel, wheeldir=wheeldir)

    except EndPass:

        return

    finally:

        output.write_text(os.linesep.join(requirements.output_lines) + os.linesep)

def main(argv):

    parser = argparse.ArgumentParser(

        description='Generate BuildRequires for a Python project.',

        prog='%pyproject_buildrequires',

        add_help=False,

    )

    parser.add_argument(

        '--help', action='help',

        default=argparse.SUPPRESS,

        help=argparse.SUPPRESS,

    )

    parser.add_argument(

        '-r', '--runtime', action='store_true', default=True,

        help=argparse.SUPPRESS,  # Generate run-time requirements (backwards-compatibility only)

    )

    parser.add_argument(

        '--generate-extras', action='store_true',

        help=argparse.SUPPRESS,

    )

    parser.add_argument(

        '-p', '--python3_pkgversion', metavar='PYTHON3_PKGVERSION',

        default="3", help=argparse.SUPPRESS,

    )

    parser.add_argument(

        '--output', type=pathlib.Path, required=True, help=argparse.SUPPRESS,

    )

    parser.add_argument(

        '--wheeldir', metavar='PATH', default=None,

        help=argparse.SUPPRESS,

    )

    parser.add_argument(

        '-x', '--extras', metavar='EXTRAS', action='append',

        help='comma separated list of "extras" for runtime requirements '

             '(e.g. -x testing,feature-x) (implies --runtime, can be repeated)',

    )

    parser.add_argument(

        '-t', '--tox', action='store_true',

        help=('generate test tequirements from tox environment '

              '(implies --runtime)'),

    )

    parser.add_argument(

        '-e', '--toxenv', metavar='TOXENVS', action='append',

        help=('specify tox environments (comma separated and/or repeated)'

              '(implies --tox)'),

    )

    parser.add_argument(

        '-w', '--wheel', action='store_true', default=False,

        help=('Generate run-time requirements by building the wheel '

              '(useful for build backends without the prepare_metadata_for_build_wheel hook)'),

    )

    parser.add_argument(

        '-R', '--no-runtime', action='store_false', dest='runtime',

        help="Don't generate run-time requirements (implied by -N)",

    )

    parser.add_argument(

        '-N', '--no-use-build-system', dest='use_build_system',

        action='store_false', help='Use -N to indicate that project does not use any build system',

    )

    parser.add_argument(

        'requirement_files', nargs='*', type=argparse.FileType('r'),

        metavar='REQUIREMENTS.TXT',

        help=('Add buildrequires from file'),

    )

    parser.add_argument(

        '-C',

        dest='config_settings',

        action='append',

        help='Configuration settings to pass to the PEP 517 backend',

    )

    args = parser.parse_args(argv)

    if not args.use_build_system:

        args.runtime = False

    if args.wheel:

        if not args.wheeldir:

            raise ValueError('--wheeldir must be set when -w.')

    if args.toxenv:

        args.tox = True

    if args.tox:

        args.runtime = True

        if not args.toxenv:

            _default = f'py{sys.version_info.major}{sys.version_info.minor}'

            args.toxenv = [os.getenv('RPM_TOXENV', _default)]

    if args.extras:

        args.runtime = True

    try:

        generate_requires(

            include_runtime=args.runtime,

            build_wheel=args.wheel,

            wheeldir=args.wheeldir,

            toxenv=args.toxenv,

            extras=args.extras,

            generate_extras=args.generate_extras,

            python3_pkgversion=args.python3_pkgversion,

            requirement_files=args.requirement_files,

            use_build_system=args.use_build_system,

            output=args.output,

            config_settings=parse_config_settings_args(args.config_settings),

        )

    except Exception:

        # Log the traceback explicitly (it's useful debug info)

        traceback.print_exc()

        exit(1)

if __name__ == '__main__':

    main(sys.argv[1:])