app.py

import json
import html
import os
import re
import urllib.error
import urllib.parse
import urllib.request
from pathlib import Path
from typing import Any

DEFAULT_SPACE_ID = "nvidia/AlpasimE2EClosedLoopChallenge2026"

if os.environ.get("SPACE_HOST"):
    os.environ.setdefault("SYSTEM", "spaces")
    os.environ.setdefault("SPACE_ID", DEFAULT_SPACE_ID)

import gradio as gr
from fastapi import FastAPI
from fastapi.responses import HTMLResponse
from fastapi.staticfiles import StaticFiles


API_BASE_URL = os.environ.get(
    "ALPASIM_API_BASE_URL",
    "",
).rstrip("/")
REGISTRATION_SECRET = os.environ.get("ALPASIM_REGISTRATION_SECRET", "")
ACTIVE_REGISTRATION_STATUSES = {"pending", "approved", "registered"}
REVIEW_STATUS_CHOICES = ["pending", "approved", "rejected", "all"]
LEADERBOARD_HEADERS = [
    "Rank",
    "Team",
    "Team ID",
    "Policy Capability Score",
    "Avg Distance Between At-Fault Incidents",
    "Image Tag",
    "Submission ID",
    "Submitted At",
]
LEADERBOARD_SORT_CHOICES = LEADERBOARD_HEADERS
MOCKED_HF_USER_IDS = {"11111111111111111111111"}
NVIDIA_GREEN = "#76B900"
NVIDIA_GREEN_DARK = "#5F9500"
BANNER_PATH = "assets/auto-alpasim-end-to-end-closed-loop-driving-1600x400.mp4"
BANNER_DIR = Path(__file__).resolve().parent / "assets"
BANNER_FILE = Path(__file__).resolve().parent / BANNER_PATH
gr.set_static_paths(paths=[BANNER_DIR])
APP_THEME = gr.themes.Default(primary_hue="lime").set(
    button_primary_background_fill=NVIDIA_GREEN,
    button_primary_background_fill_hover=NVIDIA_GREEN_DARK,
    button_primary_text_color="white",
    loader_color=NVIDIA_GREEN,
    slider_color=NVIDIA_GREEN,
)
BANNER_HTML = f"""
<div class="topline">
  <div class="brand">AlpaSim<span>.</span> E2E Closed Loop Challenge</div>
  <div class="navlinks">
    <a href="#overview">Overview</a>
    <a href="#tracks">Tracks</a>
    <a href="#timeline">Timeline</a>
    <a href="#prizes">Prizes</a>
    <a href="#docs">Docs</a>
    <a href="#organizers">Organizers</a>
    <a href="#registration">Leaderboard</a>
  </div>
</div>
<header class="alpasim-hero">
  <video autoplay muted loop playsinline preload="auto" aria-label="AlpaSim E2E Closed Loop Challenge 2026 banner">
    <source src="/{BANNER_PATH}" type="video/mp4" />
  </video>
  <div class="hero-overlay">
    <div class="hero-overlay-inner">
      <div class="hero-eyebrow">2026 &middot; NVIDIA AV Research &middot; KE:SAI</div>
      <h1 class="hero-title">AlpaSim E2E Closed Loop Challenge</h1>
      <p class="hero-lead">
        A closed-loop benchmark for evaluating autonomous driving policies.
      </p>
    </div>
  </div>
</header>
"""
CHALLENGE_OVERVIEW_HTML = """
<main class="challenge-info">
  <section id="overview">
    <h2><span>01</span> Overview</h2>
    <p class="lead">
      Welcome to the AlpaSim End to End Closed Loop Challenge. This competition
      invites teams to build autonomous driving policies and compare them
      head-to-head in realistic closed-loop simulation, where each policy's
      decisions shape the future scene it must handle.
    </p>
    <p class="lead">
      Autonomous driving research has made major progress, but it remains hard
      to compare policies across labs and companies in a realistic, reproducible
      way. Open-loop evaluation is useful, but it misses the compounding effects
      that make driving hard: a small planning error can change future
      observations, interactions, and risk.
    </p>
    <p class="lead">
      AlpaSim provides a shared simulator, public development data, starter
      tools, baseline policies, and a common containerized submission interface.
      Organizer-managed evaluation workers run submissions on private held-out
      scenarios and publish leaderboard results with both a policy capability
      score and a safety metric.
    </p>
    <p class="lead">
      Across both tracks, the goal is not just to crown a winner. We want to
      learn which policy families are robust under distribution shift, where
      they fail, and how the community can make AV evaluation more trustworthy.
    </p>
    <p class="lead">
      The challenge is currently in a soft-open period. Registration and
      leaderboard access are available now so teams can begin exercising the
      submission workflow, validating containers, and calibrating against the
      current evaluation service while final data updates are prepared.
    </p>
  </section>

  <section id="tracks">
    <h2><span>02</span> Challenge Tracks</h2>
    <p class="lead">
      The competition has two complementary tracks, covering both large-scale
      geographically diverse driving data and a lower-barrier entry point for
      teams working with established nuPlan-style workflows.
    </p>
    <div class="track-grid">
      <div class="info-card">
        <div class="pill">Track 1 - PAI-AV</div>
        <h3>Physical AI AV Track</h3>
        <p>
          The larger-scale setting for testing whether promising policies hold
          up as scenario diversity and long-tail coverage increase.
        </p>
        <p>
          The current test set includes a subset of the final scenes. Additional
          scenes will be added later in the competition.
        </p>
      </div>
      <div class="info-card">
        <div class="pill">Track 2 - nuPlan</div>
        <h3>nuPlan Track</h3>
        <p>
          A lower-barrier track for teams building on the widely used nuPlan
          ecosystem or NAVSIM-style development workflows.
        </p>
        <p>
          The nuPlan leaderboard is currently backed by a provisional dataset.
          Teams are encouraged to submit during this period to test their
          workflow and understand the evaluation process. When the updated
          nuPlan data is available, the nuPlan leaderboard will be cleared and
          each team's best submission will be resubmitted by the organizers.
        </p>
      </div>
    </div>
  </section>

  <section id="timeline">
    <h2><span>03</span> Timeline</h2>
    <ol class="timeline">
      <li>
        <span class="date">2026-06-15</span>
        <b>Competition goes live</b>
        <span class="desc">Registration, public data, starter tools, and submission instructions open.</span>
      </li>
      <li>
        <span class="date">2026-08-15</span>
        <b>Mid-competition checkpoint</b>
        <span class="desc">FAQ updates, leaderboard-health notes, and non-breaking clarifications.</span>
      </li>
      <li>
        <span class="date">2026-09-15</span>
        <b>Rules and submission format freeze</b>
        <span class="desc">Final rules, metric implementation, Docker base image, and public submission format freeze except for critical fixes.</span>
      </li>
      <li>
        <span class="date">2026-10-31</span>
        <b>Public leaderboard closes</b>
        <span class="desc">Teams select one final valid container per track. Technical reports are due.</span>
      </li>
      <li>
        <span class="date">2026-11-15</span>
        <b>Final results released</b>
        <span class="desc">Final results and award decisions are released to participants.</span>
      </li>
      <li>
        <span class="date">NeurIPS 2026</span>
        <b>Competition track workshop</b>
        <span class="desc">Winners and selected participants present results; organizers share final analysis and lessons learned.</span>
      </li>
    </ol>
  </section>

  <section id="prizes">
    <h2><span>04</span> Prizes</h2>
    <p class="lead">
      Each track will award two NVIDIA DGX Spark prizes: one for first place and one
      for an innovative solution.
    </p>
    <div class="prize-grid">
      <div class="prize">
        <div class="icon">DGX</div>
        <div>
          <h3>PAI-AV Track</h3>
          <p>Two NVIDIA DGX Spark prizes awarded.</p>
        </div>
      </div>
      <div class="prize">
        <div class="icon">DGX</div>
        <div>
          <h3>nuPlan Track</h3>
          <p>Two NVIDIA DGX Spark prizes awarded.</p>
        </div>
      </div>
    </div>
  </section>

  <section id="docs">
    <h2><span>05</span> Documentation Links</h2>
    <div class="track-grid">
      <a class="info-card doc-card" href="https://github.com/NVlabs/alpasim/blob/e2e_challenge/e2e_challenge/README.md" target="_blank" rel="noopener noreferrer">
        <div class="pill">Guide</div>
        <h3>Contestant Guide</h3>
        <p>Challenge setup, tracks, scoring, and participant workflow.</p>
      </a>
      <a class="info-card doc-card" href="https://github.com/NVlabs/alpasim/blob/e2e_challenge/e2e_challenge/starter_kit/README.md" target="_blank" rel="noopener noreferrer">
        <div class="pill">Kit</div>
        <h3>Starter Kit</h3>
        <p>Baseline files and examples for building an initial submission.</p>
      </a>
      <a class="info-card doc-card" href="https://github.com/NVlabs/alpasim/tree/e2e_challenge/e2e_challenge/competitor_cli" target="_blank" rel="noopener noreferrer">
        <div class="pill">CLI</div>
        <h3>Submission CLI</h3>
        <p>Command-line tooling for packaging, validating, and submitting entries.</p>
      </a>
      <a class="info-card doc-card" href="https://github.com/NVlabs/alpasim/blob/e2e_challenge/e2e_challenge/README.md#submission-image-requirements-and-constraints" target="_blank" rel="noopener noreferrer">
        <div class="pill">Requirements</div>
        <h3>Submission Image Requirements</h3>
        <p>Container image constraints and requirements for valid submissions.</p>
      </a>
      <a class="info-card doc-card" href="https://ln2697.github.io/navhard-leaderboard-2/docs/" target="_blank" rel="noopener noreferrer">
        <div class="pill">Metrics</div>
        <h3>Capability Score Computation</h3>
        <p>Reference documentation for how policy capability scores are computed.</p>
      </a>
      <a class="info-card doc-card" href="https://github.com/NVlabs/alpasim" target="_blank" rel="noopener noreferrer">
        <div class="pill">Support</div>
        <h3>Questions and Discussions</h3>
        <p>Use the public AlpaSim repository for bug reports, questions, and competition discussions.</p>
      </a>
    </div>
  </section>

  <section id="organizers">
    <h2><span>06</span> Organizers</h2>
    <p class="lead">
      This competition is hosted by NVIDIA's Autonomous Vehicle Research Group, KE:SAI, and HKU.
    </p>
    <div class="track-grid">
      <a class="info-card organizer-card" href="https://research.nvidia.com/labs/avg/" target="_blank" rel="noopener noreferrer">
        <div class="pill">Host</div>
        <h3>NVIDIA Autonomous Vehicle Research Group</h3>
        <p>Interdisciplinary NVIDIA Research team advancing vehicle autonomy across perception, prediction, planning, control, simulation, foundation models, and AI safety.</p>
      </a>
      <a class="info-card organizer-card" href="https://kesai.eu/" target="_blank" rel="noopener noreferrer">
        <div class="pill">Host</div>
        <h3>KE:SAI</h3>
        <p>Non-profit open-science research lab advancing robust, safe, and reproducible physical AI, with a focus on world models, autonomy, and open self-driving technology.</p>
      </a>
      <a class="info-card organizer-card" href="https://opendrivelab.com/" target="_blank" rel="noopener noreferrer">
        <div class="pill">Host</div>
        <h3>HKU</h3>
        <p>OpenDriveLab at The University of Hong Kong is a research group focused on embodied AI and autonomous driving. The lab develops open benchmarks, simulation infrastructure, world models, and end-to-end driving systems to support scalable, reproducible, and trustworthy physical AI research.</p>
      </a>
    </div>
  </section>
</main>
"""
APP_EMBED_HTML = """
<section id="registration" class="challenge-app">
  <h2><span>07</span> Leaderboard</h2>
  <iframe
    class="gradio-frame"
    src="/gradio/"
    title="AlpaSim leaderboard, registration, and review app"
  ></iframe>
</section>
"""
BANNER_CSS = """
html {
  scroll-behavior: smooth;
}

body {
  margin: 0;
  background: var(--bg);
  color: var(--text);
  font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Arial, sans-serif;
}

:root,
.gradio-container {
  --bg: #ffffff;
  --panel: #f8f9fb;
  --panel-2: #f1f3f7;
  --border: #e4e7ec;
  --text: #1a1d23;
  --muted: #6b7280;
  --button-primary-background-fill: #76B900;
  --button-primary-background-fill-hover: #5F9500;
  --button-primary-border-color: #76B900;
  --button-primary-text-color: white;
  --color-accent: #76B900;
  --link-text-color: #1f6feb;
  --loader-color: #76B900;
  --slider-color: #76B900;
  --body-text-color: var(--text);
  --body-text-color-subdued: #3c4250;
  --block-label-text-color: #3c4250;
  --block-title-text-color: var(--text);
  --input-text-color: var(--text);
  --input-placeholder-color: #6b7280;
  color: var(--text);
  font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Arial, sans-serif;
}

.gradio-container {
  background: var(--bg);
  max-width: none !important;
  padding-top: 0 !important;
}

.contain {
  max-width: none !important;
}

.topline {
  position: sticky;
  top: 0;
  z-index: 50;
  display: flex;
  align-items: center;
  justify-content: space-between;
  gap: 20px;
  padding: 12px 24px;
  margin: 0;
  background: rgba(255, 255, 255, 0.92);
  backdrop-filter: blur(8px);
  border-bottom: 1px solid var(--border);
}

.brand {
  font-weight: 700;
  letter-spacing: 0.3px;
}

.brand span {
  color: #76B900;
}

.navlinks {
  display: flex;
  gap: 18px;
  flex-wrap: wrap;
}

.navlinks a {
  color: var(--muted);
  text-decoration: none;
}

.navlinks a:hover {
  color: var(--text);
  text-decoration: none;
}

.alpasim-hero {
  position: relative;
  overflow: hidden;
  margin: 0;
  background: #000000;
  border-bottom: 1px solid var(--border);
}

.alpasim-hero video {
  display: block;
  width: 100%;
  height: auto;
}

.hero-overlay {
  position: absolute;
  inset: 0;
  display: flex;
  align-items: flex-end;
  background: linear-gradient(180deg, rgba(0, 0, 0, 0.10) 0%, rgba(0, 0, 0, 0.55) 100%);
  pointer-events: none;
}

.hero-overlay-inner {
  width: 100%;
  max-width: 1100px;
  margin: 0 auto;
  padding: 40px 24px;
  color: #ffffff;
}

.hero-eyebrow {
  color: #d6f3a3;
  font-size: 0.85em;
  font-weight: 600;
  letter-spacing: 0.14em;
  text-transform: uppercase;
}

.hero-title {
  margin: 8px 0 10px;
  color: #ffffff;
  font-size: clamp(28px, 4vw, 46px);
  line-height: 1.1;
}

.hero-lead {
  max-width: 760px;
  margin: 0;
  color: #e7eaef;
  font-size: 1.05em;
}

.challenge-info {
  max-width: 1100px;
  margin: 0 auto;
  padding: 0 24px;
}

.challenge-info section {
  padding: 48px 0;
  border-bottom: 1px solid var(--border);
  scroll-margin-top: 72px;
}

.challenge-info section:last-child {
  border-bottom: 0;
}

.challenge-info h2 {
  display: flex;
  align-items: baseline;
  gap: 12px;
  margin: 0 0 10px;
  font-size: 28px;
  line-height: 1.2;
  color: var(--text);
}

.challenge-info h2 span {
  color: #76B900;
  font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
  font-size: 0.7em;
  letter-spacing: 0.08em;
}

.challenge-info .lead,
.info-card p,
.prize p {
  color: #3c4250;
  line-height: 1.6;
}

.challenge-info .lead {
  max-width: 860px;
  margin: 0 0 14px;
}

.track-grid,
.prize-grid {
  display: grid;
  grid-template-columns: repeat(auto-fit, minmax(260px, 1fr));
  gap: 18px;
  margin-top: 18px;
}

.info-card {
  background: var(--panel);
  border: 1px solid var(--border);
  border-radius: 10px;
  padding: 22px;
}

.info-card h3,
.prize h3 {
  margin: 0 0 8px;
  font-size: 18px;
  color: var(--text);
}

.info-card p,
.prize p {
  margin: 0;
}

.info-card p + p {
  margin-top: 12px;
}

.organizer-card,
.doc-card {
  display: block;
  color: inherit;
  text-decoration: none;
}

.organizer-card:hover,
.doc-card:hover {
  border-color: rgba(118, 185, 0, 0.45);
  text-decoration: none;
}

.pill {
  display: inline-block;
  margin-bottom: 10px;
  padding: 3px 9px;
  border-radius: 999px;
  background: rgba(118, 185, 0, 0.15);
  color: #5F9500;
  border: 1px solid rgba(118, 185, 0, 0.3);
  font-size: 0.78em;
  letter-spacing: 0.04em;
}

.timeline {
  list-style: none;
  padding: 0;
  margin: 18px 0 0;
}

.timeline li {
  position: relative;
  padding: 12px 14px 12px 38px;
  border-left: 2px solid var(--border);
  margin-left: 8px;
}

.timeline li::before {
  content: "";
  position: absolute;
  left: -7px;
  top: 18px;
  width: 12px;
  height: 12px;
  border-radius: 50%;
  background: #76B900;
}

.timeline .date {
  color: #5F9500;
  font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
  font-size: 0.85em;
  letter-spacing: 0.03em;
}

.timeline b,
.timeline .desc {
  display: block;
}

.timeline .desc {
  color: var(--muted);
  font-size: 0.92em;
}

.prize {
  display: flex;
  align-items: center;
  gap: 18px;
  padding: 24px;
  background: linear-gradient(135deg, rgba(118, 185, 0, 0.10), rgba(118, 185, 0, 0.04));
  border: 1px solid rgba(118, 185, 0, 0.35);
  border-radius: 12px;
}

.prize .icon {
  width: 64px;
  height: 64px;
  flex: 0 0 64px;
  display: flex;
  align-items: center;
  justify-content: center;
  border-radius: 14px;
  background: #76B900;
  color: #ffffff;
  font-weight: 700;
}

.identity-strip {
  max-width: 1100px;
  margin: 0 auto;
  padding: 0 24px 18px;
}

.identity-strip p {
  margin: 0;
  color: var(--muted);
}

.tabs {
  max-width: 1100px;
  margin: 0 auto;
}

.challenge-app {
  max-width: 1100px;
  margin: 0 auto;
  padding: 48px 24px 72px;
  scroll-margin-top: 72px;
}

.challenge-app h2 {
  display: flex;
  align-items: baseline;
  gap: 12px;
  margin: 0 0 18px;
  font-size: 28px;
}

.challenge-app h2 span {
  color: #76B900;
  font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
  font-size: 0.7em;
  letter-spacing: 0.08em;
}

.gradio-frame {
  display: block;
  width: 100%;
  min-height: 940px;
  border: 1px solid var(--border);
  border-radius: 8px;
  background: #ffffff;
}

@media (max-width: 720px) {
  .topline {
    align-items: flex-start;
    flex-direction: column;
    gap: 8px;
  }

  .navlinks {
    gap: 12px;
  }

  .hero-overlay-inner {
    padding: 12px 18px;
  }

  .hero-eyebrow {
    font-size: 0.62em;
    letter-spacing: 0.08em;
  }

  .hero-title {
    margin: 4px 0 0;
    font-size: clamp(16px, 5vw, 22px);
    line-height: 1.05;
  }

  .hero-lead {
    display: none;
  }

  .challenge-info {
    padding: 0 18px;
  }

  .challenge-info section,
  .challenge-app {
    scroll-margin-top: 112px;
  }

  .challenge-app {
    padding: 48px 18px 64px;
  }

  .gradio-frame {
    min-height: 1040px;
  }

  .identity-strip {
    padding: 0 18px 18px;
  }
}
"""
GRADIO_CSS = """
:root,
.gradio-container {
  color-scheme: light;
  --bg: #ffffff;
  --panel: #f8f9fb;
  --panel-2: #f1f3f7;
  --border: #e4e7ec;
  --text: #1a1d23;
  --muted: #6b7280;
  --body-background-fill: #ffffff;
  --background-fill-primary: #ffffff;
  --background-fill-secondary: #f8f9fb;
  --block-background-fill: #ffffff;
  --block-border-color: #e4e7ec;
  --border-color-primary: #e4e7ec;
  --body-text-color: #1a1d23;
  --body-text-color-subdued: #4b5563;
  --block-label-text-color: #1a1d23;
  --block-title-text-color: #1a1d23;
  --checkbox-label-color: #1a1d23;
  --checkbox-label-text-color: #1a1d23;
  --input-background-fill: #ffffff;
  --input-border-color: #d0d5dd;
  --input-placeholder-color: #6b7280;
  --input-text-color: #1a1d23;
  --button-primary-background-fill: #76B900;
  --button-primary-background-fill-hover: #5F9500;
  --button-primary-border-color: #76B900;
  --button-primary-text-color: white;
  --color-accent: #76B900;
  --link-text-color: #1f6feb;
  --loader-color: #76B900;
  --slider-color: #76B900;
  color: var(--text);
  font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Arial, sans-serif;
}

.gradio-container {
  background: var(--bg);
  max-width: none !important;
  padding-top: 0 !important;
}

.gradio-container input[type="checkbox"] + span,
.gradio-container input[type="checkbox"] ~ span,
.gradio-container .checkbox label,
.gradio-container .checkbox span {
  color: var(--text);
}

.identity-strip {
  max-width: 1100px;
  margin: 0 auto;
  padding: 0 24px 18px;
}

.identity-strip p {
  margin: 0;
  color: var(--muted);
}

.tabs {
  max-width: 1100px;
  margin: 0 auto;
}

.leaderboard-controls {
  margin: 0 0 14px;
  max-width: 560px;
}

.leaderboard-controls .form {
  border: 1px solid var(--border);
  border-radius: 8px;
  background: #fbfcfd;
  padding: 12px;
}

.leaderboard-controls button {
  width: 100%;
}

.leaderboard-table-wrap {
  width: 100%;
  overflow-x: auto;
  border: 1px solid var(--border);
  border-radius: 8px;
  background: #ffffff;
}

.leaderboard-table {
  width: 100%;
  border-collapse: collapse;
  table-layout: fixed;
  font-size: 12px;
}

.leaderboard-table th,
.leaderboard-table td {
  padding: 10px 12px;
  border-bottom: 1px solid #edf0f4;
  vertical-align: top;
  color: var(--text);
}

.leaderboard-table th {
  position: sticky;
  top: 0;
  z-index: 1;
  background: #f7f9fb;
  color: #3c4250;
  font-size: 12px;
  font-weight: 700;
  text-align: left;
  white-space: normal;
}

.leaderboard-table td {
  overflow-wrap: anywhere;
  line-height: 1.35;
}

.leaderboard-table tbody tr:nth-child(even) {
  background: #fafbfc;
}

.leaderboard-table tbody tr:hover {
  background: #f3f8ea;
}

.leaderboard-table .rank {
  width: 6%;
}

.leaderboard-table .team {
  width: 18%;
}

.leaderboard-table .score {
  width: 14%;
}

.leaderboard-table .incident-distance {
  width: 21%;
}

.leaderboard-table .image-tag {
  width: 25%;
}

.leaderboard-table .submitted-at {
  width: 15%;
}

.leaderboard-table .number {
  text-align: right;
  font-variant-numeric: tabular-nums;
}

.leaderboard-main,
.leaderboard-sub {
  display: block;
}

.leaderboard-sub {
  margin-top: 3px;
  color: var(--muted);
  font-size: 11px;
  line-height: 1.25;
}

.leaderboard-empty {
  padding: 24px;
  color: var(--muted);
}

@media (max-width: 720px) {
  .identity-strip {
    padding: 0 18px 18px;
  }

  .leaderboard-controls {
    max-width: none;
  }
}
"""
LANDING_HTML = f"""<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8" />
  <meta name="viewport" content="width=device-width, initial-scale=1" />
  <title>AlpaSim E2E Closed Loop Challenge 2026</title>
  <style>{BANNER_CSS}</style>
</head>
<body>
{BANNER_HTML}
{CHALLENGE_OVERVIEW_HTML}
{APP_EMBED_HTML}
</body>
</html>
"""


