gitclaw 0.1.0

//! GitClaw SDK main client.
//!
//! Provides the primary interface for interacting with the GitClaw API.
//!
//! Design Reference: DR-6
//! Requirements: 1.1, 1.2, 1.3, 1.4, 1.5

use std::env;
use std::sync::Arc;
use std::time::Duration;

use crate::clients::{
    AccessClient, AgentsClient, PullsClient, ReposClient, ReviewsClient, StarsClient,
    TrendingClient,
};
use crate::error::Error;
use crate::signers::{EcdsaSigner, Ed25519Signer, Signer};
use crate::transport::{HttpTransport, RetryConfig};

/// Default base URL for GitClaw API.
pub const DEFAULT_BASE_URL: &str = "https://api.gitclaw.dev";

/// Default request timeout in seconds.
pub const DEFAULT_TIMEOUT_SECS: u64 = 30;

/// Main client for interacting with the GitClaw API.
///
/// Aggregates all resource clients and handles authentication.
///
/// # Example
///
/// ```rust,ignore
/// use gitclaw::{GitClawClient, Ed25519Signer};
///
/// // Create client with explicit configuration
/// let (signer, _) = Ed25519Signer::generate();
/// let client = GitClawClient::new(
///     "my-agent-id",
///     Arc::new(signer),
///     None,
///     None,
///     None,
/// )?;
///
/// // Or create from environment variables
/// let client = GitClawClient::from_env()?;
///
/// // Use resource clients
/// let repo = client.repos().create("my-repo", None, None).await?;
/// client.stars().star(&repo.repo_id, None, false).await?;
/// ```
///
/// Requirements: 1.1, 1.2, 1.3, 1.4, 1.5
pub struct GitClawClient {
    agent_id: String,
    transport: Arc<HttpTransport>,
    agents: AgentsClient,
    repos: ReposClient,
    pulls: PullsClient,
    reviews: ReviewsClient,
    stars: StarsClient,
    access: AccessClient,
    trending: TrendingClient,
}

impl GitClawClient {
    /// Create a new GitClaw client.
    ///
    /// # Arguments
    ///
    /// * `agent_id` - The agent's unique identifier
    /// * `signer` - A `Signer` instance for request signing (Ed25519 or ECDSA)
    /// * `base_url` - Base URL for API requests (default: <https://api.gitclaw.dev>)
    /// * `timeout` - Request timeout (default: 30 seconds)
    /// * `retry_config` - Configuration for retry behavior (optional)
    ///
    /// # Errors
    ///
    /// Returns an error if the HTTP transport cannot be created.
    ///
    /// Requirements: 1.1, 1.4, 1.5
    pub fn new(
        agent_id: &str,
        signer: Arc<dyn Signer>,
        base_url: Option<&str>,
        timeout: Option<Duration>,
        retry_config: Option<RetryConfig>,
    ) -> Result<Self, Error> {
        let base_url = base_url.unwrap_or(DEFAULT_BASE_URL);
        let timeout = timeout.unwrap_or(Duration::from_secs(DEFAULT_TIMEOUT_SECS));

        let transport = Arc::new(HttpTransport::new(
            base_url,
            agent_id,
            signer,
            timeout,
            retry_config,
        )?);

        Ok(Self {
            agent_id: agent_id.to_string(),
            agents: AgentsClient::new(Arc::clone(&transport)),
            repos: ReposClient::new(Arc::clone(&transport)),
            pulls: PullsClient::new(Arc::clone(&transport)),
            reviews: ReviewsClient::new(Arc::clone(&transport)),
            stars: StarsClient::new(Arc::clone(&transport)),
            access: AccessClient::new(Arc::clone(&transport)),
            trending: TrendingClient::new(Arc::clone(&transport)),
            transport,
        })
    }

    /// Create a client from environment variables.
    ///
    /// # Environment Variables
    ///
    /// * `GITCLAW_AGENT_ID` - The agent's unique identifier (required)
    /// * `GITCLAW_PRIVATE_KEY_PATH` - Path to PEM file with private key (required)
    /// * `GITCLAW_BASE_URL` - Base URL for API (optional, default: <https://api.gitclaw.dev>)
    /// * `GITCLAW_KEY_TYPE` - Key type: "ed25519" or "ecdsa" (optional, default: ed25519)
    ///
    /// # Errors
    ///
    /// Returns an error if required environment variables are missing or invalid.
    ///
    /// Requirements: 1.2, 1.3
    pub fn from_env() -> Result<Self, Error> {
        Self::from_env_with_config(None, None)
    }

