# Copyright (C) 2011 Google 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:
#
#     * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
#     * 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.
#     * Neither the name of Google Inc. nor the names of its
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 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 THE COPYRIGHT
# OWNER OR 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.
"""Represents a set of builder bots running web tests.

This class is used to hold a list of builder bots running web tests and their
corresponding port names and TestExpectations specifiers.
"""

import json

from blinkpy.common.path_finder import PathFinder

class BuilderList(object):
    def __init__(self, builders_dict):
        """Creates and validates a builders list.

        The given dictionary maps builder names to dicts with the keys:
            "port_name": A fully qualified port name.
            "specifiers": A list of specifiers used to describe a builder.
                The specifiers list will at the very least have a valid
                port version specifier like "Mac10.15" and and a valid build
                type specifier like "Release".
            "is_try_builder": Whether the builder is a trybot.
            "master": The master name of the builder. It is deprecated, but still required
                by test-results.appspot.com API."
            "has_webdriver_tests": Whether webdriver_tests_suite runs on this builder.

        Possible refactoring note: Potentially, it might make sense to use
        blinkpy.common.net.results_fetcher.Builder and add port_name and
        specifiers properties to that class.
        """
        self._builders = builders_dict
        for builder in builders_dict:
            specifiers = {
                s.lower() for s in builders_dict[builder].get('specifiers', {})}
            assert 'port_name' in builders_dict[builder]
            assert ('android' in specifiers or
                    len(builders_dict[builder]['specifiers']) == 2)

    @staticmethod
    def load_default_builder_list(filesystem):
        """Loads the set of builders from a JSON file and returns the BuilderList."""
        path = PathFinder(filesystem).path_from_blink_tools(
            'blinkpy', 'common', 'config', 'builders.json')
        contents = filesystem.read_text_file(path)
        return BuilderList(json.loads(contents))

    def all_builder_names(self):
        return sorted(self._builders)

    def all_try_builder_names(self):
        return self.filter_builders(is_try=True)

    def all_cq_try_builder_names(self):
        return self.filter_builders(is_cq=True)

    def all_continuous_builder_names(self):
        return self.filter_builders(is_try=False)

    def filter_builders(self, exclude_specifiers=None, include_specifiers=None,
                        is_try=False, is_cq=False):
        _lower_specifiers = lambda specifiers: {s.lower() for s in specifiers}
        exclude_specifiers = _lower_specifiers(exclude_specifiers or {})
        include_specifiers = _lower_specifiers(include_specifiers or {})
        builders = []
        for b in self._builders:
            builder_specifiers = _lower_specifiers(
                self._builders[b].get('specifiers', {}))
            if is_try and self._builders[b].get('is_try_builder', False) != is_try:
                continue
            if is_cq and self._builders[b].get('is_cq_builder', False) != is_cq:
                continue
            if ((not is_cq and not is_try) and self._builders[b].get('is_try_builder', False)):
                continue
            if builder_specifiers & exclude_specifiers:
                continue
            if  (include_specifiers and
                     not include_specifiers & builder_specifiers):
                continue
            builders.append(b)
        return sorted(builders)

    def all_port_names(self):
        return sorted({b['port_name'] for b in self._builders.values()})

    def bucket_for_builder(self, builder_name):
        return self._builders[builder_name].get('bucket', '')

    def master_for_builder(self, builder_name):
        return self._builders[builder_name].get('master', '')

    def has_webdriver_tests_for_builder(self, builder_name):
        return self._builders[builder_name].get('has_webdriver_tests')

    def port_name_for_builder_name(self, builder_name):
        return self._builders[builder_name]['port_name']

    def specifiers_for_builder(self, builder_name):
        return self._builders[builder_name]['specifiers']

    def is_try_server_builder(self, builder_name):
        return self._builders[builder_name].get('is_try_builder', False)

    def is_wpt_builder(self, builder_name):
        return 'wpt' in builder_name

    def platform_specifier_for_builder(self, builder_name):
        return self.specifiers_for_builder(builder_name)[0]

    def builder_name_for_port_name(self, target_port_name):
        """Returns a builder name for the given port name.

        Multiple builders can have the same port name; this function only
        returns builder names for non-try-bot builders, and it gives preference
        to non-debug builders. If no builder is found, None is returned.
        """
        debug_builder_name = None
        for builder_name, builder_info in self._builders.iteritems():
            if builder_info.get('is_try_builder'):
                continue
            if builder_info['port_name'] == target_port_name:
                if 'dbg' in builder_name:
                    debug_builder_name = builder_name
                else:
                    return builder_name
        return debug_builder_name

    def version_specifier_for_port_name(self, target_port_name):
        """Returns the OS version specifier for a given port name.

        This just uses information in the builder list, and it returns
        the version specifier for the first builder that matches, even
        if it's a try bot builder.
        """
        for _, builder_info in sorted(self._builders.iteritems()):
            if builder_info['port_name'] == target_port_name:
                return builder_info['specifiers'][0]
        return None

    def builder_name_for_specifiers(self, version, build_type, is_try_builder):
        """Returns the builder name for a give version and build type.

        Args:
            version: A string with the OS version specifier. e.g. "Trusty", "Win10".
            build_type: A string with the build type. e.g. "Debug" or "Release".

        Returns:
            The builder name if found, or an empty string if no match was found.
        """
        for builder_name, info in sorted(self._builders.items()):
            specifiers = set(spec.lower() for spec in info['specifiers'])
            is_try_builder_info = info.get('is_try_builder', False)
            if (version.lower() in specifiers
                    and build_type.lower() in specifiers
                    and is_try_builder_info == is_try_builder):
                return builder_name
        return ''