vynfi 0.2.0

use std::time::Duration;

use reqwest::{Response, StatusCode};
use serde::de::DeserializeOwned;
use serde_json::Value;

use crate::error::{ErrorBody, VynFiError};
use crate::resources::{ApiKeys, Catalog, Credits, Jobs, Usage};

const DEFAULT_BASE_URL: &str = "https://api.vynfi.com";
const DEFAULT_TIMEOUT_SECS: u64 = 30;
const DEFAULT_MAX_RETRIES: u32 = 2;
const USER_AGENT: &str = concat!("vynfi-rust/", env!("CARGO_PKG_VERSION"));

/// Async VynFi API client.
///
/// Created via [`Client::builder`]. Holds a connection pool internally and is
/// cheap to clone — share a single instance across tasks.
#[derive(Clone)]
pub struct Client {
    http: reqwest::Client,
    base_url: String,
    max_retries: u32,
}

impl Client {
    /// Returns a [`ClientBuilder`] that accepts an API key.
    ///
    /// ```no_run
    /// # use vynfi::Client;
    /// let client = Client::builder("vf_live_abc123").build().unwrap();
    /// ```
    pub fn builder(api_key: impl Into<String>) -> ClientBuilder {
        ClientBuilder::new(api_key)
    }

    // -- Resource accessors ---------------------------------------------------
    // Each returns a lightweight handle that borrows `&self`.

    /// Jobs resource — submit, list, get, and download generation jobs.
    pub fn jobs(&self) -> Jobs<'_> {
        Jobs::new(self)
    }

    /// Catalog resource — list sectors and tables.
    pub fn catalog(&self) -> Catalog<'_> {
        Catalog::new(self)
    }

    /// Usage resource — credit balance and daily usage breakdown.
    pub fn usage(&self) -> Usage<'_> {
        Usage::new(self)
    }

    /// API-key management resource.
    pub fn api_keys(&self) -> ApiKeys<'_> {
        ApiKeys::new(self)
    }

    /// Credits resource — purchase packs and view prepaid balance.
    pub fn credits(&self) -> Credits<'_> {
        Credits::new(self)
    }

    // -- Internal request helpers (used by resource structs) ------------------

    /// Make a JSON request (no body) with retry logic.
    pub(crate) async fn request<T: DeserializeOwned>(
        &self,
        method: reqwest::Method,
        path: &str,
    ) -> Result<T, VynFiError> {
        self.request_with_body::<T, ()>(method, path, None).await
    }

    /// Make a JSON request with an optional body and retry logic.
    pub(crate) async fn request_with_body<T, B>(
        &self,
        method: reqwest::Method,
        path: &str,
        body: Option<&B>,
    ) -> Result<T, VynFiError>
    where
        T: DeserializeOwned,
        B: serde::Serialize,
    {
        let url = format!("{}{}", self.base_url, path);
        let mut last_err: Option<VynFiError> = None;

        for attempt in 0..=self.max_retries {
            let mut req = self.http.request(method.clone(), &url);
            if let Some(b) = body {
                req = req.json(b);
            }

            let resp = match req.send().await {
                Ok(r) => r,
                Err(e) => {
                    last_err = Some(VynFiError::Http(e));
                    if attempt < self.max_retries {
                        tokio::time::sleep(Self::backoff(attempt)).await;
                        continue;
                    }
                    return Err(last_err.unwrap());
                }
            };

            let status = resp.status();

            // Retry on 429 (rate-limited) and 5xx (server errors).
            if Self::should_retry(status) && attempt < self.max_retries {
                let retry_after = resp
                    .headers()
                    .get("retry-after")
                    .and_then(|v| v.to_str().ok())
                    .and_then(|v| v.parse::<u64>().ok())
                    .map(Duration::from_secs);

                let wait = retry_after.unwrap_or_else(|| Self::backoff(attempt));
                // Consume the body so the connection can be reused.
                let _ = resp.bytes().await;
                tokio::time::sleep(wait).await;
                continue;
            }

            // 204 No Content — synthesize a null value so `()` and other
            // `Deserialize`-from-null types work seamlessly.
            if status == StatusCode::NO_CONTENT {
                return serde_json::from_value(serde_json::Value::Null).map_err(VynFiError::from);
            }

            if status.is_client_error() || status.is_server_error() {
                return Err(Self::error_from_response(resp).await);
            }

            let bytes = resp.bytes().await?;
            return serde_json::from_slice(&bytes).map_err(VynFiError::from);
        }

        Err(last_err.unwrap_or_else(|| VynFiError::Config("max retries exceeded".into())))
    }

    /// Make a JSON request with query parameters and retry logic.
    pub(crate) async fn request_with_params<T: DeserializeOwned>(
        &self,
        method: reqwest::Method,
        path: &str,
        params: &[(&str, String)],
    ) -> Result<T, VynFiError> {
        let url = format!("{}{}", self.base_url, path);
        let mut last_err: Option<VynFiError> = None;

        for attempt in 0..=self.max_retries {
            let resp = match self
                .http
                .request(method.clone(), &url)
                .query(params)
                .send()
                .await
            {
                Ok(r) => r,
                Err(e) => {
                    last_err = Some(VynFiError::Http(e));
                    if attempt < self.max_retries {
                        tokio::time::sleep(Self::backoff(attempt)).await;
                        continue;
                    }
                    return Err(last_err.unwrap());
                }
            };

            let status = resp.status();

            if Self::should_retry(status) && attempt < self.max_retries {
                let _ = resp.bytes().await;
                tokio::time::sleep(Self::backoff(attempt)).await;
                continue;
            }

            if status.is_client_error() || status.is_server_error() {
                return Err(Self::error_from_response(resp).await);
            }

            let bytes = resp.bytes().await?;
            return serde_json::from_slice(&bytes).map_err(VynFiError::from);
        }

        Err(last_err.unwrap_or_else(|| VynFiError::Config("max retries exceeded".into())))
    }

    // -- Private helpers ------------------------------------------------------

    fn should_retry(status: StatusCode) -> bool {
        status == StatusCode::TOO_MANY_REQUESTS || status.is_server_error()
    }

    /// Exponential back-off: 500ms, 1s, 2s, ...
    fn backoff(attempt: u32) -> Duration {
        Duration::from_millis(500 * 2u64.pow(attempt))
    }

    /// Convert an error HTTP response into the appropriate [`VynFiError`]
    /// variant based on its status code.
    async fn error_from_response(resp: Response) -> VynFiError {
        let status = resp.status();
        let body: ErrorBody = resp.json().await.unwrap_or_else(|_| ErrorBody {
            error_type: String::new(),
            title: String::new(),
            detail: String::new(),
            status: status.as_u16(),
            request_id: String::new(),
            fields: vec![],
        });

        let body = Box::new(body);
        match status {
            StatusCode::UNAUTHORIZED => VynFiError::Authentication(body),
            StatusCode::PAYMENT_REQUIRED => VynFiError::InsufficientCredits(body),
            StatusCode::FORBIDDEN => VynFiError::Forbidden(body),
            StatusCode::NOT_FOUND => VynFiError::NotFound(body),
            StatusCode::CONFLICT => VynFiError::Conflict(body),
            StatusCode::UNPROCESSABLE_ENTITY => VynFiError::Validation(body),
            StatusCode::TOO_MANY_REQUESTS => VynFiError::RateLimit(body),
            _ => VynFiError::Server(body),
        }
    }
}

