//! Stripe Checkout session creation and redirect handlers.

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

pub(in crate::routes::stripe) use cart::{create_cart_checkout, create_cart_checkout_all};
pub(crate) use item::grant_bundle_items;
pub(in crate::routes::stripe) use item::{cancel_pending_item_checkout, create_checkout};
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;

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

use crate::{Billing, Integrations, config::Config};
use sqlx::PgPool;

/// 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(super) 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(super) 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(db): State<PgPool>,
    State(integrations): State<Integrations>,
    State(payments): State<Billing>,
    State(config): State<Config>,
    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);

        let conversion = crate::currency::ConversionChoice::from_form_value(
            session
                .get::<String>("cart_conversion")
                .await
                .ok()
                .flatten()
                .as_deref(),
        );

        match cart::drain_to_paid(
            &db,
            integrations.wam.as_ref(),
            &payments,
            &config,
            &user,
            next_seller_id.clone(),
            share_contact,
            &session,
            conversion,
        )
        .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/{id}?purchase=success"))
        }
        _ => 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)
}