#!/usr/bin/env python

# Copyright (C) 2016 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.

'''Main test suite execution script.'''
import argparse
import inspect
import logging
import os
import signal
import subprocess
import sys
import time
import collections
import xml.etree.ElementTree as ET

from config import Config
from tests.harness import util_constants
from tests.harness.exception import TestSuiteException, FailFastException
from tests.harness import UtilAndroid
from tests.harness import UtilBundle
from tests.harness import util_log
from tests.harness.util_functions import load_py_module
from tests.harness.decorators import deprecated

# For some reason pylint is not able to understand the class returned by
# from util_log.get_logger() and generates a lot of false warnings
#pylint: disable=maybe-no-member

EMU_PROC = None

def _parse_args():
    '''Parse the command line arguments.

    Returns:
        A namespace object that contains the options specified to run_tests on
        the command line.
    '''

    parser = argparse.ArgumentParser(description='Run the test suite.')

    parser.add_argument('--config', '-c',
                        metavar='path',
                        help='Path to a custom config file.')
    parser.add_argument('--device', '-d',
                        help='Specify the device id of the device to test on.')
    parser.add_argument('--test', '-t',
                        metavar='path',
                        help='Specify a specific test to run.')
    group = parser.add_mutually_exclusive_group()
    group.add_argument('--wimpy', '-w',
                        action='store_true',
                        default=None,
                        help='Test only a core subset of features.')
    group.add_argument('--app-types',
                        default=['java', 'cpp', 'jni'],
                        nargs='*',
                        help='Specify a list of Android app types against which'
                             ' to run the tests',
                        dest='bundle_types')
    parser.add_argument('--install-only',
                        action='store_true',
                        default=False,
                        help='It only runs the pre-run stage of the test suite.'
                             ' It installs the required APKs but does not '
                             'execute the tests.',
                        dest='install_only')
    parser.add_argument('--no-install', '-n',
                        action='store_true',
                        default=False,
                        help='Stop the test suite installing apks to device.',
                        dest='noinstall')
    parser.add_argument('--no-uninstall',
                        action='store_true',
                        default=False,
                        help='Stop the test suite uninstalling apks after '
                             'completion.',
                        dest='nouninstall')
    parser.add_argument('--print-to-stdout',
                        action='store_true',
                        default=False,
                        help='Print all logging information to standard out.',
                        dest='print_to_stdout')
    parser.add_argument('--verbose', '-v',
                        action='store_true',
                        default=None,
                        help='Store extra info in the log.')
    parser.add_argument('--fail-fast',
                        action='store_true',
                        default=False,
                        help='Exit the test suite immediately on the first failure.')
    parser.add_argument('--run-emu',
                        action='store_true',
                        default=None,
                        help='Spawn an emulator and run the test suite on that.'
                             ' Specify the emulator command line in the config'
                             ' file or with -emu-cmd.',
                        dest='run_emu')

    # Get the properties of the Config class and add a command line argument
    # for each.
    this_module = sys.modules[__name__]
    for member_name, member_obj in inspect.getmembers(Config):
        if (inspect.isdatadescriptor(member_obj) and
            member_name not in ['__weakref__', 'device', 'verbose']):

            # List type properties can take one or more arguments
            num_args = None
            if (isinstance(member_obj, property)
                and isinstance(member_obj.fget(Config), list)):
                num_args = '+'

            opt_name = member_name.replace('_', '-')

            setattr(this_module, opt_name, '')

            parser.add_argument('--' + opt_name,
                                nargs=num_args,
                                help=member_obj.__doc__,
                                dest=member_name)

    return parser.parse_args()


def _choice(first_choice, second_choice):
    '''Return first_choice if it is not None otherwise return second_choice.

    Args:
        first_choice: The first choice value.
        second_choice: The alternative value.

    Returns:
        The first argument if it is not None, and the second otherwise.
    '''
    return first_choice if first_choice else second_choice


