import json
import os
import os.path
import re
import sys
import warnings

from collections import defaultdict
from distutils.command.build_scripts import build_scripts as BuildScripts
from distutils.command.sdist import sdist as SDist

try:
    from setuptools import setup, find_packages
    from setuptools.command.build_py import build_py as BuildPy
    from setuptools.command.install_lib import install_lib as InstallLib
    from setuptools.command.install_scripts import install_scripts as InstallScripts
except ImportError:
    print(
        "Ansible now needs setuptools in order to build. Install it using"
        " your package manager (usually python-setuptools) or via pip (pip"
        " install setuptools).",
        file=sys.stderr,
    )
    sys.exit(1)

sys.path.insert(0, os.path.abspath("lib"))
from ansible.release import __version__, __author__


SYMLINK_CACHE = "SYMLINK_CACHE.json"


def _find_symlinks(topdir, extension=""):
    """Find symlinks that should be maintained

    Maintained symlinks exist in the bin dir or are modules which have
    aliases.  Our heuristic is that they are a link in a certain path which
    point to a file in the same directory.
    """
    symlinks = defaultdict(list)
    for base_path, dirs, files in os.walk(topdir):
        for filename in files:
            filepath = os.path.join(base_path, filename)
            if os.path.islink(filepath) and filename.endswith(extension):
                target = os.readlink(filepath)
                if os.path.dirname(target) == "":
                    link = filepath[len(topdir) :]
                    if link.startswith("/"):
                        link = link[1:]
                    symlinks[os.path.basename(target)].append(link)
    return symlinks


def _cache_symlinks(symlink_data):
    with open(SYMLINK_CACHE, "w") as f:
        json.dump(symlink_data, f)


def _maintain_symlinks(symlink_type, base_path):
    """Switch a real file into a symlink"""
    try:
        # Try the cache first because going from git checkout to sdist is the
        # only time we know that we're going to cache correctly
        with open(SYMLINK_CACHE, "r") as f:
            symlink_data = json.load(f)
    except (IOError, OSError) as e:
        # IOError on py2, OSError on py3.  Both have errno
        if e.errno == 2:
            # SYMLINKS_CACHE doesn't exist.  Fallback to trying to create the
            # cache now.  Will work if we're running directly from a git
            # checkout or from an sdist created earlier.
            symlink_data = {
                "script": _find_symlinks("bin"),
                "library": _find_symlinks("lib", ".py"),
            }

            # Sanity check that something we know should be a symlink was
            # found.  We'll take that to mean that the current directory
            # structure properly reflects symlinks in the git repo
            if "ansible-playbook" in symlink_data["script"]["ansible"]:
                _cache_symlinks(symlink_data)
            else:
                raise
        else:
            raise
    symlinks = symlink_data[symlink_type]

    for source in symlinks:
        for dest in symlinks[source]:
            dest_path = os.path.join(base_path, dest)
            if not os.path.islink(dest_path):
                try:
                    os.unlink(dest_path)
                except OSError as e:
                    if e.errno == 2:
                        # File does not exist which is all we wanted
                        pass
                os.symlink(source, dest_path)


class BuildPyCommand(BuildPy):
    def run(self):
        BuildPy.run(self)
        _maintain_symlinks("library", self.build_lib)


class BuildScriptsCommand(BuildScripts):
    def run(self):
        BuildScripts.run(self)
        _maintain_symlinks("script", self.build_dir)


class InstallLibCommand(InstallLib):
    def run(self):
        InstallLib.run(self)
        _maintain_symlinks("library", self.install_dir)


class InstallScriptsCommand(InstallScripts):
    def run(self):
        InstallScripts.run(self)
        _maintain_symlinks("script", self.install_dir)


class SDistCommand(SDist):
    def run(self):
        # have to generate the cache of symlinks for release as sdist is the
        # only command that has access to symlinks from the git repo
        symlinks = {
            "script": _find_symlinks("bin"),
            "library": _find_symlinks("lib", ".py"),
        }
        _cache_symlinks(symlinks)

        SDist.run(self)


def read_file(file_name):
    """Read file and return its contents."""
    with open(file_name, "r") as f:
        return f.read()


def read_requirements(file_name):
    """Read requirements file as a list."""
    reqs = read_file(file_name).splitlines()
    if not reqs:
        raise RuntimeError(
            "Unable to read requirements from the %s file"
            "That indicates this copy of the source code is incomplete." % file_name
        )
    return reqs


PYCRYPTO_DIST = "pycrypto"


def get_crypto_req():
    """Detect custom crypto from ANSIBLE_CRYPTO_BACKEND env var.

    pycrypto or cryptography. We choose a default but allow the user to
    override it. This translates into pip install of the sdist deciding what
    package to install and also the runtime dependencies that pkg_resources
    knows about.
    """
    crypto_backend = os.environ.get("ANSIBLE_CRYPTO_BACKEND", "").strip()

    if crypto_backend == PYCRYPTO_DIST:
        # Attempt to set version requirements
        return "%s >= 2.6" % PYCRYPTO_DIST

    return crypto_backend or None


