sprites 0.1.0

//! Sprites API client
//!
//! The main entry point for interacting with the Sprites API.

use crate::error::{Error, Result};
use crate::sprite::Sprite;
use crate::types::{
    CreateSpriteRequest, CreateSpriteResponse, ListOptions, ListSpritesResponse, SpriteConfig,
    SpriteInfo, UrlSettings,
};
use serde::{Deserialize, Serialize};
use std::sync::Arc;
use std::time::Duration;

/// Default API base URL
const DEFAULT_BASE_URL: &str = "https://api.sprites.dev";

/// Sprites API client
///
/// # Example
///
/// ```no_run
/// use sprites::SpritesClient;
///
/// #[tokio::main]
/// async fn main() -> Result<(), Box<dyn std::error::Error>> {
///     let client = SpritesClient::new("your-token");
///
///     // List all sprites
///     let sprites = client.list().await?;
///     for sprite in sprites {
///         println!("{}: {:?}", sprite.name, sprite.status);
///     }
///
///     Ok(())
/// }
/// ```
#[derive(Clone)]
pub struct SpritesClient {
    inner: Arc<ClientInner>,
}

struct ClientInner {
    base_url: String,
    token: String,
    http: reqwest::Client,
}

impl SpritesClient {
    /// Create a new client with the given token
    ///
    /// # Example
    ///
    /// ```
    /// use sprites::SpritesClient;
    ///
    /// let client = SpritesClient::new("your-token");
    /// ```
    pub fn new(token: impl Into<String>) -> Self {
        Self::with_base_url(token, DEFAULT_BASE_URL)
    }

    /// Create a new client with a custom base URL
    ///
    /// # Example
    ///
    /// ```
    /// use sprites::SpritesClient;
    ///
    /// let client = SpritesClient::with_base_url("token", "https://custom.api.dev");
    /// ```
    pub fn with_base_url(token: impl Into<String>, base_url: impl Into<String>) -> Self {
        let token = token.into();
        let base_url = base_url.into().trim_end_matches('/').to_string();

        let http = reqwest::Client::new();

        Self {
            inner: Arc::new(ClientInner {
                base_url,
                token,
                http,
            }),
        }
    }

    /// Create a new client with a custom HTTP client
    ///
    /// This allows you to configure timeouts, retries, proxies, etc.
    ///
    /// # Example
    ///
    /// ```no_run
    /// use sprites::SpritesClient;
    /// use std::time::Duration;
    ///
    /// let http = reqwest::Client::builder()
    ///     .timeout(Duration::from_secs(60))
    ///     .build()
    ///     .unwrap();
    ///
    /// let client = SpritesClient::with_http_client("token", http);
    /// ```
    pub fn with_http_client(token: impl Into<String>, http: reqwest::Client) -> Self {
        Self {
            inner: Arc::new(ClientInner {
                base_url: DEFAULT_BASE_URL.to_string(),
                token: token.into(),
                http,
            }),
        }
    }

    /// Create a builder for configuring the client
    ///
    /// # Example
    ///
    /// ```no_run
    /// use sprites::SpritesClient;
    /// use std::time::Duration;
    ///
    /// let client = SpritesClient::builder("your-token")
    ///     .base_url("https://custom.api.dev")
    ///     .timeout(Duration::from_secs(30))
    ///     .build();
    /// ```
    pub fn builder(token: impl Into<String>) -> SpritesClientBuilder {
        SpritesClientBuilder::new(token)
    }

