from typing import Iterator


class World:
    """
    Un monde contenant des entités et des ressources.
    """

    def __init__(self):
        """
        Permet de créer un nouveau monde vide.
        """
        self._to_apply: set[Entity] = set()
        self._entities: set[Entity] = set()
        self._mapping: dict[type, set[Entity]] = {}
        self._to_apply_resources: list[tuple[type, object]] = []
        self._resources: dict[type, object] = {}
    
    def create_entity(self, *components):
        """
        Crée une entité avec les composants donnés en paramètres.

        Paramètres:
            *components: Les composants de l'entité.

        Retourne:
            L'entité crée.
        """
        return Entity(self, *components)

    def remove_entity(self, entity: 'Entity'):
        """
        Supprime une entité du monde.

        Paramètres:
            entity: L'entité a supprimer.
        """
        entity._deleted = True
        self._to_apply.add(entity)
    
    def set(self, *resources):
        """
        Définit les ressources données en paramètres.
        Si les ressources existent deja, elles seront remplacées.

        Paramètres:
            *resources: Les ressources a definir.
        """
        for resource in resources:
            self._to_apply_resources.append((type(resource), resource))
    
    def remove(self, *resource_types):
        """
        Supprime les ressources données en paramètres.

        Paramètres:
            *resource_types: Les types des ressources à supprimer.
        """
        for resource_type in resource_types:
            if resource_type in self._resources:
                self._to_apply_resources.append((resource_type, None))

    def apply(self):
        """
        Applique les changements réaliser dans le monde.
        """
        for entity in self._to_apply:
            if entity._deleted:
                self._entities.remove(entity)
                for component_type in entity._components:
                    self._mapping[component_type].remove(entity)
            else:
                self._entities.add(entity)
                for component_type, component in entity._to_apply:
                    if component is None:
                        del entity._components[component_type]
                        self._mapping[component_type].remove(entity)
                    else:
                        entity._components[component_type] = component
                        self._mapping.setdefault(component_type, set()).add(entity)
                entity._to_apply.clear()
        self._to_apply.clear()
        for resource_type, resource in self._to_apply_resources:
            if resource is None: del self._resources[resource_type]
            else: self._resources[resource_type] = resource
        self._to_apply_resources.clear()
    
    def query(self, *needed: type, without: tuple[type] = []) -> Iterator['Entity']:
        """
        Renvoie les entités qui ont les composants de *needed et sans les composants de *without.
        
        Paramètres:
            *needed: Le type de composants que les entités doivent avoir.
            *without: Les type de composants que les entités ne doivent pas avoir.

        Retourne:
            Les entités qui ont les composants de *needed et sans les composants de *without.
            Si *needed est vide, on retourne toutes les entités qui ont les composants de *without.
        """
        if not needed:
            for entity in self._entities:
                if all(without_type not in entity for without_type in without):
                    yield entity
        else:
            for entity in self._mapping.get(needed[0], set()):
                if all(entity in self._mapping.get(component_type, set()) for component_type in needed[1:]) and \
                        all(without_type not in entity for without_type in without):
                    yield entity
    
    def __getitem__(self, resource_type: type) -> object:
        """
        Renvoie la ressource de type *resource_type.

        Paramètres:
            resource_type: Le type de ressource à récupérer.

        Retourne:
            La ressource de type *resource_type.
        """
        return self._resources[resource_type]
    
    def __contains__(self, resource_type: type) -> bool:
        """
        Renvoie si la ressource de type *resource_type existe.

        Paramètres:
            resource_type: Le type de ressource à tester.

        Retourne:
            Si la ressource de type *resource_type existe.
        """
        return resource_type in self._resources

class Entity:
    """
    Une entité du monde.
    """
    def __init__(self, world: World, *components):
        """
        Créer une entité avec les composants en paramètres et l'ajoute au monde.

        Paramètres:
            world: Le monde auquel ajouter l'entité.
            *components: Les composants de l'entité.
        """
        self._world = world
        self._to_apply: list[tuple[type, object]] = [(type(component), component) for component in components]
        self._components: dict[type, object] = {}
        self._deleted = False
        self._world._to_apply.add(self)
    
    def set(self, *components):
        """
        Définit les composants de l'entité donnés en paramètres.

        Paramètres:
            *components: Les composants a definir.
        """
        for component in components:
            self._to_apply.append((type(component), component))
        self._world._to_apply.add(self)
    
    def remove(self, *component_types: type):
        """
        Supprime les composants de l'entité donnés en paramètres.

        Paramètres:
            *component_types: Le type des composants à supprimer.
        """
        for component_type in component_types:
            if component_type in self._components:
                self._to_apply.append((component_type, None))
        self._world._to_apply.add(self)
    
    def __getitem__(self, component_type: type) -> object:
        """
        Renvoie le composant de type *component_type.

        Paramètres:
            component_type: Le type du composant à récupérer.

        Retourne:
            Le composant de type *component_type.
        """
        return self._components[component_type]

    def __contains__(self, component_type: type) -> bool:
        """
        Renvoie si le composant de type *component_type existe.

        Paramètres:
            component_type: Le type du composant à tester.

        Retourne:
            Si le composant de type *component_type existe.
        """
        return component_type in self._components