How It Works

┌─────────────────────────────────────────────────────────────┐
│                    CROWDAQ + PulseDaq                        │
│                  Real-Time Decision Graph                    │
└─────────────────────────────────────────────────────────────┘

  ┌──────────────────────┐
  │   LIVE SPORTS DATA   │  API-Football / Opta / Nadwell
  │  (Goals, Cards, VAR) │  Orchestrator (production)
  └──────────┬───────────┘
             │ WebSocket / Supabase Realtime
             ▼
  ┌──────────────────────────────────────────────────────┐
  │               DECISION ENGINE  (server)              │
  │                                                      │
  │   ┌──────────────┐  ┌────────────────┐              │
  │   │  Excitement  │  │  Display Mode  │              │
  │   │    Score     │  │   Selector     │              │
  │   │  Calculator  │  │ LIVE/STATS/AD  │              │
  │   └──────┬───────┘  └───────┬────────┘              │
  │          │                  │                        │
  │   ┌──────▼──────────────────▼────────┐              │
  │   │       Ad Rotation Engine         │              │
  │   │  Slot A (30s) · B (45s) · C (60s)│              │
  │   │  Revenue tracking per impression  │              │
  │   └──────────────────┬───────────────┘              │
  │                      │                              │
  │   ┌──────────────────▼───────────────┐              │
  │   │    Message Generator (Claude AI) │              │
  │   │    Novice / Casual / Expert      │              │
  │   │    Cached per event_id + tier    │              │
  │   └──────────────────────────────────┘              │
  └──────────────────────────────────────────────────────┘
             │                        │
             ▼                        ▼
  ┌──────────────────┐     ┌──────────────────────┐
  │  CROWDAQ Screen  │     │  PulseDaq Fan App    │
  │  (bar TV)        │     │  (fan's phone)       │
  │  · Scoreboard    │     │  · Score chip        │
  │  · Excitement    │     │  · Pulse bar         │
  │  · Event / Stats │     │  · Commentary msg    │
  │  · Ad slots      │     │  · Badge unlocks     │
  │  · QR code       │     │  · [PLAY-BY-PLAY /   │
  └──────────────────┘     │    COLOR] tag        │
                           └──────────────────────┘

function resolveDisplayMode(ticksSinceEvent: number, eventType?: EventType): DisplayMode {
  // Halftime jumps straight to AD_CENTER — no LIVE or STATS phase
  if (eventType === 'HALFTIME') return 'AD_CENTER';

  if (ticksSinceEvent >= 6) return 'AD_CENTER';  // cut to commercial
  if (ticksSinceEvent >= 3) return 'STATS';       // broadcast stats
  return 'LIVE';                                  // event card
}

// In the tick loop:
ticksSinceLastEvent++;
const newMode = resolveDisplayMode(ticksSinceLastEvent);

if (newMode !== currentMode && (newMode === 'STATS' || newMode === 'AD_CENTER')) {
  // Push downtime (color) messages to all connected phones
  pushToPhones({ novice: event.noviceDowntime, casual: event.casualDowntime,
                 expert: event.expertDowntime, commentaryType: 'color' });
  logEntry('MODE', `Display → ${newMode} · color commentary dispatched`);
}

// lib/data/otherGames.ts
// Each of the 4 parallel games has a scoring timeline and a minute offset
// relative to USA's current match minute.

// England vs Iran — kicked off 30 min before USA
const engMin = Math.min(usaMatchMin + 30, 98);

// Spain vs Germany — kicks off 45 min AFTER USA (shows as "Upcoming" early on)
const spaRawMin = usaMatchMin - 45;
const spaMin = Math.max(0, spaRawMin);
const spaStatus = spaRawMin < 0 ? 'pre' : spaMin >= 91 ? 'ft' : 'live';

// Score computed from a timeline of goal moments
function scoreAt(min, events) {
  let home = 0, away = 0;
  for (const e of events) {
    if (min >= e.min) { home = e.home; away = e.away; }
  }
  return { home, away };
}
// e.g. Brazil vs Serbia goals: [20' Serbia 0-1] [30' Brazil 1-1] [58' Brazil 2-1] [73' Brazil 3-1]

function rotateAd(state, slot) {
  const ad = ADS[slot][nextIndex];

  // AD_CENTER multiplier: ad fills the main screen = 1.5× impressions
  const multiplier = state.displayMode === 'AD_CENTER' ? 1.5 : 1.0;

  // Revenue = rate × active users in venue × display multiplier
  const earned = ad.rate × activeUsers × multiplier;

  totalRevenue += earned;
  // e.g. Guinness at $0.08 × 3 users × 1.5 (AD_CENTER) = $0.36 per rotation
}

// Ad selection decision tree (production):
// 1. If excitement > 80 (GOAL just fired) → prioritize beer/celebration ads
// 2. If displayMode === 'HALFTIME'         → bar specials (Ryan's Happy Hour)
// 3. If excitement < 40 (quiet period)    → highest-CPM ad available
// 4. Default                              → round-robin by slot timer

// lib/messages/generate.ts
import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

// System prompt is cached — only sent once, subsequent calls are cache hits
const SYSTEM_PROMPT = `You are a live soccer commentary engine for CROWDAQ/PulseDaq.
Generate calibrated commentary for three fan tiers from a single game event.

NOVICE:  No jargon. Emojis encouraged. Explain WHY it matters. ≤60 words.
CASUAL:  Player names, basic stats, assume they know the rules. ≤80 words.
EXPERT:  Tactics, xG, formations, pressing intensity. No hand-holding. ≤100 words.

Always return JSON: { novice, casual, expert, noviceType, casualType, expertType }
Types: "play-by-play" (immediate reaction) or "color" (tactical analysis between events).`;

export async function generateMessages(event: GameEvent, commentaryContext: 'live' | 'downtime') {
  // Cache key: skip Claude if we already generated for this event + context
  const cacheKey = `${event.matchId}:${event.matchMin}:${event.type}:${commentaryContext}`;
  const cached = await messageCache.get(cacheKey);
  if (cached) return cached;

  const response = await client.messages.create({
    model: "claude-haiku-4-5-20251001",  // fastest + cheapest for speed-critical push
    max_tokens: 500,
    system: [
      {
        type: "text",
        text: SYSTEM_PROMPT,
        cache_control: { type: "ephemeral" },  // cache the system prompt — 5 min TTL
      }
    ],
    messages: [{
      role: "user",
      content: `Event: ${event.type} at ${event.matchMin}' — ${event.description}
Score: ${event.score.home}–${event.score.away}
Context: ${commentaryContext === 'live' ? 'Event just happened' : 'Between events — provide insight/analysis'}`,
    }],
  });

  const result = JSON.parse(response.content[0].text);
  await messageCache.set(cacheKey, result, { ttl: 3600 }); // cache 1 hour
  return result;
}
// Cost estimate: Haiku at $0.00025/1K input tokens
// Cached system prompt: ~$0.000025 per call after first (90% savings)
// Per game (~15 events × 2 contexts × 3 tiers): ~$0.02 total

A fan who scans a QR code at Ryan's Bar during the USA vs Mexico match is not just a “user.” They are a verified, venue-anchored, emotionally engaged sports fan with a known location, a known team, and a timestamped emotional context (excitement score at time of scan). That is the inventory unit advertisers are buying — not a cookie, not a demographic guess. A real person, in a real bar, watching a real game, who just felt something.