# Copyright (C) 2018-2019 Apple Inc. All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
# 1.  Redistributions of source code must retain the above copyright
#     notice, this list of conditions and the following disclaimer.
# 2.  Redistributions in binary form must reproduce the above copyright
#     notice, this list of conditions and the following disclaimer in the
#     documentation and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR
# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

import logging
import traceback

from webkitpy.common.version_name_map import VersionNameMap, PUBLIC_TABLE, INTERNAL_TABLE
from webkitpy.layout_tests.models.test_configuration import TestConfiguration
from webkitpy.port.darwin import DarwinPort
from webkitpy.port.simulator_process import SimulatorProcess
from webkitpy.results.upload import Upload
from webkitpy.xcode.device_type import DeviceType
from webkitpy.xcode.simulated_device import DeviceRequest, SimulatedDeviceManager


_log = logging.getLogger(__name__)


class DevicePort(DarwinPort):

    DEVICE_MANAGER = None
    NO_DEVICE_MANAGER = 'No device manager found for port'

    def __init__(self, *args, **kwargs):
        super(DevicePort, self).__init__(*args, **kwargs)
        self._test_runner_process_constructor = SimulatorProcess
        self._printing_cmd_line = False

    def driver_cmd_line_for_logging(self):
        # Avoid creating/connecting to devices just for command line logging.
        self._printing_cmd_line = True
        result = super(DevicePort, self).driver_cmd_line_for_logging()
        self._printing_cmd_line = False
        return result

    def _generate_all_test_configurations(self):
        configurations = []
        for build_type in self.ALL_BUILD_TYPES:
            for architecture in self.ARCHITECTURES:
                configurations.append(TestConfiguration(version=self.version_name(), architecture=architecture, build_type=build_type))
        return configurations

    def child_processes(self):
        return int(self.get_option('child_processes'))

    def driver_name(self):
        if self.get_option('driver_name'):
            return self.get_option('driver_name')
        if self.get_option('webkit_test_runner'):
            return 'WebKitTestRunnerApp.app'
        return 'DumpRenderTree.app'

    # A device is the target host for a specific worker number.
    def target_host(self, worker_number=None):
        if self._printing_cmd_line or worker_number is None:
            return self.host
        if self.DEVICE_MANAGER is None:
            raise RuntimeError('No device manager for specified port')
        if self.DEVICE_MANAGER.INITIALIZED_DEVICES is None:
            raise RuntimeError('No initialized devices for testing')
        return self.DEVICE_MANAGER.INITIALIZED_DEVICES[worker_number]

    def devices(self):
        if self.DEVICE_MANAGER is None:
            return []
        if self.DEVICE_MANAGER.INITIALIZED_DEVICES is None:
            return []
        return self.DEVICE_MANAGER.INITIALIZED_DEVICES

    # Despite their names, these flags do not actually get passed all the way down to webkit-build.
    def _build_driver_flags(self):
        return ['--sdk', self.SDK] + (['ARCHS=%s' % self.architecture()] if self.architecture() else [])

    def _install(self):
        if not self.get_option('install'):
            _log.debug('Skipping installation')
            return

        for i in xrange(self.child_processes()):
            device = self.target_host(i)
            _log.debug(u'Installing to {}'.format(device))
            # Without passing DYLD_LIBRARY_PATH, libWebCoreTestSupport cannot be loaded and DRT/WKTR will crash pre-launch,
            # leaving a crash log which will be picked up in results. DYLD_FRAMEWORK_PATH is needed to prevent an early crash.
            if not device.install_app(self._path_to_driver(), {'DYLD_LIBRARY_PATH': self._build_path(), 'DYLD_FRAMEWORK_PATH': self._build_path()}):
                raise RuntimeError('Failed to install app {} on device {}'.format(self._path_to_driver(), device.udid))
            if not device.install_dylibs(self._build_path()):
                raise RuntimeError('Failed to install dylibs at {} on device {}'.format(self._build_path(), device.udid))

    def _device_type_with_version(self, device_type=None):
        device_type = device_type if device_type else self.DEVICE_TYPE
        return DeviceType(
            hardware_family=device_type.hardware_family,
            hardware_type=device_type.hardware_type,
            software_version=self.device_version(),
            software_variant=device_type.software_variant,
        )

    def default_child_processes(self, device_type=None):
        if not self.DEVICE_MANAGER:
            raise RuntimeError(self.NO_DEVICE_MANAGER)

        device_type = self._device_type_with_version(device_type)
        if device_type not in self.DEVICE_TYPE:
            return 0

        if self.get_option('force'):
            device_type.hardware_family = None
            device_type.hardware_type = None

        return self.DEVICE_MANAGER.device_count_for_type(
            self._device_type_with_version(device_type),
            host=self.host,
            use_booted_simulator=not self.get_option('dedicated_simulators', False),
        )

    def max_child_processes(self, device_type=None):
        result = self.default_child_processes(device_type=device_type)
        if result and self.DEVICE_MANAGER == SimulatedDeviceManager:
            return super(DevicePort, self).max_child_processes(device_type=None)
        return result

    def supported_device_types(self):
        types = set()
        for device in self.DEVICE_MANAGER.available_devices(host=self.host):
            if self.DEVICE_MANAGER == SimulatedDeviceManager and not device.platform_device.is_booted_or_booting():
                continue
            if device.device_type in self.DEVICE_TYPE:
                types.add(device.device_type)
        if types and not self.get_option('dedicated_simulators', False):

            def sorted_by_default_device_type(type):
                try:
                    return self.DEFAULT_DEVICE_TYPES.index(type)
                except ValueError:
                    return len(self.DEFAULT_DEVICE_TYPES)

            return sorted(types, key=sorted_by_default_device_type)

        return self.DEFAULT_DEVICE_TYPES or [self.DEVICE_TYPE]

    def setup_test_run(self, device_type=None):
        if not self.DEVICE_MANAGER:
            raise RuntimeError(self.NO_DEVICE_MANAGER)

        device_type = self._device_type_with_version(device_type)
        _log.debug(u'\nCreating devices for {}'.format(device_type))

        request = DeviceRequest(
            device_type,
            use_booted_simulator=not self.get_option('dedicated_simulators', False),
            use_existing_simulator=False,
            allow_incomplete_match=self.get_option('force'),
        )
        self.DEVICE_MANAGER.initialize_devices(
            [request] * self.child_processes(),
            self.host,
            layout_test_dir=self.layout_tests_dir(),
            pin=self.get_option('pin', None),
            use_nfs=self.get_option('use_nfs', True),
            reboot=self.get_option('reboot', False),
        )

        if not self.devices():
            raise RuntimeError('No devices are available for testing')
        if len(self.DEVICE_MANAGER.INITIALIZED_DEVICES) < self.child_processes():
            raise RuntimeError('To few connected devices for {} processes'.format(self.child_processes()))

        self._install()

        for i in xrange(self.child_processes()):
            host = self.target_host(i)
            host.prepare_for_testing(
                self.ports_to_forward(),
                self.app_identifier_from_bundle(self._path_to_driver()),
                self.layout_tests_dir(),
            )
            self._crash_logs_to_skip_for_host[host] = host.filesystem.files_under(self.path_to_crash_logs())

    def clean_up_test_run(self):
        super(DevicePort, self).clean_up_test_run()

        # Best effort to let every device teardown before throwing any exceptions here.
        # Failure to teardown devices can leave things in a bad state.
        exception_list = []
        for i in xrange(self.child_processes()):
            device = self.target_host(i)
            if not device:
                continue
            try:
                device.finished_testing()
            except BaseException as e:
                trace = traceback.format_exc()
                if isinstance(e, Exception):
                    exception_list.append([e, trace])
                else:
                    exception_list.append([Exception(u'Exception while tearing down {}'.format(device)), trace])

        if len(exception_list) == 1:
            raise
        if len(exception_list) > 1:
            print('\n')
            for exception in exception_list:
                _log.error('{} raised: {}'.format(exception[0].__class__.__name__, exception[0]))
                _log.error(exception[1])
                _log.error('--------------------------------------------------')

            raise RuntimeError('Multiple failures when teardown devices')

    def did_spawn_worker(self, worker_number):
        super(DevicePort, self).did_spawn_worker(worker_number)

        self.target_host(worker_number).release_worker_resources()

    def setup_environ_for_server(self, server_name=None):
        env = super(DevicePort, self).setup_environ_for_server(server_name)
        if server_name == self.driver_name() and self.get_option('guard_malloc'):
            self._append_value_colon_separated(env, 'DYLD_INSERT_LIBRARIES', '/usr/lib/libgmalloc.dylib')
            self._append_value_colon_separated(env, '__XPC_DYLD_INSERT_LIBRARIES', '/usr/lib/libgmalloc.dylib')
        env['XML_CATALOG_FILES'] = ''  # work around missing /etc/catalog <rdar://problem/4292995>
        return env

    def device_version(self):
        raise NotImplementedError

    def configuration_for_upload(self, host=None):
        configuration = self.test_configuration()

        device_type = host.device_type if host else self.DEVICE_TYPE
        model = device_type.hardware_family
        if model and device_type.hardware_type:
            model += u' {}'.format(device_type.hardware_type)

        version = self.device_version()
        version_name = None
        for table in [INTERNAL_TABLE, PUBLIC_TABLE]:
            version_name = VersionNameMap.map(self.host.platform).to_name(version, platform=device_type.software_variant.lower(), table=table)
            if version_name:
                break

        if self.get_option('guard_malloc'):
            style = 'guard-malloc'
        elif self._config.asan:
            style = 'asan'
        else:
            style = configuration.build_type

        return Upload.create_configuration(
            platform=device_type.software_variant.lower(),
            is_simulator=self.DEVICE_MANAGER == SimulatedDeviceManager,
            version=str(version),
            version_name=version_name,
            architecture=configuration.architecture,
            style=style,
            model=model,
            sdk=host.build_version if host else None,
        )