class State(object):
    '''This class manages all objects required by the test suite.'''

    # pylint: disable=too-many-instance-attributes
    # Since this is a state class many attributes are expected.

    def __init__(self):
        '''State constructor.

        Raises:
            TestSuiteException: When unable to load config file.

            AssertionError: When assertions fail.
        '''

        # Parse the command line options
        args = _parse_args()

        # create a config instance
        if args.config:
            # use the user supplied
            config = State.load_user_configuration(args.config)
        else:
            # use the default configuration
            config = Config()

        # save the test denylist
        self.blocklist = _choice(args.blocklist, config.blocklist)

        # Allow any of the command line arguments to override the
        # values in the config file.
        self.adb_path = _choice(args.adb_path, config.adb_path)

        self.host_port = int(_choice(args.host_port, config.host_port))

        self.device = _choice(args.device, config.device)

        self.user_specified_device = self.device

        self.device_port = int(_choice(args.device_port, config.device_port))

        self.lldb_server_path_device = _choice(args.lldb_server_path_device,
                                               config.lldb_server_path_device)

        self.lldb_server_path_host = _choice(args.lldb_server_path_host,
                                             config.lldb_server_path_host)

        self.aosp_product_path = _choice(args.aosp_product_path,
                                         config.aosp_product_path)

        self.log_file_path = _choice(args.log_file_path, config.log_file_path)

        self.results_file_path = _choice(args.results_file_path,
                                         config.results_file_path)

        self.lldb_path = _choice(args.lldb_path, config.lldb_path)
        self.print_to_stdout = args.print_to_stdout
        self.verbose = _choice(args.verbose, config.verbose)
        self.timeout = int(_choice(args.timeout, config.timeout))
        self.emu_cmd = _choice(args.emu_cmd, config.emu_cmd)
        self.run_emu = args.run_emu
        self.wimpy = args.wimpy
        self.bundle_types = args.bundle_types if not self.wimpy else ['java']
        self.fail_fast = args.fail_fast

        # validate the param "verbose"
        if not isinstance(self.verbose, bool):
            raise TestSuiteException('The parameter "verbose" should be a '
                                     'boolean: {0}'.format(self.verbose))

        # create result array
        self.results = dict()
        self.single_test = args.test

        # initialise the logging facility
        log_level = logging.INFO if not self.verbose else logging.DEBUG
        util_log.initialise("driver",
                            print_to_stdout=self.print_to_stdout,
                            level=log_level,
                            file_mode='w', # open for write
                            file_path=self.log_file_path
                            )
        log = util_log.get_logger()

        if self.run_emu and not self.emu_cmd:
            log.TestSuiteException('Need to specify --emu-cmd (or specify a'
                ' value in the config file) if using --run-emu.')

        # create a results file
        self.results_file = open(self.results_file_path, 'w')

        # create an android helper object
        self.android = UtilAndroid(self.adb_path,
                                   self.lldb_server_path_device,
                                   self.device)
        assert self.android

        # create a test bundle
        self.bundle = UtilBundle(self.android,
                                 self.aosp_product_path)
        assert self.bundle

        # save the no pushing option
        assert isinstance(args.noinstall, bool)
        self.noinstall = args.noinstall

        assert isinstance(args.nouninstall, bool)
        self.nouninstall = args.nouninstall

        # install only option
        assert type(args.install_only) is bool
        self.install_only = args.install_only
        if self.install_only:
            log.log_and_print('Option --install-only set. The test APKs will '
                              'be installed on the device but the tests will '
                              'not be executed.')
            if self.noinstall:
                raise TestSuiteException('Conflicting options given: '
                                         '--install-only and --no-install')

        # TCP port modifier which is used to increment the port number used for
        # each test case to avoid collisions.
        self.port_mod = 0

        # total number of test files that have been executed
        self.test_count = 0

    def get_android(self):
        '''Return the android ADB helper instance.

        Returns:
            The android ADB helper, instance of UtilAndroid.
        '''
        assert self.android
        return self.android

    def get_bundle(self):
        '''Return the test executable bundle.

        Returns:
            The test exectable collection, instance of UtilBundle.
        '''
        return self.bundle

    def add_result(self, name, app_type, result):
        '''Add a test result to the collection.

        Args:
            name: String name of the test that has executed.
            app_type: type of app i.e. java, jni, or cpp
            result: String result of the test, "pass", "fail", "error".
        '''
        key = (name, app_type)
        assert key not in self.results
        self.results[key] = result

    def get_single_test(self):
        '''Get the name of the single test to run.

        Returns:
            A string that is the name of the python file containing the test to
            be run. If all tests are to be run this returns None.
        '''
        return self.single_test

    @staticmethod
    def load_user_configuration(path):
        '''Load the test suite config from the give path.

        Instantiate the Config class found in the module at the given path.
        If no suitable class is available, it raises a TestSuiteException.

        Args:
            path: String location of the module.

        Returns:
            an instance of the Config class, defined in the module.

        Raises:
            TestSuiteException: when unable to import the module or when a
                                subclass of Config is not found inside it.
        '''

        # load the module
        config_module = load_py_module(path)
        if not config_module:
            raise TestSuiteException('Unable to import the module from "%s"'
                                     % (path))

        # look for a subclass of Config
        for name, value in inspect.getmembers(config_module):
            if (inspect.isclass(value)
                and name != 'Config'
                and issubclass(value, Config)):
                # that's our candidate
                return value()

        # otherwise there are no valid candidates
        raise TestSuiteException('The provided user configuration is not '
                                 'valid. The module must define a subclass '
                                 'of Config')


