# This source file is part of the Swift.org open source project
#
# Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
# Licensed under Apache License v2.0 with Runtime Library Exception
#
# See https://swift.org/LICENSE.txt for license information
# See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors

from __future__ import print_function

import argparse
import os
import sys
import unittest

from contextlib import contextmanager
from io import StringIO

from build_swift import driver_arguments
from build_swift.tests import expected_options as eo

from swift_build_support.swift_build_support import migration
from swift_build_support.swift_build_support.SwiftBuildSupport import (
    get_all_preset_names,
    get_preset_options,
)

FILE_PATH = os.path.abspath(__file__)
TESTS_PATH = os.path.abspath(os.path.join(FILE_PATH, os.pardir))
BUILD_SWIFT_PATH = os.path.abspath(os.path.join(TESTS_PATH, os.pardir))
UTILS_PATH = os.path.abspath(os.path.join(BUILD_SWIFT_PATH, os.pardir))

BUILD_SCRIPT_IMPL = os.path.join(UTILS_PATH, 'build-script-impl')

PRESETS_FILES = [
    os.path.join(UTILS_PATH, 'build-presets.ini'),
]


class ParserError(Exception):
    pass


@contextmanager
def redirect_stderr(stream=None):
    stream = stream or StringIO()
    old_stderr, sys.stderr = sys.stderr, stream
    try:
        yield stream
    finally:
        sys.stderr = old_stderr


@contextmanager
def redirect_stdout(stream=None):
    stream = stream or StringIO()
    old_stdout, sys.stdout = sys.stdout, stream
    try:
        yield stream
    finally:
        sys.stdout = old_stdout


def _load_all_presets(presets_files):
    preset_names = get_all_preset_names(presets_files)

    # Hack to filter out mixins which are not expected to be valid presets
    preset_names = [n for n in preset_names if not n.startswith('mixin')]

    substitutions = {
        'install_destdir': '/tmp/install',
        'install_symroot': '/tmp/symroot',
        'installable_package': '/tmp/xcode-xyz-root.tar.gz',
    }

    presets = dict()
    for name in preset_names:
        try:
            # Attempt to parse preset
            presets[name] = get_preset_options(substitutions,
                                               presets_files, name)
        except SystemExit:
            continue

    return presets


