use std::time::Duration;

use openrouter_rs::{Message, api::chat::ChatCompletionRequest};

pub struct ChatResult {
    pub message: String,
    pub cost: Option<f64>,
}

pub struct OpenRouterClient {
    client: openrouter_rs::OpenRouterClient,
    model: String,
}

impl OpenRouterClient {
    pub fn new(token: &str, model: &str, timeout: u64) -> anyhow::Result<Self> {
        Ok(Self {
            client: openrouter_rs::OpenRouterClient::builder()
                .api_key(token)
                .http_client(
                    reqwest::Client::builder()
                        .timeout(Duration::from_secs(timeout))
                        .build()?,
                )
                .build()?,
            model: String::from(model),
        })
    }

    pub async fn chat(&self, msg: &str) -> anyhow::Result<ChatResult> {
        let request = ChatCompletionRequest::builder()
            .model(&self.model)
            .enable_reasoning()
            .messages(vec![Message::new(openrouter_rs::types::Role::User, msg)])
            .build()?;

        let response = self.client.chat().create(&request).await?;

        Ok(ChatResult {
            message: response.choices[0]
                .content()
                .map(|msg| String::from(msg))
                .ok_or(anyhow::anyhow!("No content"))?,
            cost: response.usage.and_then(|u| u.cost),
        })
    }
}