def _kill_emulator():
    ''' Kill the emulator process. '''
    global EMU_PROC
    if EMU_PROC:
        try:
            EMU_PROC.terminate()
        except OSError:
            # can't kill a dead proc
            log = util_log.get_logger()
            log.debug('Trying to kill an emulator but it is already dead.')


def _check_emulator_terminated():
    ''' Throw an exception if the emulator process has ended.

    Raises:
        TestSuiteException: If the emulator process has ended.
    '''
    global EMU_PROC
    assert EMU_PROC
    if EMU_PROC.poll():
        stdout, stderr = EMU_PROC.communicate()
        raise TestSuiteException('The emulator terminated with output:'
            '\nstderr: {0}\nstdout: {1}.'.format(stderr, stdout))


@deprecated()
def _launch_emulator(state):
    '''Launch the emulator and wait for it to boot.

    Args:
        emu_cmd: The command line to run the emulator.

    Raises:
        TestSuiteException: If an emulator already exists or the emulator
                            process terminated before we could connect to it, or
                            we failed to copy lldb-server to the emulator.
    '''
    global EMU_PROC
    android = state.android
    if state.user_specified_device:
        if android.device_with_substring_exists(state.user_specified_device):
            raise TestSuiteException(
                'A device with name {0} already exists.',
                state.user_specified_device)
    else:
        if android.device_with_substring_exists('emulator'):
            raise TestSuiteException('An emulator already exists.')

    assert state.emu_cmd
    EMU_PROC = subprocess.Popen(state.emu_cmd.split(),
                                stdout=None,
                                stderr=subprocess.STDOUT)

    log = util_log.get_logger()
    log.info('Launching emulator with command line {0}'.format(state.emu_cmd))

    tries_number = 180
    tries = tries_number
    found_device = False
    while not found_device:
        try:
            android.validate_device(False, 'emulator')
            found_device = True
        except TestSuiteException as ex:
            tries -= 1
            if tries == 0:
                # Avoid infinitely looping if the emulator won't boot
                log.warning(
                    'Giving up trying to validate device after {0} tries.'
                    .format(tries_number))
                raise ex
            _check_emulator_terminated()
            # wait a bit and try again, maybe it has now booted
            time.sleep(10)

    tries = 500
    while not android.is_booted():
        tries -= 1
        if tries == 0:
            # Avoid infinitely looping if the emulator won't boot
            raise TestSuiteException('The emulator has failed to boot.')
        _check_emulator_terminated()
        time.sleep(5)

    # Need to be root before we can push lldb-server
    android.adb_root()
    android.wait_for_device()

    # Push the lldb-server executable to the device.
    output = android.adb('push {0} {1}'.format(state.lldb_server_path_host,
                                               state.lldb_server_path_device))

    if 'failed to copy' in output or 'No such file or directory' in output:
        raise TestSuiteException(
            'unable to push lldb-server to the emulator: {0}.'
            .format(output))

    output = android.shell('chmod a+x {0}'
                           .format(state.lldb_server_path_device))

    if 'No such file or directory' in output:
        raise TestSuiteException('Failed to copy lldb-server to the emulator.')


def _restart_emulator(state):
    '''Kill the emulator and start a new instance.

    Args:
        state: Test suite state collection, instance of State.
    '''
    _kill_emulator()
    _launch_emulator(state)