    /// Create a Sprites token from a Fly.io macaroon
    ///
    /// This exchanges Fly.io credentials for a Sprites API token.
    ///
    /// # Example
    ///
    /// ```no_run
    /// use sprites::SpritesClient;
    ///
    /// #[tokio::main]
    /// async fn main() -> Result<(), Box<dyn std::error::Error>> {
    ///     let token = SpritesClient::create_token(
    ///         "your-fly-macaroon",
    ///         "your-org-slug",
    ///         None,
    ///     ).await?;
    ///
    ///     let client = SpritesClient::new(token);
    ///     Ok(())
    /// }
    /// ```
    pub async fn create_token(
        fly_macaroon: &str,
        org_slug: &str,
        invite_code: Option<&str>,
    ) -> Result<String> {
        Self::create_token_with_url(fly_macaroon, org_slug, invite_code, DEFAULT_BASE_URL).await
    }

    /// Create a Sprites token with a custom API URL
    ///
    /// # Example
    ///
    /// ```no_run
    /// use sprites::SpritesClient;
    ///
    /// #[tokio::main]
    /// async fn main() -> Result<(), Box<dyn std::error::Error>> {
    ///     let token = SpritesClient::create_token_with_url(
    ///         "your-fly-macaroon",
    ///         "your-org-slug",
    ///         None,
    ///         "https://custom.api.dev",
    ///     ).await?;
    ///
    ///     let client = SpritesClient::new(token);
    ///     Ok(())
    /// }
    /// ```
    pub async fn create_token_with_url(
        fly_macaroon: &str,
        org_slug: &str,
        invite_code: Option<&str>,
        api_url: &str,
    ) -> Result<String> {
        let http = reqwest::Client::new();
        let url = format!("{}/v1/tokens", api_url.trim_end_matches('/'));

        let mut request = CreateTokenRequest {
            fly_macaroon: fly_macaroon.to_string(),
            org_slug: org_slug.to_string(),
            invite_code: None,
        };

        if let Some(code) = invite_code {
            request.invite_code = Some(code.to_string());
        }

        let response = http.post(&url).json(&request).send().await?;

        let status = response.status();
        if !status.is_success() {
            let message = response.text().await.unwrap_or_default();
            return Err(Error::api(status.as_u16(), message));
        }

        let token_response: CreateTokenResponse = response.json().await?;
        Ok(token_response.token)
    }

    /// Get the base URL
    pub fn base_url(&self) -> &str {
        &self.inner.base_url
    }

    /// Get the token
    pub fn token(&self) -> &str {
        &self.inner.token
    }

    /// Get the HTTP client
    pub(crate) fn http(&self) -> &reqwest::Client {
        &self.inner.http
    }

    /// Build a URL for an API endpoint
    pub(crate) fn url(&self, path: &str) -> String {
        format!("{}/v1{}", self.inner.base_url, path)
    }

    /// Get the authorization header value
    pub(crate) fn auth_header(&self) -> String {
        format!("Bearer {}", self.inner.token)
    }

    /// Get a sprite handle by name
    ///
    /// This does NOT create the sprite on the server. Use [`create`] to create a new sprite.
    ///
    /// # Example
    ///
    /// ```
    /// use sprites::SpritesClient;
    ///
    /// let client = SpritesClient::new("token");
    /// let sprite = client.sprite("my-sprite");
    /// ```
    pub fn sprite(&self, name: impl Into<String>) -> Sprite {
        Sprite::new(self.clone(), name.into())
    }

    /// Create a new sprite
    ///
    /// # Example
    ///
    /// ```no_run
    /// use sprites::SpritesClient;
    ///
    /// #[tokio::main]
    /// async fn main() -> Result<(), Box<dyn std::error::Error>> {
    ///     let client = SpritesClient::new("token");
    ///     let sprite = client.create("my-sprite").await?;
    ///     println!("Created sprite: {}", sprite.name());
    ///     Ok(())
    /// }
    /// ```
    pub async fn create(&self, name: impl Into<String>) -> Result<Sprite> {
        self.create_with_config(name, None, None).await
    }

