use serde::{Deserialize, Serialize};
use reqwest::Client;
use anyhow::{Result, Context};
use std::collections::HashMap;

#[derive(Debug, Serialize)]
pub struct EvalRequest {
    pub run_id: String,
    pub preamble: String,
    pub prompt: String,
    pub model_ref: ModelRef,
    pub log_meta: HashMap<String, serde_json::Value>,
}

#[derive(Debug, Serialize)]
pub struct ModelRef {
    pub provider_id: String,
    pub model_name: String,
}

#[derive(Debug, Deserialize)]
pub struct EvalResponse {
    pub response: String,
    pub token_usage: Option<TokenUsage>,
    pub run_id: String,
}

#[derive(Debug, Deserialize)]
pub struct TokenUsage {
    pub prompt_tokens: u32,
    pub completion_tokens: u32,
    pub total_tokens: u32,
}

#[derive(Debug, Serialize)]
pub struct CreateAgentRequest {
    pub name: String,
    pub preamble: String,
    pub description: Option<String>,
}

#[derive(Debug, Deserialize)]
pub struct Agent {
    pub id: String,
    pub name: String,
    pub description: Option<String>,
    pub preamble: String,
    pub created_at: String,
    pub updated_at: String,
}

pub struct CoAgentClient {
    client: Client,
    base_url: String,
}

impl CoAgentClient {
    pub fn new(base_url: String) -> Self {
        let client = Client::new();
        Self { client, base_url }
    }
    
    pub async fn eval(&self, request: EvalRequest) -> Result<EvalResponse> {
        let url = format!("{}/evals", self.base_url);
        
        let response = self.client
            .post(&url)
            .json(&request)
            .send()
            .await
            .context("Failed to send eval request")?;
        
        if response.status().is_success() {
            let eval_response: EvalResponse = response
                .json()
                .await
                .context("Failed to parse eval response")?;
            Ok(eval_response)
        } else {
            let status = response.status();
            let error_text = response.text().await.unwrap_or_default();
            anyhow::bail!("API error {}: {}", status, error_text);
        }
    }
    
    pub async fn create_agent(&self, request: CreateAgentRequest) -> Result<Agent> {
        let url = format!("{}/agents", self.base_url);
        
        let response = self.client
            .post(&url)
            .json(&request)
            .send()
            .await
            .context("Failed to send create agent request")?;
        
        if response.status().is_success() {
            let agent: Agent = response
                .json()
                .await
                .context("Failed to parse agent response")?;
            Ok(agent)
        } else {
            let status = response.status();
            let error_text = response.text().await.unwrap_or_default();
            anyhow::bail!("API error {}: {}", status, error_text);
        }
    }
    
    pub async fn list_agents(&self) -> Result<Vec<Agent>> {
        let url = format!("{}/agents", self.base_url);
        
        let response = self.client
            .get(&url)
            .send()
            .await
            .context("Failed to send list agents request")?;
        
        if response.status().is_success() {
            #[derive(Deserialize)]
            struct AgentsResponse {
                agents: Vec<Agent>,
            }
            
            let agents_response: AgentsResponse = response
                .json()
                .await
                .context("Failed to parse agents response")?;
            Ok(agents_response.agents)
        } else {
            let status = response.status();
            let error_text = response.text().await.unwrap_or_default();
            anyhow::bail!("API error {}: {}", status, error_text);
        }
    }
}

// Usage example
#[tokio::main]
async fn main() -> Result<()> {
    let client = CoAgentClient::new("http://localhost:3000/api/v1".to_string());
    
    // Create an evaluation
    let eval_request = EvalRequest {
        run_id: "eval_12345".to_string(),
        preamble: "You are a helpful assistant.".to_string(),
        prompt: "What are your business hours?".to_string(),
        model_ref: ModelRef {
            provider_id: "openai-prod".to_string(),
            model_name: "gpt-4".to_string(),
        },
        log_meta: {
            let mut meta = HashMap::new();
            meta.insert("component".to_string(), serde_json::Value::String("customer-service".to_string()));
            meta
        },
    };
    
    let eval_result = client.eval(eval_request).await?;
    println!("Response: {}", eval_result.response);
    if let Some(token_usage) = eval_result.token_usage {
        println!("Tokens used: {}", token_usage.total_tokens);
    }
    
    // Create an agent
    let agent_request = CreateAgentRequest {
        name: "support-agent".to_string(),
        preamble: "You are a customer support specialist.".to_string(),
        description: Some("Handles customer inquiries".to_string()),
    };
    
    let agent = client.create_agent(agent_request).await?;
    println!("Created agent: {}", agent.id);
    
    Ok(())
}

use uuid::Uuid;
let run_id = Uuid::new_v4().to_string();

use backoff::{future::retry, ExponentialBackoff};

let result = retry(ExponentialBackoff::default(), || async {
    match client.eval(request.clone()).await {
        Ok(response) => Ok(response),
        Err(e) if should_retry(&e) => Err(backoff::Error::transient(e)),
        Err(e) => Err(backoff::Error::permanent(e)),
    }
}).await?;

env_logger::init();