# -*- coding: utf-8 -*-
#
# Copyright (C) 2013-2020 Vinay Sajip.
# Licensed to the Python Software Foundation under a contributor agreement.
# See LICENSE.txt and CONTRIBUTORS.txt.
#
from __future__ import unicode_literals

import base64
import codecs
import datetime
from email import message_from_file
import hashlib
import json
import logging
import os
import posixpath
import re
import shutil
import sys
import tempfile
import zipfile

from . import __version__, DistlibException
from .compat import sysconfig, ZipFile, fsdecode, text_type, filter
from .database import InstalledDistribution
from .metadata import (
    Metadata,
    METADATA_FILENAME,
    WHEEL_METADATA_FILENAME,
    LEGACY_METADATA_FILENAME,
)
from .util import (
    FileOperator,
    convert_path,
    CSVReader,
    CSVWriter,
    Cache,
    cached_property,
    get_cache_base,
    read_exports,
    tempdir,
    get_platform,
)
from .version import NormalizedVersion, UnsupportedVersionError

logger = logging.getLogger(__name__)

cache = None  # created when needed

if hasattr(sys, "pypy_version_info"):  # pragma: no cover
    IMP_PREFIX = "pp"
elif sys.platform.startswith("java"):  # pragma: no cover
    IMP_PREFIX = "jy"
elif sys.platform == "cli":  # pragma: no cover
    IMP_PREFIX = "ip"
else:
    IMP_PREFIX = "cp"

VER_SUFFIX = sysconfig.get_config_var("py_version_nodot")
if not VER_SUFFIX:  # pragma: no cover
    VER_SUFFIX = "%s%s" % sys.version_info[:2]
PYVER = "py" + VER_SUFFIX
IMPVER = IMP_PREFIX + VER_SUFFIX

ARCH = get_platform().replace("-", "_").replace(".", "_")

ABI = sysconfig.get_config_var("SOABI")
if ABI and ABI.startswith("cpython-"):
    ABI = ABI.replace("cpython-", "cp").split("-")[0]
else:

    def _derive_abi():
        parts = ["cp", VER_SUFFIX]
        if sysconfig.get_config_var("Py_DEBUG"):
            parts.append("d")
        if IMP_PREFIX == "cp":
            vi = sys.version_info[:2]
            if vi < (3, 8):
                wpm = sysconfig.get_config_var("WITH_PYMALLOC")
                if wpm is None:
                    wpm = True
                if wpm:
                    parts.append("m")
                if vi < (3, 3):
                    us = sysconfig.get_config_var("Py_UNICODE_SIZE")
                    if us == 4 or (us is None and sys.maxunicode == 0x10FFFF):
                        parts.append("u")
        return "".join(parts)

    ABI = _derive_abi()
    del _derive_abi

FILENAME_RE = re.compile(
    r"""
(?P<nm>[^-]+)
-(?P<vn>\d+[^-]*)
(-(?P<bn>\d+[^-]*))?
-(?P<py>\w+\d+(\.\w+\d+)*)
-(?P<bi>\w+)
-(?P<ar>\w+(\.\w+)*)
\.whl$
""",
    re.IGNORECASE | re.VERBOSE,
)

NAME_VERSION_RE = re.compile(
    r"""
(?P<nm>[^-]+)
-(?P<vn>\d+[^-]*)
(-(?P<bn>\d+[^-]*))?$
""",
    re.IGNORECASE | re.VERBOSE,
)

SHEBANG_RE = re.compile(rb"\s*#![^\r\n]*")
SHEBANG_DETAIL_RE = re.compile(rb'^(\s*#!("[^"]+"|\S+))\s+(.*)$')
SHEBANG_PYTHON = b"#!python"
SHEBANG_PYTHONW = b"#!pythonw"

if os.sep == "/":
    to_posix = lambda o: o
else:
    to_posix = lambda o: o.replace(os.sep, "/")

if sys.version_info[0] < 3:
    import imp
else:
    imp = None
    import importlib.machinery
    import importlib.util


def _get_suffixes():
    if imp:
        return [s[0] for s in imp.get_suffixes()]
    else:
        return importlib.machinery.EXTENSION_SUFFIXES


def _load_dynamic(name, path):
    # https://docs.python.org/3/library/importlib.html#importing-a-source-file-directly
    if imp:
        return imp.load_dynamic(name, path)
    else:
        spec = importlib.util.spec_from_file_location(name, path)
        module = importlib.util.module_from_spec(spec)
        sys.modules[name] = module
        spec.loader.exec_module(module)
        return module


