"""
Collect interpreter information, also run as the subprocess interrogation script (stdlib only).

Executed by the interpreter being probed. Collection supports Python 3.6+, but the file must parse on 2.7 so the
version gate below can report older interpreters instead of dying with a ``SyntaxError``: no f-strings, no walrus
operator, no annotations, no typing imports, no imports from this package. The gate sits above every other import
so that 3.0 and 3.1, which lack ``sysconfig``, still reach it.
"""

import sys

MIN_INTERROGATE_VERSION = (3, 6)
UNSUPPORTED_EXIT_CODE = 79  # first value past the sysexits.h range, so no stdlib or shell meaning
UNSUPPORTED_MARKER = "unsupported Python version "

if __name__ == "__main__" and sys.version_info[:2] < MIN_INTERROGATE_VERSION:  # pragma: no cover # needs <3.6
    sys.stderr.write(UNSUPPORTED_MARKER + ".".join(str(i) for i in sys.version_info[:3]))
    raise SystemExit(UNSUPPORTED_EXIT_CODE)

import json
import os
import platform
import re
import struct
import sysconfig
import warnings
from collections import namedtuple

# ruff:ignore[collections-named-tuple] # typing.NamedTuple class syntax needs annotations, unavailable on 3.6
VersionInfo = namedtuple("VersionInfo", ["major", "minor", "micro", "releaselevel", "serial"])

_32BIT_POINTER_SIZE = 4
_CONF_VAR_RE = re.compile(
    r"""
    \{ \w+  }   # sysconfig variable placeholder like {base}
    """,
    re.VERBOSE,
)