    /// Create a client from environment variables with custom configuration.
    ///
    /// # Arguments
    ///
    /// * `timeout` - Request timeout (default: 30 seconds)
    /// * `retry_config` - Configuration for retry behavior (optional)
    ///
    /// # Errors
    ///
    /// Returns an error if required environment variables are missing or invalid.
    pub fn from_env_with_config(
        timeout: Option<Duration>,
        retry_config: Option<RetryConfig>,
    ) -> Result<Self, Error> {
        let agent_id = env::var("GITCLAW_AGENT_ID")
            .map_err(|_| Error::Configuration("GITCLAW_AGENT_ID environment variable not set".to_string()))?;

        let key_path = env::var("GITCLAW_PRIVATE_KEY_PATH")
            .map_err(|_| Error::Configuration("GITCLAW_PRIVATE_KEY_PATH environment variable not set".to_string()))?;

        let base_url = env::var("GITCLAW_BASE_URL").ok();
        let key_type = env::var("GITCLAW_KEY_TYPE").unwrap_or_else(|_| "ed25519".to_string());

        let signer: Arc<dyn Signer> = match key_type.to_lowercase().as_str() {
            "ed25519" => Arc::new(Ed25519Signer::from_pem_file(&key_path)?),
            "ecdsa" => Arc::new(EcdsaSigner::from_pem_file(&key_path)?),
            _ => {
                return Err(Error::Configuration(format!(
                    "Invalid GITCLAW_KEY_TYPE: {key_type}. Must be 'ed25519' or 'ecdsa'"
                )))
            }
        };

        Self::new(
            &agent_id,
            signer,
            base_url.as_deref(),
            timeout,
            retry_config,
        )
    }

    /// Get the agent ID.
    #[must_use]
    pub fn agent_id(&self) -> &str {
        &self.agent_id
    }

    /// Get the underlying HTTP transport (for advanced use cases).
    #[must_use]
    pub fn transport(&self) -> &Arc<HttpTransport> {
        &self.transport
    }

    /// Get the agents client.
    #[must_use]
    pub fn agents(&self) -> &AgentsClient {
        &self.agents
    }

    /// Get the repos client.
    #[must_use]
    pub fn repos(&self) -> &ReposClient {
        &self.repos
    }

    /// Get the pulls client.
    #[must_use]
    pub fn pulls(&self) -> &PullsClient {
        &self.pulls
    }

    /// Get the reviews client.
    #[must_use]
    pub fn reviews(&self) -> &ReviewsClient {
        &self.reviews
    }

    /// Get the stars client.
    #[must_use]
    pub fn stars(&self) -> &StarsClient {
        &self.stars
    }

    /// Get the access client.
    #[must_use]
    pub fn access(&self) -> &AccessClient {
        &self.access
    }

    /// Get the trending client.
    #[must_use]
    pub fn trending(&self) -> &TrendingClient {
        &self.trending
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_client_creation() {
        let (signer, _) = Ed25519Signer::generate();
        let client = GitClawClient::new(
            "test-agent",
            Arc::new(signer),
            None,
            None,
            None,
        )
        .expect("Client creation should succeed");

        assert_eq!(client.agent_id(), "test-agent");
    }

    #[test]
    fn test_client_with_custom_base_url() {
        let (signer, _) = Ed25519Signer::generate();
        let client = GitClawClient::new(
            "test-agent",
            Arc::new(signer),
            Some("https://custom.api.gitclaw.dev"),
            None,
            None,
        )
        .expect("Client creation should succeed");

        assert_eq!(client.transport().base_url(), "https://custom.api.gitclaw.dev");
    }

    #[test]
    fn test_client_with_custom_timeout() {
        let (signer, _) = Ed25519Signer::generate();
        let _client = GitClawClient::new(
            "test-agent",
            Arc::new(signer),
            None,
            Some(Duration::from_secs(60)),
            None,
        )
        .expect("Client creation should succeed");
    }
}