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

from .code_generator_info import CodeGeneratorInfoMutable
from .composition_parts import Identifier
from .composition_parts import WithCodeGeneratorInfo
from .composition_parts import WithComponent
from .composition_parts import WithDebugInfo
from .composition_parts import WithIdentifier
from .idl_type import IdlType
from .typedef import Typedef


# NewUnion is a tentative name and will be renamed to Union.
class NewUnion(WithIdentifier, WithCodeGeneratorInfo, WithComponent,
               WithDebugInfo):
    """
    Union class makes a group of union types with the same flattened member
    types and the same result whether it includes a nullable type or not.

    For example, the following union types will be grouped into one Union
    instance.
      (A? or B or C), (A or B? or C), ((A or B) or C?), (A or (B or C?)), ...
    All these unions have the same set of flattened member types (A, B, C) and
    include a nullable type.

    However, all following union types will be grouped into separate Union
    instances.
      (A or B), ([X] A or B), ([Y] A or B)
    IdlType(A), IdlType([X] A), and IdlType([Y] A) are all distinguished from
    each other as they behave differently.  Bindings code generators are
    expected to define an implementation class for each Union instance.
    """

    _null_token = "Null"

    @classmethod
    def unique_token(cls, union_type):
        """
        Returns an unique token per a set of union types that are considered
        as the same group.
        """
        assert union_type.is_union

        token_pieces = []

        def collect_token_pieces(idl_type):
            idl_type = idl_type.unwrap()
            if idl_type.is_union:
                for member_type in idl_type.member_types:
                    collect_token_pieces(member_type)
            else:
                # Typename is not guaranteed to be unique, however it's
                # unlikely that a conflict happens.
                token_pieces.append(
                    idl_type.type_name_with_extended_attribute_key_values)

        collect_token_pieces(union_type)
        token_pieces.sort()
        if union_type.does_include_nullable_type:
            token_pieces.append(cls._null_token)
        return tuple(token_pieces)

    class IR(object):
        # Note that Union.IR is, despite of its name, very different from other
        # IDL definitions' IR classes.  This class is not meant to be stored in
        # IRMap nor managed with 'compilation phase'.

        def __init__(self, token, union_types):
            assert all(union_type.is_union for union_type in union_types)

            self.token = token
            self._member_set = set(token)
            self.union_types = union_types
            self.typedefs = []
            self.sub_union_irs = []
            self.public_object = None

        def __lt__(self, other):
            if len(self.token) == len(other.token):
                return self.token < other.token
            else:
                return len(self.token) < len(other.token)

        def contains(self, other):
            assert isinstance(other, NewUnion.IR)
            return (self.token != other.token
                    and self._member_set.issuperset(other._member_set))

    def __init__(self, ir):
        assert isinstance(ir, NewUnion.IR)
        assert ir.public_object is None

        identifier = Identifier('Union_{}'.format('_'.join(ir.token)))
        union_type = ir.union_types[0]
        flattened_member_types = union_type.flattened_member_types
        does_include_nullable_type = union_type.does_include_nullable_type
        does_include_nullable_or_dict = (
            union_type.does_include_nullable_or_dict)

        typedef_members = set()
        union_members = set()
        for union_type in ir.union_types:
            assert union_type.flattened_member_types == flattened_member_types
            assert (union_type.does_include_nullable_type ==
                    does_include_nullable_type)
            for member_type in union_type.member_types:
                if member_type.is_typedef:
                    typedef_members.add(member_type.typedef_object)
        for sub_union_ir in ir.sub_union_irs:
            assert isinstance(sub_union_ir.public_object, NewUnion)
            typedef_members.update(sub_union_ir.typedefs)
            union_members.add(sub_union_ir.public_object)

        components = set()
        for_testing = [False]

        def collect_primary_component(idl_type):
            type_definition_object = idl_type.type_definition_object
            if type_definition_object and type_definition_object.components:
                components.add(type_definition_object.components[0])
            if (type_definition_object and
                    type_definition_object.code_generator_info.for_testing):
                for_testing[0] = True

        for idl_type in flattened_member_types:
            idl_type.apply_to_all_composing_elements(collect_primary_component)
        code_generator_info = CodeGeneratorInfoMutable()
        code_generator_info.set_for_testing(for_testing[0])

        WithIdentifier.__init__(self, identifier)
        WithCodeGeneratorInfo.__init__(self,
                                       code_generator_info,
                                       readonly=True)
        WithComponent.__init__(self, sorted(components), readonly=True)
        WithDebugInfo.__init__(self)

        sort_key_typename = lambda idl_type: (
            idl_type.type_name_with_extended_attribute_key_values)
        sort_key_identifier = lambda x: x.identifier

        self._idl_types = tuple(ir.union_types)
        self._member_tokens = ir.token
        self._flattened_member_types = tuple(
            sorted(flattened_member_types, key=sort_key_typename))
        self._does_include_nullable_type = does_include_nullable_type
        self._does_include_nullable_or_dict = does_include_nullable_or_dict
        self._typedef_members = tuple(
            sorted(typedef_members, key=sort_key_identifier))
        self._union_members = tuple(
            sorted(union_members, key=sort_key_identifier))
        self._aliasing_typedefs = tuple(
            sorted(ir.typedefs, key=sort_key_identifier))

        ir.public_object = self

        for idl_type in self._idl_types:
            idl_type.set_new_union_definition_object(self)

    @property
    def idl_types(self):
        """Returns a list of IdlTypes which this object represents."""
        return self._idl_types

    @property
    def member_tokens(self):
        """Returns a list of unique names of union member types."""
        return self._member_tokens

    @property
    def flattened_member_types(self):
        """
        Returns the same list of flattened member types as
        IdlType.flattened_member_types.
        """
        return self._flattened_member_types

    @property
    def does_include_nullable_type(self):
        """
        Returns True if any of member type is nullable or a member union
        includes a nullable type.
        """
        return self._does_include_nullable_type

    @property
    def does_include_nullable_or_dict(self):
        """
        Returns True if this type includes a nullable type or a dictionary
        type.
        """
        return self._does_include_nullable_or_dict

    @property
    def typedef_members(self):
        """
        Returns a list of typedef types which are direct members of union types
        which this object represents.

        Given the following union types,
          (AT or B), (A or BT) where typedef A AT, and typedef B BT
        typedef_members returns a list of IdlType(AT) and IdlType(BT).
        """
        return self._typedef_members

    @property
    def union_members(self):
        """
        Returns a list of union types which are direct members of union types
        which this object represents.

        Given the following union types,
          ((A or B) or C), (A or (B or C))
        union_members returns a list of IdlType(A or B) and IdlType(B or C).
        """
        return self._union_members

    @property
    def aliasing_typedefs(self):
        """
        Returns a list of typedef types which are aliases to union types which
        this object represents.

        Given the following typedef definitions,
          typedef ((A or B) or C) T1;
          typedef (A or (B or C)) T2;
        aliasing_typedefs returns a list of IdlType(T1) and IdlType(T2).
        """
        return self._aliasing_typedefs