class Mounter(object):
    def __init__(self):
        self.impure_wheels = {}
        self.libs = {}

    def add(self, pathname, extensions):
        self.impure_wheels[pathname] = extensions
        self.libs.update(extensions)

    def remove(self, pathname):
        extensions = self.impure_wheels.pop(pathname)
        for k, v in extensions:
            if k in self.libs:
                del self.libs[k]

    def find_module(self, fullname, path=None):
        if fullname in self.libs:
            result = self
        else:
            result = None
        return result

    def load_module(self, fullname):
        if fullname in sys.modules:
            result = sys.modules[fullname]
        else:
            if fullname not in self.libs:
                raise ImportError("unable to find extension for %s" % fullname)
            result = _load_dynamic(fullname, self.libs[fullname])
            result.__loader__ = self
            parts = fullname.rsplit(".", 1)
            if len(parts) > 1:
                result.__package__ = parts[0]
        return result


_hook = Mounter()


class Wheel(object):
    """
    Class to build and install from Wheel files (PEP 427).
    """

    wheel_version = (1, 1)
    hash_kind = "sha256"

    def __init__(self, filename=None, sign=False, verify=False):
        """
        Initialise an instance using a (valid) filename.
        """
        self.sign = sign
        self.should_verify = verify
        self.buildver = ""
        self.pyver = [PYVER]
        self.abi = ["none"]
        self.arch = ["any"]
        self.dirname = os.getcwd()
        if filename is None:
            self.name = "dummy"
            self.version = "0.1"
            self._filename = self.filename
        else:
            m = NAME_VERSION_RE.match(filename)
            if m:
                info = m.groupdict("")
                self.name = info["nm"]
                # Reinstate the local version separator
                self.version = info["vn"].replace("_", "-")
                self.buildver = info["bn"]
                self._filename = self.filename
            else:
                dirname, filename = os.path.split(filename)
                m = FILENAME_RE.match(filename)
                if not m:
                    raise DistlibException("Invalid name or " "filename: %r" % filename)
                if dirname:
                    self.dirname = os.path.abspath(dirname)
                self._filename = filename
                info = m.groupdict("")
                self.name = info["nm"]
                self.version = info["vn"]
                self.buildver = info["bn"]
                self.pyver = info["py"].split(".")
                self.abi = info["bi"].split(".")
                self.arch = info["ar"].split(".")

    @property
    def filename(self):
        """
        Build and return a filename from the various components.
        """
        if self.buildver:
            buildver = "-" + self.buildver
        else:
            buildver = ""
        pyver = ".".join(self.pyver)
        abi = ".".join(self.abi)
        arch = ".".join(self.arch)
        # replace - with _ as a local version separator
        version = self.version.replace("-", "_")
        return "%s-%s%s-%s-%s-%s.whl" % (self.name, version, buildver, pyver, abi, arch)

    @property
    def exists(self):
        path = os.path.join(self.dirname, self.filename)
        return os.path.isfile(path)

    @property
    def tags(self):
        for pyver in self.pyver:
            for abi in self.abi:
                for arch in self.arch:
                    yield pyver, abi, arch

    @cached_property
    def metadata(self):
        pathname = os.path.join(self.dirname, self.filename)
        name_ver = "%s-%s" % (self.name, self.version)
        info_dir = "%s.dist-info" % name_ver
        wrapper = codecs.getreader("utf-8")
        with ZipFile(pathname, "r") as zf:
            wheel_metadata = self.get_wheel_metadata(zf)
            wv = wheel_metadata["Wheel-Version"].split(".", 1)
            file_version = tuple([int(i) for i in wv])
            # if file_version < (1, 1):
            # fns = [WHEEL_METADATA_FILENAME, METADATA_FILENAME,
            # LEGACY_METADATA_FILENAME]
            # else:
            # fns = [WHEEL_METADATA_FILENAME, METADATA_FILENAME]
            fns = [WHEEL_METADATA_FILENAME, LEGACY_METADATA_FILENAME]
            result = None
            for fn in fns:
                try:
                    metadata_filename = posixpath.join(info_dir, fn)
                    with zf.open(metadata_filename) as bf:
                        wf = wrapper(bf)
                        result = Metadata(fileobj=wf)
                        if result:
                            break
                except KeyError:
                    pass
            if not result:
                raise ValueError(
                    "Invalid wheel, because metadata is "
                    "missing: looked in %s" % ", ".join(fns)
                )
        return result

    def get_wheel_metadata(self, zf):
        name_ver = "%s-%s" % (self.name, self.version)
        info_dir = "%s.dist-info" % name_ver
        metadata_filename = posixpath.join(info_dir, "WHEEL")
        with zf.open(metadata_filename) as bf:
            wf = codecs.getreader("utf-8")(bf)
            message = message_from_file(wf)
        return dict(message)

    @cached_property
    def info(self):
        pathname = os.path.join(self.dirname, self.filename)
        with ZipFile(pathname, "r") as zf:
            result = self.get_wheel_metadata(zf)
        return result

    def process_shebang(self, data):
        m = SHEBANG_RE.match(data)
        if m:
            end = m.end()
            shebang, data_after_shebang = data[:end], data[end:]
            # Preserve any arguments after the interpreter
            if b"pythonw" in shebang.lower():
                shebang_python = SHEBANG_PYTHONW
            else:
                shebang_python = SHEBANG_PYTHON
            m = SHEBANG_DETAIL_RE.match(shebang)
            if m:
                args = b" " + m.groups()[-1]
            else:
                args = b""
            shebang = shebang_python + args
            data = shebang + data_after_shebang
        else:
            cr = data.find(b"\r")
            lf = data.find(b"\n")
            if cr < 0 or cr > lf:
                term = b"\n"
            else:
                if data[cr : cr + 2] == b"\r\n":
                    term = b"\r\n"
                else:
                    term = b"\r"
            data = SHEBANG_PYTHON + term + data
        return data

    def get_hash(self, data, hash_kind=None):
        if hash_kind is None:
            hash_kind = self.hash_kind
        try:
            hasher = getattr(hashlib, hash_kind)
        except AttributeError:
            raise DistlibException("Unsupported hash algorithm: %r" % hash_kind)
        result = hasher(data).digest()
        result = base64.urlsafe_b64encode(result).rstrip(b"=").decode("ascii")
        return hash_kind, result

    def write_record(self, records, record_path, archive_record_path):
        records = list(records)  # make a copy, as mutated
        records.append((archive_record_path, "", ""))
        with CSVWriter(record_path) as writer:
            for row in records:
                writer.writerow(row)

    def write_records(self, info, libdir, archive_paths):
        records = []
        distinfo, info_dir = info
        hasher = getattr(hashlib, self.hash_kind)
        for ap, p in archive_paths:
            with open(p, "rb") as f:
                data = f.read()
            digest = "%s=%s" % self.get_hash(data)
            size = os.path.getsize(p)
            records.append((ap, digest, size))

        p = os.path.join(distinfo, "RECORD")
        ap = to_posix(os.path.join(info_dir, "RECORD"))
        self.write_record(records, p, ap)
        archive_paths.append((ap, p))

    def build_zip(self, pathname, archive_paths):
        with ZipFile(pathname, "w", zipfile.ZIP_DEFLATED) as zf:
            for ap, p in archive_paths:
                logger.debug("Wrote %s to %s in wheel", p, ap)
                zf.write(p, ap)

    def build(self, paths, tags=None, wheel_version=None):
        """
        Build a wheel from files in specified paths, and use any specified tags
        when determining the name of the wheel.
        """
        if tags is None:
            tags = {}

        libkey = list(filter(lambda o: o in paths, ("purelib", "platlib")))[0]
        if libkey == "platlib":
            is_pure = "false"
            default_pyver = [IMPVER]
            default_abi = [ABI]
            default_arch = [ARCH]
        else:
            is_pure = "true"
            default_pyver = [PYVER]
            default_abi = ["none"]
            default_arch = ["any"]

        self.pyver = tags.get("pyver", default_pyver)
        self.abi = tags.get("abi", default_abi)
        self.arch = tags.get("arch", default_arch)

        libdir = paths[libkey]

        name_ver = "%s-%s" % (self.name, self.version)
        data_dir = "%s.data" % name_ver
        info_dir = "%s.dist-info" % name_ver

        archive_paths = []

        # First, stuff which is not in site-packages
        for key in ("data", "headers", "scripts"):
            if key not in paths:
                continue
            path = paths[key]
            if os.path.isdir(path):
                for root, dirs, files in os.walk(path):
                    for fn in files:
                        p = fsdecode(os.path.join(root, fn))
                        rp = os.path.relpath(p, path)
                        ap = to_posix(os.path.join(data_dir, key, rp))
                        archive_paths.append((ap, p))
                        if key == "scripts" and not p.endswith(".exe"):
                            with open(p, "rb") as f:
                                data = f.read()
                            data = self.process_shebang(data)
                            with open(p, "wb") as f:
                                f.write(data)

        # Now, stuff which is in site-packages, other than the
        # distinfo stuff.
        path = libdir
        distinfo = None
        for root, dirs, files in os.walk(path):
            if root == path:
                # At the top level only, save distinfo for later
                # and skip it for now
                for i, dn in enumerate(dirs):
                    dn = fsdecode(dn)
                    if dn.endswith(".dist-info"):
                        distinfo = os.path.join(root, dn)
                        del dirs[i]
                        break
                assert distinfo, ".dist-info directory expected, not found"

            for fn in files:
                # comment out next suite to leave .pyc files in
                if fsdecode(fn).endswith((".pyc", ".pyo")):
                    continue
                p = os.path.join(root, fn)
                rp = to_posix(os.path.relpath(p, path))
                archive_paths.append((rp, p))

        # Now distinfo. Assumed to be flat, i.e. os.listdir is enough.
        files = os.listdir(distinfo)
        for fn in files:
            if fn not in ("RECORD", "INSTALLER", "SHARED", "WHEEL"):
                p = fsdecode(os.path.join(distinfo, fn))
                ap = to_posix(os.path.join(info_dir, fn))
                archive_paths.append((ap, p))

        wheel_metadata = [
            "Wheel-Version: %d.%d" % (wheel_version or self.wheel_version),
            "Generator: distlib %s" % __version__,
            "Root-Is-Purelib: %s" % is_pure,
        ]
        for pyver, abi, arch in self.tags:
            wheel_metadata.append("Tag: %s-%s-%s" % (pyver, abi, arch))
        p = os.path.join(distinfo, "WHEEL")
        with open(p, "w") as f:
            f.write("\n".join(wheel_metadata))
        ap = to_posix(os.path.join(info_dir, "WHEEL"))
        archive_paths.append((ap, p))

        # sort the entries by archive path. Not needed by any spec, but it
        # keeps the archive listing and RECORD tidier than they would otherwise
        # be. Use the number of path segments to keep directory entries together,
        # and keep the dist-info stuff at the end.
        def sorter(t):
            ap = t[0]
            n = ap.count("/")
            if ".dist-info" in ap:
                n += 10000
            return (n, ap)

        archive_paths = sorted(archive_paths, key=sorter)

        # Now, at last, RECORD.
        # Paths in here are archive paths - nothing else makes sense.
        self.write_records((distinfo, info_dir), libdir, archive_paths)
        # Now, ready to build the zip file
        pathname = os.path.join(self.dirname, self.filename)
        self.build_zip(pathname, archive_paths)
        return pathname

    def skip_entry(self, arcname):
        """
        Determine whether an archive entry should be skipped when verifying
        or installing.
        """
        # The signature file won't be in RECORD,
        # and we  don't currently don't do anything with it
        # We also skip directories, as they won't be in RECORD
        # either. See:
        #
        # https://github.com/pypa/wheel/issues/294
        # https://github.com/pypa/wheel/issues/287
        # https://github.com/pypa/wheel/pull/289
        #
        return arcname.endswith(("/", "/RECORD.jws"))

    def install(self, paths, maker, **kwargs):
        """
        Install a wheel to the specified paths. If kwarg ``warner`` is
        specified, it should be a callable, which will be called with two
        tuples indicating the wheel version of this software and the wheel
        version in the file, if there is a discrepancy in the versions.
        This can be used to issue any warnings to raise any exceptions.
        If kwarg ``lib_only`` is True, only the purelib/platlib files are
        installed, and the headers, scripts, data and dist-info metadata are
        not written. If kwarg ``bytecode_hashed_invalidation`` is True, written
        bytecode will try to use file-hash based invalidation (PEP-552) on
        supported interpreter versions (CPython 2.7+).

        The return value is a :class:`InstalledDistribution` instance unless
        ``options.lib_only`` is True, in which case the return value is ``None``.
        """

        dry_run = maker.dry_run
        warner = kwargs.get("warner")
        lib_only = kwargs.get("lib_only", False)
        bc_hashed_invalidation = kwargs.get("bytecode_hashed_invalidation", False)

        pathname = os.path.join(self.dirname, self.filename)
        name_ver = "%s-%s" % (self.name, self.version)
        data_dir = "%s.data" % name_ver
        info_dir = "%s.dist-info" % name_ver

        metadata_name = posixpath.join(info_dir, LEGACY_METADATA_FILENAME)
        wheel_metadata_name = posixpath.join(info_dir, "WHEEL")
        record_name = posixpath.join(info_dir, "RECORD")

        wrapper = codecs.getreader("utf-8")

        with ZipFile(pathname, "r") as zf:
            with zf.open(wheel_metadata_name) as bwf:
                wf = wrapper(bwf)
                message = message_from_file(wf)
            wv = message["Wheel-Version"].split(".", 1)
            file_version = tuple([int(i) for i in wv])
            if (file_version != self.wheel_version) and warner:
                warner(self.wheel_version, file_version)

            if message["Root-Is-Purelib"] == "true":
                libdir = paths["purelib"]
            else:
                libdir = paths["platlib"]

            records = {}
            with zf.open(record_name) as bf:
                with CSVReader(stream=bf) as reader:
                    for row in reader:
                        p = row[0]
                        records[p] = row

            data_pfx = posixpath.join(data_dir, "")
            info_pfx = posixpath.join(info_dir, "")
            script_pfx = posixpath.join(data_dir, "scripts", "")

            # make a new instance rather than a copy of maker's,
            # as we mutate it
            fileop = FileOperator(dry_run=dry_run)
            fileop.record = True  # so we can rollback if needed

            bc = not sys.dont_write_bytecode  # Double negatives. Lovely!

            outfiles = []  # for RECORD writing

            # for script copying/shebang processing
            workdir = tempfile.mkdtemp()
            # set target dir later
            # we default add_launchers to False, as the
            # Python Launcher should be used instead
            maker.source_dir = workdir
            maker.target_dir = None
            try:
                for zinfo in zf.infolist():
                    arcname = zinfo.filename
                    if isinstance(arcname, text_type):
                        u_arcname = arcname
                    else:
                        u_arcname = arcname.decode("utf-8")
                    if self.skip_entry(u_arcname):
                        continue
                    row = records[u_arcname]
                    if row[2] and str(zinfo.file_size) != row[2]:
                        raise DistlibException("size mismatch for " "%s" % u_arcname)
                    if row[1]:
                        kind, value = row[1].split("=", 1)
                        with zf.open(arcname) as bf:
                            data = bf.read()
                        _, digest = self.get_hash(data, kind)
                        if digest != value:
                            raise DistlibException(
                                "digest mismatch for " "%s" % arcname
                            )

                    if lib_only and u_arcname.startswith((info_pfx, data_pfx)):
                        logger.debug("lib_only: skipping %s", u_arcname)
                        continue
                    is_script = u_arcname.startswith(
                        script_pfx
                    ) and not u_arcname.endswith(".exe")

                    if u_arcname.startswith(data_pfx):
                        _, where, rp = u_arcname.split("/", 2)
                        outfile = os.path.join(paths[where], convert_path(rp))
                    else:
                        # meant for site-packages.
                        if u_arcname in (wheel_metadata_name, record_name):
                            continue
                        outfile = os.path.join(libdir, convert_path(u_arcname))
                    if not is_script:
                        with zf.open(arcname) as bf:
                            fileop.copy_stream(bf, outfile)
                        # Issue #147: permission bits aren't preserved. Using
                        # zf.extract(zinfo, libdir) should have worked, but didn't,
                        # see https://www.thetopsites.net/article/53834422.shtml
                        # So ... manually preserve permission bits as given in zinfo
                        if os.name == "posix":
                            # just set the normal permission bits
                            os.chmod(outfile, (zinfo.external_attr >> 16) & 0x1FF)
                        outfiles.append(outfile)
                        # Double check the digest of the written file
                        if not dry_run and row[1]:
                            with open(outfile, "rb") as bf:
                                data = bf.read()
                                _, newdigest = self.get_hash(data, kind)
                                if newdigest != digest:
                                    raise DistlibException(
                                        "digest mismatch "
                                        "on write for "
                                        "%s" % outfile
                                    )
                        if bc and outfile.endswith(".py"):
                            try:
                                pyc = fileop.byte_compile(
                                    outfile, hashed_invalidation=bc_hashed_invalidation
                                )
                                outfiles.append(pyc)
                            except Exception:
                                # Don't give up if byte-compilation fails,
                                # but log it and perhaps warn the user
                                logger.warning("Byte-compilation failed", exc_info=True)
                    else:
                        fn = os.path.basename(convert_path(arcname))
                        workname = os.path.join(workdir, fn)
                        with zf.open(arcname) as bf:
                            fileop.copy_stream(bf, workname)

                        dn, fn = os.path.split(outfile)
                        maker.target_dir = dn
                        filenames = maker.make(fn)
                        fileop.set_executable_mode(filenames)
                        outfiles.extend(filenames)

                if lib_only:
                    logger.debug("lib_only: returning None")
                    dist = None
                else:
                    # Generate scripts

                    # Try to get pydist.json so we can see if there are
                    # any commands to generate. If this fails (e.g. because
                    # of a legacy wheel), log a warning but don't give up.
                    commands = None
                    file_version = self.info["Wheel-Version"]
                    if file_version == "1.0":
                        # Use legacy info
                        ep = posixpath.join(info_dir, "entry_points.txt")
                        try:
                            with zf.open(ep) as bwf:
                                epdata = read_exports(bwf)
                            commands = {}
                            for key in ("console", "gui"):
                                k = "%s_scripts" % key
                                if k in epdata:
                                    commands["wrap_%s" % key] = d = {}
                                    for v in epdata[k].values():
                                        s = "%s:%s" % (v.prefix, v.suffix)
                                        if v.flags:
                                            s += " [%s]" % ",".join(v.flags)
                                        d[v.name] = s
                        except Exception:
                            logger.warning(
                                "Unable to read legacy script "
                                "metadata, so cannot generate "
                                "scripts"
                            )
                    else:
                        try:
                            with zf.open(metadata_name) as bwf:
                                wf = wrapper(bwf)
                                commands = json.load(wf).get("extensions")
                                if commands:
                                    commands = commands.get("python.commands")
                        except Exception:
                            logger.warning(
                                "Unable to read JSON metadata, so "
                                "cannot generate scripts"
                            )
                    if commands:
                        console_scripts = commands.get("wrap_console", {})
                        gui_scripts = commands.get("wrap_gui", {})
                        if console_scripts or gui_scripts:
                            script_dir = paths.get("scripts", "")
                            if not os.path.isdir(script_dir):
                                raise ValueError("Valid script path not " "specified")
                            maker.target_dir = script_dir
                            for k, v in console_scripts.items():
                                script = "%s = %s" % (k, v)
                                filenames = maker.make(script)
                                fileop.set_executable_mode(filenames)

                            if gui_scripts:
                                options = {"gui": True}
                                for k, v in gui_scripts.items():
                                    script = "%s = %s" % (k, v)
                                    filenames = maker.make(script, options)
                                    fileop.set_executable_mode(filenames)

                    p = os.path.join(libdir, info_dir)
                    dist = InstalledDistribution(p)

                    # Write SHARED
                    paths = dict(paths)  # don't change passed in dict
                    del paths["purelib"]
                    del paths["platlib"]
                    paths["lib"] = libdir
                    p = dist.write_shared_locations(paths, dry_run)
                    if p:
                        outfiles.append(p)

                    # Write RECORD
                    dist.write_installed_files(outfiles, paths["prefix"], dry_run)
                return dist
            except Exception:  # pragma: no cover
                logger.exception("installation failed.")
                fileop.rollback()
                raise
            finally:
                shutil.rmtree(workdir)

    def _get_dylib_cache(self):
        global cache
        if cache is None:
            # Use native string to avoid issues on 2.x: see Python #20140.
            base = os.path.join(
                get_cache_base(), str("dylib-cache"), "%s.%s" % sys.version_info[:2]
            )
            cache = Cache(base)
        return cache

    def _get_extensions(self):
        pathname = os.path.join(self.dirname, self.filename)
        name_ver = "%s-%s" % (self.name, self.version)
        info_dir = "%s.dist-info" % name_ver
        arcname = posixpath.join(info_dir, "EXTENSIONS")
        wrapper = codecs.getreader("utf-8")
        result = []
        with ZipFile(pathname, "r") as zf:
            try:
                with zf.open(arcname) as bf:
                    wf = wrapper(bf)
                    extensions = json.load(wf)
                    cache = self._get_dylib_cache()
                    prefix = cache.prefix_to_dir(pathname)
                    cache_base = os.path.join(cache.base, prefix)
                    if not os.path.isdir(cache_base):
                        os.makedirs(cache_base)
                    for name, relpath in extensions.items():
                        dest = os.path.join(cache_base, convert_path(relpath))
                        if not os.path.exists(dest):
                            extract = True
                        else:
                            file_time = os.stat(dest).st_mtime
                            file_time = datetime.datetime.fromtimestamp(file_time)
                            info = zf.getinfo(relpath)
                            wheel_time = datetime.datetime(*info.date_time)
                            extract = wheel_time > file_time
                        if extract:
                            zf.extract(relpath, cache_base)
                        result.append((name, dest))
            except KeyError:
                pass
        return result

    def is_compatible(self):
        """
        Determine if a wheel is compatible with the running system.
        """
        return is_compatible(self)

    def is_mountable(self):
        """
        Determine if a wheel is asserted as mountable by its metadata.
        """
        return True  # for now - metadata details TBD

    def mount(self, append=False):
        pathname = os.path.abspath(os.path.join(self.dirname, self.filename))
        if not self.is_compatible():
            msg = "Wheel %s not compatible with this Python." % pathname
            raise DistlibException(msg)
        if not self.is_mountable():
            msg = "Wheel %s is marked as not mountable." % pathname
            raise DistlibException(msg)
        if pathname in sys.path:
            logger.debug("%s already in path", pathname)
        else:
            if append:
                sys.path.append(pathname)
            else:
                sys.path.insert(0, pathname)
            extensions = self._get_extensions()
            if extensions:
                if _hook not in sys.meta_path:
                    sys.meta_path.append(_hook)
                _hook.add(pathname, extensions)

    def unmount(self):
        pathname = os.path.abspath(os.path.join(self.dirname, self.filename))
        if pathname not in sys.path:
            logger.debug("%s not in path", pathname)
        else:
            sys.path.remove(pathname)
            if pathname in _hook.impure_wheels:
                _hook.remove(pathname)
            if not _hook.impure_wheels:
                if _hook in sys.meta_path:
                    sys.meta_path.remove(_hook)

    def verify(self):
        pathname = os.path.join(self.dirname, self.filename)
        name_ver = "%s-%s" % (self.name, self.version)
        data_dir = "%s.data" % name_ver
        info_dir = "%s.dist-info" % name_ver

        metadata_name = posixpath.join(info_dir, LEGACY_METADATA_FILENAME)
        wheel_metadata_name = posixpath.join(info_dir, "WHEEL")
        record_name = posixpath.join(info_dir, "RECORD")

        wrapper = codecs.getreader("utf-8")

        with ZipFile(pathname, "r") as zf:
            with zf.open(wheel_metadata_name) as bwf:
                wf = wrapper(bwf)
                message = message_from_file(wf)
            wv = message["Wheel-Version"].split(".", 1)
            file_version = tuple([int(i) for i in wv])
            # TODO version verification

            records = {}
            with zf.open(record_name) as bf:
                with CSVReader(stream=bf) as reader:
                    for row in reader:
                        p = row[0]
                        records[p] = row

            for zinfo in zf.infolist():
                arcname = zinfo.filename
                if isinstance(arcname, text_type):
                    u_arcname = arcname
                else:
                    u_arcname = arcname.decode("utf-8")
                # See issue #115: some wheels have .. in their entries, but
                # in the filename ... e.g. __main__..py ! So the check is
                # updated to look for .. in the directory portions
                p = u_arcname.split("/")
                if ".." in p:
                    raise DistlibException("invalid entry in " "wheel: %r" % u_arcname)

                if self.skip_entry(u_arcname):
                    continue
                row = records[u_arcname]
                if row[2] and str(zinfo.file_size) != row[2]:
                    raise DistlibException("size mismatch for " "%s" % u_arcname)
                if row[1]:
                    kind, value = row[1].split("=", 1)
                    with zf.open(arcname) as bf:
                        data = bf.read()
                    _, digest = self.get_hash(data, kind)
                    if digest != value:
                        raise DistlibException("digest mismatch for " "%s" % arcname)

    def update(self, modifier, dest_dir=None, **kwargs):
        """
        Update the contents of a wheel in a generic way. The modifier should
        be a callable which expects a dictionary argument: its keys are
        archive-entry paths, and its values are absolute filesystem paths
        where the contents the corresponding archive entries can be found. The
        modifier is free to change the contents of the files pointed to, add
        new entries and remove entries, before returning. This method will
        extract the entire contents of the wheel to a temporary location, call
        the modifier, and then use the passed (and possibly updated)
        dictionary to write a new wheel. If ``dest_dir`` is specified, the new
        wheel is written there -- otherwise, the original wheel is overwritten.

        The modifier should return True if it updated the wheel, else False.
        This method returns the same value the modifier returns.
        """

        def get_version(path_map, info_dir):
            version = path = None
            key = "%s/%s" % (info_dir, LEGACY_METADATA_FILENAME)
            if key not in path_map:
                key = "%s/PKG-INFO" % info_dir
            if key in path_map:
                path = path_map[key]
                version = Metadata(path=path).version
            return version, path

        def update_version(version, path):
            updated = None
            try:
                v = NormalizedVersion(version)
                i = version.find("-")
                if i < 0:
                    updated = "%s+1" % version
                else:
                    parts = [int(s) for s in version[i + 1 :].split(".")]
                    parts[-1] += 1
                    updated = "%s+%s" % (version[:i], ".".join(str(i) for i in parts))
            except UnsupportedVersionError:
                logger.debug(
                    "Cannot update non-compliant (PEP-440) " "version %r", version
                )
            if updated:
                md = Metadata(path=path)
                md.version = updated
                legacy = path.endswith(LEGACY_METADATA_FILENAME)
                md.write(path=path, legacy=legacy)
                logger.debug("Version updated from %r to %r", version, updated)

        pathname = os.path.join(self.dirname, self.filename)
        name_ver = "%s-%s" % (self.name, self.version)
        info_dir = "%s.dist-info" % name_ver
        record_name = posixpath.join(info_dir, "RECORD")
        with tempdir() as workdir:
            with ZipFile(pathname, "r") as zf:
                path_map = {}
                for zinfo in zf.infolist():
                    arcname = zinfo.filename
                    if isinstance(arcname, text_type):
                        u_arcname = arcname
                    else:
                        u_arcname = arcname.decode("utf-8")
                    if u_arcname == record_name:
                        continue
                    if ".." in u_arcname:
                        raise DistlibException(
                            "invalid entry in " "wheel: %r" % u_arcname
                        )
                    zf.extract(zinfo, workdir)
                    path = os.path.join(workdir, convert_path(u_arcname))
                    path_map[u_arcname] = path

            # Remember the version.
            original_version, _ = get_version(path_map, info_dir)
            # Files extracted. Call the modifier.
            modified = modifier(path_map, **kwargs)
            if modified:
                # Something changed - need to build a new wheel.
                current_version, path = get_version(path_map, info_dir)
                if current_version and (current_version == original_version):
                    # Add or update local version to signify changes.
                    update_version(current_version, path)
                # Decide where the new wheel goes.
                if dest_dir is None:
                    fd, newpath = tempfile.mkstemp(
                        suffix=".whl", prefix="wheel-update-", dir=workdir
                    )
                    os.close(fd)
                else:
                    if not os.path.isdir(dest_dir):
                        raise DistlibException("Not a directory: %r" % dest_dir)
                    newpath = os.path.join(dest_dir, self.filename)
                archive_paths = list(path_map.items())
                distinfo = os.path.join(workdir, info_dir)
                info = distinfo, info_dir
                self.write_records(info, workdir, archive_paths)
                self.build_zip(newpath, archive_paths)
                if dest_dir is None:
                    shutil.copyfile(newpath, pathname)
        return modified


