Secretary Agent Example

use mofa_sdk::secretary::{
    AgentInfo, ChannelConnection, DefaultInput, DefaultOutput,
    DefaultSecretaryBuilder, DispatchStrategy, SecretaryCore
};
use tracing::info;

mod llm_integration;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    tracing_subscriber::fmt()
        .with_env_filter("info")
        .init();

    info!("╔══════════════════════════════════════════════════════════════╗");
    info!("║   Secretary Agent Mode - LLM-based Work Cycle Demonstration  ║");
    info!("╚══════════════════════════════════════════════════════════════╝\n");

    // Create LLM provider
    let llm_provider = llm_integration::create_llm_provider();
    info!("✅ LLM provider created: {}\n", llm_provider.name());

    // Create execution agent information
    let mut frontend_agent = AgentInfo::new(
        "frontend_agent", 
        "Frontend Development Agent"
    );
    frontend_agent.capabilities = vec![
        "frontend".to_string(),
        "ui_design".to_string(),
        "react".to_string(),
    ];
    frontend_agent.current_load = 20;
    frontend_agent.available = true;
    frontend_agent.performance_score = 0.85;

    let mut backend_agent = AgentInfo::new(
        "backend_agent", 
        "Backend Development Agent"
    );
    backend_agent.capabilities = vec![
        "backend".to_string(),
        "api_design".to_string(),
        "database".to_string(),
    ];
    backend_agent.current_load = 30;
    backend_agent.available = true;
    backend_agent.performance_score = 0.9;

    let mut test_agent = AgentInfo::new("test_agent", "Testing Agent");
    test_agent.capabilities = vec!["testing".to_string(), "qa".to_string()];
    test_agent.current_load = 10;
    test_agent.available = true;
    test_agent.performance_score = 0.88;

    // Create secretary agent
    let secretary_behavior = DefaultSecretaryBuilder::new()
        .with_name("LLM-based Development Project Secretary")
        .with_dispatch_strategy(DispatchStrategy::CapabilityFirst)
        .with_auto_clarify(true)   // Auto clarification
        .with_auto_dispatch(true)  // Auto dispatch
        .with_llm(llm_provider)
        .with_executor(frontend_agent)
        .with_executor(backend_agent)
        .with_executor(test_agent)
        .build();

    info!("✅ Secretary Agent created\n");

    // Create channel connection
    let (connection, input_tx, mut output_rx) = 
        ChannelConnection::new_pair(32);

    // Create and start core engine
    let (handle, join_handle) = SecretaryCore::new(secretary_behavior)
        .start(connection)
        .await;

    info!("✅ Secretary Agent core engine started\n");

    // Send test idea
    info!("📥 Sending idea to Secretary Agent:");
    info!("   'Develop a user management system...'");

    let idea = DefaultInput::Idea {
        content: "Develop a user management system with \
                  registration, login, and role-based access control"
            .to_string(),
        priority: None,
        metadata: None,
    };

    input_tx.send(idea).await?;

    // Receive responses
    info!("📤 Receiving Secretary Agent response:\n");

    let mut interval = tokio::time::interval(
        tokio::time::Duration::from_millis(100)
    );
    let timeout = tokio::time::sleep(
        tokio::time::Duration::from_secs(10)
    );
    tokio::pin!(timeout);

    let mut received_welcome = false;
    let mut received_response = false;

    loop {
        tokio::select! {
            _ = &mut timeout => {
                info!("   ⏰ Timeout reached");
                break;
            },
            _ = interval.tick() => {
                match output_rx.try_recv() {
                    Ok(result) => {
                        match result {
                            DefaultOutput::Message { content } => {
                                if content.contains("Welcome") {
                                    info!("   💬 Welcome: {}", content);
                                    received_welcome = true;
                                } else {
                                    info!("   💬 Message: {}", content);
                                }
                            },
                            DefaultOutput::Acknowledgment { message } => {
                                info!("   ✅ Ack: {}", message);
                                received_response = true;
                            },
                            DefaultOutput::DecisionRequired { decision } => {
                                info!("   ⏸️  Decision: {}", 
                                    decision.description);
                                received_response = true;
                            },
                            _ => {}
                        }
                    },
                    Err(tokio::sync::mpsc::error::TryRecvError::Disconnected) => {
                        break;
                    },
                    _ => {}
                }

                if received_welcome && received_response {
                    break;
                }
            }
        }
    }

    // Stop agent
    handle.stop().await;
    join_handle.abort();

    info!("\n✅ Example completed!");
    Ok(())
}