Basic Usage Examples¶

use std::sync::Arc;
use std::time::Duration;

use acteon_core::{Action, ActionOutcome};
use acteon_executor::ExecutorConfig;
use acteon_gateway::GatewayBuilder;
use acteon_provider::{DynProvider, ProviderError};
use acteon_rules::RuleFrontend;
use acteon_rules_yaml::YamlFrontend;
use acteon_state_memory::{MemoryDistributedLock, MemoryStateStore};
use async_trait::async_trait;

// Define a mock provider
struct MockEmailProvider;

#[async_trait]
impl DynProvider for MockEmailProvider {
    fn name(&self) -> &str { "email" }

    async fn execute(&self, action: &Action)
        -> Result<acteon_core::ProviderResponse, ProviderError>
    {
        println!("Sending email to {}",
            action.payload.get("to")
                .and_then(|v| v.as_str())
                .unwrap_or("unknown"));
        Ok(acteon_core::ProviderResponse::success(
            serde_json::json!({"sent": true}),
        ))
    }

    async fn health_check(&self) -> Result<(), ProviderError> { Ok(()) }
}

#[tokio::main]
async fn main() {
    // Load rules
    let frontend = YamlFrontend;
    let rules = frontend.parse_file("rules/basic.yaml")
        .expect("failed to parse rules");

    // Build gateway
    let gateway = GatewayBuilder::new()
        .state(Arc::new(MemoryStateStore::new()))
        .lock(Arc::new(MemoryDistributedLock::new()))
        .rules(rules)
        .provider(Arc::new(MockEmailProvider))
        .executor_config(ExecutorConfig {
            max_retries: 1,
            execution_timeout: Duration::from_secs(5),
            max_concurrent: 10,
            ..ExecutorConfig::default()
        })
        .build()
        .expect("failed to build gateway");

    // Scenario 1: Deduplication
    let email = Action::new(
        "notifications", "tenant-1", "email", "send_email",
        serde_json::json!({"to": "user@example.com", "subject": "Hello!"}),
    ).with_dedup_key("email-user@example.com-hello");

    let outcome1 = gateway.dispatch(email.clone(), None).await.unwrap();
    println!("First:  {:?}", outcome1);  // Executed

    let outcome2 = gateway.dispatch(email, None).await.unwrap();
    println!("Second: {:?}", outcome2);  // Deduplicated

    // Scenario 2: Suppression
    let spam = Action::new(
        "notifications", "tenant-1", "email", "spam",
        serde_json::json!({"to": "victim@example.com"}),
    );

    let outcome3 = gateway.dispatch(spam, None).await.unwrap();
    println!("Spam:   {:?}", outcome3);  // Suppressed

    // Print metrics
    let m = gateway.metrics().snapshot();
    println!("Dispatched: {}, Executed: {}, Dedup: {}, Suppressed: {}",
        m.dispatched, m.executed, m.deduplicated, m.suppressed);
}