class TestDriverArgumentParserMeta(type):
    """Metaclass used to dynamically generate test methods for each of the
    individual options accepted by the parser and methods to validate all of
    the presets.
    """

    def __new__(cls, name, bases, attrs):
        # Generate tests for each default value
        for dest, value in eo.EXPECTED_DEFAULTS.items():
            test_name = 'test_default_value_' + dest
            attrs[test_name] = cls.generate_default_value_test(dest, value)

        # Generate tests for each expected option
        for option in eo.EXPECTED_OPTIONS:
            test_name = 'test_option_' + option.sanitized_string()
            attrs[test_name] = cls.generate_option_test(option)

        # Generate tests for each preset
        presets = _load_all_presets(PRESETS_FILES)

        for name, args in presets.items():
            test_name = 'test_preset_' + name
            attrs[test_name] = cls.generate_preset_test(name, args)

        return super(TestDriverArgumentParserMeta, cls).__new__(
            cls, name, bases, attrs)

    @classmethod
    def generate_default_value_test(cls, dest, default_value):
        def test(self):
            with self.assertNotRaises(ParserError):
                parsed_values = self.parse_default_args([])

            parsed_value = getattr(parsed_values, dest)
            if default_value.__class__ is str:
                parsed_value = str(parsed_value)

            self.assertEqual(default_value, parsed_value,
                             'Invalid default value for "{}": {} != {}'
                             .format(dest, default_value, parsed_value))

        return test

    @classmethod
    def _generate_help_option_test(cls, option):
        def test(self):
            with redirect_stdout() as output, self.assertRaises(ParserError):
                self.parse_args([option.option_string])
                self.assertNotEmpty(output)

        return test

    @classmethod
    def _generate_set_option_test(cls, option):
        def test(self):
            with self.assertNotRaises(ParserError):
                namespace = self.parse_args([option.option_string])
                self.assertEqual(getattr(namespace, option.dest), option.value)

            with self.assertRaises(ParserError):
                self.parse_args([option.option_string, 'foo'])

        return test

    @classmethod
    def _generate_set_true_option_test(cls, option):
        def test(self):
            with self.assertNotRaises(ParserError):
                # TODO: Move to unit-tests for the action class
                namespace = self.parse_args([])
                self.assertFalse(getattr(namespace, option.dest))

                namespace = self.parse_args([option.option_string])
                self.assertTrue(getattr(namespace, option.dest))

        return test

    @classmethod
    def _generate_set_false_option_test(cls, option):
        def test(self):
            with self.assertNotRaises(ParserError):
                # TODO: Move to unit-tests for the action class
                namespace = self.parse_args([])
                self.assertTrue(getattr(namespace, option.dest))

                namespace = self.parse_args([option.option_string])
                self.assertFalse(getattr(namespace, option.dest))

        return test

    @classmethod
    def _generate_enable_option_test(cls, option):
        def test(self):
            with self.assertNotRaises(ParserError):
                # TODO: Move to unit-tests for the action class
                # Test parsing True values
                self.parse_args([option.option_string, '1'])
                self.parse_args([option.option_string, 'true'])
                self.parse_args([option.option_string, 'True'])
                self.parse_args([option.option_string, 'TRUE'])

                # TODO: Move to unit-tests for the action class
                # Test parsing False values
                self.parse_args([option.option_string, '0'])
                self.parse_args([option.option_string, 'false'])
                self.parse_args([option.option_string, 'False'])
                self.parse_args([option.option_string, 'FALSE'])

                # TODO: Move to unit-tests for the action class
                # Test default value
                namespace = self.parse_args([option.option_string])
                self.assertTrue(getattr(namespace, option.dest))

                # Test setting value to True
                namespace = self.parse_args([option.option_string, 'True'])
                self.assertTrue(getattr(namespace, option.dest))

                # Test setting value to False
                namespace = self.parse_args([option.option_string, 'False'])
                self.assertFalse(getattr(namespace, option.dest))

        return test

    @classmethod
    def _generate_disable_option_test(cls, option):
        def test(self):
            with self.assertNotRaises(ParserError):
                # TODO: Move to unit-tests for the action class
                # Test parsing True values
                self.parse_args([option.option_string, '1'])
                self.parse_args([option.option_string, 'true'])
                self.parse_args([option.option_string, 'True'])
                self.parse_args([option.option_string, 'TRUE'])

                # TODO: Move to unit-tests for the action class
                # Test parsing False values
                self.parse_args([option.option_string, '0'])
                self.parse_args([option.option_string, 'false'])
                self.parse_args([option.option_string, 'False'])
                self.parse_args([option.option_string, 'FALSE'])

                # TODO: Move to unit-tests for the action class
                # Test default value
                namespace = self.parse_args([option.option_string])
                self.assertFalse(getattr(namespace, option.dest))

                # Test setting value to True resulting in False
                namespace = self.parse_args([option.option_string, 'True'])
                self.assertFalse(getattr(namespace, option.dest))

                # Test setting value to False resulting in True
                namespace = self.parse_args([option.option_string, 'False'])
                self.assertTrue(getattr(namespace, option.dest))

        return test

    @classmethod
    def _generate_choices_option_test(cls, option):
        def test(self):
            with self.assertNotRaises(ParserError):
                for choice in option.choices:
                    namespace = self.parse_args(
                        [option.option_string, str(choice)])
                    self.assertEqual(getattr(namespace, option.dest), choice)

            with self.assertRaises(ParserError):
                self.parse_args([option.option_string, 'INVALID'])

        return test

    @classmethod
    def _generate_int_option_test(cls, option):
        def test(self):
            with self.assertNotRaises(ParserError):
                for i in [0, 1, 42]:
                    namespace = self.parse_args([option.option_string, str(i)])
                    self.assertEqual(int(getattr(namespace, option.dest)), i)

            # FIXME: int-type options should not accept non-int strings
            # with self.assertRaises(ParserError):
            #     self.parse_args([option.option_string, str(0.0)])
            #     self.parse_args([option.option_string, str(1.0)])
            #     self.parse_args([option.option_string, str(3.14)])
            #     self.parse_args([option.option_string, 'NaN'])

        return test

    @classmethod
    def _generate_str_option_test(cls, option):
        def test(self):
            with self.assertNotRaises(ParserError):
                self.parse_args([option.option_string, 'foo'])

        return test

    @classmethod
    def _generate_path_option_test(cls, option):
        def test(self):
            with self.assertNotRaises(ParserError):
                self.parse_args([option.option_string, sys.executable])

            # FIXME: path-type options should not accept non-path inputs
            # with self.assertRaises(ParserError):
            #     self.parse_args([option.option_string, 'foo'])

        return test

    @classmethod
    def _generate_append_option_test(cls, option):
        def test(self):
            with self.assertNotRaises(ParserError):
                # Range size is arbitrary, just needs to be more than once
                for i in range(1, 4):
                    namespace = self.parse_args(
                        [option.option_string, 'ARG'] * i)
                    self.assertEqual(getattr(namespace, option.dest),
                                     ['ARG'] * i)

        return test

    @classmethod
    def _generate_unsupported_option_test(cls, option):
        def test(self):
            with self.assertRaises(ParserError):
                self.parse_args([option.option_string])

        return test

    @classmethod
    def generate_option_test(cls, option):
        generate_test_funcs = {
            eo.HelpOption: cls._generate_help_option_test,
            eo.SetOption: cls._generate_set_option_test,
            eo.SetTrueOption: cls._generate_set_true_option_test,
            eo.SetFalseOption: cls._generate_set_false_option_test,
            eo.EnableOption: cls._generate_enable_option_test,
            eo.DisableOption: cls._generate_disable_option_test,
            eo.ChoicesOption: cls._generate_choices_option_test,
            eo.IntOption: cls._generate_int_option_test,
            eo.StrOption: cls._generate_str_option_test,
            eo.PathOption: cls._generate_path_option_test,
            eo.AppendOption: cls._generate_append_option_test,
            eo.UnsupportedOption: cls._generate_unsupported_option_test,

            # IgnoreOptions should be manually tested
            eo.IgnoreOption: lambda self: None,
        }

        test_func = generate_test_funcs.get(option.__class__, None)
        if test_func is not None:
            return test_func(option)

        # Catch-all meaningless test
        return lambda self: \
            self.fail('unexpected option "{}"'.format(option.option_string))

    @classmethod
    def generate_preset_test(cls, preset_name, preset_args):
        def test(self):
            try:
                self.parse_default_args(preset_args, check_impl_args=True)
            except ParserError as e:
                self.fail('failed to parse preset "{}": {}'.format(
                    preset_name, e))

        return test


