app.py

"""Offsides — Tactical Edge Detection Demo.

Gradio app displaying pre-computed Qwen-VL 72B tactical assessments
of UEFA Champions League matches on AMD MI300X.
"""

import json
from pathlib import Path

import gradio as gr
import plotly.graph_objects as go

APP_DIR = Path(__file__).resolve().parent
RESULTS_PATH = APP_DIR / "data" / "vlm_results" / "results.json"
DEMO_PATH = APP_DIR / "data" / "demo_matches.json"
FRAMES_DIR = APP_DIR / "data" / "vlm_results" / "frames"


def load_results():
    with open(RESULTS_PATH) as f:
        results = json.load(f)
    with open(DEMO_PATH) as f:
        demos = json.load(f)
    demo_lookup = {d["match_id"]: d for d in demos}
    for m in results["matches"]:
        demo = demo_lookup.get(m["match_id"], {})
        m["first_leg"] = demo.get("first_leg", "")
        m["odds"] = demo.get("odds", {})
        m["narrative"] = demo.get("narrative", "")
    return results


RESULTS = load_results()
MATCHES = RESULTS["matches"]


def result_key(actual_result: str) -> str:
    if actual_result == "home_win":
        return "home"
    if actual_result == "away_win":
        return "away"
    return "draw"


def get_match_choices():
    choices = []
    for m in MATCHES:
        label = f"{m['home_team']} vs {m['away_team']} — {m['stage']} ({m['date']})"
        choices.append(label)
    return choices


def get_scorecard():
    correct = 0
    for m in MATCHES:
        edge = m["vlm_assessment"]["edge"]
        actual = result_key(m["actual_result"])
        best = max(edge.items(), key=lambda x: x[1])
        if best[0] == actual:
            correct += 1
    return correct, len(MATCHES)


def make_prob_chart(match):
    market = match["market_odds"]
    vlm = match["vlm_assessment"]["probabilities"]

    categories = ["Home", "Draw", "Away"]
    market_vals = [market["home"] * 100, market["draw"] * 100, market["away"] * 100]
    vlm_vals = [vlm.get("home", 0) * 100, vlm.get("draw", 0) * 100, vlm.get("away", 0) * 100]

    fig = go.Figure()
    fig.add_trace(go.Bar(
        name="Market Implied",
        x=categories,
        y=market_vals,
        marker_color="#6366f1",
        text=[f"{v:.0f}%" for v in market_vals],
        textposition="outside",
    ))
    fig.add_trace(go.Bar(
        name="VLM Assessment",
        x=categories,
        y=vlm_vals,
        marker_color="#10b981",
        text=[f"{v:.0f}%" for v in vlm_vals],
        textposition="outside",
    ))
    fig.update_layout(
        barmode="group",
        title="Probability Comparison: Market vs VLM",
        yaxis_title="Probability (%)",
        yaxis_range=[0, 75],
        template="plotly_dark",
        height=350,
        margin=dict(t=40, b=40),
        legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1),
    )
    return fig


def get_frame_images(match):
    images = []
    for fp in match.get("frames_used", []):
        parts = Path(fp).parts
        match_dir = parts[2]
        frame_name = parts[-1]
        local_path = FRAMES_DIR / match_dir / frame_name
        if local_path.exists():
            images.append(str(local_path))
    return images


def format_edge_badge(match):
    edge = match["vlm_assessment"]["edge"]
    actual = result_key(match["actual_result"])
    best = max(edge.items(), key=lambda x: x[1])
    best_outcome, best_val = best

    correct = best_outcome == actual
    outcome_label = {"home": match["home_team"], "draw": "Draw", "away": match["away_team"]}
    badge = f"**Edge: +{best_val*100:.0f}pp on {outcome_label[best_outcome]}**"

    if correct:
        return f"### {badge}\n\nActual result: **{match['actual_score']}** ({match['actual_result'].replace('_', ' ')}) — CORRECT"
    else:
        return f"### {badge}\n\nActual result: **{match['actual_score']}** ({match['actual_result'].replace('_', ' ')})"


def format_reasoning(match):
    a = match["vlm_assessment"]
    lines = []
    lines.append(f"**Confidence:** {a['confidence']}")
    lines.append("")
    lines.append(f"**Reasoning:** {a['reasoning']}")
    lines.append("")
    lines.append("**Visual Evidence:**")
    for ev in a.get("visual_evidence", []):
        lines.append(f"- {ev}")
    lines.append("")
    lines.append(f"**Edge Signal:** {a['edge_signal']}")
    return "\n".join(lines)


def format_metrics(match):
    ctx = match.get("metrics_context", {})
    lines = []
    for side, label in [("home", match["home_team"]), ("away", match["away_team"])]:
        data = ctx.get(side, {})
        metrics = data.get("metrics", {})
        if not metrics:
            continue
        lines.append(f"**{label}** (last 3 matches):")
        matches_analyzed = data.get("matches_analyzed", [])
        if matches_analyzed:
            lines.append(f"- Matches: {', '.join(m.replace('_', ' ') for m in matches_analyzed)}")
        if "avg_pressing_speed" in metrics:
            lines.append(f"- Pressing speed: {metrics['avg_pressing_speed']:.4f}")
        if "avg_def_line_movement" in metrics:
            lines.append(f"- Defensive line movement: {metrics['avg_def_line_movement']:.4f}")
        if "avg_compactness_delta" in metrics:
            lines.append(f"- Compactness delta: {metrics['avg_compactness_delta']:.3f}")
        if "avg_transition_speed" in metrics:
            lines.append(f"- Transition speed: {metrics['avg_transition_speed']:.4f}")
        lines.append("")
    return "\n".join(lines)


