main.py

"""
main.py — ExitFlow FastAPI application.
Serves landing page, attendee view, organizer dashboard, and JSON APIs.
"""

import asyncio
import os
from contextlib import asynccontextmanager

from dotenv import load_dotenv
load_dotenv()

from fastapi import FastAPI, HTTPException, Request
from fastapi.responses import HTMLResponse, JSONResponse
from fastapi.staticfiles import StaticFiles
from fastapi.templating import Jinja2Templates
from pydantic import BaseModel

import simulator
import gemini_client

# ---------------------------------------------------------------------------
# App lifespan: seed data, start background tick, run initial Gemini strategy
# ---------------------------------------------------------------------------

@asynccontextmanager
async def lifespan(app: FastAPI):
    # Seed with default wave assignments first so the app is immediately usable
    simulator.seed()

    # Try to get a Gemini-generated dispersal strategy
    venue_snapshot = {
        "venue_name": simulator.VENUE_NAME,
        "event_name": simulator.EVENT_NAME,
        "gates": {
            gid: {
                "name": g["name"],
                "capacity": g["capacity"],
                "direction": g["direction"],
                "transit": g["transit"],
            }
            for gid, g in simulator.GATES.items()
        },
        "transit_nodes": {
            tid: {
                "name": t["name"],
                "capacity": t["capacity"],
                "walk_min": t["walk_min"],
            }
            for tid, t in simulator.TRANSIT_NODES.items()
        },
        "sections": simulator.SECTIONS,
        "total_attendees": 15000,
    }

    strategy = await gemini_client.generate_dispersal_strategy(venue_snapshot)
    simulator.dispersal_strategy_text = strategy.get("rationale", "")

    # Re-seed with Gemini-suggested wave assignments
    wave_override = strategy.get("wave_assignments", {})
    simulator.seed(strategy_override={
        gid: {"wave": w} for gid, w in wave_override.items()
    })
    simulator.dispersal_strategy_text = strategy.get("rationale", "")

    # Start background simulation tick
    task = asyncio.create_task(_simulation_loop())

    yield

    task.cancel()
    try:
        await task
    except asyncio.CancelledError:
        pass


async def _simulation_loop() -> None:
    while True:
        await asyncio.sleep(5)
        simulator.tick()
        # Enrich any new alerts with Gemini suggestions (non-blocking)
        for alert in simulator.active_alerts:
            if alert.get("suggestion") is None:
                try:
                    alert["suggestion"] = await gemini_client.generate_intervention(alert)
                except Exception:
                    alert["suggestion"] = gemini_client._fallback_intervention(alert)


# ---------------------------------------------------------------------------
# FastAPI app
# ---------------------------------------------------------------------------

app = FastAPI(title="ExitFlow", lifespan=lifespan)
app.mount("/static", StaticFiles(directory="static"), name="static")
templates = Jinja2Templates(directory="templates")


# ---------------------------------------------------------------------------
# Page routes
# ---------------------------------------------------------------------------

@app.get("/", response_class=HTMLResponse)
async def landing(request: Request):
    demo_ticket = simulator.get_demo_ticket()
    return templates.TemplateResponse(
        "index.html",
        {
            "request": request,
            "event_name": simulator.EVENT_NAME,
            "venue_name": simulator.VENUE_NAME,
            "demo_ticket": demo_ticket,
            "strategy_text": simulator.dispersal_strategy_text,
        },
    )


@app.get("/attendee/{ticket_id}", response_class=HTMLResponse)
async def attendee_view(request: Request, ticket_id: str):
    ctx = simulator.get_attendee_context(ticket_id)
    if not ctx:
        raise HTTPException(status_code=404, detail=f"Ticket {ticket_id} not found")

    gate_id = ctx["gate_id"]
    gate = simulator.GATES[gate_id]
    transit_id = gate["transit"]   # "metro" | "bus" | "taxi"
    transit = simulator.TRANSIT_NODES[transit_id]

    # Build timeline steps
    wave_offset = round(ctx["depart_offset_min"])
    gate_arrive = wave_offset + 3   # ~3 min walk
    transit_arrive = gate_arrive + 5  # ~5 min at gate
    board_time = transit_arrive + transit["walk_min"]

    timeline = [
        {
            "icon": "🪑",
            "label": "Leave your seat",
            "detail": f"Section {ctx['section']}, Row {ctx['seat_row']}",
            "offset_min": wave_offset,
            "state": "depart",
        },
        {
            "icon": "🚶",
            "label": f"Walk to {gate['name']}",
            "detail": f"Head {gate['direction']} — follow green ExitFlow signs",
            "offset_min": gate_arrive,
            "state": "walk",
        },
        {
            "icon": "🚪",
            "label": "Exit through gate",
            "detail": "Have your ticket ready for scanning",
            "offset_min": transit_arrive,
            "state": "gate",
        },
        {
            "icon": transit["icon"],
            "label": f"Board at {transit['name']}",
            "detail": f"{transit['walk_min']} min walk from gate",
            "offset_min": board_time,
            "state": "transit",
        },
    ]

    return templates.TemplateResponse(
        "attendee.html",
        {
            "request": request,
            "ctx": ctx,
            "gate": gate,
            "transit": transit,
            "transit_id": transit_id,
            "timeline": timeline,
            "ticket_id": ticket_id,
            "event_name": simulator.EVENT_NAME,
            "venue_name": simulator.VENUE_NAME,
        },
    )


@app.get("/dashboard", response_class=HTMLResponse)
async def dashboard(request: Request):
    return templates.TemplateResponse(
        "dashboard.html",
        {
            "request": request,
            "event_name": simulator.EVENT_NAME,
            "venue_name": simulator.VENUE_NAME,
            "venue_center": simulator.VENUE_CENTER,
            "gates": [{"gate_id": gid, **g} for gid, g in simulator.GATES.items()],
            "transit_nodes": [{"transit_id": tid, **t} for tid, t in simulator.TRANSIT_NODES.items()],
            "strategy_text": simulator.dispersal_strategy_text,
        },
    )


# ---------------------------------------------------------------------------
# API routes
# ---------------------------------------------------------------------------

class ChatRequest(BaseModel):
    ticket_id: str
    message: str


@app.post("/api/chat")
async def chat(req: ChatRequest):
    ctx = simulator.get_attendee_context(req.ticket_id)
    if not ctx:
        raise HTTPException(status_code=404, detail="Ticket not found")
    reply = await gemini_client.chat_with_attendee(req.message, ctx)
    return {"reply": reply}


@app.get("/api/crowd_state")
async def crowd_state():
    return JSONResponse(simulator.get_crowd_state_snapshot())


@app.get("/api/alerts")
async def alerts():
    # Ensure all alerts have suggestions before returning
    for alert in simulator.active_alerts:
        if alert.get("suggestion") is None:
            alert["suggestion"] = gemini_client._fallback_intervention(alert)
    return JSONResponse({"alerts": simulator.active_alerts})


@app.get("/api/strategy")
async def strategy():
    return {"strategy": simulator.dispersal_strategy_text}