def split_multivalue(value: str) -> list[str]:
    items: list[str] = []
    seen: set[str] = set()
    for item in re.split(r"[\n,]", value or ""):
        cleaned = item.strip()
        if not cleaned or cleaned in seen:
            continue
        items.append(cleaned)
        seen.add(cleaned)
    return items


def profile_value(profile: gr.OAuthProfile, *keys: str) -> str:
    for key in keys:
        value = profile.get(key)
        if value:
            text = str(value)
            if key == "sub" and text in MOCKED_HF_USER_IDS:
                return ""
            return text
    return ""


def current_identity(profile: gr.OAuthProfile | None) -> str:
    if profile is None:
        return (
            "To register a team, connect this Space to your Hugging Face account. "
            "If you are already signed in on huggingface.co, this just authorizes "
            "the Space to read your Hugging Face profile. "
            "[Connect Hugging Face account](/login/huggingface?_target_url=/gradio/) "
            "If the link fails, open it in a new tab."
        )

    username = profile_value(profile, "preferred_username", "name")
    user_id = profile_value(profile, "sub")
    email = profile_value(profile, "email")
    parts = [f"Connected to this Space as Hugging Face user `{username}`."]
    if user_id:
        parts.append(f"Stable HF user ID: `{user_id}`.")
    if email:
        parts.append(f"HF email: `{email}`.")
    parts.append("[Disconnect](/logout?_target_url=/gradio/).")
    return " ".join(parts)


