// src/routes/posts.rs

// ── Pre-Quota: OAuth Credentials Validation ────────────────────────────
let creds_col = state.db.collection::<UserCredential>("user_credentials");

// Convert the requested platforms to BSON
let platforms_bson: Vec<bson::Bson> = body.platforms.iter()
    .map(|p| bson::to_bson(p).unwrap())
    .collect();

// Query MongoDB for existing credentials
let mut cursor = creds_col.find(doc! {
    "user_id": user_id,
    "platform": { "$in": platforms_bson }
}).await?;

let mut connected_platforms = std::collections::HashSet::new();
use futures_util::TryStreamExt;
while let Ok(Some(cred)) = cursor.try_next().await {
    connected_platforms.insert(cred.platform);
}

// Find exactly which platforms the user is missing
let missing_platforms: Vec<Platform> = body.platforms
    .iter()
    .filter(|&p| !connected_platforms.contains(p))
    .cloned()
    .collect();

if !missing_platforms.is_empty() {
    let names = missing_platforms.iter()
        .map(|p| format!("{:?}", p))
        .collect::<Vec<_>>()
        .join(", ");

    // Reject instantly before quota deduction!
    return Err(AppError::MissingOauth(
        format!("You haven't connected {} to DotSuite Cloud yet.", names),
        missing_platforms,
    ));
}

{
  "error": {
    "code": "MISSING_OAUTH_CREDENTIALS",
    "message": "You haven't connected X, LinkedIn to DotSuite Cloud yet.",
    "missing_platforms": ["x", "linkedin"]
  }
}

// DotShare/src/handlers/PostHandler.ts

const result = await SchedulerClient.schedulePost(context, postData, platforms, scheduledTime);

if (!result.success) {
    if (result.errorCode === 'MISSING_OAUTH_CREDENTIALS') {
        const action = 'Open Dashboard';
        vscode.window.showErrorMessage(
            '☁️ Cloud Scheduling requires secure OAuth. Please open the DotSuite Dashboard to connect your social accounts.',
            action
        ).then(selection => {
            if (selection === action) {
                // Deep link right to the login/integrations page
                const DOTSUITE_LOGIN_URL = `https://dotsuite.dev/en/login?intent=vscode`;
                vscode.env.openExternal(vscode.Uri.parse(DOTSUITE_LOGIN_URL));
            }
        });
    } else {
        vscode.window.showErrorMessage(`Failed: ${result.message}`);
    }
}

// src/scheduler.rs

let now = DateTime::now();

// Check if token expires in less than 5 minutes
if now.timestamp_millis() > oauth_token.expires_at.timestamp_millis() - (5 * 60 * 1000) {
    tracing::info!("Refreshing OAuth token for platform {:?}", cred.platform);

    let refresh_token_str = oauth_token.refresh_token_encrypted.as_deref().unwrap_or("");

    // Fetch API keys from environment
    let cid = std::env::var(format!("{:?}_CLIENT_ID", cred.platform).to_uppercase()).unwrap_or_default();
    let csec = std::env::var(format!("{:?}_CLIENT_SECRET", cred.platform).to_uppercase()).unwrap_or_default();

    // Match the platform to its specific refresh logic via reqwest::Client
    let refresh_result = match cred.platform {
        Platform::X => refresh_x_token(&client, refresh_token_str, &cid, &csec, enc_key).await,
        Platform::LinkedIn => refresh_linkedin_token(&client, refresh_token_str, &cid, &csec, enc_key).await,
        Platform::Facebook => refresh_facebook_token(&client, refresh_token_str, &cid, &csec, enc_key).await,
        Platform::Reddit => refresh_reddit_token(&client, refresh_token_str, &cid, &csec, enc_key).await,
        _ => Err(anyhow::anyhow!("Platform unsupported for auto-refresh")),
    };

    if let Ok((new_access_enc, new_refresh_enc, expires_in)) = refresh_result {
        // 1. Decrypt and use the newly fetched token immediately
        let plain_access = crate::crypto::decrypt_token(&new_access_enc, enc_key).unwrap();
        tokens.insert(cred.platform, plain_access);

        // 2. Save the new encrypted tokens back to MongoDB atomically
        let new_expires_at = DateTime::from_millis(now.timestamp_millis() + (expires_in as i64 * 1000));
        let update_doc = doc! {
            "$set": {
                "oauth_token.access_token_encrypted": new_access_enc,
                "oauth_token.refresh_token_encrypted": if new_refresh_enc.is_empty() { None::<String> } else { Some(new_refresh_enc) },
                "oauth_token.expires_at": new_expires_at,
                "updated_at": DateTime::now(),
            }
        };

        creds_col.update_one(doc! { "_id": cred.id.unwrap() }, update_doc).await.unwrap();
        tracing::info!("✅ Successfully saved refreshed token for {:?}", cred.platform);
    }
}