#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
BATTERIE DE TESTS — « Bourse au dossard » (Spixer, environnement de TEST).

Couvre les 4 volets de la fonctionnalite, bout en bout, contre l'API reelle :
  A. Liste d'attente   : file FIFO, offre automatique, deadline, conversion
  B. Cession a un ami  : invitation par e-mail, apercu, acceptation, refus
  C. Revente publique  : mise en vente + REMBOURSEMENT STRIPE (mode test)
  D. Securite          : les failles corrigees ne doivent pas revenir

Le volet C realise un VRAI paiement puis un VRAI remboursement via l'API Stripe
en mode TEST (cle sk_test_, carte de test pm_card_visa) : aucun argent reel.
La cle Stripe est lue depuis Z:\\api-test\\.env et n'est jamais affichee.

Usage : python battery_bourse.py
"""
import json, re, sys, time, urllib.parse, urllib.request, urllib.error, uuid

API = "https://test.api.spixer.fr/v1"
ENV_TEST = r"Z:/api-test/.env"
PWD = "spixerdemo"

# --------------------------------------------------------------------------
class Res:
    def __init__(self): self.rows = []
    def add(self, vol, label, ok, detail=""):
        self.rows.append((vol, label, ok, detail))
        tag = {True: "[OK]  ", False: "[FAIL]", None: "[SKIP]"}[ok]
        print(f"  {tag} {label}" + (f"   — {detail}" if detail else ""))
    def failed(self): return [r for r in self.rows if r[2] is False]
    def counts(self):
        return (sum(1 for r in self.rows if r[2] is True),
                sum(1 for r in self.rows if r[2] is False),
                sum(1 for r in self.rows if r[2] is None))
R = Res()

def http(method, url, headers=None, data=None, timeout=30):
    req = urllib.request.Request(url, data=data, headers=headers or {}, method=method)
    try:
        with urllib.request.urlopen(req, timeout=timeout) as r:
            raw = r.read().decode("utf-8", "replace")
            return r.status, raw
    except urllib.error.HTTPError as e:
        return e.code, e.read().decode("utf-8", "replace")
    except Exception as ex:
        return 0, f"{type(ex).__name__}: {ex}"

def api(m, path, token=None, body=None):
    h = {"Content-Type": "application/json", "Accept": "application/json"}
    if token: h["Authorization"] = "Bearer " + token
    st, raw = http(m, API + path, h, json.dumps(body).encode() if body is not None else None)
    try: return st, (json.loads(raw) if raw.strip() else None)
    except Exception: return st, {"raw": raw[:200]}

def login(email):
    return (api("POST", "/auth/login", body={"email": email, "password": PWD})[1] or {}).get("access_token")

def err_of(d):
    return str(((d or {}).get("error") or {}).get("message") or "")[:90]

def stripe_key():
    """Cle Stripe TEST, lue du .env serveur. Jamais affichee. Abandon si ce n'est pas sk_test_."""
    try:
        for line in open(ENV_TEST, encoding="utf-8", errors="ignore"):
            m = re.match(r"^STRIPE_SECRET_KEY=(.*)$", line.strip())
            if m:
                k = m.group(1).strip().strip('"').strip("'")
                return k if k.startswith("sk_test_") else None
    except Exception:
        return None
    return None

def stripe_post(sk, path, params):
    st, raw = http("POST", "https://api.stripe.com/v1/" + path,
                   {"Authorization": "Bearer " + sk,
                    "Content-Type": "application/x-www-form-urlencoded"},
                   urllib.parse.urlencode(params, doseq=True).encode())
    try: return st, json.loads(raw)
    except Exception: return st, {"raw": raw[:200]}

def stripe_get(sk, path):
    st, raw = http("GET", "https://api.stripe.com/v1/" + path, {"Authorization": "Bearer " + sk})
    try: return st, json.loads(raw)
    except Exception: return st, {"raw": raw[:200]}

def make_race(token, price_cents=0, maxp=1, name="Batterie"):
    _, ev = api("POST", "/events", token, {
        "name": f"{name} {uuid.uuid4().hex[:6]}", "kind": "training",
        "visibility": "private", "start_date": "2027-08-01T09:00:00"})
    eid = (ev or {}).get("id")
    _, rc = api("POST", f"/events/{eid}/races", token, {
        "name": "Epreuve", "discipline": "running", "distance_km": 10,
        "start_time": "2027-08-01 09:00:00", "max_participants": maxp,
        "price_cents": price_cents, "currency": "EUR", "status": "registration_open"})
    return eid, (rc or {}).get("id")

