# Copyright 2019 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

from .argument import Argument
from .composition_parts import WithIdentifier
from .idl_type import IdlType


class FunctionLike(WithIdentifier):
    class IR(WithIdentifier):
        def __init__(self, identifier, arguments, return_type,
                     is_static=False):
            assert isinstance(arguments, (list, tuple)) and all(
                isinstance(arg, Argument.IR) for arg in arguments)
            assert isinstance(return_type, IdlType)
            assert isinstance(is_static, bool)

            WithIdentifier.__init__(self, identifier)
            self.arguments = list(arguments)
            self.return_type = return_type
            self.is_static = is_static

    def __init__(self, ir):
        assert isinstance(ir, FunctionLike.IR)

        WithIdentifier.__init__(self, ir.identifier)
        self._overload_group = None
        self._arguments = tuple(
            [Argument(arg_ir, self) for arg_ir in ir.arguments])
        self._return_type = ir.return_type
        self._is_static = ir.is_static

    @property
    def overload_group(self):
        """Returns the OverloadGroup that this function belongs to."""
        return self._overload_group

    def set_overload_group(self, overload_group):
        assert isinstance(overload_group, OverloadGroup)
        assert self._overload_group is None
        assert self in overload_group
        self._overload_group = overload_group

    @property
    def overload_index(self):
        """Returns the index in the OverloadGroup."""
        return self.overload_group.index(self)

    @property
    def arguments(self):
        """Returns a list of arguments."""
        return self._arguments

    @property
    def return_type(self):
        """Returns the return type."""
        return self._return_type

    @property
    def is_static(self):
        """Returns True if this is a static function."""
        return self._is_static

    @property
    def is_variadic(self):
        """Returns True if this function takes variadic arguments."""
        return bool(self.arguments and self.arguments[-1].is_variadic)

    @property
    def num_of_required_arguments(self):
        """Returns the number of required arguments."""
        return len(
            list(
                filter(lambda arg: not (arg.is_optional or arg.is_variadic),
                       self.arguments)))