def _get_glibc_version():
    import platform

    ver = platform.libc_ver()
    result = []
    if ver[0] == "glibc":
        for s in ver[1].split("."):
            result.append(int(s) if s.isdigit() else 0)
        result = tuple(result)
    return result


def compatible_tags():
    """
    Return (pyver, abi, arch) tuples compatible with this Python.
    """
    versions = [VER_SUFFIX]
    major = VER_SUFFIX[0]
    for minor in range(sys.version_info[1] - 1, -1, -1):
        versions.append("".join([major, str(minor)]))

    abis = []
    for suffix in _get_suffixes():
        if suffix.startswith(".abi"):
            abis.append(suffix.split(".", 2)[1])
    abis.sort()
    if ABI != "none":
        abis.insert(0, ABI)
    abis.append("none")
    result = []

    arches = [ARCH]
    if sys.platform == "darwin":
        m = re.match(r"(\w+)_(\d+)_(\d+)_(\w+)$", ARCH)
        if m:
            name, major, minor, arch = m.groups()
            minor = int(minor)
            matches = [arch]
            if arch in ("i386", "ppc"):
                matches.append("fat")
            if arch in ("i386", "ppc", "x86_64"):
                matches.append("fat3")
            if arch in ("ppc64", "x86_64"):
                matches.append("fat64")
            if arch in ("i386", "x86_64"):
                matches.append("intel")
            if arch in ("i386", "x86_64", "intel", "ppc", "ppc64"):
                matches.append("universal")
            while minor >= 0:
                for match in matches:
                    s = "%s_%s_%s_%s" % (name, major, minor, match)
                    if s != ARCH:  # already there
                        arches.append(s)
                minor -= 1

    # Most specific - our Python version, ABI and arch
    for abi in abis:
        for arch in arches:
            result.append(("".join((IMP_PREFIX, versions[0])), abi, arch))
            # manylinux
            if abi != "none" and sys.platform.startswith("linux"):
                arch = arch.replace("linux_", "")
                parts = _get_glibc_version()
                if len(parts) == 2:
                    if parts >= (2, 5):
                        result.append(
                            (
                                "".join((IMP_PREFIX, versions[0])),
                                abi,
                                "manylinux1_%s" % arch,
                            )
                        )
                    if parts >= (2, 12):
                        result.append(
                            (
                                "".join((IMP_PREFIX, versions[0])),
                                abi,
                                "manylinux2010_%s" % arch,
                            )
                        )
                    if parts >= (2, 17):
                        result.append(
                            (
                                "".join((IMP_PREFIX, versions[0])),
                                abi,
                                "manylinux2014_%s" % arch,
                            )
                        )
                    result.append(
                        (
                            "".join((IMP_PREFIX, versions[0])),
                            abi,
                            "manylinux_%s_%s_%s" % (parts[0], parts[1], arch),
                        )
                    )

    # where no ABI / arch dependency, but IMP_PREFIX dependency
    for i, version in enumerate(versions):
        result.append(("".join((IMP_PREFIX, version)), "none", "any"))
        if i == 0:
            result.append(("".join((IMP_PREFIX, version[0])), "none", "any"))

    # no IMP_PREFIX, ABI or arch dependency
    for i, version in enumerate(versions):
        result.append(("".join(("py", version)), "none", "any"))
        if i == 0:
            result.append(("".join(("py", version[0])), "none", "any"))

    return set(result)


COMPATIBLE_TAGS = compatible_tags()

del compatible_tags


def is_compatible(wheel, tags=None):
    if not isinstance(wheel, Wheel):
        wheel = Wheel(wheel)  # assume it's a filename
    result = False
    if tags is None:
        tags = COMPATIBLE_TAGS
    for ver, abi, arch in tags:
        if ver in wheel.pyver and abi in wheel.abi and arch in wheel.arch:
            result = True
            break
    return result