class PythonInfoCollector:
    """Collects information about the currently running Python interpreter."""

    def __init__(self):
        self._init_identity()
        self._init_prefixes()
        self._init_schemes()
        self._init_sysconfig()

    def _init_identity(self):
        self.platform = sys.platform
        self.implementation = platform.python_implementation()
        if self.implementation == "GraalVM":
            self.implementation = "GraalPy"
        if self.implementation == "PyPy":
            self.pypy_version_info = tuple(sys.pypy_version_info)  # ty: ignore[unresolved-attribute] # pypy only

        self.version_info = VersionInfo(*sys.version_info)
        # same as stdlib platform.architecture to account for pointer size != max int
        self.architecture = 32 if struct.calcsize("P") == _32BIT_POINTER_SIZE else 64
        self.sysconfig_platform = sysconfig.get_platform()
        self.version_nodot = sysconfig.get_config_var("py_version_nodot")
        self.version = sys.version
        self.os = os.name
        self.free_threaded = sysconfig.get_config_var("Py_GIL_DISABLED") == 1
        self.debug_build = bool(sysconfig.get_config_var("Py_DEBUG"))

    def _init_prefixes(self):
        def abs_path(value):
            return None if value is None else os.path.abspath(value)

        self.prefix = abs_path(getattr(sys, "prefix", None))
        self.base_prefix = abs_path(getattr(sys, "base_prefix", None))
        self.real_prefix = abs_path(getattr(sys, "real_prefix", None))
        self.base_exec_prefix = abs_path(getattr(sys, "base_exec_prefix", None))
        self.exec_prefix = abs_path(getattr(sys, "exec_prefix", None))

        self.executable = abs_path(sys.executable)
        self.original_executable = abs_path(self.executable)
        self.system_executable = self._fast_get_system_executable()

        try:
            __import__("venv")
            has = True
        except ImportError:  # pragma: no cover # venv is always available in standard CPython
            has = False
        self.has_venv = has
        self.path = sys.path
        self.file_system_encoding = sys.getfilesystemencoding()
        self.stdout_encoding = getattr(sys.stdout, "encoding", None)

    def _init_schemes(self):
        scheme_names = sysconfig.get_scheme_names()

        if "venv" in scheme_names:  # pragma: >=3.11 cover
            self.sysconfig_scheme = "venv"
            self.sysconfig_paths = {
                i: sysconfig.get_path(i, expand=False, scheme=self.sysconfig_scheme) for i in sysconfig.get_path_names()
            }
            self.distutils_install = {}
        # debian / ubuntu python 3.10 without `python3-distutils` will report mangled `local/bin` / etc. names
        elif sys.version_info[:2] == (3, 10) and "deb_system" in scheme_names:  # pragma: no cover # Debian/Ubuntu 3.10
            self.sysconfig_scheme = "posix_prefix"
            self.sysconfig_paths = {
                i: sysconfig.get_path(i, expand=False, scheme=self.sysconfig_scheme) for i in sysconfig.get_path_names()
            }
            self.distutils_install = {}
        else:  # pragma: no cover # "venv" scheme always present on Python 3.12+
            self.sysconfig_scheme = None
            self.sysconfig_paths = {i: sysconfig.get_path(i, expand=False) for i in sysconfig.get_path_names()}
            self.distutils_install = self._distutils_install().copy()

    def _init_sysconfig(self):
        makefile = getattr(sysconfig, "get_makefile_filename", getattr(sysconfig, "_get_makefile_filename", None))
        self.sysconfig = {
            k: v
            for k, v in [
                ("makefile_filename", makefile() if makefile is not None else None),
            ]
            if k is not None
        }

        config_var_keys = set()
        for element in self.sysconfig_paths.values():
            config_var_keys.update(k[1:-1] for k in _CONF_VAR_RE.findall(element))
        config_var_keys.add("PYTHONFRAMEWORK")
        config_var_keys.update(("Py_ENABLE_SHARED", "INSTSONAME", "LIBDIR"))

        self.sysconfig_vars = {i: sysconfig.get_config_var(i or "") for i in config_var_keys}

        if "TCL_LIBRARY" in os.environ:
            self.tcl_lib, self.tk_lib = self._get_tcl_tk_libs()
        else:
            self.tcl_lib, self.tk_lib = None, None

        system_prefix = self.real_prefix or self.base_prefix or self.prefix
        confs = {
            k: (system_prefix if isinstance(v, str) and v.startswith(self.prefix) else v)
            for k, v in self.sysconfig_vars.items()
        }
        self.system_stdlib = self._sysconfig_path("stdlib", confs)
        self.system_stdlib_platform = self._sysconfig_path("platstdlib", confs)
        self.max_size = getattr(sys, "maxsize", getattr(sys, "maxint", None))
        self._creators = None  # virtualenv-specific, set via monkey-patch

    def _sysconfig_path(self, key, config_var):
        pattern = self.sysconfig_paths.get(key)
        if pattern is None:  # custom builds may ship schemes without stdlib / platstdlib
            return ""
        base = self.sysconfig_vars.copy()
        base.update(config_var)
        return pattern.format(**base).replace("/", os.sep)

    @staticmethod
    def _get_tcl_tk_libs():  # pragma: no cover # tkinter availability varies; tested indirectly via __init__
        """Detect the tcl and tk libraries using tkinter."""
        tcl_lib, tk_lib = None, None
        try:
            import tkinter as tk  # ruff:ignore[import-outside-top-level] # novermin # unreached below the version gate
        except ImportError:
            pass
        else:
            try:
                tcl = tk.Tcl()
                tcl_lib = tcl.eval("info library")
                tk_lib = PythonInfoCollector._resolve_tk_lib(tcl, tcl_lib)
            except tk.TclError:
                pass

        return tcl_lib, tk_lib

    @staticmethod
    def _query_tk_library(tcl):  # pragma: no cover
        """Try to get the TK library path directly from Tcl."""
        import tkinter as tk  # ruff:ignore[import-outside-top-level] # novermin # unreached below the version gate

        try:
            tk_lib = tcl.eval("set tk_library")
            if tk_lib and os.path.isdir(tk_lib):
                return tk_lib
        except tk.TclError:
            pass
        return None

    @staticmethod
    def _resolve_tk_lib(tcl, tcl_lib):  # pragma: no cover
        """Resolve the TK library path by direct query or path construction."""
        tk_lib = PythonInfoCollector._query_tk_library(tcl)
        if tk_lib is not None:
            return tk_lib
        tk_version = tcl.eval("package require Tk")
        tcl_parent = os.path.dirname(tcl_lib)
        for version in (tk_version, ".".join(tk_version.split(".")[:2]), tk_version.split(".")[0]):
            tk_lib_path = os.path.join(tcl_parent, "tk{}".format(version))
            if os.path.isdir(tk_lib_path) and os.path.exists(os.path.join(tk_lib_path, "tk.tcl")):
                return tk_lib_path
        return None

    def _fast_get_system_executable(self):
        """Try to get the system executable by just looking at properties."""
        # if we're not in a virtual environment, this is already a system python, so return the original executable
        # note we must choose the original and not the pure executable as shim scripts might throw us off
        if not (self.real_prefix or (self.base_prefix is not None and self.base_prefix != self.prefix)):
            return self._resolve_executable_symlink(self.original_executable)

        # if this is NOT a virtual environment, can't determine easily, bail out
        if self.real_prefix is not None:
            return None

        base_executable = getattr(sys, "_base_executable", None)  # some platforms may set this to help us
        if base_executable is None:  # use the saved system executable if present
            return None

        # we know we're in a virtual environment, can not be us
        if sys.executable == base_executable:
            return None

        # We're not in a venv and base_executable exists; use it directly
        if os.path.exists(base_executable):  # pragma: >=3.11 cover
            return self._resolve_executable_symlink(base_executable)

        # Try fallback for POSIX virtual environments
        return self._try_posix_fallback_executable(base_executable)  # pragma: >=3.11 cover

    def _resolve_executable_symlink(self, path):
        """
        Resolve symlinks of the executable itself, but never of its parent directories.

        Mirrors CPython's ``getpath.realpath`` (and ``venv`` in python/cpython#115237): an executable-only symlink
        resolves to the real interpreter so its home can be located, while a fully symlinked interpreter tree is
        kept as-is. Like ``getpath``, resolution stops as soon as the stdlib landmark is reachable from the current
        directory - an alias such as Debian's ``/usr/bin/python3`` is a usable home and stays untouched.
        """
        result = os.path.abspath(path)
        if self.os != "posix":  # pragma: win32 cover # CPython only does this where HAVE_READLINK
            return result
        if sysconfig.get_config_var("PYTHONFRAMEWORK"):  # macOS framework builds self-locate via dyld; e.g. Homebrew
            return result  # resolving would pin the versioned Cellar path into the recorded home
        real_path = os.path.realpath(result)
        if not os.path.exists(real_path):  # symlink loop or broken symlink
            return result
        while os.path.islink(result):
            if self._stdlib_landmark_exists(os.path.dirname(result)):
                return result
            link = os.readlink(result)
            candidate = link if os.path.isabs(link) else os.path.normpath(os.path.join(os.path.dirname(result), link))
            # normpath through a symlinked directory may point at a different file - stop resolving there
            if not (os.path.exists(candidate) and os.path.samefile(real_path, candidate)):
                return result
            result = candidate
        return result

    @staticmethod
    def _stdlib_landmark_exists(dir_path):
        lib_name = os.path.basename(os.path.dirname(os.__file__))
        return any(
            os.path.exists(os.path.join(dir_path, os.pardir, lib, lib_name, "os.py")) for lib in ("lib", "lib64")
        )

    def _try_posix_fallback_executable(self, base_executable):
        """Find a versioned Python binary as fallback for POSIX virtual environments."""
        major, minor = self.version_info.major, self.version_info.minor
        if self.os != "posix" or (major, minor) < (3, 11):
            return None

        # search relative to the directory of sys._base_executable
        base_dir = os.path.dirname(base_executable)
        candidates = ["python{}".format(major), "python{}.{}".format(major, minor)]
        if self.implementation == "PyPy":
            candidates.extend(["pypy", "pypy3", "pypy{}".format(major), "pypy{}.{}".format(major, minor)])

        for candidate in candidates:
            full_path = os.path.join(base_dir, candidate)
            if os.path.exists(full_path):
                return full_path

        return None  # in this case we just can't tell easily without poking around FS and calling them, bail

    @staticmethod
    def _distutils_install():  # pragma: <3.11 cover # 3.11+ uses the "venv" scheme instead
        # use distutils primarily because that's what pip does
        # https://github.com/pypa/pip/blob/main/src/pip/_internal/locations.py#L95
        # note here we don't import Distribution directly to allow setuptools to patch it
        with warnings.catch_warnings():  # disable warning for PEP-632
            warnings.simplefilter("ignore")
            try:
                # ruff:ignore[import-outside-top-level]
                from distutils import dist  # ty: ignore[unresolved-import]

                # ruff:ignore[import-outside-top-level]
                from distutils.command.install import SCHEME_KEYS  # ty: ignore[unresolved-import]
            except ImportError:  # pragma: no cover # if removed or not installed ignore
                return {}

        distribution = dist.Distribution({
            "script_args": "--no-user-cfg",
        })  # conf files not parsed so they do not hijack paths
        if hasattr(sys, "_framework"):  # pragma: no cover # macOS framework builds only
            sys._framework = None  # ruff:ignore[private-member-access]  # disable macOS static paths for framework

        with warnings.catch_warnings():  # disable warning for PEP-632
            warnings.simplefilter("ignore")
            install = distribution.get_command_obj("install", create=True)

        install.prefix = os.sep  # paths generated are relative to prefix that contains the path sep
        install.finalize_options()
        return {key: (getattr(install, "install_{}".format(key))[1:]).lstrip(os.sep) for key in SCHEME_KEYS}

    def to_dict(self):
        """Convert the collected information to a plain dictionary."""
        data = {var: (getattr(self, var) if var != "_creators" else None) for var in vars(self)}
        data["version_info"] = self.version_info._asdict()
        return data


def _main():  # pragma: no cover # exercised via subprocess runs
    argv = sys.argv[1:]

    if len(argv) >= 1:
        start_cookie = argv[0]
        argv = argv[1:]
    else:
        start_cookie = ""

    if len(argv) >= 1:
        end_cookie = argv[0]
        argv = argv[1:]
    else:
        end_cookie = ""

    sys.argv = sys.argv[:1] + argv

    result = json.dumps(PythonInfoCollector().to_dict(), indent=2)
    sys.stdout.write("".join((start_cookie[::-1], result, end_cookie[::-1])))
    sys.stdout.flush()


__all__ = [
    "MIN_INTERROGATE_VERSION",
    "UNSUPPORTED_MARKER",
    "PythonInfoCollector",
]

if __name__ == "__main__":
    _main()