class OverloadGroup(WithIdentifier):
    class IR(WithIdentifier):
        def __init__(self, functions):
            assert isinstance(functions, (list, tuple))
            assert all(
                isinstance(function, FunctionLike.IR)
                for function in functions)
            assert len(set(
                [function.identifier for function in functions])) == 1
            assert len(set(
                [function.is_static for function in functions])) == 1

            WithIdentifier.__init__(self, functions[0].identifier)
            self.functions = list(functions)
            self.is_static = functions[0].is_static

        def __iter__(self):
            return iter(self.functions)

        def __len__(self):
            return len(self.functions)

    class EffectiveOverloadItem(object):
        """
        Represents an item in an effective overload set.
        https://webidl.spec.whatwg.org/#dfn-effective-overload-set
        """

        def __init__(self, function_like, type_list, opt_list):
            assert len(type_list) == len(opt_list)
            assert isinstance(function_like, FunctionLike)
            assert isinstance(type_list, (list, tuple))
            assert all(isinstance(idl_type, IdlType) for idl_type in type_list)
            assert isinstance(opt_list, (list, tuple))
            assert all(
                isinstance(optionality, IdlType.Optionality.Type)
                for optionality in opt_list)

            self._function_like = function_like
            self._type_list = tuple(type_list)
            self._opt_list = tuple(opt_list)

        @property
        def function_like(self):
            return self._function_like

        @property
        def type_list(self):
            return self._type_list

        @property
        def opt_list(self):
            return self._opt_list

    def __init__(self, functions):
        assert isinstance(functions, (list, tuple))
        assert all(
            isinstance(function, FunctionLike) for function in functions)
        assert len(set([function.identifier for function in functions])) == 1
        assert len(set([function.is_static for function in functions])) == 1

        WithIdentifier.__init__(self, functions[0].identifier)
        self._functions = tuple(functions)
        for function in self._functions:
            function.set_overload_group(self)
        self._is_static = functions[0].is_static

    def __getitem__(self, index):
        return self._functions[index]

    def __iter__(self):
        return iter(self._functions)

    def __len__(self):
        return len(self._functions)

    def index(self, value):
        return self._functions.index(value)

    @property
    def is_static(self):
        return self._is_static

    @property
    def min_num_of_required_arguments(self):
        """
        Returns the minimum number of required arguments of overloaded
        functions.
        """
        return min(map(lambda func: func.num_of_required_arguments, self))

    def effective_overload_set(self, argument_count=None):
        """
        Returns the effective overload set.
        https://webidl.spec.whatwg.org/#compute-the-effective-overload-set
        """
        assert argument_count is None or isinstance(argument_count, int)

        N = argument_count
        S = []
        F = self

        maxarg = max(map(lambda X: len(X.arguments), F))
        if N is None:
            arg_sizes = [len(X.arguments) for X in F if not X.is_variadic]
            N = 1 + (max(arg_sizes) if arg_sizes else 0)

        for X in F:
            n = len(X.arguments)

            S.append(
                OverloadGroup.EffectiveOverloadItem(
                    X, list(map(lambda arg: arg.idl_type, X.arguments)),
                    list(map(lambda arg: arg.optionality, X.arguments))))

            if X.is_variadic:
                for i in range(n, max(maxarg, N)):
                    t = list(map(lambda arg: arg.idl_type, X.arguments))
                    o = list(map(lambda arg: arg.optionality, X.arguments))
                    for _ in range(n, i + 1):
                        t.append(X.arguments[-1].idl_type)
                        o.append(X.arguments[-1].optionality)
                    S.append(OverloadGroup.EffectiveOverloadItem(X, t, o))

            t = list(map(lambda arg: arg.idl_type, X.arguments))
            o = list(map(lambda arg: arg.optionality, X.arguments))
            for i in range(n - 1, -1, -1):
                if X.arguments[i].optionality == IdlType.Optionality.REQUIRED:
                    break
                S.append(OverloadGroup.EffectiveOverloadItem(X, t[:i], o[:i]))

        return S

    @staticmethod
    def distinguishing_argument_index(items_of_effective_overload_set):
        """
        Returns the distinguishing argument index.
        https://webidl.spec.whatwg.org/#dfn-distinguishing-argument-index
        """
        items = items_of_effective_overload_set
        assert isinstance(items, (list, tuple))
        assert all(
            isinstance(item, OverloadGroup.EffectiveOverloadItem)
            for item in items)
        assert len(items) > 1

        for index in range(len(items[0].type_list)):
            # Assume that the given items are valid, and we only need to test
            # the two types.
            if OverloadGroup.are_distinguishable_types(
                    items[0].type_list[index], items[1].type_list[index]):
                return index
        assert False

    @staticmethod
    def are_distinguishable_types(idl_type1, idl_type2):
        """
        Returns True if the two given types are distinguishable.
        https://webidl.spec.whatwg.org/#dfn-distinguishable
        """
        assert isinstance(idl_type1, IdlType)
        assert isinstance(idl_type2, IdlType)

        # step 1. If one type includes a nullable type and the other type either
        #   includes a nullable type, is a union type with flattened member
        #   types including a dictionary type, or is a dictionary type, ...
        if ((idl_type1.does_include_nullable_type
             and idl_type2.does_include_nullable_or_dict)
                or (idl_type2.does_include_nullable_type
                    and idl_type1.does_include_nullable_or_dict)):
            return False

        type1 = idl_type1.unwrap()
        type2 = idl_type2.unwrap()

        # step 2. If both types are either a union type or nullable union type,
        #   ...
        if type1.is_union and type2.is_union:
            for member1 in type1.member_types:
                for member2 in type2.member_types:
                    if not OverloadGroup.are_distinguishable_types(
                            member1, member2):
                        return False
            return True

        # step 3. If one type is a union type or nullable union type, ...
        if type1.is_union or type2.is_union:
            union = type1 if type1.is_union else type2
            other = type2 if type1.is_union else type1
            for member in union.member_types:
                if not OverloadGroup.are_distinguishable_types(member, other):
                    return False
            return True

        # step 4. Consider the two "innermost" types ...
        def is_string_type(idl_type):
            return idl_type.is_string or idl_type.is_enumeration

        def is_interface_like(idl_type):
            return idl_type.is_interface or idl_type.is_buffer_source_type

        def is_dictionary_like(idl_type):
            return (idl_type.is_dictionary or idl_type.is_record
                    or idl_type.is_callback_interface)

        def is_sequence_like(idl_type):
            return idl_type.is_sequence or idl_type.is_frozen_array

        if not (type2.is_undefined or type2.is_boolean or type2.is_numeric
                or type2.is_bigint or type2.is_string or type2.is_object
                or type2.is_symbol or is_interface_like(type2)
                or type2.is_callback_function or is_dictionary_like(type2)
                or is_sequence_like(type2)):
            return False  # Out of the table

        if type1.is_undefined:
            return not (type2.is_undefined or is_dictionary_like(type2))
        if type1.is_boolean:
            return not type2.is_boolean
        if type1.is_numeric or type1.is_bigint:
            # The spec distinguishes numeric types from bigint, but there is no
            # good use case yet. Also note that it's quite confusing and
            # problematic to abuse this distinguishment. Thus, we don't
            # distinguish them for now.
            return not (type2.is_numeric or type2.is_bigint)
        if is_string_type(type1):
            return not is_string_type(type2)
        if type1.is_object:
            return (type2.is_undefined or type2.is_boolean or type2.is_numeric
                    or type2.is_bigint or is_string_type(type2)
                    or type2.is_symbol)
        if type1.is_symbol:
            return not type2.is_symbol
        if is_interface_like(type1):
            if type2.is_object:
                return False
            if not is_interface_like(type2):
                return True
            # Additional requirements: The two identified interface-like types
            # are not the same, and no single platform object implements both
            # interface-like types.
            if type1.is_buffer_source_type or type2.is_buffer_source_type:
                return type1.keyword_typename != type2.keyword_typename
            interface1 = type1.type_definition_object
            interface2 = type2.type_definition_object
            return not (
                interface1 in interface2.inclusive_inherited_interfaces
                or interface2 in interface1.inclusive_inherited_interfaces)
        if type1.is_callback_function:
            if type2.is_object or type2.is_callback_function:
                return False
            if not is_dictionary_like(type2):
                return True
            # Additional requirements: A callback function that does not have
            # [LegacyTreatNonObjectAsNull] extended attribute is
            # distinguishable from a type in the dictionary-like category.
            return ("LegacyTreatNonObjectAsNull"
                    not in type1.type_definition_object.extended_attributes)
        if is_dictionary_like(type1):
            if (type2.is_undefined or type2.is_object
                    or is_dictionary_like(type2)):
                return False
            if not type2.is_callback_function:
                return True
            # Additional requirements: A callback function that does not have
            # [LegacyTreatNonObjectAsNull] extended attribute is
            # distinguishable from a type in the dictionary-like category.
            return ("LegacyTreatNonObjectAsNull"
                    not in type2.type_definition_object.extended_attributes)
        if is_sequence_like(type1):
            return not (type2.is_object or is_sequence_like(type2))
        return False  # Out of the table