//! App-level send orchestration: OAuth token caching + one 401 retry.

use std::collections::HashMap;

use super::client::{HttpResponse, send_request};
use super::oauth::{OAuthToken, fetch_token, token_valid};
use crate::model::{OAuthConfig, SavedRequest};

pub struct SendOutcome {
    pub result: Result<HttpResponse, String>,
    /// Latest token cache (unchanged on failure, refreshed on (re)fetch).
    pub token: Option<OAuthToken>,
}

/// Send a request, transparently handling OAuth client-credentials auth:
/// reuse a cached token while valid, fetch one otherwise, and retry the
/// request once with a fresh token on a 401 response.
pub async fn send_with_auth(
    client: &reqwest::Client,
    base_url: &str,
    req: &SavedRequest,
    vars: &HashMap<String, String>,
    auth: Option<&OAuthConfig>,
    cached: Option<OAuthToken>,
) -> SendOutcome {
    let mut token = cached;
    let auth = auth.filter(|c| c.is_configured());

    let mut bearer: Option<String> = None;
    if let Some(cfg) = auth {
        let stale = token.as_ref().map(|t| !token_valid(t)).unwrap_or(true);
        if stale {
            match fetch_token(client, cfg).await {
                Ok(t) => token = Some(t),
                Err(e) => {
                    return SendOutcome {
                        result: Err(format!("token fetch failed: {e:#}")),
                        token,
                    };
                }
            }
        }
        bearer = token.as_ref().map(|t| t.access_token.clone());
    }

    let mut resp = send_request(client, base_url, req, vars, bearer.as_deref())
        .await
        .map_err(|e| format!("{e:#}"));

    if let (Ok(r), Some(cfg)) = (&resp, auth)
        && r.status == 401
        && let Ok(t) = fetch_token(client, cfg).await
    {
        bearer = Some(t.access_token.clone());
        token = Some(t);
        resp = send_request(client, base_url, req, vars, bearer.as_deref())
            .await
            .map_err(|e| format!("{e:#}"));
    }

    SendOutcome {
        result: resp,
        token,
    }
}