    /// Create a new sprite with configuration
    pub async fn create_with_config(
        &self,
        name: impl Into<String>,
        config: Option<SpriteConfig>,
        url_settings: Option<UrlSettings>,
    ) -> Result<Sprite> {
        let name = name.into();
        let request = CreateSpriteRequest {
            name: name.clone(),
            config,
            url_settings,
        };

        let response = self
            .http()
            .post(self.url("/sprites"))
            .header("Authorization", self.auth_header())
            .json(&request)
            .send()
            .await?;

        let status = response.status();
        if !status.is_success() {
            let message = response.text().await.unwrap_or_default();
            return Err(Error::api(status.as_u16(), message));
        }

        let _: CreateSpriteResponse = response.json().await?;

        Ok(self.sprite(name))
    }

    /// Get sprite information
    pub async fn get(&self, name: &str) -> Result<SpriteInfo> {
        let response = self
            .http()
            .get(self.url(&format!("/sprites/{name}")))
            .header("Authorization", self.auth_header())
            .send()
            .await?;

        let status = response.status();
        if status == reqwest::StatusCode::NOT_FOUND {
            return Err(Error::not_found(name));
        }
        if !status.is_success() {
            let message = response.text().await.unwrap_or_default();
            return Err(Error::api(status.as_u16(), message));
        }

        let info: SpriteInfo = response.json().await?;
        Ok(info)
    }

    /// List all sprites
    pub async fn list(&self) -> Result<Vec<SpriteInfo>> {
        self.list_all_with_options(ListOptions::default()).await
    }

    /// List sprites with options
    pub async fn list_with_options(&self, options: ListOptions) -> Result<ListSpritesResponse> {
        let mut url = self.url("/sprites");
        let mut query_params = Vec::new();

        if let Some(max) = options.max_results {
            query_params.push(format!("max_results={max}"));
        }
        if let Some(ref token) = options.continuation_token {
            query_params.push(format!("continuation_token={token}"));
        }
        if let Some(ref prefix) = options.prefix {
            query_params.push(format!("prefix={prefix}"));
        }

        if !query_params.is_empty() {
            url = format!("{}?{}", url, query_params.join("&"));
        }

        let response = self.http().get(&url).header("Authorization", self.auth_header()).send().await?;

        let status = response.status();
        if !status.is_success() {
            let message = response.text().await.unwrap_or_default();
            return Err(Error::api(status.as_u16(), message));
        }

        let list: ListSpritesResponse = response.json().await?;
        Ok(list)
    }

    /// List all sprites (handles pagination automatically)
    pub async fn list_all_with_options(&self, options: ListOptions) -> Result<Vec<SpriteInfo>> {
        let mut all_sprites = Vec::new();
        let mut continuation_token = options.continuation_token.clone();

        loop {
            let opts = ListOptions {
                max_results: options.max_results,
                continuation_token: continuation_token.clone(),
                prefix: options.prefix.clone(),
            };

            let response = self.list_with_options(opts).await?;
            all_sprites.extend(response.sprites);

            // Break if no more pages, or if has_more but no continuation token
            // (prevents infinite loop when API returns has_more=true without a token)
            match (response.has_more, response.next_continuation_token) {
                (true, Some(token)) => continuation_token = Some(token),
                _ => break,
            }
        }

        Ok(all_sprites)
    }

    /// Delete a sprite
    pub async fn delete(&self, name: &str) -> Result<()> {
        let response = self
            .http()
            .delete(self.url(&format!("/sprites/{name}")))
            .header("Authorization", self.auth_header())
            .send()
            .await?;

        let status = response.status();
        if status == reqwest::StatusCode::NOT_FOUND {
            return Err(Error::not_found(name));
        }
        if !status.is_success() {
            let message = response.text().await.unwrap_or_default();
            return Err(Error::api(status.as_u16(), message));
        }

        Ok(())
    }