/// Builder for configuring and constructing a [`Client`].
///
/// ```no_run
/// # use vynfi::Client;
/// # use std::time::Duration;
/// let client = Client::builder("vf_live_abc123")
///     .base_url("https://staging-api.vynfi.com")
///     .timeout(Duration::from_secs(60))
///     .max_retries(3)
///     .build()
///     .unwrap();
/// ```
pub struct ClientBuilder {
    api_key: String,
    base_url: String,
    timeout: Duration,
    max_retries: u32,
}

impl ClientBuilder {
    fn new(api_key: impl Into<String>) -> Self {
        Self {
            api_key: api_key.into(),
            base_url: DEFAULT_BASE_URL.to_string(),
            timeout: Duration::from_secs(DEFAULT_TIMEOUT_SECS),
            max_retries: DEFAULT_MAX_RETRIES,
        }
    }

    /// Override the base URL (trailing slashes are stripped).
    pub fn base_url(mut self, url: impl Into<String>) -> Self {
        self.base_url = url.into().trim_end_matches('/').to_string();
        self
    }

    /// Set the request timeout (default: 30 s).
    pub fn timeout(mut self, timeout: Duration) -> Self {
        self.timeout = timeout;
        self
    }

    /// Set the maximum number of automatic retries on 429 / 5xx (default: 2).
    pub fn max_retries(mut self, retries: u32) -> Self {
        self.max_retries = retries;
        self
    }

    /// Build the [`Client`]. Returns an error if the API key is empty or the
    /// underlying HTTP client cannot be constructed.
    pub fn build(self) -> Result<Client, VynFiError> {
        if self.api_key.is_empty() {
            return Err(VynFiError::Config("api_key is required".into()));
        }

        let mut headers = reqwest::header::HeaderMap::new();
        headers.insert(
            reqwest::header::AUTHORIZATION,
            format!("Bearer {}", self.api_key)
                .parse()
                .expect("valid authorization header value"),
        );
        headers.insert(
            reqwest::header::USER_AGENT,
            USER_AGENT.parse().expect("valid user-agent header value"),
        );
        headers.insert(
            reqwest::header::CONTENT_TYPE,
            "application/json"
                .parse()
                .expect("valid content-type header value"),
        );

        let http = reqwest::Client::builder()
            .default_headers(headers)
            .timeout(self.timeout)
            .build()?;

        Ok(Client {
            http,
            base_url: self.base_url,
            max_retries: self.max_retries,
        })
    }
}

/// Extract a `Vec<T>` from an API response that may be a bare JSON array or an
/// object wrapping the array under `"data"` or another key.
pub(crate) fn extract_list<T: DeserializeOwned>(value: Value) -> Result<Vec<T>, VynFiError> {
    if value.is_array() {
        return Ok(serde_json::from_value(value)?);
    }
    if let Some(obj) = value.as_object() {
        // Try "data" first, then the first array-valued key.
        if let Some(arr) = obj.get("data").filter(|v| v.is_array()) {
            return Ok(serde_json::from_value(arr.clone())?);
        }
        for v in obj.values() {
            if v.is_array() {
                return Ok(serde_json::from_value(v.clone())?);
            }
        }
    }
    Ok(vec![])
}