def _run_test(state, name, bundle_type):
    '''Execute a single test case.

    Args:
        state: Test suite state collection, instance of State.
        name: String file name of the test to execute.
        bundle_type: string for the installed app type (cpp|jni|java)

    Raises:
        AssertionError: When assertion fails.
    '''
    assert isinstance(name, str)

    try:
        state.android.check_adb_alive()
    except TestSuiteException as expt:
        global EMU_PROC
        if EMU_PROC:
            _restart_emulator(state)
        else:
            raise expt

    log = util_log.get_logger()
    sys.stdout.write('Running {0}\r'.format(name))
    sys.stdout.flush()
    log.info('Running {0}'.format(name))

    run_tests_dir = os.path.dirname(os.path.realpath(__file__))
    run_test_path = os.path.join(run_tests_dir, 'tests', 'run_test.py')

    # Forward port for lldb-server on the device to our host
    hport = int(state.host_port) + state.port_mod
    dport = int(state.device_port) + state.port_mod
    state.android.forward_port(hport, dport)
    state.port_mod += 1

    log.debug('Giving up control to {0}...'.format(name))

    params = map(str, [
        sys.executable,
        run_test_path,
        name,
        state.log_file_path,
        state.adb_path,
        state.lldb_server_path_device,
        state.aosp_product_path,
        dport,
        state.android.get_device_id(),
        state.print_to_stdout,
        state.verbose,
        state.wimpy,
        state.timeout,
        bundle_type
    ])

    return_code = subprocess.call(params)
    state.test_count += 1
    state.android.remove_port_forwarding()
    log.seek_to_end()

    # report in sys.stdout the result
    success = return_code == util_constants.RC_TEST_OK
    status_handlers = collections.defaultdict(lambda: ('error', log.error), (
            (util_constants.RC_TEST_OK, ('pass', log.info)),
            (util_constants.RC_TEST_TIMEOUT, ('timeout', log.error)),
            (util_constants.RC_TEST_IGNORED, ('ignored', log.info)),
            (util_constants.RC_TEST_FAIL, ('fail', log.critical))
        )
    )
    status_name, status_logger = status_handlers[return_code]
    log.info('Running %s: %s', name, status_name.upper())
    status_logger("Test %r: %s", name, status_name)

    # Special case for ignored tests - just return now
    if return_code == util_constants.RC_TEST_IGNORED:
        return

    state.add_result(name, bundle_type, status_name)

    if state.fail_fast and not success:
        raise FailFastException(name)

    # print a running total pass rate
    passes = sum(1 for key, value in state.results.items() if value == 'pass')
    log.info('Current pass rate: %s of %s executed.', passes, len(state.results))


def _check_lldbserver_exists(state):
    '''Check lldb-server exists on the target device and it is executable.

    Raises:
        TestSuiteError: If lldb-server does not exist on the target.
    '''
    assert state

    message = 'Unable to verify valid lldb-server on target'

    android = state.get_android()
    assert android

    cmd = state.lldb_server_path_device
    out = android.shell(cmd, False)
    if not isinstance(out, str):
        raise TestSuiteException(message)
    if out.find('Usage:') < 0:
        raise TestSuiteException(message)


def _suite_pre_run(state):
    '''This function is executed before the test cases are run (setup).

    Args:
        state: Test suite state collection, instance of State.

    Return:
        True if the pre_run step completes without error.
        Checks made:
            - Validating that adb exists and runs.
            - Validating that a device is attached.
            - We have root access to the device.
            - All test binaries were pushed to the device.
            - The port for lldb-server was forwarded correctly.

    Raises:
        AssertionError: When assertions fail.
    '''
    assert state
    log = util_log.get_logger()

    try:
        android = state.get_android()
        bundle = state.get_bundle()
        assert android
        assert bundle

        # validate ADB helper class
        android.validate_adb()
        log.log_and_print('Located ADB')

        if state.run_emu:
            log.log_and_print('Launching emulator...')
            _launch_emulator(state)
            log.log_and_print('Started emulator ' + android.device)
        else:
            android.validate_device()
            log.log_and_print('Located device ' + android.device)

        if state.noinstall and not state.single_test:
            bundle.check_apps_installed(state.wimpy)

        # elevate to root user
        android.adb_root()
        android.wait_for_device()
        # check that lldb-server exists on device
        android.kill_servers()
        _check_lldbserver_exists(state)

        if not state.noinstall:
            # push all tests to the device
            log.log_and_print('Pushing all tests...')
            bundle.push_all()
            log.log_and_print('Pushed all tests')
        log.log_and_print('Pre run complete')

    except TestSuiteException as expt:
        log.exception('Test suite pre run failure')

        # Even if we are logging the error, it may be helpful and more
        # immediate to find out the error into the terminal
        log.log_and_print('ERROR: Unable to set up the test suite: %s\n'
                          % expt.message, logging.ERROR)

        return False
    return True


