use std::{borrow::Cow, sync::Arc};
use crate::claude::config::ClaudeConfig;
use crate::claude::types::{ClaudeMessage, ClaudeRequest, ClaudeResponse};
use reqwest::header::HeaderMap;
const API_BASE: &str = "https://api.anthropic.com/v1";
#[derive(Clone)]
pub struct ClaudeApiClient {
 client: reqwest::Client,
 config: Arc<ClaudeConfig>,
}
impl ClaudeApiClient {
 pub fn init(config: ClaudeConfig) -> anyhow::Result<Self> {
 let mut headers = HeaderMap::new();
 // Add authentication
 headers.insert("x-api-key", config.api_key.parse()?);
 headers.insert("content-type", "application/json".parse().unwrap());
 headers.insert("anthropic-version", "2023-06-01".parse().unwrap());
 // reqwest client
 let client = reqwest::Client::builder()
 .default_headers(headers)
 .build()?;
 // self
 Ok(Self {
 client,
 config: Arc::new(config),
 })
 }
 pub async fn send_message(
 &self,
 tools: &[serde_json::Value],
 messages: Vec<ClaudeMessage<'_>>,
 system_prompt: &str,
 ) -> Result<ClaudeResponse<'static>, tonic::Status> {
 // Create the request from the config
 let request = ClaudeRequest {
 model: Cow::Borrowed(self.config.model),
 max_tokens: self.config.max_tokens,
 messages,
 system: Some(Cow::Borrowed(system_prompt)),
 temperature: self.config.temperature,
 top_p: self.config.top_p,
 top_k: self.config.top_k,
 tools: Some(Cow::Borrowed(tools)),
 };
 // Send the request
 let res = self
 .client
 .post(format!("{}/messages", API_BASE))
 .json(&request)
 .send()
 .await
 .map_err(|e| {
 tracing::warn!("Failed to send request to Claude API: {}", e);
 tonic::Status::unavailable("Failed to connect to Claude API")
 })?;
 // Parse if success
 let status_code = res.status();
 if status_code.is_success() {
 let text = res.text().await.map_err(|e| {
 tracing::warn!("Failed to read response text: {}", e);
 tonic::Status::internal("Failed to read response text")
 })?;
 return serde_json::from_str::<ClaudeResponse<'static>>(&text)
 .inspect_err(|err| tracing::warn!("Failed to parse Claude api response {err}"))
 .map_err(|_| tonic::Status::internal("Failed to parse Claude api response"));
 }
 let error_text = res.text().await.unwrap_or_else(|e| {
 tracing::warn!("Failed to read error response: {}", e);
 "Unknown error".to_string()
 });
 // Log the full error details internally
 tracing::error!(
 status_code = %status_code,
 response_body = %error_text,
 model = %self.config.model,
 "Claude API request failed"
 );
 // Map to appropriate tonic::Status based on status code
 match status_code.as_u16() {
 429 => Err(tonic::Status::resource_exhausted(
 "Claude API Rate limit exceeded",
 )),
 500..=599 => Err(tonic::Status::unavailable("Claude API is unavailable")),
 _ => Err(tonic::Status::internal("Claude API error")),
 }
 }
}
#[derive(Debug, serde::Serialize, serde::Deserialize, Default)]
pub struct ClaudeConfig {
 pub api_key: Cow<'static, str>,
 pub model: &'static str,
 pub max_tokens: u32,
 pub temperature: Option<f32>,
 pub top_p: Option<f32>,
 pub top_k: Option<u32>,
}