import base64
import json
import requests
from payments_py import Payments, PaymentOptions
from payments_py.x402 import (
    CreateDelegationPayload,
    DelegationConfig,
    X402TokenOptions,
)

payments = Payments.get_instance(
    PaymentOptions(nvm_api_key="nvm:subscriber-key", environment="sandbox")
)

# Fetch protected resource to get the payment requirements
response = requests.get("https://api.example.com/protected")

if response.status_code == 402:
    # Decode the payment-required header
    payment_required = json.loads(
        base64.b64decode(response.headers.get("payment-required")).decode()
    )

    # Extract planId and agentId from accepts array
    plan_id = payment_required["accepts"][0]["planId"]
    agent_id = payment_required["accepts"][0].get("extra", {}).get("agentId")

    # 1. Create a delegation once. `provider` and `currency` are required:
    #    'usdc' for the crypto (erc4337) scheme, 'usd' for card providers.
    delegation = payments.delegation.create_delegation(
        CreateDelegationPayload(
            provider="erc4337",
            spending_limit_cents=10000,
            duration_secs=604800,
            currency="usdc",
        )
    )

    # 2. Request a token by delegationId (reuse it for subsequent requests).
    token_res = payments.x402.get_x402_access_token(
        plan_id,
        agent_id,
        token_options=X402TokenOptions(
            delegation_config=DelegationConfig(
                delegation_id=delegation.delegation_id
            )
        ),
    )
    access_token = token_res["accessToken"]

from fastapi import FastAPI
from payments_py import Payments, PaymentOptions
from payments_py.x402.fastapi import PaymentMiddleware

app = FastAPI()

payments = Payments.get_instance(
    PaymentOptions(nvm_api_key=os.environ["NVM_API_KEY"], environment="sandbox")
)

# One line to protect routes
app.add_middleware(
    PaymentMiddleware,
    payments=payments,
    routes={
        "POST /ask": {"plan_id": PLAN_ID, "credits": 1}
    }
)

# Route handler - no payment logic needed
@app.post("/ask")
async def ask(request: Request):
    body = await request.json()
    result = await process_request(body)
    return {"result": result}

from payments_py import Payments, PaymentOptions

payments = Payments.get_instance(
    PaymentOptions(nvm_api_key="nvm:agent-key", environment="sandbox")
)

# Get token from payment-signature header
x402_token = request.headers.get("payment-signature")

if not x402_token:
    # Return 402 with payment requirements
    return {"error": "Payment Required"}, 402

# Verify permissions - facilitator extracts planId and subscriberAddress from token
verification = payments.facilitator.verify_permissions(
    x402_access_token=x402_token,
    max_amount=credits_required,
)

if not verification.is_valid:
    return {"error": "Payment verification failed"}, 402

import base64
import json

# Settle after work is complete - burns the actual credits used
settlement = payments.facilitator.settle_permissions(
    x402_access_token=x402_token,
    max_amount=actual_credits_used,
)

# Return response with settlement receipt in payment-response header
settlement_receipt = base64.b64encode(json.dumps({
    "success": True,
    "creditsRedeemed": actual_credits_used,
    "transactionHash": settlement.tx_hash,
}).encode()).decode()

response.headers["payment-response"] = settlement_receipt
return {"result": result}