def empty_review_state() -> tuple[list[list[str]], list[dict[str, Any]], object, str, str]:
    return (
        [],
        [],
        gr.update(choices=[], value=None),
        "No registration selected.",
        "",
    )


def load_initial_review_state(
    profile: gr.OAuthProfile | None,
) -> tuple[object, list[list[str]], list[dict[str, Any]], object, str, str]:
    if profile is None or not REGISTRATION_SECRET:
        rows, registrations, selected, details, result = empty_review_state()
        return gr.update(visible=False), rows, registrations, selected, details, result
    try:
        body = review_api_json(
            "GET",
            "/review/registrations",
            profile,
            query={"status": "pending"},
        )
    except (urllib.error.HTTPError, urllib.error.URLError, gr.Error):
        rows, registrations, selected, details, result = empty_review_state()
        return gr.update(visible=False), rows, registrations, selected, details, result

    registrations = body.get("registrations") or []
    choices = registration_choices(registrations)
    selected = choices[0] if choices else None
    item = find_registration(registrations, selected_team_id(selected))
    result = f"Loaded {body.get('count', len(registrations))} pending registration(s)."
    return (
        gr.update(visible=True),
        registration_rows(registrations),
        registrations,
        gr.update(choices=choices, value=selected),
        review_details(item),
        result,
    )


