//! Stripe Checkout session creation and redirect handlers.

mod item;
mod project;
mod subscriptions;
mod tips;
mod cart;

pub(in crate::routes::stripe) use item::{cancel_pending_item_checkout, create_checkout};
pub(crate) use item::grant_bundle_items;
pub(in crate::routes::stripe) use project::create_project_checkout;
pub(in crate::routes::stripe) use subscriptions::{
    cancel_fan_plus, create_creator_tier_checkout, create_fan_plus_checkout,
    create_subscription_checkout, open_billing_portal, resume_fan_plus,
};
pub(in crate::routes::stripe) use tips::create_tip_checkout;
pub(in crate::routes::stripe) use cart::{create_cart_checkout, create_cart_checkout_all};

use axum::{
    extract::{Query, State},
    response::{IntoResponse, Redirect},
};
use serde::Deserialize;
use tower_sessions::Session;

use crate::AppState;

/// Form data for checkout (supports optional promo code).
#[derive(Debug, Deserialize)]
pub(super) struct CheckoutForm {
    pub promo_code: Option<String>,
    #[serde(default)]
    pub share_contact: bool,
    /// PWYW: buyer-chosen amount in cents (only used when item has pwyw_enabled).
    pub amount_cents: Option<i32>,
}

/// Query parameters for the checkout success redirect.
#[derive(Debug, Deserialize)]
pub struct SuccessQuery {
    pub session_id: Option<String>,
    /// Single-item checkout sets this so the success redirect lands on `/l/{id}`
    /// instead of the library index. Cart checkouts leave it unset.
    pub item_id: Option<String>,
}

/// Query parameters for the checkout cancellation redirect.
#[derive(Debug, Deserialize)]
pub struct CancelQuery {
    pub item_id: Option<String>,
}

/// GET /stripe/success - Handle successful payment return
///
/// If a cart checkout queue exists in the session (cross-seller cart),
/// processes the next seller automatically.
#[tracing::instrument(skip_all, name = "stripe_checkout::checkout_success")]
pub(super) async fn checkout_success(
    State(state): State<AppState>,
    session: Session,
    crate::auth::MaybeUserVerified(maybe_user): crate::auth::MaybeUserVerified,
    Query(query): Query<SuccessQuery>,
) -> impl IntoResponse {
    if let Some(session_id) = &query.session_id {
        tracing::info!(session_id = %session_id, "checkout success return");
    }

    // Check if there's a cross-seller cart queue to continue
    if let Some(user) = maybe_user
        && let Ok(Some(mut queue)) = session.get::<Vec<String>>("cart_queue").await
        && let Some(next_seller_id) = queue.first().cloned()
    {
        queue.remove(0);
        if queue.is_empty() {
            session.remove::<Vec<String>>("cart_queue").await.ok();
        } else {
            session.insert("cart_queue", queue).await.ok();
        }

        let share_contact = session.get::<bool>("cart_share_contact").await
            .ok().flatten().unwrap_or(false);

        match cart::drain_to_paid(&state, &user, next_seller_id.clone(), share_contact, &session).await {
            Ok(Some(redirect_url)) => return Redirect::to(&redirect_url),
            Ok(None) => {
                // Queue drained with everything claimed free; fall through to
                // the library redirect below.
                session.remove::<Vec<String>>("cart_queue").await.ok();
                session.remove::<bool>("cart_share_contact").await.ok();
            }
            Err(e) => {
                tracing::error!(error = ?e, seller_id = %next_seller_id, "failed to process next cart seller");
                session.remove::<Vec<String>>("cart_queue").await.ok();
                session.remove::<bool>("cart_share_contact").await.ok();
                // Previous sellers' purchases succeeded but this one failed.
                // Redirect to cart where remaining items are still present.
                return Redirect::to("/cart?checkout=partial");
            }
        }
    }

    session.remove::<Vec<String>>("cart_queue").await.ok();
    session.remove::<bool>("cart_share_contact").await.ok();

    // Single-item purchase: land on the item's library view so the buyer sees
    // their downloads/player immediately. Cart purchases land on the library
    // index (no single item to deep-link to).
    match query.item_id.as_deref() {
        Some(id) if uuid::Uuid::parse_str(id).is_ok() => {
            Redirect::to(&format!("/l/{}?purchase=success", id))
        }
        _ => Redirect::to("/library?purchase=success"),
    }
}

/// GET /stripe/cancel - Handle cancelled payment
#[tracing::instrument(skip_all, name = "stripe_checkout::checkout_cancel")]
pub(super) async fn checkout_cancel(
    Query(query): Query<CancelQuery>,
) -> impl IntoResponse {
    // Redirect back to the item page (validate as UUID to prevent path traversal)
    let redirect_url = match query.item_id {
        Some(ref id) if uuid::Uuid::parse_str(id).is_ok() => format!("/i/{}", id),
        _ => "/discover".to_string(),
    };

    Redirect::to(&redirect_url)
}