CREATED_EVENTS = []

# ==========================================================================
print("=" * 78)
print("  BATTERIE — BOURSE AU DOSSARD".center(78))
print("=" * 78)

A = login("demo01@demo.spixer.fr")
Bb = login("demo02@demo.spixer.fr")
C = login("demo03@demo.spixer.fr")
if not (A and Bb and C):
    print("  Connexion impossible — abandon."); sys.exit(1)
print(f"  API : {API}\n  Comptes : demo01 / demo02 / demo03\n")

# ==========================================================================
print("-" * 78); print("  A. LISTE D'ATTENTE"); print("-" * 78)
eid, rid = make_race(A, 0, 1, "Bat-A"); CREATED_EVENTS.append((A, eid))

st, _ = api("POST", "/orders/checkout", A, {"participants": [{"race_id": rid, "self": True}]})
R.add("A", "l'epreuve se remplit (1 place prise)", st in (200, 201), f"HTTP {st}")

st, s0 = api("GET", f"/races/{rid}/waitlist", Bb)
R.add("A", "l'API signale l'epreuve complete", bool((s0 or {}).get("full")))

st, d = api("POST", f"/races/{rid}/waitlist", Bb, {"opt_in_organizer": True})
R.add("A", "B rejoint la file (position 1)", (d or {}).get("position") == 1, f"HTTP {st}")
st, d3 = api("POST", f"/races/{rid}/waitlist", C, {})
R.add("A", "C rejoint la file (position 2) — l'ordre FIFO est tenu", (d3 or {}).get("position") == 2)

st, dup = api("POST", f"/races/{rid}/waitlist", Bb, {})
R.add("A", "pas de doublon dans la file", (dup or {}).get("position") == 1, f"position={(dup or {}).get('position')}")

st, blk = api("POST", "/orders/checkout", Bb, {"participants": [{"race_id": rid, "self": True}]})
R.add("A", "impossible de s'inscrire sans offre", st >= 400, f"HTTP {st} · {err_of(blk)}")

regs = api("GET", "/me/registrations", A)[1] or []
regA = next((r["id"] for r in regs if r.get("race_id") == rid), None)
api("POST", f"/registrations/{regA}/cancel", A)

st, mineB = api("GET", "/me/waitlist", Bb)
eB = next((e for e in (mineB or []) if e.get("race_id") == rid), None)
R.add("A", "l'annulation offre la place au 1er de la file (B)", (eB or {}).get("status") == "offered")
R.add("A", "l'offre porte une deadline", bool((eB or {}).get("offer_expires_at")),
      str((eB or {}).get("offer_expires_at")))

st, mineC = api("GET", "/me/waitlist", C)
eC = next((e for e in (mineC or []) if e.get("race_id") == rid), None)
R.add("A", "C (position 2) n'est PAS servi en meme temps", (eC or {}).get("status") == "waiting",
      f"statut={(eC or {}).get('status')}")
st, blkC = api("POST", "/orders/checkout", C, {"participants": [{"race_id": rid, "self": True}]})
R.add("A", "C ne peut pas doubler B", blkC and blkC.get("order_id") is None, f"HTTP {st}")

st, okB = api("POST", "/orders/checkout", Bb, {"participants": [{"race_id": rid, "self": True}]})
R.add("A", "B transforme son offre en inscription", st in (200, 201), f"HTTP {st}")
st, mineB2 = api("GET", "/me/waitlist", Bb)
R.add("A", "l'offre est consommee", not any(e.get("race_id") == rid for e in (mineB2 or [])))

st, q = api("GET", f"/races/{rid}/waitlist/entries", A)
R.add("A", "l'organisateur voit sa file d'attente", st == 200 and isinstance(q, list), f"HTTP {st} · {len(q or [])} entree(s)")

api("DELETE", f"/races/{rid}/waitlist", C)
st, mineC2 = api("GET", "/me/waitlist", C)
R.add("A", "on peut quitter la file", not any(e.get("race_id") == rid for e in (mineC2 or [])))

# ==========================================================================
print(); print("-" * 78); print("  B. CESSION A UN AMI"); print("-" * 78)
eid, rid = make_race(A, 0, 5, "Bat-B"); CREATED_EVENTS.append((A, eid))
st, o = api("POST", "/orders/checkout", A, {"participants": [{"race_id": rid, "self": True}]})
regA = ((o or {}).get("registration_ids") or [None])[0]