def session_state(
    profile: gr.OAuthProfile | None,
) -> tuple[
    str,
    object,
    list[list[str]],
    list[dict[str, Any]],
    object,
    str,
    str,
]:
    review_state = load_initial_review_state(profile)
    return (current_identity(profile), *review_state)


def api_json(method: str, path: str, payload: dict | None = None) -> dict:
    if not API_BASE_URL:
        raise gr.Error("Space is missing ALPASIM_API_BASE_URL.")
    data = None if payload is None else json.dumps(payload).encode("utf-8")
    request = urllib.request.Request(
        f"{API_BASE_URL}{path}",
        data=data,
        method=method,
        headers={
            "Content-Type": "application/json",
            "Accept": "application/json",
            "X-AlpaSim-Registration-Secret": REGISTRATION_SECRET,
        },
    )
    with urllib.request.urlopen(request, timeout=15) as response:
        return json.loads(response.read().decode("utf-8"))


def api_error_summary(action: str, exc: Exception) -> str:
    if isinstance(exc, urllib.error.HTTPError):
        details = exc.read().decode("utf-8", errors="replace")
        return f"{action} failed with HTTP {exc.code}. {details}".strip()
    if isinstance(exc, urllib.error.URLError):
        return f"{action} failed: {exc.reason}"
    return f"{action} failed: {exc}"


def has_active_registered_team(user: dict[str, Any] | None) -> bool:
    if not user:
        return False

    team_id = str(user.get("team_id") or "")
    status = str(user.get("registration_status") or "").strip().lower()
    return bool(team_id) and status != "disabled"


def registered_team_status_detail(
    profile: gr.OAuthProfile | None,
) -> tuple[str, str, bool]:
    if profile is None:
        return "Sign in with Hugging Face to view team access.", "", False
    if not REGISTRATION_SECRET:
        return "Registration Space is missing ALPASIM_REGISTRATION_SECRET.", "", False

    hf_user_id = profile_value(profile, "sub")
    hf_username = profile_value(profile, "preferred_username", "name")
    if not hf_user_id or not hf_username:
        return "Could not read your Hugging Face identity.", "", False

    query = urllib.parse.urlencode(
        {
            "hf_user_id": hf_user_id,
            "hf_username": hf_username,
        }
    )
    try:
        body = api_json("GET", f"/registrations/submitter-invitations?{query}")
    except urllib.error.HTTPError as exc:
        details = exc.read().decode("utf-8", errors="replace")
        return f"Could not load team access status. HTTP {exc.code}.", details, False
    except urllib.error.URLError as exc:
        return f"Could not load team access status: {exc.reason}", "", False

    registered_user = body.get("registered_user")
    if not has_active_registered_team(registered_user):
        return (
            "No approved team access found for your Hugging Face account.",
            json.dumps(body, indent=2),
            False,
        )

    team_id = registered_user.get("team_id")
    role = registered_user.get("role") or "member"
    status = registered_user.get("registration_status") or "unknown"
    return (
        f"You already have `{status}` access to team `{team_id}` as `{role}`.",
        json.dumps(body, indent=2),
        True,
    )


def registration_status_detail(profile: gr.OAuthProfile | None) -> tuple[str, str, bool]:
    if profile is None:
        return "Sign in with Hugging Face to view registration status.", "", False
    if not REGISTRATION_SECRET:
        return "Registration Space is missing ALPASIM_REGISTRATION_SECRET.", "", False

    captain_hf_user_id = profile_value(profile, "sub")
    if not captain_hf_user_id:
        return "Could not read your stable Hugging Face user ID.", "", False

    query = urllib.parse.urlencode({"captain_hf_user_id": captain_hf_user_id})
    try:
        body = api_json("GET", f"/registrations/me?{query}")
    except urllib.error.HTTPError as exc:
        details = exc.read().decode("utf-8", errors="replace")
        return f"Could not load registration status. HTTP {exc.code}.", details, False
    except urllib.error.URLError as exc:
        return f"Could not load registration status: {exc.reason}", "", False

    registrations = body.get("registrations") or []
    if not registrations:
        return (
            "No team registration found for your Hugging Face account.",
            json.dumps(body, indent=2),
            False,
        )

    latest = registrations[0]
    status = str(latest.get("registration_status") or "unknown").strip().lower()
    team = latest.get("team_id") or ""
    display_name = latest.get("team_display_name") or team
    if status == "pending":
        summary = f"Registration pending review: {display_name} ({team})."
    elif status == "approved":
        summary = f"Team approved: {display_name} ({team})."
    elif status == "registered":
        summary = f"Team registered: {display_name} ({team})."
    elif status == "rejected":
        reason = latest.get("rejection_reason") or "No reason provided."
        summary = f"Registration rejected: {display_name} ({team}). Reason: {reason}"
    else:
        summary = f"Registration status for {display_name} ({team}): {status}."

    return summary, json.dumps(body, indent=2), status in ACTIVE_REGISTRATION_STATUSES


