import os
import shutil
import subprocess
import sys

from email.parser import Parser

from functools import cmp_to_key

from ..command import Command


class SelfUpdateCommand(Command):
    """
    Updates poetry to the latest version.

    self:update
        { version? : The version to update to. }
        { --preview : Install prereleases. }
    """

    def handle(self):
        from poetry.__version__ import __version__
        from poetry.repositories.pypi_repository import PyPiRepository

        version = self.argument("version")
        if not version:
            version = ">=" + __version__

        repo = PyPiRepository(fallback=False)
        packages = repo.find_packages(
            "poetry", version, allow_prereleases=self.option("preview")
        )
        if not packages:
            self.line("No release found for the specified version")
            return

        packages.sort(
            key=cmp_to_key(
                lambda x, y: 0
                if x.version == y.version
                else int(x.version < y.version or -1)
            )
        )

        release = None
        for package in reversed(packages):
            if package.is_prerelease():
                if self.option("preview"):
                    release = package

                    break

                continue

            release = package

            break

        if release is None:
            self.line("No new release found")
            return

        if release.version == __version__:
            self.line("You are using the latest version")
            return

        try:
            self.update(release)
        except subprocess.CalledProcessError as e:
            self.line("")
            self.output.block(
                [
                    "[CalledProcessError]",
                    "An error has occured: {}".format(str(e)),
                    e.output,
                ],
                style="error",
            )

            return e.returncode

    def update(self, release):
        from poetry.utils._compat import Path
        from poetry.utils.helpers import temporary_directory

        version = release.version
        self.line("Updating to <info>{}</info>".format(version))

        prefix = sys.prefix
        base_prefix = getattr(sys, "base_prefix", None)
        real_prefix = getattr(sys, "real_prefix", None)

        prefix_poetry = Path(prefix) / "bin" / "poetry"
        if prefix_poetry.exists():
            pip = (prefix_poetry.parent / "pip").resolve()
        elif (
            base_prefix
            and base_prefix != prefix
            and (Path(base_prefix) / "bin" / "poetry").exists()
        ):
            pip = Path(base_prefix) / "bin" / "pip"
        elif real_prefix:
            pip = Path(real_prefix) / "bin" / "pip"
        else:
            pip = Path(prefix) / "bin" / "pip"

            if not pip.exists():
                raise RuntimeError("Unable to determine poetry's path")

        with temporary_directory(prefix="poetry-update-") as temp_dir:
            temp_dir = Path(temp_dir)
            dist = temp_dir / "dist"
            self.line("  - Getting dependencies")
            self.process(
                str(pip),
                "install",
                "-U",
                "poetry=={}".format(release.version),
                "--target",
                str(dist),
            )

            self.line("  - Vendorizing dependencies")

            poetry_dir = dist / "poetry"
            vendor_dir = poetry_dir / "_vendor"

            # Everything, except poetry itself, should
            # be put in the _vendor directory
            for file in dist.glob("*"):
                if file.name.startswith("poetry"):
                    continue

                dest = vendor_dir / file.name
                if file.is_dir():
                    shutil.copytree(str(file), str(dest))
                    shutil.rmtree(str(file))
                else:
                    shutil.copy(str(file), str(dest))
                    os.unlink(str(file))

            wheel_data = dist / "poetry-{}.dist-info".format(version) / "WHEEL"
            with wheel_data.open() as f:
                wheel_data = Parser().parsestr(f.read())

            tag = wheel_data["Tag"]

            # Repack everything and install
            self.line("  - Updating <info>poetry</info>")

            shutil.make_archive(
                str(temp_dir / "poetry-{}-{}".format(version, tag)),
                format="zip",
                root_dir=str(dist),
            )

            os.rename(
                str(temp_dir / "poetry-{}-{}.zip".format(version, tag)),
                str(temp_dir / "poetry-{}-{}.whl".format(version, tag)),
            )

            self.process(
                str(pip),
                "install",
                "--upgrade",
                "--no-deps",
                str(temp_dir / "poetry-{}-{}.whl".format(version, tag)),
            )

            self.line("")
            self.line(
                "<info>poetry</> (<comment>{}</>) "
                "successfully installed!".format(version)
            )

    def process(self, *args):
        return subprocess.check_output(list(args), stderr=subprocess.STDOUT)