st, tr = api("POST", f"/registrations/{regA}/transfer", A, {"to_email": "demo02@demo.spixer.fr", "terms_accepted": True})
tok = (tr or {}).get("token")
R.add("B", "creation de la cession nominative", st in (200, 201) and bool(tok), f"HTTP {st}")

st, prev = api("GET", f"/transfers/{tok}")
R.add("B", "apercu public sans etre connecte", st == 200 and bool((prev or {}).get("race_name")),
      f"epreuve={(prev or {}).get('race_name')}")

st, dbl = api("POST", f"/registrations/{regA}/transfer", A, {"to_email": "x@y.fr", "terms_accepted": True})
R.add("B", "une seule cession a la fois", st >= 400, f"HTTP {st} · {err_of(dbl)}")

st, wrong = api("POST", f"/transfers/{tok}/accept", C)
R.add("B", "un TIERS avec le jeton est refuse (faille corrigee)", st >= 400, f"HTTP {st} · {err_of(wrong)}")

st, self_ = api("POST", f"/transfers/{tok}/accept", A)
R.add("B", "le cedant ne peut pas reprendre sa propre place", st >= 400, f"HTTP {st} · {err_of(self_)}")

st, acc = api("POST", f"/transfers/{tok}/accept", Bb)
R.add("B", "le VRAI destinataire accepte", st in (200, 204), f"HTTP {st}")

regsB = api("GET", "/me/registrations", Bb)[1] or []
R.add("B", "l'inscription appartient desormais a B", any(r.get("id") == regA for r in regsB))
regsA = api("GET", "/me/registrations", A)[1] or []
R.add("B", "elle a disparu de chez A", not any(r.get("id") == regA for r in regsA))

st, again = api("POST", f"/transfers/{tok}/accept", Bb)
R.add("B", "le jeton n'est pas rejouable", st >= 400, f"HTTP {st}")

st, canc = api("POST", f"/registrations/{regA}/cancel", A)
R.add("B", "le cedant ne peut plus annuler la place cedee (faille corrigee)",
      st >= 400, f"HTTP {st} · {err_of(canc)}")

# refus + revocation
st, o2 = api("POST", "/orders/checkout", A, {"participants": [{"race_id": rid, "self": True}]})
reg2 = ((o2 or {}).get("registration_ids") or [None])[0]
st, tr2 = api("POST", f"/registrations/{reg2}/transfer", A, {"to_email": "demo03@demo.spixer.fr", "terms_accepted": True})
tok2 = (tr2 or {}).get("token")
st, _ = api("POST", f"/transfers/{tok2}/decline")
R.add("B", "le destinataire peut refuser", st in (200, 204), f"HTTP {st}")
st, after = api("POST", f"/transfers/{tok2}/accept", C)
R.add("B", "une cession refusee n'est plus acceptable", st >= 400, f"HTTP {st}")

st, tr3 = api("POST", f"/registrations/{reg2}/transfer", A, {"to_email": "demo03@demo.spixer.fr", "terms_accepted": True})
tid3 = (tr3 or {}).get("id"); tok3 = (tr3 or {}).get("token")
st, _ = api("POST", f"/transfers/{tid3}/revoke", A)
R.add("B", "le cedant peut revoquer sa cession", st in (200, 204), f"HTTP {st}")
st, after3 = api("POST", f"/transfers/{tok3}/accept", C)
R.add("B", "une cession revoquee ne fonctionne plus", st >= 400, f"HTTP {st}")

# ==========================================================================
print(); print("-" * 78); print("  C. REVENTE PUBLIQUE + REMBOURSEMENT STRIPE (mode test)"); print("-" * 78)
SK = stripe_key()
if SK is None:
    R.add("C", "cle Stripe de TEST disponible", None, "sk_test_ introuvable — volet paiement saute")
else:
    R.add("C", "cle Stripe de TEST chargee (sk_test_, aucun argent reel)", True)

PRICE = 2500  # 25,00 €
eid, rid = make_race(A, PRICE, 1, "Bat-C"); CREATED_EVENTS.append((A, eid))

st, o = api("POST", "/orders/checkout", A, {"participants": [{"race_id": rid, "self": True}]})
oid = (o or {}).get("order_id"); regA = ((o or {}).get("registration_ids") or [None])[0]
total = (o or {}).get("total_cents")
R.add("C", "commande payante creee", st in (200, 201) and (total or 0) > 0, f"total={total} cts")