def format_stats(match):
    stats = match.get("stats", {})
    lines = []
    for side in ["home", "away"]:
        s = stats.get(side, {})
        if not s:
            continue
        lines.append(f"**{s.get('team', side.title())}:**")
        lines.append(f"| Metric | Value |")
        lines.append(f"|--------|-------|")
        lines.append(f"| xG/match | {s.get('xg_last5', '-')} |")
        lines.append(f"| xGA/match | {s.get('xga_last5', '-')} |")
        lines.append(f"| PPDA | {s.get('ppda', '-')} |")
        lines.append(f"| Possession | {s.get('possession_pct', '-')}% |")
        lines.append(f"| Form | {s.get('form', '-')} |")
        lines.append(f"| Goals (last 5) | {s.get('goals_scored_last5', '-')}F / {s.get('goals_conceded_last5', '-')}A |")
        lines.append("")
    return "\n".join(lines)


def format_match_info(match):
    lines = []
    lines.append(f"**{match['home_team']}** vs **{match['away_team']}**")
    lines.append(f"- Stage: {match['stage']}")
    lines.append(f"- Date: {match['date']}")
    if match.get("first_leg"):
        lines.append(f"- First leg: {match['first_leg']}")
    odds = match.get("odds", {})
    if odds:
        lines.append(f"- Decimal odds: {match['home_team']} {odds.get('home', '-')} / Draw {odds.get('draw', '-')} / {match['away_team']} {odds.get('away', '-')}")
    market = match["market_odds"]
    lines.append(f"- Implied probability: {match['home_team']} {market['home']*100:.0f}% / Draw {market['draw']*100:.0f}% / {match['away_team']} {market['away']*100:.0f}%")
    if match.get("narrative"):
        lines.append(f"\n*{match['narrative']}*")
    return "\n".join(lines)


def on_match_select(choice):
    idx = get_match_choices().index(choice)
    match = MATCHES[idx]

    chart = make_prob_chart(match)
    frames = get_frame_images(match)
    edge_text = format_edge_badge(match)
    reasoning_text = format_reasoning(match)
    metrics_text = format_metrics(match)
    stats_text = format_stats(match)
    info_text = format_match_info(match)

    return chart, frames, edge_text, reasoning_text, metrics_text, stats_text, info_text


correct, total = get_scorecard()

with gr.Blocks(title="Offsides — Tactical Edge Detection") as demo:
    gr.Markdown(f"""
# Offsides — Tactical Edge Detection

**Where the market gets it wrong.** Multimodal AI analyzes UEFA Champions League footage using YOLO + Qwen-VL 72B on AMD MI300X to detect mispriced prediction markets.

**Scorecard: {correct}/{total} correct edge calls** | Model: {RESULTS['model']} | Generated: {RESULTS['generated_at'][:10]}
""")

    with gr.Row():
        match_dropdown = gr.Dropdown(
            choices=get_match_choices(),
            value=get_match_choices()[0],
            label="Select Match",
            interactive=True,
        )

    with gr.Row():
        with gr.Column(scale=1):
            prob_chart = gr.Plot(label="Probability Comparison")
            edge_badge = gr.Markdown()
            reasoning_box = gr.Markdown(label="VLM Assessment")

        with gr.Column(scale=1):
            frame_gallery = gr.Gallery(
                label="Annotated Frames (analyzed by VLM)",
                columns=2,
                height=400,
            )
            with gr.Accordion("Tactical Metrics", open=False):
                metrics_box = gr.Markdown()
            with gr.Accordion("Match Statistics", open=False):
                stats_box = gr.Markdown()

    with gr.Row():
        info_box = gr.Markdown()

    match_dropdown.change(
        fn=on_match_select,
        inputs=[match_dropdown],
        outputs=[prob_chart, frame_gallery, edge_badge, reasoning_box, metrics_box, stats_box, info_box],
    )

    demo.load(
        fn=on_match_select,
        inputs=[match_dropdown],
        outputs=[prob_chart, frame_gallery, edge_badge, reasoning_box, metrics_box, stats_box, info_box],
    )

    gr.Markdown("""
---
**Architecture:** YouTube highlights → Frame extraction → YOLO detection → Annotation (OpenCV) → Qwen-VL 72B reasoning (AMD MI300X via vLLM on ROCm)

**How it works:** For each upcoming match, the system analyzes the most recent 3 matches for both teams. YOLO detects player positions and ball location. OpenCV renders tactical overlays (defensive lines, compactness ellipses, team colors). Qwen-VL reasons over these annotated frames alongside stats and market odds to identify where the market may be mispriced.

Built for the AMD Developer Hackathon 2026 (Track 3: Vision & Multimodal AI)
""")


if __name__ == "__main__":
    demo.launch()