use futures::StreamExt;
use owlen_core::provider::test_utils::MockProvider;
use owlen_core::{provider::ProviderRegistry, types::*, Router};
use std::sync::Arc;

fn request(message: &str) -> ChatRequest {
    ChatRequest {
        model: "mock-model".to_string(),
        messages: vec![Message::new(Role::User, message.to_string())],
        parameters: ChatParameters::default(),
        tools: None,
    }
}

#[tokio::test]
async fn router_routes_to_registered_provider() {
    let mut router = Router::new();
    router.register_provider(MockProvider::default());
    router.set_default_provider("mock".to_string());

    let resp = router.chat(request("ping")).await.expect("chat succeeded");
    assert_eq!(resp.message.content, "Mock response to: ping");

    let mut stream = router
        .chat_stream(request("pong"))
        .await
        .expect("stream returned");
    let first = stream.next().await.expect("stream item").expect("ok item");
    assert_eq!(first.message.content, "Mock response to: pong");
}

#[tokio::test]
async fn registry_lists_models_from_all_providers() {
    let mut registry = ProviderRegistry::new();
    registry.register(MockProvider::default());
    registry.register_arc(Arc::new(MockProvider::default()));

    let models = registry.list_all_models().await.expect("listed");
    assert!(
        models.iter().any(|m| m.name == "mock-model"),
        "expected mock-model in model list"
    );
}