def substitute_crypto_to_req(req):
    """Replace crypto requirements if customized."""
    crypto_backend = get_crypto_req()

    if crypto_backend is None:
        return req

    def is_not_crypto(r):
        CRYPTO_LIBS = PYCRYPTO_DIST, "cryptography"
        return not any(r.lower().startswith(c) for c in CRYPTO_LIBS)

    return [r for r in req if is_not_crypto(r)] + [crypto_backend]


def read_extras():
    """Specify any extra requirements for installation."""
    extras = dict()
    extra_requirements_dir = "packaging/requirements"
    for extra_requirements_filename in os.listdir(extra_requirements_dir):
        filename_match = re.search(
            r"^requirements-(\w*).txt$", extra_requirements_filename
        )
        if not filename_match:
            continue
        extra_req_file_path = os.path.join(
            extra_requirements_dir, extra_requirements_filename
        )
        try:
            extras[filename_match.group(1)] = read_file(
                extra_req_file_path
            ).splitlines()
        except RuntimeError:
            pass
    return extras


def get_dynamic_setup_params():
    """Add dynamically calculated setup params to static ones."""
    return {
        # Retrieve the long description from the README
        "long_description": read_file("README.rst"),
        "install_requires": substitute_crypto_to_req(
            read_requirements("requirements.txt")
        ),
        "extras_require": read_extras(),
    }


static_setup_params = dict(
    # Use the distutils SDist so that symlinks are not expanded
    # Use a custom Build for the same reason
    cmdclass={
        "build_py": BuildPyCommand,
        "build_scripts": BuildScriptsCommand,
        "install_lib": InstallLibCommand,
        "install_scripts": InstallScriptsCommand,
        "sdist": SDistCommand,
    },
    name="ansible",
    version=__version__,
    description="Radically simple IT automation",
    author=__author__,
    author_email="info@ansible.com",
    url="https://ansible.com/",
    project_urls={
        "Bug Tracker": "https://github.com/ansible/ansible/issues",
        "CI: Shippable": "https://app.shippable.com/github/ansible/ansible",
        "Code of Conduct": "https://docs.ansible.com/ansible/latest/community/code_of_conduct.html",
        "Documentation": "https://docs.ansible.com/ansible/",
        "Mailing lists": "https://docs.ansible.com/ansible/latest/community/communication.html#mailing-list-information",
        "Source Code": "https://github.com/ansible/ansible",
    },
    license="GPLv3+",
    # Ansible will also make use of a system copy of python-six and
    # python-selectors2 if installed but use a Bundled copy if it's not.
    python_requires=">=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*",
    package_dir={"": "lib"},
    packages=find_packages("lib"),
    package_data={
        "": [
            "module_utils/powershell/*.psm1",
            "module_utils/powershell/*/*.psm1",
            "modules/windows/*.ps1",
            "modules/windows/*/*.ps1",
            "galaxy/data/*/*.*",
            "galaxy/data/*/*/.*",
            "galaxy/data/*/*/*.*",
            "galaxy/data/*/tests/inventory",
            "config/base.yml",
            "config/module_defaults.yml",
        ]
    },
    classifiers=[
        "Development Status :: 5 - Production/Stable",
        "Environment :: Console",
        "Intended Audience :: Developers",
        "Intended Audience :: Information Technology",
        "Intended Audience :: System Administrators",
        "License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)",
        "Natural Language :: English",
        "Operating System :: POSIX",
        "Programming Language :: Python :: 2",
        "Programming Language :: Python :: 2.7",
        "Programming Language :: Python :: 3",
        "Programming Language :: Python :: 3.5",
        "Programming Language :: Python :: 3.6",
        "Programming Language :: Python :: 3.7",
        "Topic :: System :: Installation/Setup",
        "Topic :: System :: Systems Administration",
        "Topic :: Utilities",
    ],
    scripts=[
        "bin/ansible",
        "bin/ansible-playbook",
        "bin/ansible-pull",
        "bin/ansible-doc",
        "bin/ansible-galaxy",
        "bin/ansible-console",
        "bin/ansible-connection",
        "bin/ansible-vault",
        "bin/ansible-config",
        "bin/ansible-inventory",
    ],
    data_files=[],
    # Installing as zip files would break due to references to __file__
    zip_safe=False,
)


def main():
    """Invoke installation process using setuptools."""
    setup_params = dict(static_setup_params, **get_dynamic_setup_params())
    ignore_warning_regex = (
        r"Unknown distribution option: '(project_urls|python_requires)'"
    )
    warnings.filterwarnings(
        "ignore",
        message=ignore_warning_regex,
        category=UserWarning,
        module="distutils.dist",
    )
    setup(**setup_params)
    warnings.resetwarnings()


if __name__ == "__main__":
    main()
