"""Command line interface tests for llvmprojs.py

Note that although this uses the unittest framework, it does *not* contain unit
tests.

"""

import shutil
import os
import subprocess
import unittest

from tempfile import mkdtemp
from uuid import uuid4

from linaropy.cd import cd
from llvmtestcase import LLVMTestCase


class Testllvmprojs(LLVMTestCase):

    @classmethod
    def llvm_projects(cls, *args, **kwargs):
        return cls.command_with_defaults("projects", *args, **kwargs)

    @classmethod
    def get_subproj_repo(cls, subproj):
        return os.path.join(cls.repos, subproj)

    @classmethod
    def setUpClass(cls):
        """Create the file structure and environment that llvmprojs expects"""
        cls.llvm_root = mkdtemp()
        cls.repos = os.path.join(cls.llvm_root, "repos")

        cls.all_repos = ("llvm", "clang", "compiler-rt", "lld", "lldb",
                         "libcxx", "libcxxabi", "libunwind", "test-suite")

        # Create dummy repos
        for reponame in cls.all_repos:
            cls.create_dummy_repo(cls.get_subproj_repo(reponame))

    @classmethod
    def tearDownClass(cls):
        shutil.rmtree(cls.llvm_root)

    @classmethod
    def setUp(cls):
        cls.env = os.path.join(cls.llvm_root, "env" + str(uuid4()))
        cls.llvm_src = os.path.join(cls.env, "llvm")

        # Create LLVM worktree
        cls.branch = "br" + str(uuid4())
        cls.add_worktree(cls.get_subproj_repo("llvm"), cls.llvm_src,
                         cls.branch)

    @classmethod
    def tearDown(cls):
        # Clean up the directories where we might have added subprojects.
        # This isn't 100% clean, because we don't clean up the repos between
        # tests (so any branches will remain), but it's good enough for the
        # current tests.
        for subprojdir in (os.path.join(cls.llvm_src, "projects"),
                           os.path.join(cls.llvm_src, "tools")):
            if os.path.isdir(subprojdir):
                shutil.rmtree(subprojdir)
                os.makedirs(subprojdir)

        # Run prune on the original repos, to remove any dangling worktrees.
        for reponame in cls.all_repos:
            repopath = cls.get_subproj_repo(reponame)
            with cd(repopath):
                cls.run_quietly(["git", "worktree", "prune"])

    def test_repos_arg_is_compulsory(self):
        """
        Test that we must pass in the repos for various combinations of input
        args.
        """
        with self.assertRaises(subprocess.CalledProcessError) as context:
            self.run_with_output(self.llvm_projects(repos=None))

        self.assertRegex(
            str(context.exception.output),
            "(.*\n)*.*the following arguments are required:(.*)--repos(.*\n)*")

        with self.assertRaises(subprocess.CalledProcessError) as context:
            self.run_with_output(
                self.llvm_projects(
                    "--add", "clang", repos=None))

        self.assertRegex(
            str(context.exception.output),
            "(.*\n)*.*the following arguments are required:(.*)--repos(.*\n)*")

        with self.assertRaises(subprocess.CalledProcessError) as context:
            self.run_with_output(
                self.llvm_projects(
                    "--remove",
                    "clang",
                    repos=None))

        self.assertRegex(
            str(context.exception.output),
            "(.*\n)*.*the following arguments are required:(.*)--repos(.*\n)*")

    def test_env_arg_is_compulsory(self):
        """
        Test that we must pass in the environment for various combinations of
        input args.
        """
        with self.assertRaises(subprocess.CalledProcessError) as context:
            self.run_with_output(self.llvm_projects(env=None))

        self.assertRegex(
            str(context.exception.output),
            "(.*\n)*.*the following arguments are required:(.*)--env(.*\n)*")

        with self.assertRaises(subprocess.CalledProcessError) as context:
            self.run_with_output(
                self.llvm_projects(
                    "--add", "clang", env=None))

        self.assertRegex(
            str(context.exception.output),
            "(.*\n)*.*the following arguments are required:(.*)--env(.*\n)*")

        with self.assertRaises(subprocess.CalledProcessError) as context:
            self.run_with_output(
                self.llvm_projects(
                    "--remove", "clang", env=None))

        self.assertRegex(
            str(context.exception.output),
            "(.*\n)*.*the following arguments are required:(.*)--env(.*\n)*")

    def test_dump_empty_config(self):
        """
        Test that we're correctly dumping an empty configuration (i.e. no
        projects linked) when running llvmprojs without arguments.
        """
        output = self.run_with_output(self.llvm_projects())
        self.assertRegex(output, "Projects linked:.*\n.*none.*")

    def test_add_remove_subprojects(self):
        """
        Test that we can add and remove one or several subprojects.
        """
        output = self.run_with_output(self.llvm_projects("--add", "clang"))
        self.assertRegex(output, "Projects linked:.*\n.*clang.*")

        output = self.run_with_output(
            self.llvm_projects(
                "--add", "libcxx", "lldb"))
        self.assertRegex(
            output,
            "Projects linked:.*\n" +
            ".*clang.*\n" +
            ".*libcxx.*\n" +
            ".*lldb.*")

        output = self.run_with_output(self.llvm_projects("--remove", "libcxx"))
        self.assertRegex(output,
                         "Projects linked:.*\n" +
                         ".*clang.*\n" +
                         ".*lldb.*")

        output = self.run_with_output(
            self.llvm_projects(
                "--remove", "clang", "lldb"))
        self.assertRegex(output,
                         "Projects linked:.*\n" +
                         ".*none.*")

    def test_add_remove_invalid_subprojects(self):
        """
        Test that we error out nicely when trying to add/remove invalid
        subprojects.
        """
        with self.assertRaises(subprocess.CalledProcessError) as context:
            self.run_with_output(
                self.llvm_projects(
                    "--add", "inventedsubproject"))

        self.assertRegex(
            str(context.exception.output),
            "(.*\n)*.*invalid choice:.*inventedsubproject(.*\n)*")

        with self.assertRaises(subprocess.CalledProcessError) as context:
            self.run_with_output(
                self.llvm_projects(
                    "--remove",
                    "inventedsubproject"))

        self.assertRegex(
            str(context.exception.output),
            "(.*\n)*.*invalid choice:.*inventedsubproject(.*\n)*")

    def test_duplicate_add_remove(self):
        """
        Test that we don't crash when trying to add / remove the same subproject
        twice with the same command.
        """
        output = self.run_with_output(
            self.llvm_projects(
                "--add", "clang", "lld", "clang"))
        self.assertRegex(output,
                         "Projects linked:.*\n" +
                         ".*clang.*\n" +
                         ".*lld.*")

        output = self.run_with_output(
            self.llvm_projects(
                "--remove", "lld", "lld", "clang"))
        self.assertRegex(output,
                         "Projects linked:.*\n" +
                         ".*none.*")

    def test_redundant_add_remove(self):
        """
        Test that we can add a subproject that already exists (either because it
        was added by our script or manually) or remove a subproject that doesn't
        exist.
        """
        self.add_worktree(self.get_subproj_repo("clang"),
                          os.path.join(self.llvm_src, "tools", "clang"),
                          self.branch)
        self.add_worktree(
            self.get_subproj_repo("compiler-rt"),
            os.path.join(self.llvm_src, "projects", "compiler-rt"),
            self.branch)

        output = self.run_with_output(self.llvm_projects("--add", "clang"))
        self.assertRegex(output,
                         "Projects linked:.*\n" +
                         ".*clang.*")

        output = self.run_with_output(
            self.llvm_projects(
                "--add", "compiler-rt", "lld"))
        self.assertRegex(
            output,
            "Projects linked:.*\n" +
            ".*clang.*\n" +
            ".*compiler-rt.*\n" +
            ".*lld.*")

        output = self.run_with_output(
            self.llvm_projects(
                "--remove", "lldb", "libcxx", "lld"))
        self.assertRegex(
            output,
            "Projects linked:.*\n" +
            ".*clang.*\n" +
            ".*compiler-rt.*")

    def test_simultaneous_add_remove(self):
        """
        Test that we error out when someone is trying to add and remove the same
        project with the same command.
        """
        # Try the really basic case and make sure we're not touching anything
        with self.assertRaises(subprocess.CalledProcessError) as context:
            self.run_with_output(
                self.llvm_projects(
                    "--add",
                    "clang",
                    "--remove",
                    "clang"))

        self.assertRegex(
            str(context.exception.output),
            "(.*\n)*.*Can't add and remove clang at the same time(.*\n)*")

        self.assertFalse(
            os.path.exists(
                os.path.join(self.llvm_src, "tools", "clang")))

        # Try something a bit more complicated and make sure we're not touching
        # anything
        self.add_worktree(
            self.get_subproj_repo("lld"),
            os.path.join(self.llvm_src, "tools", "lld"),
            self.branch)

        with self.assertRaises(subprocess.CalledProcessError) as context:
            self.run_with_output(
                self.llvm_projects(
                    "--add",
                    "clang",
                    "lld",
                    "libcxx",
                    "--remove",
                    "lld",
                    "libcxx"))
        self.assertRegex(
            str(context.exception.output),
            "(.*\n)*" +
            ".*Can't add and remove (lld|libcxx) at the same time(.*\n)*")

        # Make sure we didn't touch anything
        self.assertFalse(
            os.path.exists(
                os.path.join(self.llvm_src, "tools", "clang")))
        self.assertTrue(
            os.path.exists(
                os.path.join(self.llvm_src, "tools", "lld")))
        self.assertFalse(
            os.path.exists(
                os.path.join(self.llvm_src, "projects", "libcxx")))

    def test_multiple_adds_removes(self):
        """
        Test that we can have multiple --add and --remove options in the same
        command and that only the last one of each kind matters.
        """
        output = self.run_with_output(
            self.llvm_projects(
                "--add",
                "libcxxabi",
                "--remove",
                "lld",
                "lldb",
                "--add",
                "clang",
                "libcxx",
                "--remove",
                "libunwind"))
        self.assertRegex(output,
                         "Projects linked:.*\n" +
                         ".*clang.*\n" +
                         ".*libcxx.*\n")

        output = self.run_with_output(
            self.llvm_projects(
                "--add",
                "libunwind",
                "libcxxabi",
                "--remove",
                "clang",
                "libcxx",
                "--add",
                "compiler-rt",
                "--remove",
                "libcxxabi"))
        self.assertRegex(output,
                         "Projects linked:.*\n" +
                         ".*clang.*\n" +
                         ".*compiler-rt.*\n" +
                         ".*libcxx.*\n")

        output = self.run_with_output(
            self.llvm_projects(
                "--add",
                "libcxx",
                "--remove",
                "lld",
                "--add",
                "lld",
                "--remove",
                "libcxx"))
        self.assertRegex(output,
                         "Projects linked:.*\n" +
                         ".*clang.*\n" +
                         ".*compiler-rt.*\n" +
                         ".*lld.*\n")

    def test_different_env(self):
        """
        Test that we can have different environments in completely different
        paths and they don't interfere when we try to add/remove projects.
        """
        # Create a separate environment
        new_env = mkdtemp()
        new_branch = "br" + str(uuid4())
        self.add_worktree(self.get_subproj_repo("llvm"),
                          os.path.join(new_env, "llvm"), new_branch)

        # Check that we start with a clean slate in both the new environment and
        # the one that's already set up
        output = self.run_with_output(self.llvm_projects())
        self.assertRegex(output, "Projects linked:.*\n.*none.*")

        output = self.run_with_output(self.llvm_projects(env=new_env))
        self.assertRegex(output, "Projects linked:.*\n.*none.*")

        # Make sure that adding projects works
        output = self.run_with_output(
            self.llvm_projects(
                "--add", "clang", "lld"))
        self.assertRegex(output, "Projects linked:.*\n.*clang.*\n.*lld.*\n")

        output = self.run_with_output(
            self.llvm_projects(
                "--add",
                "libcxx",
                "libcxxabi",
                env=new_env))
        self.assertRegex(output,
                         "Projects linked:.*\n.*libcxx.*\n.*libcxxabi.*\n.*")

        output = self.run_with_output(self.llvm_projects())
        self.assertRegex(output, "Projects linked:.*\n.*clang.*\n.*lld.*\n")

        # Make sure that removing projects works
        output = self.run_with_output(self.llvm_projects("--remove", "lld"))
        self.assertRegex(output, "Projects linked:.*\n.*clang.*\n")

        output = self.run_with_output(self.llvm_projects("--remove", "libcxx",
                                                         env=new_env))
        self.assertRegex(output,
                         "Projects linked:.*\n.*libcxxabi.*\n.*")

        output = self.run_with_output(self.llvm_projects())
        self.assertRegex(output, "Projects linked:.*\n.*clang.*\n")

        shutil.rmtree(new_env)