proofgate 0.1.1

//! ProofGate SDK client implementation.

use crate::{
    AgentCheckResponse, Error, EvidenceResponse, UsageResponse, ValidateRequest, ValidateResponse,
};
use reqwest::Client;
use std::time::Duration;

/// Configuration for ProofGate client.
#[derive(Debug, Clone)]
pub struct ProofGateConfig {
    /// API key from ProofGate dashboard (starts with pg_)
    pub api_key: String,
    /// Base URL for API
    pub base_url: String,
    /// Default chain ID (8453 = Base)
    pub chain_id: u64,
    /// Default guardrail ID to use for validations
    pub guardrail_id: Option<String>,
    /// Request timeout
    pub timeout: Duration,
}

impl Default for ProofGateConfig {
    fn default() -> Self {
        Self {
            api_key: String::new(),
            base_url: "https://www.proofgate.xyz/api".to_string(),
            chain_id: 8453,
            guardrail_id: None,
            timeout: Duration::from_secs(30),
        }
    }
}

/// ProofGate SDK client.
///
/// # Example
///
/// ```rust,no_run
/// use proofgate::{ProofGate, ValidateRequest};
///
/// #[tokio::main]
/// async fn main() -> Result<(), proofgate::Error> {
///     let pg = ProofGate::new("pg_your_api_key")?;
///
///     let result = pg.validate(ValidateRequest {
///         from: "0xAgent...".to_string(),
///         to: "0xContract...".to_string(),
///         data: "0xa9059cbb...".to_string(),
///         value: Some("0".to_string()),
///         guardrail_id: None,
///         chain_id: None,
///     }).await?;
///
///     if result.safe {
///         println!("Transaction approved!");
///     } else {
///         println!("Blocked: {}", result.reason);
///     }
///
///     Ok(())
/// }
/// ```
pub struct ProofGate {
    config: ProofGateConfig,
    client: Client,
}

impl ProofGate {
    /// Create a new ProofGate client with an API key.
    ///
    /// # Arguments
    ///
    /// * `api_key` - API key from ProofGate dashboard (starts with `pg_`)
    ///
    /// # Errors
    ///
    /// Returns `Error::MissingApiKey` if the API key is empty.
    /// Returns `Error::InvalidApiKey` if the API key doesn't start with `pg_`.
    pub fn new(api_key: &str) -> Result<Self, Error> {
        Self::with_config(ProofGateConfig {
            api_key: api_key.to_string(),
            ..Default::default()
        })
    }

    /// Create a new ProofGate client with custom configuration.
    ///
    /// # Arguments
    ///
    /// * `config` - Client configuration
    ///
    /// # Errors
    ///
    /// Returns `Error::MissingApiKey` if the API key is empty.
    /// Returns `Error::InvalidApiKey` if the API key doesn't start with `pg_`.
    pub fn with_config(config: ProofGateConfig) -> Result<Self, Error> {
        if config.api_key.is_empty() {
            return Err(Error::MissingApiKey);
        }

        if !config.api_key.starts_with("pg_") {
            return Err(Error::InvalidApiKey);
        }

        let client = Client::builder()
            .timeout(config.timeout)
            .build()
            .map_err(Error::NetworkError)?;

        Ok(Self { config, client })
    }

