#!/usr/bin/env python
#
# Copyright (C) 2015 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
"""Runs the libc++ tests against the platform libc++."""
from __future__ import print_function

import argparse
import logging
import os
import posixpath
import sys

THIS_DIR = os.path.dirname(os.path.realpath(__file__))
ANDROID_DIR = os.path.realpath(os.path.join(THIS_DIR, '../..'))


def logger():
    """Returns the logger for the module."""
    return logging.getLogger(__name__)


def call(cmd, *args, **kwargs):
    """subprocess.call with logging."""
    import subprocess
    logger().info('call %s', ' '.join(cmd))
    return subprocess.call(cmd, *args, **kwargs)


def check_call(cmd, *args, **kwargs):
    """subprocess.check_call with logging."""
    import subprocess
    logger().info('check_call %s', ' '.join(cmd))
    return subprocess.check_call(cmd, *args, **kwargs)


def check_output(cmd, *args, **kwargs):
    """subprocess.check_output with logging."""
    import subprocess
    logger().info('check_output %s', ' '.join(cmd))
    return subprocess.check_output(cmd, *args, **kwargs)


class ArgParser(argparse.ArgumentParser):
    """Parses command line arguments."""

    def __init__(self):
        super(ArgParser, self).__init__()
        self.add_argument('--bitness', choices=(32, 64), type=int, default=32)
        self.add_argument('--host', action='store_true')


def extract_build_cmds(commands, exe_name):
    """Extracts build command information from `ninja -t commands` output.

    Args:
        commands: String containing the output of `ninja -t commands` for the
            libcxx_test_template.
        exe_name: The basename of the built executable.

    Returns:
        Tuple of (compiler, compiler_flags, linker_flags).
    """
    cc = None
    cflags = None
    ldflags = None
    template_name = 'external/libcxx/libcxx_test_template.cpp'

    for cmd in commands.splitlines():
        cmd_args = cmd.split()
        if cc is None and template_name in cmd_args:
            for i, arg in enumerate(cmd_args):
                if arg == '-o':
                    cmd_args[i + 1] = '%OUT%'
                elif arg == template_name:
                    cmd_args[i] = '%SOURCE%'
                # Drop dependency tracking args since they can cause file
                # not found errors at test time.
                if arg == '-MD':
                    cmd_args[i] = ''
                if arg == '-MF':
                    cmd_args[i] = ''
                    cmd_args[i + 1] = ''
            if cmd_args[0] == 'PWD=/proc/self/cwd':
                cmd_args = cmd_args[1:]
            if cmd_args[0].endswith('gomacc'):
                cmd_args = cmd_args[1:]
            cc = cmd_args[0]
            cflags = cmd_args[1:]
        if ldflags is None:
            is_ld = False
            for i, arg in enumerate(cmd_args):
                # Here we assume that the rspfile contains the path to the
                # object file and nothing else.
                if arg.startswith('@'):
                    cmd_args[i] = '%SOURCE%'
                if arg == '-o' and cmd_args[i + 1].endswith(exe_name):
                    cmd_args[i + 1] = '%OUT%'
                    is_ld = True
            if is_ld:
                ldflags = cmd_args[1:]

    return cc, cflags, ldflags


def get_build_cmds(bitness, host):
    """Use ninja -t commands to find the build commands for an executable."""
    out_dir = os.getenv('OUT_DIR', os.path.join(ANDROID_DIR, 'out'))
    product_out = os.getenv('ANDROID_PRODUCT_OUT')

    if host:
        rel_out_dir = os.path.relpath(
            os.path.join(out_dir, 'soong/host/linux-x86/bin'), ANDROID_DIR)
        target = os.path.join(rel_out_dir, 'libcxx_test_template64')
    else:
        exe_name = 'libcxx_test_template' + str(bitness)
        rel_out_dir = os.path.relpath(product_out, ANDROID_DIR)
        target = os.path.join(rel_out_dir, 'system/bin', exe_name)

    # Generate $OUT_DIR/combined-$TARGET_PRODUCT.ninja and build the
    # template target's dependencies.
    check_call(['make', '-C', ANDROID_DIR, target])

    ninja_path = os.path.join(
        out_dir, 'combined-' + os.getenv('TARGET_PRODUCT') + '.ninja')
    commands = check_output([
        os.path.join(ANDROID_DIR, 'prebuilts/build-tools/linux-x86/bin/ninja'),
        '-C', ANDROID_DIR, '-f', ninja_path, '-t', 'commands', target
    ])

    return extract_build_cmds(commands, os.path.basename(target))


def setup_test_directory():
    """Prepares a device test directory for use by the shell user."""
    stdfs_test_data = os.path.join(
        THIS_DIR, 'test/std/input.output/filesystems/Inputs/static_test_env')
    device_dir = '/data/local/tmp/libcxx'
    dynamic_dir = posixpath.join(device_dir, 'dynamic_test_env')
    check_call(['adb', 'shell', 'rm', '-rf', device_dir])
    check_call(['adb', 'shell', 'mkdir', '-p', device_dir])
    check_call(['adb', 'shell', 'mkdir', '-p', dynamic_dir])
    check_call(['adb', 'push', '--sync', stdfs_test_data, device_dir])
    check_call(['adb', 'shell', 'chown', '-R', 'shell:shell', device_dir])


def main():
    """Program entry point."""
    logging.basicConfig(level=logging.INFO)

    args, lit_args = ArgParser().parse_known_args()
    lit_path = os.path.join(ANDROID_DIR, 'external/llvm/utils/lit/lit.py')
    cc, cflags, ldflags = get_build_cmds(args.bitness, args.host)

    mode_str = 'host' if args.host else 'device'
    android_mode_arg = '--param=android_mode=' + mode_str
    cxx_under_test_arg = '--param=cxx_under_test=' + cc
    cxx_template_arg = '--param=cxx_template=' + ' '.join(cflags)
    link_template_arg = '--param=link_template=' + ' '.join(ldflags)
    site_cfg_path = os.path.join(THIS_DIR, 'test/lit.site.cfg')
    libcxx_site_cfg_arg = '--param=libcxx_site_config=' + site_cfg_path
    libcxxabi_site_cfg_arg = '--param=libcxxabi_site_config=' + site_cfg_path
    default_test_paths = [
        os.path.join(THIS_DIR, 'test'),
        os.path.join(ANDROID_DIR, 'external/libcxxabi/test')
    ]

    have_filter_args = False
    for arg in lit_args:
        # If the argument is a valid path with default_test_paths, it is a test
        # filter.
        real_path = os.path.realpath(arg)
        if not any(real_path.startswith(path) for path in default_test_paths):
            continue
        if not os.path.exists(real_path):
            continue

        have_filter_args = True
        break  # No need to keep scanning.

    if not args.host:
        setup_test_directory()

    lit_args = [
        '-sv', android_mode_arg, cxx_under_test_arg, cxx_template_arg,
        link_template_arg, libcxx_site_cfg_arg, libcxxabi_site_cfg_arg
    ] + lit_args
    cmd = ['python', lit_path] + lit_args
    if not have_filter_args:
        cmd += default_test_paths
    sys.exit(call(cmd))


if __name__ == '__main__':
    main()