def registration_panel_status(profile: gr.OAuthProfile | None):
    summary, raw_json, has_active_registration = registration_status_detail(profile)
    needs_connection = profile is None
    if not needs_connection and not has_active_registration:
        member_summary, member_raw_json, has_active_team = registered_team_status_detail(
            profile
        )
        if has_active_team:
            summary = member_summary
            raw_json = member_raw_json
            has_active_registration = True

    return (
        summary,
        raw_json,
        gr.update(visible=not needs_connection and not has_active_registration),
    )


def submitter_invitation_status(
    profile: gr.OAuthProfile | None,
) -> tuple[str, list[dict[str, Any]], object, object]:
    if profile is None:
        return (
            "Connect your Hugging Face account to check submitter invitations.",
            [],
            gr.update(choices=[], value=None),
            gr.update(visible=False),
        )
    if not REGISTRATION_SECRET:
        return (
            "Registration Space is missing ALPASIM_REGISTRATION_SECRET.",
            [],
            gr.update(choices=[], value=None),
            gr.update(visible=False),
        )

    hf_user_id = profile_value(profile, "sub")
    hf_username = profile_value(profile, "preferred_username", "name")
    if not hf_user_id or not hf_username:
        return (
            "Could not read your Hugging Face identity.",
            [],
            gr.update(choices=[], value=None),
            gr.update(visible=False),
        )

    query = urllib.parse.urlencode(
        {
            "hf_user_id": hf_user_id,
            "hf_username": hf_username,
        }
    )
    try:
        body = api_json("GET", f"/registrations/submitter-invitations?{query}")
    except (urllib.error.HTTPError, urllib.error.URLError) as exc:
        return api_error_summary("Loading submitter invitations", exc), [], gr.update(choices=[], value=None), gr.update(visible=False)

    registered_user = body.get("registered_user") or {}
    invitations = body.get("invitations") or []
    choices = registration_choices(invitations)

    if invitations:
        summary = (
            f"You are listed as an approved submitter for {len(invitations)} team(s). "
            "Select a team and join it to enable challenge CLI, ECR login, and submissions."
        )
    elif has_active_registered_team(registered_user):
        summary = ""
    else:
        summary = "No approved submitter invitations found for your Hugging Face username."

    return (
        summary,
        invitations,
        gr.update(choices=choices, value=choices[0] if choices else None),
        gr.update(visible=bool(choices)),
    )


def claim_submitter_invitation(
    choice: str,
    profile: gr.OAuthProfile | None,
) -> str:
    if profile is None:
        raise gr.Error("Connect your Hugging Face account first.")

    team_id = selected_team_id(choice)
    if not team_id:
        raise gr.Error("Select a team invitation first.")

    payload = {
        "team_id": team_id,
        "hf_user_id": profile_value(profile, "sub"),
        "hf_username": profile_value(profile, "preferred_username", "name"),
        "email": profile_value(profile, "email"),
    }
    try:
        body = api_json("POST", "/registrations/claim-submitter", payload)
    except (urllib.error.HTTPError, urllib.error.URLError) as exc:
        raise gr.Error(api_error_summary(f"Joining {team_id}", exc)) from exc

    return str(body.get("message") or f"Joined {team_id}.")


def leaderboard_html(rows: list[list[Any]]) -> str:
    if not rows:
        return '<div class="leaderboard-table-wrap"><div class="leaderboard-empty">No successful submissions yet.</div></div>'

    visible_headers = [
        "Rank",
        "Team",
        "Policy Capability Score",
        "Avg Distance Between At-Fault Incidents",
        "Image Tag / Submission ID",
        "Submitted At",
    ]
    column_classes = [
        "rank number",
        "team",
        "score number",
        "incident-distance number",
        "image-tag",
        "submitted-at",
    ]
    header_cells = "".join(
        f'<th class="{css_class}">{html.escape(header)}</th>'
        for header, css_class in zip(visible_headers, column_classes)
    )
    body_rows = []
    for row in rows:
        rank, team, team_id, score, incident_distance, image_tag, submission_id, submitted_at = row

        def escaped_text(value: Any) -> str:
            return html.escape("" if value is None else str(value))

        team_title = html.escape(
            " / ".join(str(value) for value in (team, team_id) if value not in ("", None))
        )
        image_title = html.escape(
            " / ".join(str(value) for value in (image_tag, submission_id) if value not in ("", None))
        )
        cells = [
            f'<td class="rank number" title="{escaped_text(rank)}">{escaped_text(rank)}</td>',
            (
                f'<td class="team" title="{team_title}">'
                f'<span class="leaderboard-main">{escaped_text(team)}</span>'
                f'<span class="leaderboard-sub">{escaped_text(team_id)}</span>'
                "</td>"
            ),
            f'<td class="score number" title="{escaped_text(score)}">{escaped_text(score)}</td>',
            (
                '<td class="incident-distance number" '
                f'title="{escaped_text(incident_distance)}">{escaped_text(incident_distance)}</td>'
            ),
            (
                f'<td class="image-tag" title="{image_title}">'
                f'<span class="leaderboard-main">{escaped_text(image_tag)}</span>'
                f'<span class="leaderboard-sub">{escaped_text(submission_id)}</span>'
                "</td>"
            ),
            (
                f'<td class="submitted-at" title="{escaped_text(submitted_at)}">'
                f"{escaped_text(submitted_at)}</td>"
            ),
        ]
        body_rows.append(f"<tr>{''.join(cells)}</tr>")

    return (
        '<div class="leaderboard-table-wrap">'
        '<table class="leaderboard-table">'
        f"<thead><tr>{header_cells}</tr></thead>"
        f"<tbody>{''.join(body_rows)}</tbody>"
        "</table>"
        "</div>"
    )


def leaderboard(
    show_all_successful: bool = False,
    sort_by: str = "Rank",
    sort_ascending: bool = True,
    track: str = "pai",
) -> tuple[str, str, str]:
    try:
        body = api_json("GET", f"/leaderboard?{urllib.parse.urlencode({'track': track})}")
    except urllib.error.HTTPError as exc:
        details = exc.read().decode("utf-8", errors="replace")
        return f"Could not load leaderboard. HTTP {exc.code}.", leaderboard_html([]), details
    except urllib.error.URLError as exc:
        return f"Could not load leaderboard: {exc.reason}", leaderboard_html([]), ""

    entries = body.get("leaderboard") or []
    if not show_all_successful:
        score_order = str(body.get("score_order") or "desc").lower()
        best_by_team: dict[str, dict[str, Any]] = {}
        for index, entry in enumerate(entries):
            team_id = str(
                entry.get("team_id")
                or entry.get("team_display_name")
                or entry.get("submission_id")
                or f"row-{index}"
            )
            policy_score = entry.get("policy_capability_score")
            if policy_score is None:
                policy_score = entry.get("best_score")
            try:
                numeric_score = float(policy_score)
            except (TypeError, ValueError):
                numeric_score = None

            current = best_by_team.get(team_id)
            current_score = current.get("_numeric_policy_score") if current else None
            if current is None:
                best_entry = dict(entry)
                best_entry["_numeric_policy_score"] = numeric_score
                best_entry["_leaderboard_source_index"] = index
                best_by_team[team_id] = best_entry
            elif numeric_score is not None and (
                current_score is None
                or (score_order == "asc" and numeric_score < current_score)
                or (score_order != "asc" and numeric_score > current_score)
            ):
                best_entry = dict(entry)
                best_entry["_numeric_policy_score"] = numeric_score
                best_entry["_leaderboard_source_index"] = index
                best_by_team[team_id] = best_entry
        entries = sorted(
            best_by_team.values(),
            key=lambda entry: entry.get("_leaderboard_source_index", 0),
        )

    def metric_value(value: Any) -> float | str:
        if value is None:
            return ""
        try:
            return round(float(value), 3)
        except (TypeError, ValueError):
            return str(value)

    rows: list[list[Any]] = []
    for row_rank, entry in enumerate(entries, start=1):
        displayed_rank = (entry.get("rank") or row_rank) if show_all_successful else row_rank
        policy_score = entry.get("policy_capability_score")
        if policy_score is None:
            policy_score = entry.get("best_score")
        incident_distance = entry.get("avg_dist_between_incidents_at_fault")
        if incident_distance is None:
            incident_distance = entry.get("legacy_score")
        rows.append(
            [
                displayed_rank,
                entry.get("team_display_name") or entry.get("team_id") or "",
                entry.get("team_id") or "",
                metric_value(policy_score),
                metric_value(incident_distance),
                entry.get("image_tag") or "",
                entry.get("submission_id") or "",
                entry.get("submitted_at") or "",
            ]
        )

    if sort_by in LEADERBOARD_HEADERS:
        sort_index = LEADERBOARD_HEADERS.index(sort_by)

        def sort_key(row: list[Any]) -> Any:
            value = row[sort_index]
            if isinstance(value, (int, float)):
                return value
            return str(value).lower()

        populated_rows = [row for row in rows if row[sort_index] not in ("", None)]
        empty_rows = [row for row in rows if row[sort_index] in ("", None)]
        rows = sorted(populated_rows, key=sort_key, reverse=not sort_ascending) + empty_rows

    summary = (
        f"{track.upper()} leaderboard entries: {len(entries)} shown"
        f" out of {body.get('count', 0)}. "
        f"Score order: {body.get('score_order', 'desc')}."
    )
    return summary, leaderboard_html(rows), json.dumps(body, indent=2)