    /// Get server version information
    ///
    /// # Example
    ///
    /// ```no_run
    /// use sprites::SpritesClient;
    ///
    /// #[tokio::main]
    /// async fn main() -> Result<(), Box<dyn std::error::Error>> {
    ///     let client = SpritesClient::new("token");
    ///     let version = client.version().await?;
    ///     println!("Server version: {}", version.version);
    ///     Ok(())
    /// }
    /// ```
    pub async fn version(&self) -> Result<Version> {
        let response = self
            .http()
            .get(self.url("/version"))
            .header("Authorization", self.auth_header())
            .send()
            .await?;

        let status = response.status();
        if !status.is_success() {
            let message = response.text().await.unwrap_or_default();
            return Err(Error::api(status.as_u16(), message));
        }

        let version: Version = response.json().await?;
        Ok(version)
    }
}

impl std::fmt::Debug for SpritesClient {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("SpritesClient")
            .field("base_url", &self.inner.base_url)
            .field("token", &"[REDACTED]")
            .finish()
    }
}

/// Builder for configuring a SpritesClient
///
/// # Example
///
/// ```no_run
/// use sprites::SpritesClient;
/// use std::time::Duration;
///
/// let client = SpritesClient::builder("your-token")
///     .base_url("https://custom.api.dev")
///     .timeout(Duration::from_secs(30))
///     .build();
/// ```
pub struct SpritesClientBuilder {
    token: String,
    base_url: Option<String>,
    http_client: Option<reqwest::Client>,
    timeout: Option<Duration>,
}

impl SpritesClientBuilder {
    /// Create a new builder with the given token
    pub fn new(token: impl Into<String>) -> Self {
        Self {
            token: token.into(),
            base_url: None,
            http_client: None,
            timeout: None,
        }
    }

    /// Set a custom base URL
    pub fn base_url(mut self, url: impl Into<String>) -> Self {
        self.base_url = Some(url.into());
        self
    }

    /// Set a custom HTTP client
    ///
    /// This overrides the timeout setting if both are specified.
    pub fn http_client(mut self, client: reqwest::Client) -> Self {
        self.http_client = Some(client);
        self
    }

    /// Set a request timeout
    ///
    /// This is ignored if a custom HTTP client is provided.
    pub fn timeout(mut self, timeout: Duration) -> Self {
        self.timeout = Some(timeout);
        self
    }

    /// Build the SpritesClient
    pub fn build(self) -> SpritesClient {
        let base_url = self
            .base_url
            .unwrap_or_else(|| DEFAULT_BASE_URL.to_string())
            .trim_end_matches('/')
            .to_string();

        let http = if let Some(client) = self.http_client {
            client
        } else if let Some(timeout) = self.timeout {
            reqwest::Client::builder()
                .timeout(timeout)
                .build()
                .unwrap_or_else(|_| reqwest::Client::new())
        } else {
            reqwest::Client::new()
        };

        SpritesClient {
            inner: Arc::new(ClientInner {
                base_url,
                token: self.token,
                http,
            }),
        }
    }
}

/// Request to create a token from Fly.io credentials
#[derive(Serialize)]
struct CreateTokenRequest {
    fly_macaroon: String,
    org_slug: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    invite_code: Option<String>,
}

/// Response from token creation
#[derive(Deserialize)]
struct CreateTokenResponse {
    token: String,
}

/// Server version information
#[derive(Debug, Clone, Deserialize)]
pub struct Version {
    /// Server version string
    pub version: String,

    /// API version
    #[serde(default)]
    pub api_version: Option<String>,
}

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

    #[test]
    fn test_client_creation() {
        let client = SpritesClient::new("test-token");
        assert_eq!(client.base_url(), DEFAULT_BASE_URL);
    }

    #[test]
    fn test_client_custom_url() {
        let client = SpritesClient::with_base_url("token", "https://custom.api.dev/");
        assert_eq!(client.base_url(), "https://custom.api.dev");
    }

    #[test]
    fn test_url_building() {
        let client = SpritesClient::new("token");
        assert_eq!(
            client.url("/sprites"),
            "https://api.sprites.dev/v1/sprites"
        );
    }
}