# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at https://mozilla.org/MPL/2.0/.

# fmt: off

from __future__ import annotations

import functools
import os
from typing import Any, TypeVar

from WebIDL import (
    IDLExternalInterface,
    IDLSequenceType,
    IDLWrapperType,
    WebIDLError,
    IDLEnum,
    IDLObject,
    IDLObjectWithIdentifier,
    IDLType,
    IDLTypedef,
    IDLInterfaceOrNamespace,
    IDLDictionary,
    IDLCallback,
    IDLAttribute,
    IDLMethod,
    IDLInterfaceMember,
)

TargetType = TypeVar('TargetType')
def assert_type(object: Any, cls: type[TargetType]) -> TargetType:
    assert isinstance(object, cls)
    return object

FilterItemsType = TypeVar('FilterItemsType', bound=IDLObjectWithIdentifier)
class Configuration:
    """
    Represents global configuration state based on IDL parse data and
    the configuration file.
    """
    glbl: dict[str, Any]
    enumConfig: dict[str, Any]
    dictConfig: dict[str, Any]
    unionConfig: dict[str, Any]
    descriptors: list[Descriptor]
    interfaces: dict[str, IDLInterfaceOrNamespace]
    enums: list[IDLEnum]
    typedefs: list[IDLTypedef]
    dictionaries: list[IDLDictionary]
    callbacks: list[IDLCallback]

    def __init__(self, filename: str, parseData: list[IDLObjectWithIdentifier]) -> None:
        # Read the configuration file.
        glbl = {}
        exec(compile(open(filename).read(), filename, 'exec'), glbl)
        config = glbl['DOMInterfaces']
        self.enumConfig = glbl['Enums']
        self.dictConfig = glbl['Dictionaries']
        self.unionConfig = glbl['Unions']

        # Build descriptors for all the interfaces we have in the parse data.
        # This allows callers to specify a subset of interfaces by filtering
        # |parseData|.
        self.descriptors = []
        self.interfaces = {}
        self.maxProtoChainLength = 0
        for thing in parseData:
            # Servo does not support external interfaces.
            if isinstance(thing, IDLExternalInterface):
                raise WebIDLError("Servo does not support external interfaces.",
                                  [thing.location])

            assert not thing.isType()

            if not thing.isInterface() and not thing.isNamespace():
                continue

            iface = thing
            assert isinstance(iface, IDLInterfaceOrNamespace)
            self.interfaces[iface.identifier.name] = iface
            if iface.identifier.name not in config:
                entry = {}
            else:
                entry = config[iface.identifier.name]
            if not isinstance(entry, list):
                assert isinstance(entry, dict)
                entry = [entry]
            self.descriptors.extend(
                [Descriptor(self, iface, x) for x in entry])

        # Mark the descriptors for which only a single nativeType implements
        # an interface.
        for descriptor in self.descriptors:
            interfaceName = descriptor.interface.identifier.name
            otherDescriptors = [d for d in self.descriptors
                                if d.interface.identifier.name == interfaceName]
            descriptor.uniqueImplementation = len(otherDescriptors) == 1

        self.enums = [assert_type(e, IDLEnum) for e in parseData if e.isEnum()]
        self.typedefs = [assert_type(e, IDLTypedef) for e in parseData if e.isTypedef()]
        self.dictionaries = [assert_type(d, IDLDictionary) for d in parseData if d.isDictionary()]
        self.callbacks = [assert_type(c, IDLCallback) for c in parseData if
                          c.isCallback() and not c.isInterface()]

        # Keep the descriptor list sorted for determinism.
        def cmp(x: str, y: str) -> int:
            return (x > y) - (x < y)
        self.descriptors.sort(key=functools.cmp_to_key(lambda x, y: cmp(x.name, y.name)))

    def getInterface(self, ifname: str) -> IDLInterfaceOrNamespace:
        return self.interfaces[ifname]

    def getDescriptors(self, **filters: Any) -> list[Descriptor]:
        """Gets the descriptors that match the given filters."""
        curr = self.descriptors
        for key, val in filters.items():
            if key == 'webIDLFile':
                def getter(x: Descriptor) -> str:
                    return x.interface.location.filename
            elif key == 'hasInterfaceObject':
                def getter(x: Descriptor) -> bool:
                    return x.interface.hasInterfaceObject()
            elif key == 'isCallback':
                def getter(x: Descriptor) -> bool:
                    return x.interface.isCallback()
            elif key == 'isNamespace':
                def getter(x: Descriptor) -> bool:
                    return x.interface.isNamespace()
            elif key == 'isJSImplemented':
                def getter(x: Descriptor) -> bool:
                    return x.interface.isJSImplemented()
            elif key == 'isGlobal':
                def getter(x: Descriptor) -> bool:
                    return x.isGlobal()
            elif key == 'isInline':
                def getter(x: Descriptor) -> bool:
                    return x.interface.getExtendedAttribute('Inline') is not None
            elif key == 'isExposedConditionally':
                def getter(x: Descriptor) -> bool:
                    return x.interface.isExposedConditionally()
            elif key == 'isIteratorInterface':
                def getter(x: Descriptor) -> bool:
                    return x.interface.isIteratorInterface()
            else:
                def getter(x: Descriptor) -> Any:
                    return getattr(x, key)
            curr = [x for x in curr if getter(x) == val]
        return curr

    def getEnums(self, webIDLFile: str) -> list[IDLEnum]:
        return [e for e in self.enums if e.filename == webIDLFile]

    def getEnumConfig(self, name: str) -> dict[str, Any]:
        return self.enumConfig.get(name, {})

    def getTypedefs(self, webIDLFile: str) -> list[IDLTypedef]:
        return [e for e in self.typedefs if e.filename == webIDLFile]

    @staticmethod
    def _filterForFile(items: list[FilterItemsType], webIDLFile: str = "") -> list[FilterItemsType]:
        """Gets the items that match the given filters."""
        if not webIDLFile:
            return items

        return [x for x in items if x.filename == webIDLFile]

    def getUnionConfig(self, name: str) -> dict[str, Any]:
        return self.unionConfig.get(name, {})

    def getDictionaries(self, webIDLFile: str = "") -> list[IDLDictionary]:
        return self._filterForFile(self.dictionaries, webIDLFile=webIDLFile)

    def getDictConfig(self, name: str) -> dict[str, Any]:
        return self.dictConfig.get(name, {})

    def getCallbacks(self, webIDLFile: str = "") -> list[IDLCallback]:
        return self._filterForFile(self.callbacks, webIDLFile=webIDLFile)

    def getDescriptor(self, interfaceName: str) -> Descriptor:
        """
        Gets the appropriate descriptor for the given interface name.
        """
        iface = self.getInterface(interfaceName)
        descriptors = self.getDescriptors(interface=iface)

        # We should have exactly one result.
        if len(descriptors) != 1:
            raise NoSuchDescriptorError("For " + interfaceName + " found "
                                        + str(len(descriptors)) + " matches")
        return descriptors[0]

    def getDescriptorProvider(self) -> DescriptorProvider:
        """
        Gets a descriptor provider that can provide descriptors as needed.
        """
        return DescriptorProvider(self)