    /// Validate a transaction before execution.
    ///
    /// # Arguments
    ///
    /// * `request` - Transaction details to validate
    ///
    /// # Returns
    ///
    /// Validation result with detailed checks.
    ///
    /// # Example
    ///
    /// ```rust,no_run
    /// # use proofgate::{ProofGate, ValidateRequest};
    /// # async fn example() -> Result<(), proofgate::Error> {
    /// let pg = ProofGate::new("pg_xxx")?;
    /// let result = pg.validate(ValidateRequest {
    ///     from: "0xAgent...".to_string(),
    ///     to: "0xUniswap...".to_string(),
    ///     data: "0x38ed1739...".to_string(), // swap calldata
    ///     value: None,
    ///     guardrail_id: None,
    ///     chain_id: None,
    /// }).await?;
    ///
    /// if result.safe {
    ///     // Execute the swap
    /// } else {
    ///     println!("Blocked: {}", result.reason);
    /// }
    /// # Ok(())
    /// # }
    /// ```
    pub async fn validate(&self, request: ValidateRequest) -> Result<ValidateResponse, Error> {
        let url = format!("{}/validate", self.config.base_url);

        let mut body = serde_json::json!({
            "from": request.from,
            "to": request.to,
            "data": request.data,
            "value": request.value.unwrap_or_else(|| "0".to_string()),
            "chainId": request.chain_id.unwrap_or(self.config.chain_id),
        });

        if let Some(guardrail_id) = request.guardrail_id.or(self.config.guardrail_id.clone()) {
            body["guardrailId"] = serde_json::Value::String(guardrail_id);
        }

        let response = self
            .client
            .post(&url)
            .header("Content-Type", "application/json")
            .header("X-API-Key", &self.config.api_key)
            .json(&body)
            .send()
            .await?;

        let status = response.status();
        if !status.is_success() {
            let error_body: serde_json::Value = response.json().await.unwrap_or_default();
            return Err(Error::ApiError {
                status: status.as_u16(),
                message: error_body["error"]
                    .as_str()
                    .or(error_body["message"].as_str())
                    .unwrap_or("Unknown error")
                    .to_string(),
            });
        }

        Ok(response.json().await?)
    }

    /// Validate and return error if unsafe (convenience method).
    ///
    /// # Arguments
    ///
    /// * `request` - Transaction details to validate
    ///
    /// # Returns
    ///
    /// Validation result (only if safe).
    ///
    /// # Errors
    ///
    /// Returns `Error::ValidationFailed` if the transaction is not safe.
    ///
    /// # Example
    ///
    /// ```rust,no_run
    /// # use proofgate::{ProofGate, ValidateRequest, Error};
    /// # async fn example() -> Result<(), Error> {
    /// let pg = ProofGate::new("pg_xxx")?;
    ///
    /// match pg.validate_or_throw(ValidateRequest {
    ///     from: "0xAgent...".to_string(),
    ///     to: "0xContract...".to_string(),
    ///     data: "0x...".to_string(),
    ///     value: None,
    ///     guardrail_id: None,
    ///     chain_id: None,
    /// }).await {
    ///     Ok(result) => {
    ///         // Safe to execute
    ///     }
    ///     Err(Error::ValidationFailed { reason, .. }) => {
    ///         println!("Blocked: {}", reason);
    ///     }
    ///     Err(e) => return Err(e),
    /// }
    /// # Ok(())
    /// # }
    /// ```
    pub async fn validate_or_throw(
        &self,
        request: ValidateRequest,
    ) -> Result<ValidateResponse, Error> {
        let result = self.validate(request).await?;

        if !result.safe {
            return Err(Error::ValidationFailed {
                reason: result.reason.clone(),
                result: Box::new(result),
            });
        }

        Ok(result)
    }

    /// Check an agent's trust score and verification status.
    ///
    /// # Arguments
    ///
    /// * `wallet` - Agent wallet address
    ///
    /// # Returns
    ///
    /// Agent verification info including trust score and tier.
    ///
    /// # Example
    ///
    /// ```rust,no_run
    /// # use proofgate::{ProofGate, VerificationStatus};
    /// # async fn example() -> Result<(), proofgate::Error> {
    /// let pg = ProofGate::new("pg_xxx")?;
    /// let agent = pg.check_agent("0x123...").await?;
    ///
    /// if agent.verification_status == VerificationStatus::Verified {
    ///     println!("Trusted agent: {} {}/100", agent.tier_emoji, agent.trust_score);
    /// } else {
    ///     println!("Warning: Unverified agent");
    /// }
    /// # Ok(())
    /// # }
    /// ```
    pub async fn check_agent(&self, wallet: &str) -> Result<AgentCheckResponse, Error> {
        let url = format!("{}/agents/check?wallet={}", self.config.base_url, wallet);

        let response = self
            .client
            .get(&url)
            .header("X-API-Key", &self.config.api_key)
            .send()
            .await?;

        let status = response.status();
        if !status.is_success() {
            let error_body: serde_json::Value = response.json().await.unwrap_or_default();
            return Err(Error::ApiError {
                status: status.as_u16(),
                message: error_body["error"]
                    .as_str()
                    .unwrap_or("Unknown error")
                    .to_string(),
            });
        }

        Ok(response.json().await?)
    }