paid_ok = False
if SK and oid:
    st, intent = api("POST", f"/orders/{oid}/pay", A)
    pi = (intent or {}).get("payment_intent", "")
    R.add("C", "PaymentIntent Stripe cree", bool(pi), f"{pi[:12]}… ({(intent or {}).get('amount_cents')} cts)")
    if pi and not pi.startswith("pi_stub_"):
        # Confirmation avec la carte de test Stripe (equivalent d'un vrai paiement)
        st_s, conf = stripe_post(SK, f"payment_intents/{pi}/confirm",
                                 {"payment_method": "pm_card_visa", "return_url": "https://test.spixer.fr/"})
        R.add("C", "paiement confirme chez Stripe (carte de test)",
              (conf or {}).get("status") == "succeeded", f"statut={(conf or {}).get('status')}")
    st, cf = api("POST", f"/orders/{oid}/confirm", A)
    paid_ok = (cf or {}).get("status") == "paid"
    R.add("C", "Spixer enregistre la commande comme PAYEE", paid_ok, f"{(cf or {}).get('status')}")

# B se met en file, A remet sa place en vente
api("POST", f"/races/{rid}/waitlist", Bb, {})
st, sale = api("POST", f"/registrations/{regA}/resale", A, {"terms_accepted": True})
refund_due = (sale or {}).get("refund_if_sold_cents")
R.add("C", "mise en vente acceptee", st in (200, 201), f"HTTP {st}")
R.add("C", "le montant a rembourser = le prix paye", refund_due == PRICE, f"{refund_due} cts (attendu {PRICE})")
R.add("C", "la place part en priorite a la liste d'attente", bool((sale or {}).get("offered_to_waitlist")))

# B cree son panier. A ce stade il n'a RIEN paye : le cedant ne doit donc rien
# voir bouger. C'est la non-regression de BD-04, mesure le 2026-09-18 : un
# panier jamais paye declenchait un remboursement Stripe reel de 25 EUR chez le
# vendeur, sans que personne n'encaisse ni ne s'inscrive.
st, o2 = api("POST", "/orders/checkout", Bb, {"participants": [{"race_id": rid, "self": True}]})
oid2 = (o2 or {}).get("order_id")
R.add("C", "B cree son panier", st in (200, 201), f"HTTP {st}")

time.sleep(2)
ra0 = next((r for r in (api("GET", "/me/registrations", A)[1] or []) if r.get("id") == regA), None)
R.add("C", "=> BD-04 : un panier NON PAYE ne rembourse pas le cedant",
      int((ra0 or {}).get("refund_cents") or 0) == 0,
      f"refund_cents={(ra0 or {}).get('refund_cents')} (attendu vide ou 0)")

# B paie REELLEMENT. C'est l'encaissement, et lui seul, qui doit declencher le
# reglement du vendeur. Meme plomberie que pour le vendeur plus haut.
if SK and oid2:
    st, intentB = api("POST", f"/orders/{oid2}/pay", Bb)
    piB = (intentB or {}).get("payment_intent", "")
    if piB and not piB.startswith("pi_stub_"):
        stripe_post(SK, f"payment_intents/{piB}/confirm",
                    {"payment_method": "pm_card_visa", "return_url": "https://test.spixer.fr/"})
    st, cfB = api("POST", f"/orders/{oid2}/confirm", Bb)
    R.add("C", "B a REELLEMENT paye sa reprise", (cfB or {}).get("status") == "paid",
          f"statut={(cfB or {}).get('status')}")
else:
    R.add("C", "B a REELLEMENT paye sa reprise", None, "pas de cle Stripe, volet saute")

time.sleep(2)
regsA = api("GET", "/me/registrations", A)[1] or []
ra = next((r for r in regsA if r.get("id") == regA), None)
R.add("C", "l'inscription du cedant est liberee", (ra or {}).get("status") == "cancelled",
      f"statut={(ra or {}).get('status')}")
R.add("C", "=> LE CEDANT EST REMBOURSE DU BON MONTANT",
      int((ra or {}).get("refund_cents") or 0) == PRICE,
      f"refund_cents={(ra or {}).get('refund_cents')} (attendu {PRICE})")
R.add("C", "le remboursement est horodate", bool((ra or {}).get("refunded_at")),
      str((ra or {}).get("refunded_at")))