def submit_registration(
    team_display_name: str,
    team_id: str,
    captain_name: str,
    contact_email: str,
    additional_submitters: str,
    credited_contributors: str,
    organization: str,
    country_region: str,
    notes: str,
    organization_email_ack: bool,
    roster_ack: bool,
    limit_ack: bool,
    rules_ack: bool,
    profile: gr.OAuthProfile | None,
) -> tuple[str, str, str, object]:
    if profile is None:
        return "Connect your Hugging Face account first.", "", "", gr.update(visible=False)
    if not REGISTRATION_SECRET:
        return "Registration Space is missing ALPASIM_REGISTRATION_SECRET.", "", "", gr.update(visible=True)
    if not organization_email_ack or not roster_ack or not limit_ack or not rules_ack:
        return "Please accept all required acknowledgments.", "", "", gr.update(visible=True)

    status_summary, raw_json, form_update = registration_panel_status(profile)
    if isinstance(form_update, dict) and form_update.get("visible") is False:
        return (
            "You already have an active team registration or team access.",
            raw_json,
            status_summary,
            form_update,
        )

    captain_hf_user_id = profile_value(profile, "sub")
    captain_hf_username = profile_value(profile, "preferred_username", "name")
    captain_email = contact_email.strip() or profile_value(profile, "email")

    payload = {
        "team_display_name": team_display_name.strip(),
        "team_id": team_id.strip(),
        "captain_name": captain_name.strip(),
        "captain_email": captain_email,
        "captain_hf_user_id": captain_hf_user_id,
        "captain_hf_username": captain_hf_username,
        "submitter_hf_usernames": split_multivalue(additional_submitters),
        "credited_contributors": split_multivalue(credited_contributors),
        "organization": organization.strip(),
        "country_region": country_region.strip(),
        "notes": notes.strip(),
    }

    try:
        body = api_json("POST", "/registrations", payload)
    except urllib.error.HTTPError as exc:
        body = exc.read().decode("utf-8", errors="replace")
        status_summary, _, form_update = registration_panel_status(profile)
        return f"Registration failed with HTTP {exc.code}.", body, status_summary, form_update
    except urllib.error.URLError as exc:
        status_summary, _, form_update = registration_panel_status(profile)
        return f"Registration request failed: {exc.reason}", "", status_summary, form_update

    status_summary, _, form_update = registration_panel_status(profile)
    return "Registration submitted for admin review.", json.dumps(body, indent=2), status_summary, form_update


def reviewer_identity(profile: gr.OAuthProfile | None) -> dict[str, str]:
    if profile is None:
        raise gr.Error("Sign in with Hugging Face before reviewing registrations.")

    reviewer_hf_user_id = profile_value(profile, "sub")
    reviewer_hf_username = profile_value(profile, "preferred_username", "name")
    if not reviewer_hf_user_id:
        raise gr.Error("Could not read your stable Hugging Face user ID.")

    return {
        "reviewer_hf_user_id": reviewer_hf_user_id,
        "reviewer_hf_username": reviewer_hf_username,
    }


def review_api_json(
    method: str,
    path: str,
    profile: gr.OAuthProfile | None,
    payload: dict | None = None,
    query: dict | None = None,
) -> dict:
    reviewer = reviewer_identity(profile)
    query_with_reviewer = {**reviewer, **(query or {})}
    encoded_query = urllib.parse.urlencode(query_with_reviewer)
    path_with_query = f"{path}?{encoded_query}" if encoded_query else path
    payload_with_reviewer = {**reviewer, **(payload or {})} if payload is not None else None
    return api_json(method, path_with_query, payload_with_reviewer)


def registration_rows(registrations: list[dict[str, Any]]) -> list[list[str]]:
    return [
        [
            str(item.get("team_id") or ""),
            str(item.get("team_display_name") or ""),
            str(item.get("registration_status") or ""),
            str(item.get("captain_hf_username") or ""),
            str(item.get("organization") or ""),
            str(item.get("updated_at") or item.get("created_at") or ""),
        ]
        for item in registrations
    ]


def registration_choices(registrations: list[dict[str, Any]]) -> list[str]:
    choices = []
    for item in registrations:
        team_id = str(item.get("team_id") or "")
        display_name = str(item.get("team_display_name") or team_id)
        if team_id:
            choices.append(f"{team_id} | {display_name}")
    return choices


def selected_team_id(choice: str | None) -> str:
    return (choice or "").split("|", 1)[0].strip()


def find_registration(
    registrations: list[dict[str, Any]],
    team_id: str,
) -> dict[str, Any] | None:
    for item in registrations:
        if str(item.get("team_id") or "") == team_id:
            return item
    return None


def format_list(value: Any) -> str:
    if isinstance(value, list):
        return ", ".join(str(part) for part in value if str(part)) or "-"
    return str(value) if value not in (None, "") else "-"


def review_details(item: dict[str, Any] | None) -> str:
    if not item:
        return "No registration selected."

    def value(key: str) -> str:
        return format_list(item.get(key))

    lines = [
        f"### {value('team_display_name')} (`{value('team_id')}`)",
        f"Status: `{value('registration_status')}`",
        f"Source: `{value('registration_source')}`",
        "",
        f"Captain: {value('captain_name')} / `{value('captain_hf_username')}`",
        f"Captain email: {value('captain_email')}",
        f"Captain HF user ID: `{value('captain_hf_user_id')}`",
        "",
        f"Submitters: {value('submitter_hf_usernames')}",
        f"Credited contributors: {value('credited_contributors')}",
        f"Organization: {value('organization')}",
        f"Country/region: {value('country_region')}",
        "",
        f"Notes: {value('notes')}",
        "",
        f"Created: {value('created_at')}",
        f"Updated: {value('updated_at')}",
        f"Approved: {value('approved_at')}",
    ]
    if item.get("rejection_reason"):
        lines.append(f"Rejection reason: {value('rejection_reason')}")
    if item.get("reviewed_by_hf_username") or item.get("reviewed_by_hf_user_id"):
        lines.append(
            "Reviewed by: "
            f"{value('reviewed_by_hf_username')} (`{value('reviewed_by_hf_user_id')}`)"
        )
    return "\n".join(lines)


def refresh_review_registrations(
    status_filter: str,
    profile: gr.OAuthProfile | None,
) -> tuple[list[list[str]], list[dict[str, Any]], object, str, str]:
    if not REGISTRATION_SECRET:
        raise gr.Error("Registration Space is missing ALPASIM_REGISTRATION_SECRET.")

    try:
        body = review_api_json(
            "GET",
            "/review/registrations",
            profile,
            query={"status": status_filter or "pending"},
        )
    except (urllib.error.HTTPError, urllib.error.URLError) as exc:
        raise gr.Error(api_error_summary("Loading review registrations", exc)) from exc

    registrations = body.get("registrations") or []
    choices = registration_choices(registrations)
    selected = choices[0] if choices else None
    item = find_registration(registrations, selected_team_id(selected))
    result = f"Loaded {body.get('count', len(registrations))} registration(s)."
    return (
        registration_rows(registrations),
        registrations,
        gr.update(choices=choices, value=selected),
        review_details(item),
        result,
    )


