import errno
import os
import tempfile
import time

import lit.formats  # pylint: disable=import-error


class LibcxxTestFormat(lit.formats.FileBasedTest):
    """
    Custom test format handler for use with the test format use by libc++.

    Tests fall into two categories:
      FOO.pass.cpp - Executable test which should compile, run, and exit with
                     code 0.
      FOO.fail.cpp - Negative test case which is expected to fail compilation.
    """

    def __init__(self, cxx_under_test, use_verify_for_fail,
                 cpp_flags, ld_flags, exec_env,
                 use_ccache=False):
        self.cxx_under_test = cxx_under_test
        self.use_verify_for_fail = use_verify_for_fail
        self.cpp_flags = list(cpp_flags)
        self.ld_flags = list(ld_flags)
        self.exec_env = dict(exec_env)
        self.use_ccache = use_ccache

    def execute(self, test, lit_config):
        while True:
            try:
                return self._execute(test, lit_config)
            except OSError, oe:
                if oe.errno != errno.ETXTBSY:
                    raise
                time.sleep(0.1)

    def _execute(self, test, lit_config):
        # Extract test metadata from the test file.
        requires = []
        unsupported = []
        use_verify = False
        with open(test.getSourcePath()) as f:
            for ln in f:
                if 'XFAIL:' in ln:
                    items = ln[ln.index('XFAIL:') + 6:].split(',')
                    test.xfails.extend([s.strip() for s in items])
                elif 'REQUIRES:' in ln:
                    items = ln[ln.index('REQUIRES:') + 9:].split(',')
                    requires.extend([s.strip() for s in items])
                elif 'UNSUPPORTED:' in ln:
                    items = ln[ln.index('UNSUPPORTED:') + 12:].split(',')
                    unsupported.extend([s.strip() for s in items])
                elif 'USE_VERIFY' in ln and self.use_verify_for_fail:
                    use_verify = True
                elif not ln.strip().startswith("//") and ln.strip():
                    # Stop at the first non-empty line that is not a C++
                    # comment.
                    break

        # Check that we have the required features.
        #
        # FIXME: For now, this is cribbed from lit.TestRunner, to avoid
        # introducing a dependency there. What we more ideally would like to do
        # is lift the "requires" handling to be a core lit framework feature.
        missing_required_features = [
            f for f in requires
            if f not in test.config.available_features
        ]
        if missing_required_features:
            return (lit.Test.UNSUPPORTED,
                    "Test requires the following features: %s" % (
                        ', '.join(missing_required_features),))

        unsupported_features = [f for f in unsupported
                                if f in test.config.available_features]
        if unsupported_features:
            return (lit.Test.UNSUPPORTED,
                    "Test is unsupported with the following features: %s" % (
                        ', '.join(unsupported_features),))

        # Evaluate the test.
        return self._evaluate_test(test, use_verify, lit_config)

    def _make_report(self, cmd, out, err, rc):  # pylint: disable=no-self-use
        report = "Command: %s\n" % cmd
        report += "Exit Code: %d\n" % rc
        if out:
            report += "Standard Output:\n--\n%s--\n" % out
        if err:
            report += "Standard Error:\n--\n%s--\n" % err
        report += '\n'
        return cmd, report, rc

    def _compile(self, output_path, source_path, use_verify=False):
        cmd = [self.cxx_under_test, '-c', '-o', output_path, source_path]
        cmd += self.cpp_flags
        if use_verify:
            cmd += ['-Xclang', '-verify']
        if self.use_ccache:
            cmd = ['ccache'] + cmd
        out, err, rc = lit.util.executeCommand(cmd)
        return cmd, out, err, rc

    def _link(self, exec_path, object_path):
        cmd = [self.cxx_under_test, '-o', exec_path, object_path]
        cmd += self.cpp_flags + self.ld_flags
        out, err, rc = lit.util.executeCommand(cmd)
        return cmd, out, err, rc

    def _compile_and_link(self, exec_path, source_path):
        object_file = tempfile.NamedTemporaryFile(suffix=".o", delete=False)
        object_path = object_file.name
        object_file.close()
        try:
            cmd, out, err, rc = self._compile(object_path, source_path)
            if rc != 0:
                return cmd, out, err, rc
            return self._link(exec_path, object_path)
        finally:
            try:
                os.remove(object_path)
            except OSError:
                pass

    def _build(self, exec_path, source_path, compile_only=False,
               use_verify=False):
        if compile_only:
            cmd, out, err, rc = self._compile(exec_path, source_path,
                                              use_verify)
        else:
            assert not use_verify
            cmd, out, err, rc = self._compile_and_link(exec_path, source_path)
        return self._make_report(cmd, out, err, rc)

    def _clean(self, exec_path):  # pylint: disable=no-self-use
        try:
            os.remove(exec_path)
        except OSError:
            pass

    def _run(self, exec_path, lit_config, in_dir=None):
        cmd = []
        if self.exec_env:
            cmd.append('env')
            cmd.extend('%s=%s' % (name, value)
                       for name, value in self.exec_env.items())
        cmd.append(exec_path)
        if lit_config.useValgrind:
            cmd = lit_config.valgrindArgs + cmd
        out, err, rc = lit.util.executeCommand(cmd, cwd=in_dir)
        return self._make_report(cmd, out, err, rc)

    def _evaluate_test(self, test, use_verify, lit_config):
        name = test.path_in_suite[-1]
        source_path = test.getSourcePath()
        source_dir = os.path.dirname(source_path)

        # Check what kind of test this is.
        assert name.endswith('.pass.cpp') or name.endswith('.fail.cpp')
        expected_compile_fail = name.endswith('.fail.cpp')

        # If this is a compile (failure) test, build it and check for failure.
        if expected_compile_fail:
            cmd, report, rc = self._build('/dev/null', source_path,
                                          compile_only=True,
                                          use_verify=use_verify)
            expected_rc = 0 if use_verify else 1
            if rc == expected_rc:
                return lit.Test.PASS, ""
            else:
                return (lit.Test.FAIL,
                        report + 'Expected compilation to fail!\n')
        else:
            exec_file = tempfile.NamedTemporaryFile(suffix="exe", delete=False)
            exec_path = exec_file.name
            exec_file.close()

            try:
                cmd, report, rc = self._build(exec_path, source_path)
                compile_cmd = cmd
                if rc != 0:
                    report += "Compilation failed unexpectedly!"
                    return lit.Test.FAIL, report

                cmd, report, rc = self._run(exec_path, lit_config,
                                            source_dir)
                if rc != 0:
                    report = "Compiled With: %s\n%s" % (compile_cmd, report)
                    report += "Compiled test failed unexpectedly!"
                    return lit.Test.FAIL, report
            finally:
                # Note that cleanup of exec_file happens in `_clean()`. If you
                # override this, cleanup is your reponsibility.
                self._clean(exec_path)
        return lit.Test.PASS, ""