from typing import Optional, Type
from pydantic import BaseModel


class EventCluster:
    """
    EventCluster
    """
    def __repr__(self):
        return f"EventCluster(name={self.name})"

    def __init__(self, endpoint_uu_id: str, name: str):
        self.endpoint_uu_id = endpoint_uu_id
        self.name = name
        self.events: list["Event"] = []

    def add_event(self, event: "Event"):
        """
        Add an event to the cluster
        """
        if event.key not in [e.key for e in self.events]:
            self.events.append(event)

    def get_event(self, event_key: str):
        """
        Get an event by its key
        """

        for event in self.events:
            if event.key == event_key:
                return event
        return None

    def set_events_to_database(self):
        from Schemas import Events, EndpointRestriction

        with Events.new_session() as db_session:
            if to_save_endpoint := EndpointRestriction.filter_one(
                EndpointRestriction.operation_uu_id == self.endpoint_uu_id,
                db=db_session,
            ).data:
                for event in self.events:
                    event_dict_to_save = dict(
                        function_code=event.key,
                        function_class=event.name,
                        description=event.description,
                        endpoint_code=self.endpoint_uu_id,
                        endpoint_id=to_save_endpoint.id,
                        endpoint_uu_id=str(to_save_endpoint.uu_id),
                        is_confirmed=True,
                        db=db_session,
                    )
                    event_found = Events.filter_one(
                        Events.function_code == event_dict_to_save["function_code"],
                        db=db_session,
                    ).data
                    if event_found:
                        event_found.update(**event_dict_to_save)
                        event_found.save(db=db_session)
                    else:
                        event_to_save_database = Events.find_or_create(
                            **event_dict_to_save, 
                            include_args=[
                                Events.function_code,
                                Events.function_class,
                                Events.endpoint_code,
                                Events.endpoint_uu_id,
                            ]
                        )
                        if event_to_save_database.meta_data.created:
                            print(f"UUID: {event_to_save_database.uu_id} event is saved to {to_save_endpoint.uu_id}")
                            event_to_save_database.save(db=db_session)

    def match_event(self, event_key: str) -> "Event":
        """
        Match an event by its key
        """
        if event := self.get_event(event_key=event_key):
            return event
        raise ValueError("Event key not found")


class Event:

    def __init__(
        self,
        name: str,
        key: str,
        request_validator: Optional[Type[BaseModel]] = None,
        response_validator: Optional[Type[BaseModel]] = None,
        description: str = "",
    ):
        self.name = name
        self.key = key
        self.request_validator = request_validator
        self.response_validator = response_validator
        self.description = description

    def event_callable(self):
        """
        Example callable method
        """
        print(self.name)
        return {}


class RouterCluster:
    """
    RouterCluster
    """

    def __repr__(self):
        return f"RouterCluster(name={self.name})"

    def __init__(self, name: str):
        self.name = name
        self.event_clusters: dict[str, EventCluster] = {}

    def set_event_cluster(self, event_cluster: EventCluster):
        """
        Add an event cluster to the set
        """
        print("Setting event cluster:", event_cluster.name)
        if event_cluster.name not in self.event_clusters:
            self.event_clusters[event_cluster.name] = event_cluster

    def get_event_cluster(self, event_cluster_name: str) -> EventCluster:
        """
        Get an event cluster by its name
        """
        if event_cluster_name not in self.event_clusters:
            raise ValueError("Event cluster not found")
        return self.event_clusters[event_cluster_name]