from __future__ import annotations

import dataclasses
import logging
import os
import platform
import sys
from collections import defaultdict
from dataclasses import field
from functools import cached_property
from pathlib import Path, WindowsPath
from typing import (
    Any,
    Callable,
    DefaultDict,
    Dict,
    Iterator,
    List,
    Optional,
)

from pipenv.patched.pip._vendor.packaging.version import Version

from ..environment import ASDF_DATA_DIR, PYENV_ROOT, SYSTEM_ARCH
from ..exceptions import InvalidPythonVersion
from ..utils import (
    ensure_path,
    expand_paths,
    get_python_version,
    guess_company,
    is_in_path,
    looks_like_python,
    parse_asdf_version_order,
    parse_pyenv_version_order,
    parse_python_version,
)
from .mixins import PathEntry

logger = logging.getLogger(__name__)


@dataclasses.dataclass
class PythonFinder(PathEntry):
    root: Path = field(default_factory=Path)
    ignore_unsupported: bool = True
    version_glob_path: str = "versions/*"
    sort_function: Optional[Callable] = None
    roots: Dict = field(default_factory=lambda: defaultdict())
    paths: Optional[List[PathEntry]] = field(default_factory=list)
    _versions: Dict = field(default_factory=lambda: defaultdict())
    pythons_ref: Dict = field(default_factory=lambda: defaultdict())

    def __post_init__(self):
        # Ensuring that paths are set correctly
        self.paths = self.get_paths(self.paths)

    @property
    def version_paths(self) -> Any:
        return self._versions.values()

    @property
    def is_pyenv(self) -> bool:
        return is_in_path(str(self.root), PYENV_ROOT)

    @property
    def is_asdf(self) -> bool:
        return is_in_path(str(self.root), ASDF_DATA_DIR)

    def get_version_order(self) -> list[Path]:
        version_paths = [
            p
            for p in self.root.glob(self.version_glob_path)
            if not (p.parent.name == "envs" or p.name == "envs")
        ]
        versions = {v.name: v for v in version_paths}
        version_order = []
        if self.is_pyenv:
            version_order = [
                versions[v] for v in parse_pyenv_version_order() if v in versions
            ]
        elif self.is_asdf:
            version_order = [
                versions[v] for v in parse_asdf_version_order() if v in versions
            ]
        for version in version_order:
            if version in version_paths:
                version_paths.remove(version)
        if version_order:
            version_order += version_paths
        else:
            version_order = version_paths
        return version_order

    def get_bin_dir(self, base) -> Path:
        if isinstance(base, str):
            base = Path(base)
        if os.name == "nt":
            return base
        return base / "bin"

    @classmethod
    def version_from_bin_dir(cls, entry) -> PathEntry | None:
        py_version = next(iter(entry.find_all_python_versions()), None)
        return py_version

    def _iter_version_bases(self) -> Iterator[tuple[Path, PathEntry]]:
        for p in self.get_version_order():
            bin_dir = self.get_bin_dir(p)
            if bin_dir.exists() and bin_dir.is_dir():
                entry = PathEntry.create(
                    path=bin_dir.absolute(), only_python=False, name=p.name, is_root=True
                )
                self.roots[p] = entry
                yield (p, entry)

    def _iter_versions(self) -> Iterator[tuple[Path, PathEntry, tuple]]:
        for base_path, entry in self._iter_version_bases():
            version = None
            version_entry = None
            try:
                version = PythonVersion.parse(entry.name)
            except (ValueError, InvalidPythonVersion):
                version_entry = next(iter(entry.find_all_python_versions()), None)
                if version is None:
                    if not self.ignore_unsupported:
                        raise
                    continue
                if version_entry is not None:
                    version = version_entry.py_version.as_dict()
            except Exception:
                if not self.ignore_unsupported:
                    raise
                logger.warning(
                    "Unsupported Python version %r, ignoring...",
                    base_path.name,
                    exc_info=True,
                )
                continue
            if version is not None:
                version_tuple = (
                    version.get("major"),
                    version.get("minor"),
                    version.get("patch"),
                    version.get("is_prerelease"),
                    version.get("is_devrelease"),
                    version.get("is_debug"),
                )
                yield (base_path, entry, version_tuple)

    @cached_property
    def versions(self) -> DefaultDict[tuple, PathEntry]:
        if not self._versions:
            for _, entry, version_tuple in self._iter_versions():
                self._versions[version_tuple] = entry
        return self._versions

    def _iter_pythons(self) -> Iterator:
        for path, entry, version_tuple in self._iter_versions():
            if str(path) in self._pythons:
                yield self._pythons[str(path)]
            elif version_tuple not in self.versions:
                for python in entry.find_all_python_versions():
                    yield python
            else:
                yield self.versions[version_tuple]

    def get_paths(self, paths) -> list[PathEntry]:
        # If paths are provided, use them
        if paths is not None:
            return paths

        # Otherwise, generate paths using _iter_version_bases
        _paths = [base for _, base in self._iter_version_bases()]
        return _paths

    @property
    def pythons(self) -> dict:
        if not self.pythons_ref:
            from .path import PathEntry

            self.pythons_ref = defaultdict(PathEntry)
            for python in self._iter_pythons():
                python_path = str(python.path)
                self.pythons_ref[python_path] = python
        return self.pythons_ref

    @pythons.setter
    def pythons(self, value) -> None:
        self.pythons_ref = value

    def get_pythons(self) -> DefaultDict[str, PathEntry]:
        return self.pythons

    @classmethod
    def create(
        cls, root, sort_function, version_glob_path=None, ignore_unsupported=True
    ) -> PythonFinder:
        root = ensure_path(root)
        if not version_glob_path:
            version_glob_path = "versions/*"
        return cls(
            root=root,
            path=root,
            ignore_unsupported=ignore_unsupported,
            sort_function=sort_function,
            version_glob_path=version_glob_path,
        )

    def find_all_python_versions(
        self,
        major: str | int | None = None,
        minor: int | None = None,
        patch: int | None = None,
        pre: bool | None = None,
        dev: bool | None = None,
        arch: str | None = None,
        name: str | None = None,
    ) -> list[PathEntry]:
        """Search for a specific python version on the path. Return all copies

        :param major: Major python version to search for.
        :type major: int
        :param int minor: Minor python version to search for, defaults to None
        :param int patch: Patch python version to search for, defaults to None
        :param bool pre: Search for prereleases (default None) - prioritize releases if None
        :param bool dev: Search for devreleases (default None) - prioritize releases if None
        :param str arch: Architecture to include, e.g. '64bit', defaults to None
        :param str name: The name of a python version, e.g. ``anaconda3-5.3.0``
        :return: A list of :class:`~pythonfinder.models.PathEntry` instances matching the version requested.
        """

        call_method = "find_all_python_versions" if self.is_dir else "find_python_version"

        def sub_finder(path):
            return getattr(path, call_method)(major, minor, patch, pre, dev, arch, name)

        if not any([major, minor, patch, name]):
            pythons = [
                next(iter(py for py in base.find_all_python_versions()), None)
                for _, base in self._iter_version_bases()
            ]
        else:
            pythons = [sub_finder(path) for path in self.paths]

        pythons = expand_paths(pythons, True)

        def version_sort(py):
            return py.as_python.version_sort

        paths = [
            p for p in sorted(pythons, key=version_sort, reverse=True) if p is not None
        ]
        return paths

    def find_python_version(
        self,
        major: str | int | None = None,
        minor: int | None = None,
        patch: int | None = None,
        pre: bool | None = None,
        dev: bool | None = None,
        arch: str | None = None,
        name: str | None = None,
    ) -> PathEntry | None:
        """Search or self for the specified Python version and return the first match.

        :param major: Major version number.
        :type major: int
        :param int minor: Minor python version to search for, defaults to None
        :param int patch: Patch python version to search for, defaults to None
        :param bool pre: Search for prereleases (default None) - prioritize releases if None
        :param bool dev: Search for devreleases (default None) - prioritize releases if None
        :param str arch: Architecture to include, e.g. '64bit', defaults to None
        :param str name: The name of a python version, e.g. ``anaconda3-5.3.0``
        :returns: A :class:`~pythonfinder.models.PathEntry` instance matching the version requested.
        """

        def sub_finder(obj):
            return obj.find_python_version(major, minor, patch, pre, dev, arch, name)

        def version_sort(path_entry):
            return path_entry.as_python.version_sort

        unnested = [sub_finder(self.roots[path]) for path in self.roots]
        unnested = [
            p
            for p in unnested
            if p is not None and p.is_python and p.as_python is not None
        ]
        paths = sorted(list(unnested), key=version_sort, reverse=True)
        return next(iter(p for p in paths if p is not None), None)

    def which(self, name) -> PathEntry | None:
        """Search in this path for an executable.

        :param executable: The name of an executable to search for.
        :type executable: str
        :returns: :class:`~pythonfinder.models.PathEntry` instance.
        """

        matches = (p.which(name) for p in self.paths)
        non_empty_match = next(iter(m for m in matches if m is not None), None)
        return non_empty_match


