#!/usr/bin/env bash
# Capture a prior authorization (must equal the authorized amount in v1). Any
# 2xx is a response — branch on data.status. On a timeout/5xx, retry with the
# SAME operation_id; never mint a new one for the same capture attempt.
set -euo pipefail

API_BASE="${RADIUMONE_API_BASE:-https://api-sandbox.radiumone.io/gateway}"
: "${RADIUMONE_ACCESS_TOKEN:?set RADIUMONE_ACCESS_TOKEN to a Bearer access token}"
: "${RADIUMONE_TRANSACTION_ID:?set RADIUMONE_TRANSACTION_ID to the id of the AUTHORIZED transaction}"

curl -sS -X POST "$API_BASE/v1/transactions/$RADIUMONE_TRANSACTION_ID/capture" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $RADIUMONE_ACCESS_TOKEN" \
  -d @request.json

#!/usr/bin/env python3
"""Capture a prior authorization (must equal the authorized amount in v1).

Shared result pattern: any 2xx is a response you branch on ``status``. On a
network timeout or 5xx, retry with the SAME operation_id — never mint a new
one for the same capture attempt.
"""
import json
import os
import random
import time
from pathlib import Path

import requests

API_BASE = os.environ.get("RADIUMONE_API_BASE", "https://api-sandbox.radiumone.io/gateway")


def backoff_seconds(attempt: int) -> float:
    """Exponential backoff with jitter: attempt 1 waits ~0.25-0.5s, doubling
    each attempt, capped at 4s -- avoids hammering the gateway in a loop."""
    base = min(0.25 * 2 ** (attempt - 1), 4.0)
    return base + random.random() * base


def capture_authorization(max_attempts: int = 3) -> dict:
    body = json.loads((Path(__file__).parent / "request.json").read_text())
    transaction_id = os.environ["RADIUMONE_TRANSACTION_ID"]
    headers = {"Authorization": f"Bearer {os.environ.get('RADIUMONE_ACCESS_TOKEN', '')}"}

    for attempt in range(1, max_attempts + 1):
        try:
            resp = requests.post(
                f"{API_BASE}/v1/transactions/{transaction_id}/capture", json=body, headers=headers, timeout=30
            )
        except requests.exceptions.Timeout:
            if attempt == max_attempts:
                raise
            time.sleep(backoff_seconds(attempt))
            continue

        if resp.status_code >= 500:
            if attempt == max_attempts:
                raise RuntimeError(f"server error {resp.status_code} after {attempt} attempts")
            time.sleep(backoff_seconds(attempt))
            continue

        payload = resp.json()
        if not resp.ok:
            # 422 tx:capture-window-expired if the capture window has passed.
            code = payload.get("type") or payload.get("code")
            raise RuntimeError(f"capture failed: {code} ({resp.status_code})")
        return payload  # branch on data.status

    raise RuntimeError("unreachable")


if __name__ == "__main__":
    print(json.dumps(capture_authorization(), indent=2))