//! Google Gemini driver implementation

use async_trait::async_trait;
use futures::Stream;
use secrecy::{ExposeSecret, SecretString};
use reqwest::Client;
use std::pin::Pin;
use zclaw_types::{Result, ZclawError};

use super::{CompletionRequest, CompletionResponse, ContentBlock, LlmDriver, StopReason};
use crate::stream::StreamChunk;

/// Google Gemini driver
#[allow(dead_code)] // TODO: Implement full Gemini API support
pub struct GeminiDriver {
    client: Client,
    api_key: SecretString,
    base_url: String,
}

impl GeminiDriver {
    pub fn new(api_key: SecretString) -> Self {
        Self {
            client: Client::new(),
            api_key,
            base_url: "https://generativelanguage.googleapis.com/v1beta".to_string(),
        }
    }
}

#[async_trait]
impl LlmDriver for GeminiDriver {
    fn provider(&self) -> &str {
        "gemini"
    }

    fn is_configured(&self) -> bool {
        !self.api_key.expose_secret().is_empty()
    }

    async fn complete(&self, request: CompletionRequest) -> Result<CompletionResponse> {
        // TODO: Implement actual API call
        Ok(CompletionResponse {
            content: vec![ContentBlock::Text {
                text: "Gemini driver not yet implemented".to_string(),
            }],
            model: request.model,
            input_tokens: 0,
            output_tokens: 0,
            stop_reason: StopReason::EndTurn,
        })
    }

    fn stream(
        &self,
        _request: CompletionRequest,
    ) -> Pin<Box<dyn Stream<Item = Result<StreamChunk>> + Send + '_>> {
        // Placeholder - return error stream
        Box::pin(futures::stream::once(async {
            Err(ZclawError::LlmError("Gemini streaming not yet implemented".to_string()))
        }))
    }
}