use notmad::{Component, MadError};

use super::{agent_state::AgentState, config::AgentConfig, grpc_client::GrpcClient};

#[derive(Clone)]
pub struct EventHandler {
    config: AgentConfig,
    grpc: GrpcClient,
}

impl EventHandler {
    pub fn new(state: impl Into<AgentState>) -> Self {
        let state: AgentState = state.into();

        Self {
            config: state.config.clone(),
            grpc: state.grpc.clone(),
        }
    }
}

#[async_trait::async_trait]
impl Component for EventHandler {
    fn name(&self) -> Option<String> {
        Some("event_handler".into())
    }

    async fn run(
        &self,
        cancellation_token: tokio_util::sync::CancellationToken,
    ) -> Result<(), notmad::MadError> {
        tokio::select! {
            _ = cancellation_token.cancelled() => {},
            res = self.grpc.listen_events("agents", None::<String>, self.clone()) => {
                res.map_err(MadError::Inner)?;
            },
            res = self.grpc.listen_events("agents", Some(&self.config.agent_id), self.clone()) => {
                res.map_err(MadError::Inner)?;
            }
        }

        Ok(())
    }
}

#[async_trait::async_trait]
impl super::grpc_client::ListenEventsExecutor for EventHandler {
    async fn execute(&self, event: crate::grpc::ListenEventsResponse) -> anyhow::Result<()> {
        tracing::info!(value = event.value, "received event");

        Ok(())
    }
}