@dataclasses.dataclass
class PythonVersion:
    major: int = 0
    minor: int | None = None
    patch: int | None = None
    is_prerelease: bool = False
    is_postrelease: bool = False
    is_devrelease: bool = False
    is_debug: bool = False
    version: Version | None = None
    architecture: str | None = None
    comes_from: PathEntry | None = None
    executable: str | WindowsPath | Path | None = None
    company: str | None = None
    name: str | None = None

    def __getattribute__(self, key):
        result = super().__getattribute__(key)
        if key in ["minor", "patch"] and result is None:
            executable = None
            if self.executable:
                executable = self.executable
            elif self.comes_from:
                executable = self.comes_from.path
            if executable is not None:
                if not isinstance(executable, str):
                    executable = executable
                instance_dict = self.parse_executable(executable)
                for k in instance_dict.keys():
                    try:
                        super().__getattribute__(k)
                    except AttributeError:
                        continue
                    else:
                        setattr(self, k, instance_dict[k])
                result = instance_dict.get(key)
        return result

    @property
    def version_sort(self) -> tuple[int, int, int | None, int, int]:
        """
        A tuple for sorting against other instances of the same class.

        Returns a tuple of the python version but includes points for core python,
        non-dev,  and non-prerelease versions.  So released versions will have 2 points
        for this value.  E.g. ``(1, 3, 6, 6, 2)`` is a release, ``(1, 3, 6, 6, 1)`` is a
        prerelease, ``(1, 3, 6, 6, 0)`` is a dev release, and ``(1, 3, 6, 6, 3)`` is a
        postrelease.  ``(0, 3, 7, 3, 2)`` represents a non-core python release, e.g. by
        a repackager of python like Continuum.
        """
        company_sort = 1 if (self.company and self.company == "PythonCore") else 0
        release_sort = 2
        if self.is_postrelease:
            release_sort = 3
        elif self.is_prerelease:
            release_sort = 1
        elif self.is_devrelease:
            release_sort = 0
        elif self.is_debug:
            release_sort = 1
        return (
            company_sort,
            self.major,
            self.minor,
            self.patch if self.patch else 0,
            release_sort,
        )

    @property
    def version_tuple(self) -> tuple[int, int, int, bool, bool, bool]:
        """
        Provides a version tuple for using as a dictionary key.

        :return: A tuple describing the python version meetadata contained.
        """

        return (
            self.major,
            self.minor,
            self.patch,
            self.is_prerelease,
            self.is_devrelease,
            self.is_debug,
        )

    def matches(
        self,
        major: int | None = None,
        minor: int | None = None,
        patch: int | None = None,
        pre: bool = False,
        dev: bool = False,
        arch: str | None = None,
        debug: bool = False,
        python_name: str | None = None,
    ) -> bool:
        result = False
        if arch:
            own_arch = self.get_architecture()
            if arch.isdigit():
                arch = f"{arch}bit"

        if (
            (major is None or self.major == major)
            and (minor is None or self.minor == minor)
            # Check if patch is None OR self.patch equals patch
            and (patch is None or self.patch == patch)
            and (pre is None or self.is_prerelease == pre)
            and (dev is None or self.is_devrelease == dev)
            and (arch is None or own_arch == arch)
            and (debug is None or self.is_debug == debug)
            and (
                python_name is None
                or (python_name and self.name)
                and (self.name == python_name or self.name.startswith(python_name))
            )
        ):
            result = True

        return result

    def as_major(self) -> PythonVersion:
        self.minor = None
        self.patch = None
        return self

    def as_minor(self) -> PythonVersion:
        self.patch = None
        return self

    def as_dict(self) -> dict[str, int | bool | Version | None]:
        return {
            "major": self.major,
            "minor": self.minor,
            "patch": self.patch,
            "is_prerelease": self.is_prerelease,
            "is_postrelease": self.is_postrelease,
            "is_devrelease": self.is_devrelease,
            "is_debug": self.is_debug,
            "version": self.version,
            "company": self.company,
        }

    def update_metadata(self, metadata) -> None:
        """
        Update the metadata on the current :class:`pythonfinder.models.python.PythonVersion`

        Given a parsed version dictionary from :func:`pythonfinder.utils.parse_python_version`,
        update the instance variables of the current version instance to reflect the newly
        supplied values.
        """

        for key in metadata:
            try:
                _ = getattr(self, key)
            except AttributeError:
                continue
            else:
                setattr(self, key, metadata[key])

    @classmethod
    def parse(cls, version) -> dict[str, str | int | Version]:
        """
        Parse a valid version string into a dictionary

        Raises:
            ValueError -- Unable to parse version string
            ValueError -- Not a valid python version
            TypeError -- NoneType or unparsable type passed in

        :param str version: A valid version string
        :return: A dictionary with metadata about the specified python version.
        """

        if version is None:
            raise TypeError("Must pass a value to parse!")
        version_dict = parse_python_version(str(version))
        if not version_dict:
            raise ValueError("Not a valid python version: %r" % version)
        return version_dict

    def get_architecture(self) -> str:
        if self.architecture:
            return self.architecture
        arch = None
        if self.comes_from is not None:
            arch, _ = platform.architecture(str(self.comes_from.path))
        elif self.executable is not None:
            arch, _ = platform.architecture(self.executable)
        if arch is None:
            arch, _ = platform.architecture(sys.executable)
        self.architecture = arch
        return self.architecture

    @classmethod
    def from_path(
        cls, path, name=None, ignore_unsupported=True, company=None
    ) -> PythonVersion:
        """
        Parses a python version from a system path.

        Raises:
            ValueError -- Not a valid python path

        :param path: A string or :class:`~pythonfinder.models.path.PathEntry`
        :type path: str or :class:`~pythonfinder.models.path.PathEntry` instance
        :param str name: Name of the python distribution in question
        :param bool ignore_unsupported: Whether to ignore or error on unsupported paths.
        :param Optional[str] company: The company or vendor packaging the distribution.
        :return: An instance of a PythonVersion.
        """
        from ..environment import IGNORE_UNSUPPORTED

        ignore_unsupported = ignore_unsupported or IGNORE_UNSUPPORTED

        # Check if path is a string, a PathEntry, or a PythonFinder object
        if isinstance(path, str):
            path_obj = Path(path)  # Convert string to Path object
            path_name = path_obj.name
            path_str = path
        elif hasattr(path, "path") and isinstance(path.path, Path):
            path_obj = path.path
            path_name = getattr(path, "name", path_obj.name)
            path_str = str(path.path.absolute())
        elif isinstance(path, PythonFinder):  # If path is a PythonFinder object
            path_name = None
            path_str = path.path
        else:
            raise ValueError(
                f"Invalid path type: {type(path)}. Expected str, PathEntry, or PythonFinder."
            )

        try:
            instance_dict = cls.parse(path_name)
        except Exception:
            instance_dict = cls.parse_executable(path_str)
        else:
            if instance_dict.get("minor") is None and looks_like_python(path_obj.name):
                instance_dict = cls.parse_executable(path_str)

        if (
            not isinstance(instance_dict.get("version"), Version)
            and not ignore_unsupported
        ):
            raise ValueError("Not a valid python path: %s" % path)
        if instance_dict.get("patch") is None:
            instance_dict = cls.parse_executable(path_str)
        if name is None:
            name = path_name
        if company is None:
            company = guess_company(path_str)
        instance_dict.update({"comes_from": path, "name": name, "executable": path_str})
        return cls(**instance_dict)

    @classmethod
    def parse_executable(cls, path) -> dict[str, str | int | Version | None]:
        result_dict = {}
        result_version = None
        if path is None:
            raise TypeError("Must pass a valid path to parse.")
        if not isinstance(path, str):
            path = str(path)
        # if not looks_like_python(path):
        #     raise ValueError("Path %r does not look like a valid python path" % path)
        try:
            result_version = get_python_version(path)
        except Exception:
            raise ValueError("Not a valid python path: %r" % path)
        if result_version is None:
            raise ValueError("Not a valid python path: %s" % path)
        result_dict = cls.parse(result_version.strip())
        return result_dict

    @classmethod
    def from_windows_launcher(
        cls, launcher_entry, name=None, company=None
    ) -> PythonVersion:
        """Create a new PythonVersion instance from a Windows Launcher Entry

        :param launcher_entry: A python launcher environment object.
        :param Optional[str] name: The name of the distribution.
        :param Optional[str] company: The name of the distributing company.
        :return: An instance of a PythonVersion.
        """
        creation_dict = cls.parse(launcher_entry.info.version)
        base_path = ensure_path(launcher_entry.info.install_path.__getattr__(""))
        default_path = base_path / "python.exe"
        if not default_path.exists():
            default_path = base_path / "Scripts" / "python.exe"
        exe_path = ensure_path(
            getattr(launcher_entry.info.install_path, "executable_path", default_path)
        )
        company = getattr(launcher_entry, "company", guess_company(exe_path))
        creation_dict.update(
            {
                "architecture": getattr(
                    launcher_entry.info, "sys_architecture", SYSTEM_ARCH
                ),
                "executable": exe_path,
                "name": name,
                "company": company,
            }
        )
        py_version = cls.create(**creation_dict)
        comes_from = PathEntry.create(exe_path, only_python=True, name=name)
        py_version.comes_from = comes_from
        py_version.name = comes_from.name
        return py_version

    @classmethod
    def create(cls, **kwargs) -> PythonVersion:
        if "architecture" in kwargs:
            if kwargs["architecture"].isdigit():
                kwargs["architecture"] = "{}bit".format(kwargs["architecture"])
        return cls(**kwargs)


@dataclasses.dataclass
class VersionMap:
    versions: DefaultDict[
        tuple[int, int | None, int | None, bool, bool, bool], list[PathEntry]
    ] = field(default_factory=lambda: defaultdict(list))

    def add_entry(self, entry) -> None:
        version = entry.as_python
        if version:
            _ = self.versions[version.version_tuple]
            paths = {p.path for p in self.versions.get(version.version_tuple, [])}
            if entry.path not in paths:
                self.versions[version.version_tuple].append(entry)

    def merge(self, target) -> None:
        for version, entries in target.versions.items():
            if version not in self.versions:
                self.versions[version] = entries
            else:
                current_entries = {
                    p.path for p in self.versions[version] if version in self.versions
                }
                new_entries = {p.path for p in entries}
                new_entries -= current_entries
                self.versions[version].extend(
                    [e for e in entries if e.path in new_entries]
                )