def refresh_review_registrations_without_result(
    status_filter: str,
    profile: gr.OAuthProfile | None,
) -> tuple[list[list[str]], list[dict[str, Any]], object, str]:
    rows, registrations, selected, details, _ = refresh_review_registrations(
        status_filter,
        profile,
    )
    return rows, registrations, selected, details


def select_review_registration(
    choice: str,
    registrations: list[dict[str, Any]],
) -> str:
    item = find_registration(registrations or [], selected_team_id(choice))
    return review_details(item)


def approve_review_registration(
    choice: str,
    profile: gr.OAuthProfile | None,
) -> str:
    team_id = selected_team_id(choice)
    if not team_id:
        raise gr.Error("Select a registration first.")

    try:
        body = review_api_json(
            "POST",
            "/review/registrations/approve",
            profile,
            {"team_id": team_id},
        )
    except (urllib.error.HTTPError, urllib.error.URLError) as exc:
        raise gr.Error(api_error_summary(f"Approving {team_id}", exc)) from exc

    return str(body.get("message") or f"Approved {team_id}.")


def reject_review_registration(
    choice: str,
    reason: str,
    profile: gr.OAuthProfile | None,
) -> str:
    team_id = selected_team_id(choice)
    if not team_id:
        raise gr.Error("Select a registration first.")
    reason = reason.strip()
    if not reason:
        raise gr.Error("Enter a rejection reason.")

    try:
        body = review_api_json(
            "POST",
            "/review/registrations/reject",
            profile,
            {"team_id": team_id, "reason": reason},
        )
    except (urllib.error.HTTPError, urllib.error.URLError) as exc:
        raise gr.Error(api_error_summary(f"Rejecting {team_id}", exc)) from exc

    return str(body.get("message") or f"Rejected {team_id}.")


def add_oauth_route_marker() -> None:
    if os.environ.get("SYSTEM") != "spaces" and not os.environ.get("OAUTH_CLIENT_ID"):
        return

    original_activate = gr.LoginButton.activate
    gr.LoginButton.activate = lambda self: None
    try:
        gr.LoginButton(visible=False)
    finally:
        gr.LoginButton.activate = original_activate