class NoSuchDescriptorError(TypeError):
    def __init__(self, str: str) -> None:
        TypeError.__init__(self, str)


class DescriptorProvider:
    """
    A way of getting descriptors for interface names
    """
    def __init__(self, config: Configuration) -> None:
        self.config = config

    def getDescriptor(self, interfaceName: str) -> Descriptor:
        """
        Gets the appropriate descriptor for the given interface name given the
        context of the current descriptor.
        """
        return self.config.getDescriptor(interfaceName)


def MemberIsLegacyUnforgeable(member: IDLAttribute | IDLMethod, descriptor: Descriptor) -> bool:
    return ((member.isAttr() or member.isMethod())
            and not member.isStatic()
            and (member.isLegacyUnforgeable()
                 or bool(descriptor.interface.getExtendedAttribute("LegacyUnforgeable"))))


class Descriptor(DescriptorProvider):
    """
    Represents a single descriptor for an interface. See Bindings.conf.
    """
    interface: IDLInterfaceOrNamespace
    uniqueImplementation: bool

    def __init__(self, config: Configuration, interface: IDLInterfaceOrNamespace, desc: dict[str, Any]) -> None:
        DescriptorProvider.__init__(self, config)
        self.interface = interface

        if not self.isExposedConditionally():
            if interface.parent and interface.parent.isExposedConditionally():
                raise TypeError("%s is not conditionally exposed but inherits from "
                                "%s which is" %
                                (interface.identifier.name, interface.parent.identifier.name))

        # Read the desc, and fill in the relevant defaults.
        ifaceName = self.interface.identifier.name
        nativeTypeDefault = ifaceName

        # For generated iterator interfaces for other iterable interfaces, we
        # just use IterableIterator as the native type, templated on the
        # nativeType of the iterable interface. That way we can have a
        # templated implementation for all the duplicated iterator
        # functionality.
        prefix = "D::"
        if self.interface.isIteratorInterface():
            assert self.interface.iterableInterface is not None
            itrName = self.interface.iterableInterface.identifier.name
            itrDesc = self.getDescriptor(itrName)
            nativeTypeDefault = iteratorNativeType(itrDesc)
            prefix = ""

        typeName = desc.get('nativeType', nativeTypeDefault)

        spiderMonkeyInterface = desc.get('spiderMonkeyInterface', False)

        # Callback and SpiderMonkey types do not use JS smart pointers, so we should not use the
        # built-in rooting mechanisms for them.
        if spiderMonkeyInterface:
            self.returnType = 'Rc<%s>' % typeName
            self.argumentType = '&%s' % typeName
            self.nativeType = typeName
            pathDefault = 'crate::dom::types::%s' % typeName
        elif self.interface.isCallback():
            ty = 'crate::codegen::GenericBindings::%sBinding::%s' % (ifaceName, ifaceName)
            pathDefault = ty
            self.returnType = "Rc<%s<D>>" % ty
            self.argumentType = "???"
            self.nativeType = ty
        else:
            self.returnType = "DomRoot<%s%s>" % (prefix, typeName)
            self.argumentType = "&%s%s" % (prefix, typeName)
            self.nativeType = "*const %s%s" % (prefix, typeName)
            if self.interface.isIteratorInterface():
                pathDefault = 'crate::iterable::IterableIterator'
            else:
                pathDefault = 'crate::dom::types::%s' % MakeNativeName(typeName)

        self.concreteType = "%s%s" % (prefix, typeName)
        self.register = desc.get('register', True)
        self.path = desc.get('path', pathDefault)
        self.inRealmMethods = [name for name in desc.get('inRealms', [])]
        self.canGcMethods = [name for name in desc.get('canGc', [])]
        self.additionalTraits = [name for name in desc.get('additionalTraits', [])]
        self.bindingPath = f"{getModuleFromObject(self.interface)}::{ifaceName}_Binding"
        self.outerObjectHook = desc.get('outerObjectHook', 'None')
        self.proxy = False
        self.weakReferenceable = desc.get('weakReferenceable', False)
        self.useSystemCompartment = desc.get('useSystemCompartment', False)

        # If we're concrete, we need to crawl our ancestor interfaces and mark
        # them as having a concrete descendant.
        self.concrete = (not self.interface.isCallback()
                         and not self.interface.isNamespace()
                         and not self.interface.getExtendedAttribute("Abstract")
                         and not self.interface.getExtendedAttribute("Inline")
                         and not spiderMonkeyInterface)
        self.hasLegacyUnforgeableMembers = (self.concrete
                                            and any(MemberIsLegacyUnforgeable(m, self) for m in
                                                    self.interface.members))

        self.operations: dict[str, IDLMethod | None] = {
            'IndexedGetter': None,
            'IndexedSetter': None,
            'IndexedDeleter': None,
            'NamedGetter': None,
            'NamedSetter': None,
            'NamedDeleter': None,
            'Stringifier': None,
        }

        self.hasDefaultToJSON = False

        def addOperation(operation: str, m: IDLMethod) -> None:
            if not self.operations[operation]:
                self.operations[operation] = m

        # Since stringifiers go on the prototype, we only need to worry
        # about our own stringifier, not those of our ancestor interfaces.
        for m in self.interface.members:
            if m.isMethod() and m.isStringifier():
                addOperation('Stringifier', m)
            if m.isMethod() and m.isDefaultToJSON():
                self.hasDefaultToJSON = True

        if self.concrete:
            iface: IDLInterfaceOrNamespace | None = self.interface
            while iface:
                for m in iface.members:
                    if not m.isMethod():
                        continue

                    def addIndexedOrNamedOperation(operation: str, m: IDLMethod) -> None:
                        if not self.isGlobal():
                            self.proxy = True
                        if m.isIndexed():
                            operation = 'Indexed' + operation
                        else:
                            assert m.isNamed()
                            operation = 'Named' + operation
                        addOperation(operation, m)

                    if m.isGetter():
                        addIndexedOrNamedOperation('Getter', m)
                    if m.isSetter():
                        addIndexedOrNamedOperation('Setter', m)
                    if m.isDeleter():
                        addIndexedOrNamedOperation('Deleter', m)

                iface = iface.parent
                if iface:
                    iface.setUserData('hasConcreteDescendant', True)

            if self.isMaybeCrossOriginObject():
                self.proxy = True

            if self.proxy:
                iface = self.interface
                while iface.parent:
                    iface = iface.parent
                    iface.setUserData('hasProxyDescendant', True)

        self.name = interface.identifier.name

        # self.extendedAttributes is a dict of dicts, keyed on
        # all/getterOnly/setterOnly and then on member name. Values are an
        # array of extended attributes.
        self.extendedAttributes = {'all': {}, 'getterOnly': {}, 'setterOnly': {}}

        def addExtendedAttribute(attribute: dict[str, Any], config: Configuration) -> None:
            def add(key: str, members: list[str], attribute: dict[str, Any]) -> None:
                for member in members:
                    self.extendedAttributes[key].setdefault(member, []).append(attribute)

            if isinstance(config, dict):
                for key in ['all', 'getterOnly', 'setterOnly']:
                    add(key, config.get(key, []), attribute)
            elif isinstance(config, list):
                add('all', config, attribute)
            else:
                assert isinstance(config, str)
                if config == '*':
                    iface: IDLInterfaceOrNamespace | None = self.interface
                    while iface:
                        add('all', [m.name for m in iface.members], attribute)
                        iface = iface.parent
                else:
                    add('all', [config], attribute)

        self._binaryNames = desc.get('binaryNames', {})
        self._binaryNames.setdefault(('__legacycaller', False), 'LegacyCall')
        self._binaryNames.setdefault(('__stringifier', False), 'Stringifier')

        self._internalNames = desc.get('internalNames', {})

        for member in self.interface.members:
            if not member.isAttr() and not member.isMethod():
                continue
            binaryName = member.getExtendedAttribute("BinaryName")
            if binaryName:
                assert isinstance(binaryName, list)
                assert len(binaryName) == 1
                self._binaryNames.setdefault((member.identifier.name, member.isStatic()),
                                             binaryName[0])
            self._internalNames.setdefault(member.identifier.name,
                                           member.identifier.name.replace('-', '_'))

        # Build the prototype chain.
        self.prototypeChain = []
        parent: IDLInterfaceOrNamespace | None = interface
        while parent:
            self.prototypeChain.insert(0, parent.identifier.name)
            parent = parent.parent
        self.prototypeDepth = len(self.prototypeChain) - 1
        config.maxProtoChainLength = max(config.maxProtoChainLength,
                                         len(self.prototypeChain))

    def maybeGetSuperModule(self) -> str | None:
        """
        Returns name of super module if self is part of it
        """
        filename = getIdlFileName(self.interface)
        # if interface name is not same as webidl file
        # webidl is super module for interface
        if filename.lower() != self.interface.identifier.name.lower():
            return filename
        return None

    def binaryNameFor(self, name: str, isStatic: bool) -> str:
        return self._binaryNames.get((name, isStatic), name)

    def internalNameFor(self, name: str) -> str:
        return self._internalNames.get(name, name)

    def hasNamedPropertiesObject(self) -> bool:
        if self.interface.isExternal():
            return False

        return self.isGlobal() and self.supportsNamedProperties()

    def supportsNamedProperties(self) -> bool:
        return self.operations['NamedGetter'] is not None

    def getExtendedAttributes(self, member: IDLInterfaceMember, getter: bool = False, setter: bool = False) -> list[str]:
        def maybeAppendInfallibleToAttrs(attrs: list[str], throws: bool | None) -> None:
            if throws is None:
                attrs.append("infallible")
            elif throws is True:
                pass
            else:
                raise TypeError("Unknown value for 'Throws'")

        name = member.identifier.name
        if member.isMethod():
            attrs = self.extendedAttributes['all'].get(name, [])
            throws = member.getExtendedAttribute("Throws")
            maybeAppendInfallibleToAttrs(attrs, throws)
            return attrs

        assert member.isAttr()
        assert bool(getter) != bool(setter)
        key = 'getterOnly' if getter else 'setterOnly'
        attrs = self.extendedAttributes['all'].get(name, []) + self.extendedAttributes[key].get(name, [])
        throws = member.getExtendedAttribute("Throws")
        if throws is None:
            throwsAttr = "GetterThrows" if getter else "SetterThrows"
            throws = member.getExtendedAttribute(throwsAttr)
        maybeAppendInfallibleToAttrs(attrs, throws)
        return attrs

    def getParentName(self) -> str | None:
        parent = self.interface.parent
        while parent:
            if not parent.getExtendedAttribute("Inline"):
                return parent.identifier.name
            parent = parent.parent
        return None

    def supportsIndexedProperties(self) -> bool:
        return self.operations['IndexedGetter'] is not None

    def isMaybeCrossOriginObject(self) -> bool:
        # If we're isGlobal and have cross-origin members, we're a Window, and
        # that's not a cross-origin object.  The WindowProxy is.
        return self.concrete and self.interface.hasCrossOriginMembers and not self.isGlobal()

    def hasDescendants(self) -> bool:
        return (self.interface.getUserData("hasConcreteDescendant", False)
                or self.interface.getUserData("hasProxyDescendant", False) or False)

    def hasHTMLConstructor(self) -> bool:
        ctor = self.interface.ctor()
        return (ctor and ctor.isHTMLConstructor()) or False

    def shouldHaveGetConstructorObjectMethod(self) -> bool:
        assert self.interface.hasInterfaceObject()
        if self.interface.getExtendedAttribute("Inline"):
            return False
        return (self.interface.isCallback() or self.interface.isNamespace()
                or self.hasDescendants() or self.hasHTMLConstructor() or False)

    def shouldCacheConstructor(self) -> bool:
        return self.hasDescendants() or self.hasHTMLConstructor()

    def isExposedConditionally(self) -> bool:
        return self.interface.isExposedConditionally()

    def isGlobal(self) -> bool:
        """
        Returns true if this is the primary interface for a global object
        of some sort.
        """
        return bool(self.interface.getExtendedAttribute("Global")
                    or self.interface.getExtendedAttribute("PrimaryGlobal"))


