import express from "express";
import Stripe from "stripe";
import { Blockchain0x } from "@blockchain0x/sdk";

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);
const b0x = new Blockchain0x({ apiKey: process.env.BLOCKCHAIN0X_API_KEY! });

// Auth gate that accepts either Stripe subscription OR a paid 402 settlement.
function requirePayment(priceUsdc: string, reason: string) {
  return async (req: express.Request, res: express.Response, next: express.NextFunction) => {
    // 1. Human path: Stripe customer with an active subscription.
    const cookieCustomer = req.cookies?.stripe_customer_id;
    if (cookieCustomer) {
      const subs = await stripe.subscriptions.list({ customer: cookieCustomer, status: "active", limit: 1 });
      if (subs.data.length > 0) return next();
    }

    // 2. Agent path: x402 challenge / response.
    const receipt = req.header("X-Blockchain0x-Receipt");
    if (receipt && (await b0x.receipts.validate(receipt))) return next();

    // 3. No valid auth - issue a 402 with both payment options.
    const stripeCheckout = await stripe.checkout.sessions.create({
      mode: "subscription",
      line_items: [{ price: process.env.STRIPE_PRICE_ID!, quantity: 1 }],
      success_url: process.env.APP_URL + "/api/return?session_id={CHECKOUT_SESSION_ID}",
    });
    const agentPayment = await b0x.paymentRequests.create({
      agent_id: process.env.BLOCKCHAIN0X_AGENT_ID!,
      amount_usdc: priceUsdc,
      reason,
      callback_url: process.env.APP_URL + "/webhooks/payment",
    });

    res.status(402).json({
      stripe_checkout_url: stripeCheckout.url,
      x402: {
        hosted_url: agentPayment.hosted_url,
        amount_usdc: priceUsdc,
        expires_at: agentPayment.expires_at,
      },
    });
  };
}

from functools import wraps
from flask import request, jsonify
import stripe, os
from blockchain0x import Client

stripe.api_key = os.environ["STRIPE_SECRET_KEY"]
b0x = Client(api_key=os.environ["BLOCKCHAIN0X_API_KEY"])

def require_payment(price_usdc: str, reason: str):
    def decorator(fn):
        @wraps(fn)
        async def wrapper(*args, **kwargs):
            # 1. Human path: Stripe subscription cookie.
            customer_id = request.cookies.get("stripe_customer_id")
            if customer_id:
                subs = stripe.Subscription.list(customer=customer_id, status="active", limit=1)
                if subs["data"]:
                    return await fn(*args, **kwargs)

            # 2. Agent path: x402 receipt header.
            receipt = request.headers.get("X-Blockchain0x-Receipt")
            if receipt and b0x.receipts.validate(receipt):
                return await fn(*args, **kwargs)

            # 3. No valid auth - 402 with both options.
            stripe_checkout = stripe.checkout.Session.create(
                mode="subscription",
                line_items=[{"price": os.environ["STRIPE_PRICE_ID"], "quantity": 1}],
                success_url=os.environ["APP_URL"] + "/api/return?session_id={CHECKOUT_SESSION_ID}",
            )
            agent_payment = b0x.payment_requests.create(
                agent_id=os.environ["BLOCKCHAIN0X_AGENT_ID"],
                amount_usdc=price_usdc,
                reason=reason,
                callback_url=os.environ["APP_URL"] + "/webhooks/payment",
            )
            return jsonify({
                "stripe_checkout_url": stripe_checkout.url,
                "x402": {
                    "hosted_url": agent_payment.hosted_url,
                    "amount_usdc": price_usdc,
                    "expires_at": agent_payment.expires_at,
                },
            }), 402
        return wrapper
    return decorator