with gr.Blocks(
    title="AlpaSim E2E Closed Loop Challenge 2026",
    theme=APP_THEME,
    css=GRADIO_CSS,
) as demo:
    add_oauth_route_marker()
    with gr.Group(elem_classes=["identity-strip"]):
        identity = gr.Markdown()

    with gr.Tabs(selected="registration"):
        with gr.Tab("Registration", id="registration"):
            registration_summary = gr.Markdown()
            submitter_invitation_summary = gr.Markdown()
            submitter_invitation_state = gr.State([])

            with gr.Group(visible=False) as registration_form:
                gr.Markdown(
                    "If the captain's Hugging Face account uses a personal email address, "
                    "enter an organization email below. Before accepting the application, "
                    "the AlpaSim team will email that organization address for confirmation."
                )

                with gr.Row():
                    team_display_name = gr.Textbox(
                        label="Team Display Name",
                        placeholder="Team Alpha",
                        max_lines=1,
                    )
                    team_id = gr.Textbox(
                        label="Requested Team ID",
                        placeholder="team-alpha",
                        max_lines=1,
                        info="Lowercase letters, digits, hyphens. 3-40 characters.",
                    )

                with gr.Row():
                    captain_name = gr.Textbox(label="Captain Full Name", max_lines=1)
                    contact_email = gr.Textbox(
                        label="Captain Contact / Organization Email",
                        max_lines=1,
                        info=(
                            "Use an organization email if your Hugging Face account "
                            "email is personal. Organizers may email this address "
                            "before accepting the application."
                        ),
                    )

                additional_submitters = gr.Textbox(
                    label="Additional Submitter Hugging Face Usernames",
                    lines=4,
                    placeholder="one username per line, or comma-separated",
                )
                credited_contributors = gr.Textbox(
                    label="Credited Contributors",
                    lines=4,
                    placeholder="one name per line, or comma-separated",
                )

                with gr.Row():
                    organization = gr.Textbox(label="Organization / Affiliation", max_lines=1)
                    country_region = gr.Textbox(label="Country / Region", max_lines=1)

                notes = gr.Textbox(label="Notes To Organizers", lines=3)

                organization_email_ack = gr.Checkbox(
                    label="I understand that if my Hugging Face account uses a personal email address, I must enter my academic, company, or organization email in the Captain Contact / Organization Email field."
                )
                roster_ack = gr.Checkbox(
                    label="I understand that the submitter roster is frozen after approval except by administrator exception."
                )
                limit_ack = gr.Checkbox(
                    label="I understand that submissions are limited at the team level and should only be used for images we want evaluated."
                )
                rules_ack = gr.Checkbox(
                    label="I agree to follow the AlpaSim Challenge rules and organizer instructions."
                )

                submit = gr.Button("Submit Registration", variant="primary")
                status = gr.Textbox(label="Status", interactive=False)
                response = gr.Code(label="Response", language="json", visible=False)

            with gr.Group(visible=False) as submitter_invitation_panel:
                submitter_invitation_choice = gr.Dropdown([], label="Submitter Invitation")
                claim_submitter = gr.Button("Join Team", variant="primary")
                claim_submitter_result = gr.Textbox(label="Result", interactive=False)

        with gr.Tab("PAI Leaderboard", id="leaderboard"):
            leaderboard_summary = gr.Markdown()
            with gr.Group(elem_classes=["leaderboard-controls"]):
                leaderboard_sort_by = gr.Dropdown(
                    LEADERBOARD_SORT_CHOICES,
                    value="Rank",
                    label="Sort by",
                )
                with gr.Row():
                    show_all_successful = gr.Checkbox(
                        label="All successful submissions",
                        value=False,
                        scale=1,
                    )
                    leaderboard_sort_ascending = gr.Checkbox(
                        label="Ascending sort",
                        value=True,
                        scale=1,
                    )
                refresh_leaderboard = gr.Button("Refresh", variant="primary")
            leaderboard_table = gr.HTML()
            leaderboard_response = gr.Code(
                label="Leaderboard JSON",
                language="json",
                visible=False,
            )

        with gr.Tab("nuPlan Leaderboard", id="nuplan-leaderboard"):
            nuplan_leaderboard_summary = gr.Markdown()
            with gr.Group(elem_classes=["leaderboard-controls"]):
                nuplan_leaderboard_sort_by = gr.Dropdown(
                    LEADERBOARD_SORT_CHOICES,
                    value="Rank",
                    label="Sort by",
                )
                with gr.Row():
                    nuplan_show_all_successful = gr.Checkbox(
                        label="All successful submissions",
                        value=False,
                        scale=1,
                    )
                    nuplan_leaderboard_sort_ascending = gr.Checkbox(
                        label="Ascending sort",
                        value=True,
                        scale=1,
                    )
                refresh_nuplan_leaderboard = gr.Button("Refresh", variant="primary")
            nuplan_leaderboard_table = gr.HTML()
            nuplan_leaderboard_response = gr.Code(
                label="Leaderboard JSON",
                language="json",
                visible=False,
            )

        with gr.Tab("Review", id="review", visible=False) as review_tab:
            gr.Markdown("Reviewer access is limited to active AlpaSim reviewers.")
            review_state = gr.State([])

            with gr.Row():
                review_status_filter = gr.Dropdown(
                    REVIEW_STATUS_CHOICES,
                    value="pending",
                    label="Status",
                    scale=1,
                )
                refresh_review = gr.Button("Refresh", variant="primary", scale=1)

            review_table = gr.Dataframe(
                headers=[
                    "team_id",
                    "display_name",
                    "status",
                    "captain_hf_username",
                    "organization",
                    "updated",
                ],
                datatype=["str", "str", "str", "str", "str", "str"],
                interactive=False,
                wrap=True,
            )
            selected_review_registration = gr.Dropdown([], label="Selected Registration")
            review_registration_details = gr.Markdown("No registration selected.")

            approve_review = gr.Button("Approve", variant="primary")

            with gr.Accordion("Reject", open=False):
                review_rejection_reason = gr.Textbox(label="Reason", lines=3)
                reject_review = gr.Button("Reject", variant="stop")

            review_result = gr.Textbox(label="Result", interactive=False)

    demo.load(
        session_state,
        inputs=None,
        outputs=[
            identity,
            review_tab,
            review_table,
            review_state,
            selected_review_registration,
            review_registration_details,
            review_result,
        ],
    )
    demo.load(
        registration_panel_status,
        inputs=None,
        outputs=[
            registration_summary,
            response,
            registration_form,
        ],
    )
    demo.load(
        submitter_invitation_status,
        inputs=None,
        outputs=[
            submitter_invitation_summary,
            submitter_invitation_state,
            submitter_invitation_choice,
            submitter_invitation_panel,
        ],
    )
    demo.load(
        lambda show_all, sort_by, ascending: leaderboard(show_all, sort_by, ascending, "pai"),
        inputs=[show_all_successful, leaderboard_sort_by, leaderboard_sort_ascending],
        outputs=[leaderboard_summary, leaderboard_table, leaderboard_response],
    )
    refresh_leaderboard.click(
        lambda show_all, sort_by, ascending: leaderboard(show_all, sort_by, ascending, "pai"),
        inputs=[show_all_successful, leaderboard_sort_by, leaderboard_sort_ascending],
        outputs=[leaderboard_summary, leaderboard_table, leaderboard_response],
    )
    show_all_successful.change(
        lambda show_all, sort_by, ascending: leaderboard(show_all, sort_by, ascending, "pai"),
        inputs=[show_all_successful, leaderboard_sort_by, leaderboard_sort_ascending],
        outputs=[leaderboard_summary, leaderboard_table, leaderboard_response],
    )
    leaderboard_sort_by.change(
        lambda show_all, sort_by, ascending: leaderboard(show_all, sort_by, ascending, "pai"),
        inputs=[show_all_successful, leaderboard_sort_by, leaderboard_sort_ascending],
        outputs=[leaderboard_summary, leaderboard_table, leaderboard_response],
    )
    leaderboard_sort_ascending.change(
        lambda show_all, sort_by, ascending: leaderboard(show_all, sort_by, ascending, "pai"),
        inputs=[show_all_successful, leaderboard_sort_by, leaderboard_sort_ascending],
        outputs=[leaderboard_summary, leaderboard_table, leaderboard_response],
    )
    demo.load(
        lambda show_all, sort_by, ascending: leaderboard(show_all, sort_by, ascending, "nuplan"),
        inputs=[
            nuplan_show_all_successful,
            nuplan_leaderboard_sort_by,
            nuplan_leaderboard_sort_ascending,
        ],
        outputs=[
            nuplan_leaderboard_summary,
            nuplan_leaderboard_table,
            nuplan_leaderboard_response,
        ],
    )
    refresh_nuplan_leaderboard.click(
        lambda show_all, sort_by, ascending: leaderboard(show_all, sort_by, ascending, "nuplan"),
        inputs=[
            nuplan_show_all_successful,
            nuplan_leaderboard_sort_by,
            nuplan_leaderboard_sort_ascending,
        ],
        outputs=[
            nuplan_leaderboard_summary,
            nuplan_leaderboard_table,
            nuplan_leaderboard_response,
        ],
    )
    nuplan_show_all_successful.change(
        lambda show_all, sort_by, ascending: leaderboard(show_all, sort_by, ascending, "nuplan"),
        inputs=[
            nuplan_show_all_successful,
            nuplan_leaderboard_sort_by,
            nuplan_leaderboard_sort_ascending,
        ],
        outputs=[
            nuplan_leaderboard_summary,
            nuplan_leaderboard_table,
            nuplan_leaderboard_response,
        ],
    )
    nuplan_leaderboard_sort_by.change(
        lambda show_all, sort_by, ascending: leaderboard(show_all, sort_by, ascending, "nuplan"),
        inputs=[
            nuplan_show_all_successful,
            nuplan_leaderboard_sort_by,
            nuplan_leaderboard_sort_ascending,
        ],
        outputs=[
            nuplan_leaderboard_summary,
            nuplan_leaderboard_table,
            nuplan_leaderboard_response,
        ],
    )
    nuplan_leaderboard_sort_ascending.change(
        lambda show_all, sort_by, ascending: leaderboard(show_all, sort_by, ascending, "nuplan"),
        inputs=[
            nuplan_show_all_successful,
            nuplan_leaderboard_sort_by,
            nuplan_leaderboard_sort_ascending,
        ],
        outputs=[
            nuplan_leaderboard_summary,
            nuplan_leaderboard_table,
            nuplan_leaderboard_response,
        ],
    )
    submit.click(
        submit_registration,
        inputs=[
            team_display_name,
            team_id,
            captain_name,
            contact_email,
            additional_submitters,
            credited_contributors,
            organization,
            country_region,
            notes,
            organization_email_ack,
            roster_ack,
            limit_ack,
            rules_ack,
        ],
        outputs=[
            status,
            response,
            registration_summary,
            registration_form,
        ],
    )
    claim_submitter.click(
        claim_submitter_invitation,
        inputs=[submitter_invitation_choice],
        outputs=[claim_submitter_result],
    ).then(
        submitter_invitation_status,
        inputs=None,
        outputs=[
            submitter_invitation_summary,
            submitter_invitation_state,
            submitter_invitation_choice,
            submitter_invitation_panel,
        ],
    ).then(
        registration_panel_status,
        inputs=None,
        outputs=[
            registration_summary,
            response,
            registration_form,
        ],
    )
    refresh_review.click(
        refresh_review_registrations,
        inputs=[review_status_filter],
        outputs=[
            review_table,
            review_state,
            selected_review_registration,
            review_registration_details,
            review_result,
        ],
    )
    review_status_filter.change(
        refresh_review_registrations,
        inputs=[review_status_filter],
        outputs=[
            review_table,
            review_state,
            selected_review_registration,
            review_registration_details,
            review_result,
        ],
    )
    selected_review_registration.change(
        select_review_registration,
        inputs=[selected_review_registration, review_state],
        outputs=[review_registration_details],
    )
    approve_review.click(
        approve_review_registration,
        inputs=[
            selected_review_registration,
        ],
        outputs=[review_result],
    ).then(
        refresh_review_registrations_without_result,
        inputs=[review_status_filter],
        outputs=[
            review_table,
            review_state,
            selected_review_registration,
            review_registration_details,
        ],
    )
    reject_review.click(
        reject_review_registration,
        inputs=[selected_review_registration, review_rejection_reason],
        outputs=[review_result],
    ).then(
        refresh_review_registrations_without_result,
        inputs=[review_status_filter],
        outputs=[
            review_table,
            review_state,
            selected_review_registration,
            review_registration_details,
        ],
    )

app = FastAPI(title="AlpaSim E2E Closed Loop Challenge 2026")
app.mount("/assets", StaticFiles(directory=str(BANNER_DIR)), name="assets")


@app.get("/", response_class=HTMLResponse, include_in_schema=False)
def landing_page() -> HTMLResponse:
    return HTMLResponse(LANDING_HTML)


app = gr.mount_gradio_app(
    app,
    demo,
    path="/gradio",
    allowed_paths=[str(BANNER_FILE)],
)

for route in app.routes:
    if getattr(route, "path", None) == "/gradio" and hasattr(route, "app"):
        # Gradio Spaces OAuth redirects to /login/callback even when the app is
        # mounted under /gradio. Mount the same ASGI app at root after the exact
        # landing-page route so those OAuth endpoints still resolve.
        app.mount("/", route.app)
        break
else:
    raise RuntimeError("Unable to find mounted Gradio app for OAuth routes.")


if __name__ == "__main__":
    import uvicorn

    uvicorn.run(
        app,
        host="0.0.0.0",
        port=int(os.environ.get("PORT", "7860")),
    )