class BackwardCompatibleUnion(WithIdentifier, WithCodeGeneratorInfo,
                              WithComponent, WithDebugInfo):
    """
    Union class makes a group of union types with the same flattened member
    types and the same result whether it includes a nullable type or not.

    For example, the following union types will be grouped into one Union
    instance.
      (A? or B or C), (A or B? or C), ((A or B) or C?), (A or (B or C?)), ...
    All these unions have the same set of flattened member types (A, B, C) and
    include a nullable type.

    However, all following union types will be grouped into separate Union
    instances.
      (A or B), ([X] A or B), ([Y] A or B)
    IdlType(A), IdlType([X] A), and IdlType([Y] A) are all distinguished from
    each other as they behave differently.  Bindings code generators are
    expected to define an implementation class for each Union instance.
    """

    def __init__(self, union_types, typedef_backrefs):
        """
        Args:
            union_types: Union types of which this object consists.  All types
                in |union_types| must have the same flattened_member_types and
                the same value of does_include_nullable_type.
            typedef_backrefs: Typedef instances whose typedef'ed type is this
                union.
        """
        assert isinstance(union_types, (list, tuple))
        assert len(union_types) > 0
        assert all(
            isinstance(union_type, IdlType) and union_type.is_union
            for union_type in union_types)
        assert isinstance(typedef_backrefs, (list, tuple))
        assert all(
            isinstance(typedef, Typedef) for typedef in typedef_backrefs)

        flattened_members = union_types[0].flattened_member_types
        does_include_nullable_type = union_types[0].does_include_nullable_type

        nullable_members = set()
        typedef_members = set()
        union_members = set()
        for union_type in union_types:
            assert union_type.flattened_member_types == flattened_members
            assert (union_type.does_include_nullable_type ==
                    does_include_nullable_type)
            union_type.set_union_definition_object(self)
            for direct_member in union_type.member_types:
                if direct_member.is_nullable:
                    nullable_members.add(direct_member)
                if direct_member.is_typedef:
                    typedef_members.add(direct_member)
                if direct_member.is_union:
                    union_members.add(direct_member)

        sort_key = lambda x: x.syntactic_form

        components = set()

        def collect_primary_component(idl_type):
            type_definition_object = idl_type.type_definition_object
            if type_definition_object and type_definition_object.components:
                components.add(type_definition_object.components[0])

        for idl_type in flattened_members:
            idl_type.apply_to_all_composing_elements(collect_primary_component)
        # Make this union type look defined in 'modules' if the union type is
        # used in 'modules' in order to keep the backward compatibility with
        # the old bindings generator.
        is_defined_in_core = False
        is_defined_in_modules = False
        for idl_type in union_types:
            filepath = idl_type.debug_info.location.filepath
            if filepath.startswith('third_party/blink/renderer/core/'):
                is_defined_in_core = True
            if filepath.startswith('third_party/blink/renderer/modules/'):
                is_defined_in_modules = True
        if not is_defined_in_core and is_defined_in_modules:
            from .composition_parts import Component
            components.add(Component('modules'))

        # TODO(peria, yukishiino): Produce unique union names.  Trying to
        # produce the names compatible to the old bindings generator for the
        # time being.
        #
        # type_names = sorted(
        #     [idl_type.type_name for idl_type in flattened_members])
        def backward_compatible_member_name(idl_type):
            name = idl_type.unwrap().type_name
            if name == 'StringTreatNullAs':
                return 'StringTreatNullAsEmptyString'
            else:
                return name

        identifier = Identifier('Or'.join([
            backward_compatible_member_name(idl_type)
            for idl_type in union_types[0].member_types
        ]))

        WithIdentifier.__init__(self, identifier)
        WithCodeGeneratorInfo.__init__(self, readonly=True)
        WithComponent.__init__(self, sorted(components), readonly=True)
        WithDebugInfo.__init__(self)

        # Sort improves reproducibility.
        self._flattened_members = tuple(
            sorted(flattened_members, key=sort_key))
        self._does_include_nullable_type = does_include_nullable_type
        self._nullable_members = tuple(sorted(nullable_members, key=sort_key))
        self._typedef_members = tuple(sorted(typedef_members, key=sort_key))
        self._union_members = tuple(sorted(union_members, key=sort_key))
        self._typedef_backrefs = tuple(typedef_backrefs)

    @property
    def flattened_member_types(self):
        """
        Returns the same list of flattened member types as
        IdlType.flattened_member_types.
        """
        return self._flattened_members

    @property
    def does_include_nullable_type(self):
        """
        Returns True if any of member type is nullable or a member union
        includes a nullable type.
        """
        return self._does_include_nullable_type

    @property
    def nullable_member_types(self):
        """
        Returns a list of nullable types which are direct members of union types
        of which this object consists.

        Given the following unions,
          (A? or B or C), (A or B? or C), (A or B or CN) where typedef C? CN;
        nullable_member_types returns a list of IdlType(A?) and IdlType(B?).
        """
        return self._nullable_members

    @property
    def typedef_member_types(self):
        """
        Returns a list of typedef types which are direct members of union types
        of which this object consists.

        Given the following unions,
          (AT or B), (A or BT) where typedef A AT, and typedef B BT;
        typedef_member_types returns a list of IdlType(AT) and IdlType(BT).
        """
        return self._typedef_members

    @property
    def union_member_types(self):
        """
        Returns a list of union types which are direct members of union types of
        which this object consists.

        Given the following unions,
          ((A or B) or C), (A or (B or C))
        union_member_types returns a list of IdlType(A or B) and
        IdlType(B or C).
        """
        return self._union_members

    @property
    def aliasing_typedefs(self):
        """
        Returns a list of typedefs which are aliases to this union type.
        """
        return self._typedef_backrefs


Union = BackwardCompatibleUnion