# Some utility methods


def MakeNativeName(name: str) -> str:
    return name[0].upper() + name[1:]


def getIdlFileName(object: IDLObject) -> str:
    return os.path.basename(object.location.filename).split('.webidl')[0]


def getModuleFromObject(object: IDLObject) -> str:
    return ('crate::codegen::GenericBindings::' + getIdlFileName(object) + 'Binding')


def getTypesFromDescriptor(descriptor: Descriptor) -> list[IDLType]:
    """
    Get all argument and return types for all members of the descriptor
    """
    members = [m for m in descriptor.interface.members]
    if descriptor.interface.ctor():
        members.append(descriptor.interface.ctor())
    members.extend(descriptor.interface.legacyFactoryFunctions)
    signatures = [s for m in members if m.isMethod() for s in m.signatures()]
    types = []
    for s in signatures:
        assert len(s) == 2
        (returnType, arguments) = s
        types.append(returnType)
        types.extend(a.type for a in arguments)

    types.extend(a.type for a in members if a.isAttr())
    return types


def getTypesFromDictionary(dictionary: IDLWrapperType | IDLDictionary) -> list[IDLType]:
    """
    Get all member types for this dictionary
    """
    if isinstance(dictionary, IDLWrapperType):
        dictionary = dictionary.inner
    types = []
    curDict = dictionary
    while curDict:
        types.extend([getUnwrappedType(m.type) for m in curDict.members])
        curDict = curDict.parent
    return types


def getTypesFromCallback(callback: IDLCallback) -> list[IDLType]:
    """
    Get the types this callback depends on: its return type and the
    types of its arguments.
    """
    sig = callback.signatures()[0]
    types = [sig[0]]  # Return type
    types.extend(arg.type for arg in sig[1])  # Arguments
    return types


def getUnwrappedType(type: IDLType) -> IDLType:
    while isinstance(type, IDLSequenceType):
        type = type.inner
    return type


def iteratorNativeType(descriptor: Descriptor, infer: bool = False) -> str:
    assert descriptor.interface.maplikeOrSetlikeOrIterable is not None
    iterableDecl = descriptor.interface.maplikeOrSetlikeOrIterable
    assert (iterableDecl.isIterable() and iterableDecl.isPairIterator()) \
        or iterableDecl.isSetlike() or iterableDecl.isMaplike()
    res = "IterableIterator%s" % ("" if infer else '<D, D::%s>' % descriptor.interface.identifier.name)
    # todo: this hack is telling us that something is still wrong in codegen
    if iterableDecl.isSetlike() or iterableDecl.isMaplike():
        res = f"crate::iterable::{res}"
    return res