class TestDriverArgumentParser(unittest.TestCase):

    __metaclass__ = TestDriverArgumentParserMeta

    @contextmanager
    def _quiet_output(self):
        with open(os.devnull, 'w') as devnull:
            with redirect_stderr(devnull), redirect_stdout(devnull):
                yield

    def _parse_args(self, args):
        try:
            return migration.parse_args(self.parser, args)
        except (SystemExit, ValueError) as e:
            raise ParserError('failed to parse arguments: ' +
                              str(args), e)

    def _check_impl_args(self, namespace):
        assert hasattr(namespace, 'build_script_impl_args')

        try:
            migration.check_impl_args(BUILD_SCRIPT_IMPL,
                                      namespace.build_script_impl_args)
        except (SystemExit, ValueError) as e:
            raise ParserError('failed to parse impl arguments: ' +
                              str(namespace.build_script_impl_args), e)

    def parse_args(self, args, namespace=None):
        if namespace is None:
            namespace = argparse.Namespace()

        with self._quiet_output():
            try:
                namespace, unknown_args =\
                    super(self.parser.__class__, self.parser)\
                    .parse_known_args(args, namespace)
            except (SystemExit, argparse.ArgumentError) as e:
                raise ParserError('failed to parse arguments: ' + str(args), e)

        if unknown_args:
            raise ParserError('unknown arguments: ' + str(unknown_args))

        return namespace

    def parse_default_args(self, args, check_impl_args=False):
        with self._quiet_output():
            namespace = self._parse_args(args)

            if check_impl_args:
                self._check_impl_args(namespace)

            return namespace

    @contextmanager
    def assertNotRaises(self, exception):
        assert issubclass(exception, BaseException)

        try:
            yield
        except exception as e:
            self.fail(str(e))

    def setUp(self):
        self.parser = driver_arguments.create_argument_parser()

    # -------------------------------------------------------------------------

    def test_expected_options_exhaustive(self):
        """Test that we are exhaustively testing all options accepted by the
        parser. If this test if failing then the parser accepts more options
        than currently being tested, meaning the EXPECTED_OPTIONS list in
        build_swift/tests/expected_options.py should be updated to include
        the missing options.
        """

        expected_options = {o.option_string for o in eo.EXPECTED_OPTIONS}

        # aggregate and flatten the options_strings accepted by the parser
        actual_options = [a.option_strings for a in self.parser._actions]
        actual_options = set(sum(actual_options, []))

        diff = actual_options - expected_options

        if len(diff) > 0:
            self.fail('non-exhaustive expected options, missing: {}'
                      .format(diff))

    def test_expected_options_have_default_values(self):
        """Test that all the options in EXPECTED_OPTIONS have an associated
        default value.
        """

        skip_option_classes = [
            eo.HelpOption,
            eo.IgnoreOption,
            eo.UnsupportedOption,
        ]

        missing_defaults = set()
        for option in eo.EXPECTED_OPTIONS:
            if option.__class__ in skip_option_classes:
                continue

            if option.dest not in eo.EXPECTED_DEFAULTS:
                missing_defaults.add(option.dest)

        if len(missing_defaults) > 0:
            self.fail('non-exhaustive default values for options, missing: {}'
                      .format(missing_defaults))

    # -------------------------------------------------------------------------
    # Manual option tests

    def test_option_clang_compiler_version(self):
        option_string = '--clang-compiler-version'

        with self.assertNotRaises(ParserError):
            self.parse_default_args([option_string, '5.0.0'])
            self.parse_default_args([option_string, '5.0.1'])
            self.parse_default_args([option_string, '5.0.0.1'])

        with self.assertRaises(ParserError):
            self.parse_default_args([option_string, '1'])
            self.parse_default_args([option_string, '1.2'])
            self.parse_default_args([option_string, '0.0.0.0.1'])

    def test_option_clang_user_visible_version(self):
        option_string = '--clang-user-visible-version'

        with self.assertNotRaises(ParserError):
            self.parse_default_args([option_string, '5.0.0'])
            self.parse_default_args([option_string, '5.0.1'])
            self.parse_default_args([option_string, '5.0.0.1'])

        with self.assertRaises(ParserError):
            self.parse_default_args([option_string, '1'])
            self.parse_default_args([option_string, '1.2'])
            self.parse_default_args([option_string, '0.0.0.0.1'])

    def test_option_swift_compiler_version(self):
        option_string = '--swift-compiler-version'

        with self.assertNotRaises(ParserError):
            self.parse_default_args([option_string, '4.1'])
            self.parse_default_args([option_string, '4.0.1'])
            self.parse_default_args([option_string, '200.99.1'])

        with self.assertRaises(ParserError):
            self.parse_default_args([option_string, '1'])
            self.parse_default_args([option_string, '0.0.0.1'])

    def test_option_swift_user_visible_version(self):
        option_string = '--swift-user-visible-version'

        with self.assertNotRaises(ParserError):
            self.parse_default_args([option_string, '4.1'])
            self.parse_default_args([option_string, '4.0.1'])
            self.parse_default_args([option_string, '200.99.1'])

        with self.assertRaises(ParserError):
            self.parse_default_args([option_string, '1'])
            self.parse_default_args([option_string, '0.0.0.1'])

    def test_option_I(self):
        with self.assertRaises(ValueError):
            self.parse_default_args(['-I'])

    def test_option_ios_all(self):
        with self.assertRaises(ValueError):
            self.parse_default_args(['--ios-all'])

    def test_option_tvos_all(self):
        with self.assertRaises(ValueError):
            self.parse_default_args(['--tvos-all'])

    def test_option_watchos_all(self):
        with self.assertRaises(ValueError):
            self.parse_default_args(['--watchos-all'])

    # -------------------------------------------------------------------------
    # Implied defaults tests

    def test_implied_defaults_assertions(self):
        with self.assertNotRaises(ParserError):
            namespace = self.parse_default_args(['--assertions'])

            self.assertTrue(namespace.cmark_assertions)
            self.assertTrue(namespace.llvm_assertions)
            self.assertTrue(namespace.swift_assertions)
            self.assertTrue(namespace.swift_stdlib_assertions)

    def test_implied_defaults_cmark_build_variant(self):
        with self.assertNotRaises(ParserError):
            namespace = self.parse_default_args(['--debug-cmark'])
            self.assertTrue(namespace.build_cmark)

    def test_implied_defaults_lldb_build_variant(self):
        with self.assertNotRaises(ParserError):
            namespace = self.parse_default_args(['--debug-lldb'])
            self.assertTrue(namespace.build_lldb)

        with self.assertNotRaises(ParserError):
            namespace = self.parse_default_args(['--lldb-assertions'])
            self.assertTrue(namespace.build_lldb)

    def test_implied_defaults_build_variant(self):
        with self.assertNotRaises(ParserError):
            namespace = self.parse_default_args(['--debug'])

            self.assertEquals(namespace.cmark_build_variant, 'Debug')
            self.assertEquals(namespace.foundation_build_variant, 'Debug')
            self.assertEquals(namespace.libdispatch_build_variant, 'Debug')
            self.assertEquals(namespace.libicu_build_variant, 'Debug')
            self.assertEquals(namespace.lldb_build_variant, 'Debug')
            self.assertEquals(namespace.llvm_build_variant, 'Debug')
            self.assertEquals(namespace.swift_build_variant, 'Debug')
            self.assertEquals(namespace.swift_stdlib_build_variant, 'Debug')

    def test_implied_defaults_skip_build(self):
        with self.assertNotRaises(ParserError):
            namespace = self.parse_default_args(['--skip-build'])

            self.assertFalse(namespace.build_benchmarks)

            self.assertFalse(namespace.build_linux)
            self.assertFalse(namespace.build_android)
            self.assertFalse(namespace.build_freebsd)
            self.assertFalse(namespace.build_cygwin)
            self.assertFalse(namespace.build_osx)
            self.assertFalse(namespace.build_ios)
            self.assertFalse(namespace.build_tvos)
            self.assertFalse(namespace.build_watchos)

            self.assertFalse(namespace.build_foundation)
            self.assertFalse(namespace.build_libdispatch)
            self.assertFalse(namespace.build_libicu)
            self.assertFalse(namespace.build_lldb)
            self.assertFalse(namespace.build_llbuild)
            self.assertFalse(namespace.build_playgroundlogger)
            self.assertFalse(namespace.build_playgroundsupport)
            self.assertFalse(namespace.build_swiftpm)
            self.assertFalse(namespace.build_xctest)

    def test_implied_defaults_skip_build_ios(self):
        with self.assertNotRaises(ParserError):
            namespace = self.parse_default_args(['--skip-build-ios'])
            self.assertFalse(namespace.build_ios_device)
            self.assertFalse(namespace.build_ios_simulator)

            # Also implies that the tests should be skipped
            self.assertFalse(namespace.test_ios_host)
            self.assertFalse(namespace.test_ios_simulator)

    def test_implied_defaults_skip_build_tvos(self):
        with self.assertNotRaises(ParserError):
            namespace = self.parse_default_args(['--skip-build-tvos'])
            self.assertFalse(namespace.build_tvos_device)
            self.assertFalse(namespace.build_tvos_simulator)

            # Also implies that the tests should be skipped
            self.assertFalse(namespace.test_tvos_host)
            self.assertFalse(namespace.test_tvos_simulator)

    def test_implied_defaults_skip_build_watchos(self):
        with self.assertNotRaises(ParserError):
            namespace = self.parse_default_args(['--skip-build-watchos'])
            self.assertFalse(namespace.build_watchos_device)
            self.assertFalse(namespace.build_watchos_simulator)

            # Also implies that the tests should be skipped
            self.assertFalse(namespace.test_watchos_host)
            self.assertFalse(namespace.test_watchos_simulator)

    def test_implied_defaults_validation_test(self):
        with self.assertNotRaises(ParserError):
            namespace = self.parse_default_args(['--validation-test'])
            self.assertTrue(namespace.test)

    def test_implied_defaults_test_optimized(self):
        with self.assertNotRaises(ParserError):
            namespace = self.parse_default_args(['--test-optimized'])
            self.assertTrue(namespace.test)

    def test_implied_defaults_test_optimize_for_size(self):
        with self.assertNotRaises(ParserError):
            namespace = self.parse_default_args(['--test-optimize-for-size'])
            self.assertTrue(namespace.test)

    def test_implied_defaults_skip_all_tests(self):
        with self.assertNotRaises(ParserError):
            namespace = self.parse_default_args([
                '--test', '0',
                '--validation-test', '0',
                '--long-test', '0',
            ])

            self.assertFalse(namespace.test_linux)
            self.assertFalse(namespace.test_freebsd)
            self.assertFalse(namespace.test_cygwin)
            self.assertFalse(namespace.test_osx)
            self.assertFalse(namespace.test_ios)
            self.assertFalse(namespace.test_tvos)
            self.assertFalse(namespace.test_watchos)

    def test_implied_defaults_skip_test_ios(self):
        with self.assertNotRaises(ParserError):
            namespace = self.parse_default_args(['--skip-test-ios'])
            self.assertFalse(namespace.test_ios_host)
            self.assertFalse(namespace.test_ios_simulator)

    def test_implied_defaults_skip_test_tvos(self):
        with self.assertNotRaises(ParserError):
            namespace = self.parse_default_args(['--skip-test-tvos'])
            self.assertFalse(namespace.test_tvos_host)
            self.assertFalse(namespace.test_tvos_simulator)

    def test_implied_defaults_skip_test_watchos(self):
        with self.assertNotRaises(ParserError):
            namespace = self.parse_default_args(['--skip-test-watchos'])
            self.assertFalse(namespace.test_watchos_host)
            self.assertFalse(namespace.test_watchos_simulator)

    def test_implied_defaults_skip_build_android(self):
        with self.assertNotRaises(ParserError):
            namespace = self.parse_default_args(['--android', '0'])
            self.assertFalse(namespace.test_android_host)

        with self.assertNotRaises(ParserError):
            namespace = self.parse_default_args(['--skip-build-android'])
            self.assertFalse(namespace.test_android_host)

    def test_implied_defaults_host_test(self):
        with self.assertNotRaises(ParserError):
            namespace = self.parse_default_args(['--host-test', '0'])
            self.assertFalse(namespace.test_ios_host)
            self.assertFalse(namespace.test_tvos_host)
            self.assertFalse(namespace.test_watchos_host)
            self.assertFalse(namespace.test_android_host)


if __name__ == '__main__':
    unittest.main()