# Preuve cote STRIPE : le remboursement existe vraiment chez eux
if SK and paid_ok:
    st, intent2 = api("POST", f"/orders/{oid}/pay", A)  # relit l'order (deja paye -> erreur attendue)
    # BORNE AU PAIEMENT DE CE PASSAGE. Une recherche globale sur le montant
    # compte aussi les remboursements des campagnes precedentes : elle a
    # rapporte 5 remboursements de 2500 le 2026-09-18 alors qu'un seul venait
    # de ce test. Une assertion qui melange les passages ne prouve rien.
    st_s, refunds = stripe_get(SK, f"refunds?payment_intent={pi}&limit=10")
    got = [r for r in (refunds or {}).get("data", []) if r.get("amount") == PRICE and r.get("status") in ("succeeded", "pending")]
    # UN SEUL. bool(got) laissait passer un double remboursement, qui est
    # precisement BD-05 : 5000 rendus pour une place vendue une seule fois.
    R.add("C", "=> LE REMBOURSEMENT EXISTE CHEZ STRIPE, ET UNE SEULE FOIS", len(got) == 1,
          f"{len(got)} remboursement(s) de {PRICE} cts cote Stripe (attendu exactement 1)")

# ==========================================================================
print(); print("-" * 78); print("  D. GARDE-FOUS"); print("-" * 78)
eid, rid = make_race(A, 0, 5, "Bat-D"); CREATED_EVENTS.append((A, eid))
st, o = api("POST", "/orders/checkout", A, {"participants": [{"race_id": rid, "self": True}]})
regD = ((o or {}).get("registration_ids") or [None])[0]

st, noterms = api("POST", f"/registrations/{regD}/resale", A, {})
R.add("D", "mise en vente refusee sans confirmation d'irreversibilite", st >= 400, f"HTTP {st} · {err_of(noterms)}")

st, notmine = api("POST", f"/registrations/{regD}/transfer", Bb, {"to_email": "z@z.fr", "terms_accepted": True})
R.add("D", "on ne cede pas l'inscription d'autrui", st >= 400, f"HTTP {st}")

st, selfcede = api("POST", f"/registrations/{regD}/transfer", A, {"to_email": "demo01@demo.spixer.fr", "terms_accepted": True})
R.add("D", "on ne se cede pas sa place a soi-meme", st >= 400, f"HTTP {st} · {err_of(selfcede)}")

st, bad = api("GET", "/transfers/" + "0" * 48)
R.add("D", "jeton inconnu rejete proprement (pas de 500)", 400 <= st < 500, f"HTTP {st}")
st, bad2 = api("GET", "/waitlist-offers/" + "0" * 48)
R.add("D", "offre inconnue rejetee proprement (pas de 500)", 400 <= st < 500, f"HTTP {st}")

st, nofull = api("POST", f"/races/{rid}/waitlist", Bb, {})
R.add("D", "pas de liste d'attente sur une epreuve non complete", st >= 400, f"HTTP {st} · {err_of(nofull)}")

# epreuve avec bourse desactivee par l'organisateur
_, rid2 = make_race(A, 0, 1, "Bat-D2")
api("POST", "/orders/checkout", C, {"participants": [{"race_id": rid2, "self": True}]})
st, _ = api("PATCH", f"/races/{rid2}", A, {"transfer_allowed": False})
st, closed = api("POST", f"/races/{rid2}/waitlist", Bb, {})
R.add("D", "l'organisateur peut fermer la bourse sur son epreuve",
      st >= 400, f"HTTP {st} · {err_of(closed)}")

# ==========================================================================
print(); print("=" * 78)
ok, ko, sk = R.counts()
print(f"  RESULTAT : {ok} OK · {ko} FAIL · {sk} SKIP".center(78))
print("=" * 78)
for vol in ("A", "B", "C", "D"):
    rows = [r for r in R.rows if r[0] == vol]
    o = sum(1 for r in rows if r[2] is True)
    print(f"   {vol} : {o}/{len(rows)}")
if R.failed():
    print("\n  ECHECS :")
    for v, l, _, d in R.failed(): print(f"   - [{v}] {l}  ({d})")

# nettoyage des evenements de test
print("\n  Nettoyage…")
n = 0
for tok_, ev in CREATED_EVENTS:
    if ev and api("DELETE", f"/events/{ev}", tok_)[0] in (200, 204): n += 1
print(f"  {n}/{len(CREATED_EVENTS)} evenements de test supprimes.")
sys.exit(1 if R.failed() else 0)
