use axum::{
    extract::State,
    http::StatusCode,
    routing::{get, post},
    Json, Router,
};
use serde::{Deserialize, Serialize};
use std::net::SocketAddr;
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};

#[derive(Clone)]
struct AppState {
    beeceptor_url: String,
    client: reqwest::Client,
}

#[derive(Debug, Serialize, Deserialize)]
struct CreateOrderRequest {
    amount: u64,
    currency: Option<String>,
    package_id: Option<String>,
    user_id: Option<String>,
}

#[derive(Debug, Serialize)]
struct CreateOrderResponse {
    order_id: String,
    amount: u64,
    currency: String,
    status: String,
}

#[derive(Debug, Serialize, Deserialize)]
struct VerifyPaymentRequest {
    order_id: String,
    payment_id: String,
    signature: Option<String>,
}

#[derive(Debug, Serialize)]
struct VerifyPaymentResponse {
    verified: bool,
    payment_id: String,
    status: String,
    message: String,
}

#[derive(Debug, Serialize)]
struct PaymentStatusResponse {
    payment_id: String,
    status: String,
    amount: u64,
    currency: String,
}

async fn create_order(
    State(state): State<AppState>,
    Json(payload): Json<CreateOrderRequest>,
) -> Result<Json<CreateOrderResponse>, (StatusCode, String)> {
    tracing::info!("Creating payment order: amount={}", payload.amount);

    let resp = state
        .client
        .post(&state.beeceptor_url)
        .header("Content-Type", "application/json")
        .json(&serde_json::json!({
            "amount": payload.amount,
            "currency": payload.currency.as_deref().unwrap_or("INR"),
            "package_id": payload.package_id,
            "user_id": payload.user_id,
        }))
        .send()
        .await
        .map_err(|e| (StatusCode::BAD_GATEWAY, format!("Beeceptor error: {}", e)))?;

    let status = resp.status();
    let body: serde_json::Value = resp
        .json()
        .await
        .map_err(|e| (StatusCode::BAD_GATEWAY, format!("Parse error: {}", e)))?;

    if !status.is_success() {
        return Err((
            StatusCode::BAD_REQUEST,
            body.get("message")
                .and_then(|m| m.as_str())
                .unwrap_or("Order creation failed")
                .to_string(),
        ));
    }

    let order_id = body
        .get("order_id")
        .and_then(|v| v.as_str())
        .unwrap_or("mock_order_123")
        .to_string();

    Ok(Json(CreateOrderResponse {
        order_id,
        amount: payload.amount,
        currency: payload.currency.unwrap_or("INR".to_string()),
        status: "created".to_string(),
    }))
}

async fn verify_payment(
    State(state): State<AppState>,
    Json(payload): Json<VerifyPaymentRequest>,
) -> Result<Json<VerifyPaymentResponse>, (StatusCode, String)> {
    tracing::info!("Verifying payment: order_id={}", payload.order_id);

    let verify_url = format!("{}/verify", state.beeceptor_url.trim_end_matches('/'));

    let resp = state
        .client
        .post(&verify_url)
        .header("Content-Type", "application/json")
        .json(&payload)
        .send()
        .await
        .map_err(|e| (StatusCode::BAD_GATEWAY, format!("Beeceptor error: {}", e)))?;

    let status = resp.status();
    let body: serde_json::Value = resp
        .json()
        .await
        .map_err(|e| (StatusCode::BAD_GATEWAY, format!("Parse error: {}", e)))?;

    if !status.is_success() {
        return Err((
            StatusCode::BAD_REQUEST,
            body.get("message")
                .and_then(|m| m.as_str())
                .unwrap_or("Verification failed")
                .to_string(),
        ));
    }

    Ok(Json(VerifyPaymentResponse {
        verified: true,
        payment_id: payload.payment_id,
        status: "success".to_string(),
        message: "Payment verified successfully".to_string(),
    }))
}

async fn get_payment_status(
    State(state): State<AppState>,
    axum::extract::Path(payment_id): axum::extract::Path<String>,
) -> Result<Json<PaymentStatusResponse>, (StatusCode, String)> {
    tracing::info!("Getting payment status: payment_id={}", payment_id);

    let status_url = format!("{}/{}", state.beeceptor_url.trim_end_matches('/'), payment_id);

    let resp = state
        .client
        .get(&status_url)
        .send()
        .await
        .map_err(|e| (StatusCode::BAD_GATEWAY, format!("Beeceptor error: {}", e)))?;

    let status = resp.status();
    let body: serde_json::Value = resp
        .json()
        .await
        .map_err(|e| (StatusCode::BAD_GATEWAY, format!("Parse error: {}", e)))?;

    if !status.is_success() {
        return Ok(Json(PaymentStatusResponse {
            payment_id,
            status: "not_found".to_string(),
            amount: 0,
            currency: "INR".to_string(),
        }));
    }

    let amount = body.get("amount").and_then(|v| v.as_u64()).unwrap_or(0);
    let currency = body
        .get("currency")
        .and_then(|v| v.as_str())
        .unwrap_or("INR")
        .to_string();
    let status_str = body
        .get("status")
        .and_then(|v| v.as_str())
        .unwrap_or("unknown")
        .to_string();

    Ok(Json(PaymentStatusResponse {
        payment_id,
        status: status_str,
        amount,
        currency,
    }))
}

#[tokio::main]
async fn main() {
    tracing_subscriber::registry()
        .with(tracing_subscriber::EnvFilter::new(
            std::env::var("RUST_LOG").unwrap_or_else(|_| "info".into()),
        ))
        .with(tracing_subscriber::fmt::layer())
        .init();

    let beeceptor_url = std::env::var("BEECEPTOR_URL")
        .unwrap_or_else(|_| "https://nxtgauge.free.beeceptor.com".to_string());

    let state = AppState {
        beeceptor_url,
        client: reqwest::Client::new(),
    };

    let app = Router::new()
        .route("/api/payments/create-order", post(create_order))
        .route("/api/payments/verify", post(verify_payment))
        .route("/api/payments/:id/status", get(get_payment_status))
        .with_state(state);

    let port: u16 = std::env::var("PORT")
        .unwrap_or_else(|_| "8094".to_string())
        .parse()
        .expect("PORT must be a valid u16");
    let addr = SocketAddr::from(([0, 0, 0, 0], port));

    tracing::info!("Payments service (mock via Beeceptor) listening on {}", addr);

    let listener = tokio::net::TcpListener::bind(&addr).await.unwrap();
    axum::serve(listener, app).await.unwrap();
}