    /// Get evidence for a past validation.
    ///
    /// # Arguments
    ///
    /// * `validation_id` - Validation ID
    ///
    /// # Returns
    ///
    /// Evidence details including transaction and proof metadata.
    ///
    /// # Example
    ///
    /// ```rust,no_run
    /// # use proofgate::ProofGate;
    /// # async fn example() -> Result<(), proofgate::Error> {
    /// let pg = ProofGate::new("pg_xxx")?;
    /// let evidence = pg.get_evidence("val_abc123").await?;
    /// println!("Transaction: {:?}", evidence.transaction);
    /// println!("Result: {:?}", evidence.result);
    /// # Ok(())
    /// # }
    /// ```
    pub async fn get_evidence(&self, validation_id: &str) -> Result<EvidenceResponse, Error> {
        let url = format!("{}/evidence/{}", self.config.base_url, validation_id);

        let response = self
            .client
            .get(&url)
            .header("X-API-Key", &self.config.api_key)
            .send()
            .await?;

        let status = response.status();
        if !status.is_success() {
            let error_body: serde_json::Value = response.json().await.unwrap_or_default();
            return Err(Error::ApiError {
                status: status.as_u16(),
                message: error_body["error"]
                    .as_str()
                    .unwrap_or("Unknown error")
                    .to_string(),
            });
        }

        Ok(response.json().await?)
    }

    /// Get validation usage stats for a wallet.
    ///
    /// # Arguments
    ///
    /// * `wallet` - Wallet address
    ///
    /// # Returns
    ///
    /// Usage statistics including validations used and limit.
    pub async fn get_usage(&self, wallet: &str) -> Result<UsageResponse, Error> {
        let url = format!("{}/validate?wallet={}", self.config.base_url, wallet);

        let response = self
            .client
            .get(&url)
            .header("X-API-Key", &self.config.api_key)
            .send()
            .await?;

        let status = response.status();
        if !status.is_success() {
            let error_body: serde_json::Value = response.json().await.unwrap_or_default();
            return Err(Error::ApiError {
                status: status.as_u16(),
                message: error_body["error"]
                    .as_str()
                    .unwrap_or("Unknown error")
                    .to_string(),
            });
        }

        Ok(response.json().await?)
    }
}

/// Quick validation helper function.
///
/// # Arguments
///
/// * `api_key` - ProofGate API key
/// * `from` - Sender address
/// * `to` - Target contract address
/// * `data` - Transaction calldata
///
/// # Returns
///
/// Whether the transaction is safe.
///
/// # Example
///
/// ```rust,no_run
/// use proofgate::is_transaction_safe;
///
/// # async fn example() -> Result<(), proofgate::Error> {
/// let safe = is_transaction_safe(
///     "pg_xxx",
///     "0xAgent...",
///     "0xContract...",
///     "0xa9059cbb...",
/// ).await?;
///
/// if safe {
///     // Execute transaction
/// }
/// # Ok(())
/// # }
/// ```
pub async fn is_transaction_safe(
    api_key: &str,
    from: &str,
    to: &str,
    data: &str,
) -> Result<bool, Error> {
    let pg = ProofGate::new(api_key)?;
    let result = pg
        .validate(ValidateRequest {
            from: from.to_string(),
            to: to.to_string(),
            data: data.to_string(),
            value: None,
            guardrail_id: None,
            chain_id: None,
        })
        .await?;
    Ok(result.safe)
}