# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.

"""
Tests for the packaging examples.
"""

import os
from importlib import metadata
from subprocess import run
from tempfile import TemporaryDirectory

from build import ProjectBuilder, BuildBackendException
from build.env import DefaultIsolatedEnv
from twisted.python.filepath import FilePath
from twisted.trial.unittest import TestCase

from incremental import Version


TEST_DIR = FilePath(os.path.abspath(os.path.dirname(__file__)))


def build_and_install(path):  # type: (FilePath) -> None
    with TemporaryDirectory(prefix="dist") as dist_dir:
        with DefaultIsolatedEnv(installer="pip") as env:
            env.install(
                {
                    # Install the *exact* version of Incremental under test.
                    # Otherwise pip might select a different version from
                    # its cache.
                    #
                    # These are formally PEP 508 markers, so we pass a
                    # file URL.
                    "incremental @ file://" + os.environ["TOX_PACKAGE"],
                    # A .pth file so that subprocess generate coverage.
                    "coverage-p",
                }
            )
            builder = ProjectBuilder.from_isolated_env(env, path.path)
            env.install(builder.build_system_requires)
            env.install(builder.get_requires_for_build("wheel", {}))
            pkgfile = builder.build("wheel", output_directory=dist_dir)

        # Force reinstall in case tox reused the venv.
        run(["pip", "install", "--force-reinstall", pkgfile], check=True)


class ExampleTests(TestCase):
    def test_setuppy_version(self):
        """
        example_setuppy has a version of 1.2.3.
        """
        build_and_install(TEST_DIR.child("example_setuppy"))

        import example_setuppy

        self.assertEqual(example_setuppy.__version__.base(), "1.2.3")
        self.assertEqual(metadata.version("example_setuppy"), "1.2.3")

    def test_setuptools_version(self):
        """
        example_setuptools has a version of 2.3.4.
        """
        build_and_install(TEST_DIR.child("example_setuptools"))

        import example_setuptools

        self.assertEqual(example_setuptools.__version__.base(), "2.3.4")
        self.assertEqual(metadata.version("example_setuptools"), "2.3.4")

    def test_setuptools_no_optin(self):
        """
        The setuptools plugin is a no-op when there isn't a
        [tool.incremental] table in pyproject.toml.
        """
        src = FilePath(self.mktemp())
        src.makedirs()
        src.child("pyproject.toml").setContent(
            b"""\
[project]
name = "example_no_optin"
version = "0.0.0"
"""
        )
        package_dir = src.child("example_no_optin")
        package_dir.makedirs()
        package_dir.child("__init__.py").setContent(b"")
        package_dir.child("_version.py").setContent(
            b"from incremental import Version\n"
            b'__version__ = Version("example_no_optin", 24, 7, 0)\n'
        )

        build_and_install(src)

        self.assertEqual(metadata.version("example_no_optin"), "0.0.0")

    def test_setuptools_no_package(self):
        """
        The setuptools plugin is a no-op when there isn't a
        package directory that matches the project name.
        """
        src = FilePath(self.mktemp())
        src.makedirs()
        src.child("pyproject.toml").setContent(
            b"""\
[project]
name = "example_no_package"
version = "0.0.0"

[tool.incremental]
"""
        )

        build_and_install(src)

        self.assertEqual(metadata.version("example_no_package"), "0.0.0")

    def test_setuptools_missing_versionpy(self):
        """
        The setuptools plugin is a no-op when the ``_version.py`` file
        isn't present.
        """
        src = FilePath(self.mktemp())
        src.makedirs()
        src.child("setup.py").setContent(
            b"""\
from setuptools import setup

setup(
    name="example_missing_versionpy",
    version="0.0.1",
    packages=["example_missing_versionpy"],
    zip_safe=False,
)
"""
        )
        src.child("pyproject.toml").setContent(
            b"""\
[tool.incremental]
name = "example_missing_versionpy"
"""
        )
        package_dir = src.child("example_missing_versionpy")
        package_dir.makedirs()
        package_dir.child("__init__.py").setContent(b"")
        # No _version.py exists

        build_and_install(src)

        # The version from setup.py wins.
        self.assertEqual(metadata.version("example_missing_versionpy"), "0.0.1")

    def test_setuptools_bad_versionpy(self):
        """
        The setuptools plugin surfaces syntax errors in ``_version.py``.
        """
        src = FilePath(self.mktemp())
        src.makedirs()
        src.child("setup.py").setContent(
            b"""\
from setuptools import setup

setup(
    name="example_bad_versionpy",
    version="0.1.2",
    packages=["example_bad_versionpy"],
    zip_safe=False,
)
"""
        )
        src.child("pyproject.toml").setContent(
            b"""\
[tool.incremental]
name = "example_bad_versionpy"
"""
        )
        package_dir = src.child("example_bad_versionpy")
        package_dir.makedirs()
        package_dir.child("_version.py").setContent(b"bad version.py")

        with self.assertRaises(BuildBackendException):
            # This also spews a SyntaxError traceback to stdout.
            build_and_install(src)

    def test_hatchling_get_version(self):
        """
        example_hatchling has a version of 24.7.0.
        """
        build_and_install(TEST_DIR.child("example_hatchling"))

        import example_hatchling

        self.assertEqual(
            example_hatchling.__version__,
            Version("example_hatchling", 24, 7, 0),
        )
        self.assertEqual(metadata.version("example_hatchling"), "24.7.0")

    def test_hatch_version(self):
        """
        The ``hatch version`` command reports the version of a package
        packaged with hatchling.
        """
        proc = run(
            ["hatch", "version"],
            cwd=TEST_DIR.child("example_hatchling").path,
            check=True,
            capture_output=True,
        )

        self.assertEqual(proc.stdout, b"24.7.0\n")

    def test_hatch_version_set(self):
        """
        The ``hatch version`` command can't set the version so its output
        tells the user to use ``incremental.update`` instead.
        """
        proc = run(
            ["hatch", "--no-color", "version", "24.8.0"],
            cwd=TEST_DIR.child("example_hatchling").path,
            check=False,
            capture_output=True,
        )
        suggestion = b"Run `python -m incremental.version --newversion 24.8.0` to set the version."

        self.assertGreater(proc.returncode, 0)
        self.assertRegex(
            proc.stdout,
            # Hatch may wrap the output, so we are flexible about the specifics of whitespace.
            suggestion.replace(b".", rb"\.").replace(b" ", b"\\s+"),
        )

    def test_noop(self):
        """
        The Incremental setuptools hook is a silent no-op when there is no Incremental
        configuration to be found.
        """
        build_and_install(TEST_DIR.child("example_noop"))

        import example_noop

        self.assertEqual(example_noop.__version__, "100")
        self.assertEqual(metadata.version("example_noop"), "100")