//! SyncKit SDK key claim / release / list endpoints.
//!
//! Server-to-server: the developer's backend sends the SyncKit app's
//! `api_key` in the JSON body (no JWT, no session). Each call looks up the
//! app via `db::synckit::get_sync_app_by_api_key`, enforces billing status
//! and (for `per_key` apps) the key cap, then performs the operation.
//!
//! See migration 117 for the underlying `sync_app_keys` schema (active claim
//! is a row with `released_at IS NULL`; the unique index is partial).
//
// TODO Phase 4 integration tests: blocked on migration 117 applied to test DB

use axum::{
    extract::State,
    http::StatusCode,
    response::IntoResponse,
    Json,
};
use serde_json::json;

use crate::{
    db::{self, synckit_billing},
    error::{AppError, Result},
    AppState,
};

use super::{
    ClaimKeyRequest, ClaimKeyResponse, KeyInfo, ListKeysRequest, ListKeysResponse,
    ReleaseKeyRequest, ReleaseKeyResponse,
};

/// `POST /api/sync/keys/claim`: server-to-server SDK key claim.
///
/// Looks up the app by `api_key`, then:
/// - Internal apps bypass all billing checks.
/// - Returns 402 `{ reason: "billing_inactive" }` when billing isn't active.
/// - In `per_key` mode, returns 402
///   `{ reason: "key_limit_reached", key_cap, keys_claimed }` if the cap is
///   reached and the key is not already actively claimed (re-claims are
///   always idempotent OK).
#[tracing::instrument(skip_all, name = "synckit::keys::claim")]
pub(super) async fn claim(
    State(state): State<AppState>,
    Json(req): Json<ClaimKeyRequest>,
) -> Result<axum::response::Response> {
    let app = db::synckit::get_sync_app_by_api_key(&state.db, &req.api_key)
        .await?
        .ok_or(AppError::Unauthorized)?;

    let billing = synckit_billing::get_app_with_billing(&state.db, app.id)
        .await?
        .ok_or(AppError::NotFound)?;

    if !billing.is_internal {
        if billing.billing_status != "active" {
            return Ok((
                StatusCode::PAYMENT_REQUIRED,
                Json(json!({ "reason": "billing_inactive" })),
            )
                .into_response());
        }

        if billing.enforcement_mode == "per_key" {
            let key_cap = billing.key_cap.unwrap_or(0);
            let keys_claimed = billing.keys_claimed.unwrap_or(0);
            if keys_claimed >= key_cap {
                // Re-claim of an already-active key is always OK — it doesn't
                // consume a new slot.
                let already_active = synckit_billing::is_key_actively_claimed(
                    &state.db, app.id, &req.key,
                )
                .await?;
                if !already_active {
                    return Ok((
                        StatusCode::PAYMENT_REQUIRED,
                        Json(json!({
                            "reason": "key_limit_reached",
                            "key_cap": key_cap,
                            "keys_claimed": keys_claimed,
                        })),
                    )
                        .into_response());
                }
            }
        }
    }

    let result = synckit_billing::claim_key(&state.db, app.id, &req.key).await?;
    Ok(Json(ClaimKeyResponse {
        newly_claimed: result.newly_claimed,
        total_claimed: result.total_claimed,
    })
    .into_response())
}

/// `POST /api/sync/keys/release`: server-to-server SDK key release.
///
/// Always permitted (even when the app is canceled or suspended) so that
/// cleanup paths can drain stale claims.
#[tracing::instrument(skip_all, name = "synckit::keys::release")]
pub(super) async fn release(
    State(state): State<AppState>,
    Json(req): Json<ReleaseKeyRequest>,
) -> Result<impl IntoResponse> {
    let app = db::synckit::get_sync_app_by_api_key(&state.db, &req.api_key)
        .await?
        .ok_or(AppError::Unauthorized)?;

    let result = synckit_billing::release_key(&state.db, app.id, &req.key).await?;
    Ok(Json(ReleaseKeyResponse {
        newly_released: result.newly_released,
        total_claimed: result.total_claimed,
    }))
}

/// `POST /api/sync/keys/list`: paginated list of active key claims.
///
/// Uses POST + body (not GET + query) for consistency with `/validate-app`,
/// keeping the api_key out of access logs.
#[tracing::instrument(skip_all, name = "synckit::keys::list")]
pub(super) async fn list(
    State(state): State<AppState>,
    Json(req): Json<ListKeysRequest>,
) -> Result<impl IntoResponse> {
    let app = db::synckit::get_sync_app_by_api_key(&state.db, &req.api_key)
        .await?
        .ok_or(AppError::Unauthorized)?;

    let limit = req.limit.unwrap_or(100).clamp(1, 1000) as i64;
    let offset = req.offset.unwrap_or(0) as i64;

    let rows = synckit_billing::list_active_keys(&state.db, app.id, limit, offset).await?;

    let keys = rows
        .into_iter()
        .map(|r| KeyInfo {
            id: r.id,
            key: r.key,
            claimed_at: r.claimed_at,
            bytes_stored: r.bytes_stored,
        })
        .collect();

    Ok(Json(ListKeysResponse { keys }))
}

#[cfg(test)]
mod tests {
    use super::super::{
        ClaimKeyRequest, ClaimKeyResponse, ListKeysRequest, ListKeysResponse,
        ReleaseKeyRequest, ReleaseKeyResponse,
    };

    #[test]
    fn claim_request_roundtrips() {
        let json = r#"{"api_key":"abc","key":"dev-1"}"#;
        let req: ClaimKeyRequest = serde_json::from_str(json).unwrap();
        assert_eq!(req.api_key, "abc");
        assert_eq!(req.key, "dev-1");
    }

    #[test]
    fn claim_response_roundtrips() {
        let resp = ClaimKeyResponse {
            newly_claimed: true,
            total_claimed: 7,
        };
        let s = serde_json::to_string(&resp).unwrap();
        assert!(s.contains("\"newly_claimed\":true"));
        assert!(s.contains("\"total_claimed\":7"));
    }

    #[test]
    fn release_request_roundtrips() {
        let json = r#"{"api_key":"abc","key":"dev-1"}"#;
        let req: ReleaseKeyRequest = serde_json::from_str(json).unwrap();
        assert_eq!(req.api_key, "abc");
        assert_eq!(req.key, "dev-1");
    }

    #[test]
    fn release_response_roundtrips() {
        let resp = ReleaseKeyResponse {
            newly_released: false,
            total_claimed: 3,
        };
        let s = serde_json::to_string(&resp).unwrap();
        assert!(s.contains("\"newly_released\":false"));
        assert!(s.contains("\"total_claimed\":3"));
    }

    #[test]
    fn list_request_defaults() {
        let json = r#"{"api_key":"abc"}"#;
        let req: ListKeysRequest = serde_json::from_str(json).unwrap();
        assert_eq!(req.api_key, "abc");
        assert!(req.limit.is_none());
        assert!(req.offset.is_none());
    }

    #[test]
    fn list_response_empty_roundtrips() {
        let resp = ListKeysResponse { keys: vec![] };
        let s = serde_json::to_string(&resp).unwrap();
        assert_eq!(s, r#"{"keys":[]}"#);
    }
}