def _suite_post_run(state):
    '''This function is executed after the test cases have run (teardown).

    Args:
        state: Test suite state collection, instance of State.
    Returns:
        Number of failures
    '''
    log = util_log.get_logger()

    if not state.noinstall and not state.nouninstall:
        if state.wimpy:
            state.bundle.uninstall_all_apk()
        else:
            state.bundle.uninstall_all()
        log.log_and_print('Uninstalled/Deleted all tests')

    total = 0
    passes = 0
    failures = 0

    results = ET.Element('testsuite')
    results.attrib['name'] = 'LLDB RS Test Suite'

    for key, value in state.results.items():
        total += 1
        if value == 'pass':
            passes += 1
        else:
            failures += 1

        # test case name, followed by pass, failure or error elements
        testcase = ET.Element('testcase')
        testcase.attrib['name'] = "%s:%s" % key
        result_element = ET.Element(value)
        result_element.text = "%s:%s" % key
        testcase.append(result_element)
        results.append(testcase)

    assert passes + failures == total, 'Invalid test results status'
    if failures:
        log.log_and_print(
            'The following failures occurred:\n%s\n' %
            '\n'.join('failed: %s:%s' % test_spec
                for test_spec, result in state.results.items() if result != 'pass'
        ))

    log.log_and_print('{0} of {1} passed'.format(passes, total))
    if total:
        log.log_and_print('{0}% rate'.format((passes*100)/total))

    results.attrib['tests'] = str(total)
    state.results_file.write(ET.tostring(results, encoding='iso-8859-1'))

    return failures


def _discover_tests(state):
    '''Discover all tests in the tests directory.

    Returns:
        List of strings, test file names from the 'tests' directory.
    '''
    tests = []

    single_test = state.get_single_test()
    if single_test is None:
        file_dir = os.path.dirname(os.path.realpath(__file__))
        tests_dir = os.path.join(file_dir, 'tests')

        for sub_dir in os.listdir(tests_dir):
            current_test_dir = os.path.join(tests_dir, sub_dir)
            if os.path.isdir(current_test_dir):
                dir_name = os.path.basename(current_test_dir)

                if dir_name == 'harness':
                    continue

                for item in os.listdir(current_test_dir):
                    if (item.startswith('test')
                        and item.endswith('.py')
                        and not item in state.blocklist):
                        tests.append(item)
    else:
        if single_test.endswith('.py'):
            tests.append(single_test)
        else:
            tests.append(single_test + '.py')

    return tests


def _deduce_python_path(state):
    '''Try to deduce the PYTHONPATH environment variable via the LLDB binary.

    Args:
        state: Test suite state collection, instance of State.

    Returns:
        True if PYTHONPATH has been updated, False otherwise.

    Raises:
        TestSuiteException: If lldb path provided in the config or command line
                            is incorrect.
        AssertionError: If an assertion fails.
    '''

    lldb_path = state.lldb_path
    if not lldb_path:
        # lldb may not be provided in preference of a manual $PYTHONPATH
        return False

    params = [lldb_path, '-P']

    try:
        proc = subprocess.Popen(params, stdout=subprocess.PIPE)
    except OSError as err:
        error_string = 'Could not run lldb at %s: %s' % (lldb_path, str(err))
        raise TestSuiteException(error_string)

    stdout = proc.communicate()[0]
    if stdout:
        os.environ['PYTHONPATH'] = stdout.strip()
        return True

    return False


def main():
    '''The lldb-renderscript test suite entry point.'''
    log = None

    try:
        # parse the command line
        state = State()
        assert state

        # logging is initialised in State()
        log = util_log.get_logger()

        # if we can, set PYTHONPATH for lldb bindings
        if not _deduce_python_path(state):
            log.log_and_print('Unable to deduce PYTHONPATH', logging.WARN)

        # pre run step
        if not _suite_pre_run(state):
            raise TestSuiteException('Test suite pre-run step failed')
        # discover all tests and execute them
        tests = _discover_tests(state)
        log.log_and_print('Found {0} tests'.format(len(tests)))
        if state.install_only:
            log.log_and_print('Test applications installed. Terminating due to '
                              '--install-only option')
        else:
            # run the tests
            for bundle_type in state.bundle_types:
                log.info("Running bundle type '%s'", bundle_type)
                for item in tests:
                    _run_test(state, item, bundle_type)
                # post run step
            quit(0 if _suite_post_run(state) == 0 else 1)

    except AssertionError:
        if log:
            log.exception('Internal test suite error')

        print('Internal test suite error')
        quit(1)

    except FailFastException:
        log.exception('Early exit after first test failure')
        quit(1)

    except TestSuiteException as error:
        if log:
            log.exception('Test suite exception')

        print('{0}'.format(str(error)))
        quit(2)

    finally:
        _kill_emulator()
        logging.shutdown()

def signal_handler(_, _unused):
    '''Signal handler for SIGINT, caused by the user typing Ctrl-C.'''
    # pylint: disable=unused-argument
    # pylint: disable=protected-access
    print('Ctrl+C!')
    os._exit(1)


# execution trampoline
if __name__ == '__main__':
    signal.signal(signal.SIGINT, signal_handler)
    main()