CA/backend/routers/alerts.py

"""
Router for CBPOA alert management endpoints
Generates alerts from high-risk grids in GeoJSON files
"""
from fastapi import APIRouter, HTTPException, Query
from datetime import datetime
from typing import List
from functools import lru_cache
import asyncio
import json

from config import DATA_DIR, ALERT_P1_RISK, ALERT_P2_RISK, WUHAN_BOUNDS, LAT_STEP, LON_STEP, MAX_ALERTS
from models import Alert, AlertResponse
from utils.date_helpers import get_latest_date, validate_date_format
from utils.risk import risk_value_to_level

router = APIRouter(prefix="/api/alerts", tags=["alerts"])


def lat_lon_to_grid_id(lat: float, lon: float) -> str:
    """Convert lat/lon to 100m grid cell ID in r{row}_c{col} format."""
    row = int((lat - WUHAN_BOUNDS["min_lat"]) / LAT_STEP)
    col = int((lon - WUHAN_BOUNDS["min_lon"]) / LON_STEP)
    return f"r{row}_c{col}"


def grid_id_to_center(grid_id: str) -> tuple[float, float]:
    """Convert r{row}_c{col} grid ID back to center lat/lon."""
    parts = grid_id.split("_")
    row = int(parts[0][1:])
    col = int(parts[1][1:])
    lat = WUHAN_BOUNDS["min_lat"] + (row + 0.5) * LAT_STEP
    lon = WUHAN_BOUNDS["min_lon"] + (col + 0.5) * LON_STEP
    return lat, lon


@lru_cache(maxsize=8)
def _generate_alerts_cached(date: str) -> List[Alert]:
    """Heavy synchronous worker: parse the ~45MB GeoJSON and build alerts.

    Cached by date so the file is parsed once per date. This runs blocking
    json.load + per-feature loops, so callers must invoke it off the event
    loop (see generate_alerts_for_date).

    Phase 1: iterate features, aggregate max risk per 100m grid cell.
    Phase 2: build Alert objects from aggregated grid cells.
    Phase 3: sort by (priority, -risk_value), cap at MAX_ALERTS.
    """
    filepath = DATA_DIR / f"risk_{date}.geojson"
    if not filepath.exists():
        raise HTTPException(status_code=404, detail=f"No data found for date {date}")

    with open(filepath, 'r', encoding='utf-8') as f:
        geojson = json.load(f)

    # Phase 1: aggregate by 100m grid cell, taking max risk per cell
    grid_cells: dict[str, dict] = {}
    for feature in geojson.get("features", []):
        props = feature.get("properties", {})
        risk_1d = props.get("risk_1d", 0)
        risk_3d = props.get("risk_3d", 0)
        risk_7d = props.get("risk_7d", 0)

        if risk_1d < ALERT_P2_RISK and risk_3d < ALERT_P2_RISK:
            continue

        lat = props.get("lat", 0)
        lon = props.get("lon", 0)
        grid_id = lat_lon_to_grid_id(lat, lon)
        max_risk = max(risk_1d, risk_3d, risk_7d)

        existing = grid_cells.get(grid_id)
        if existing is None or max_risk > existing["max_risk"]:
            grid_cells[grid_id] = {
                "risk_1d": risk_1d,
                "risk_3d": risk_3d,
                "risk_7d": risk_7d,
                "max_risk": max_risk,
            }

    # Phase 2: build Alert objects from aggregated grid cells
    alerts = []
    for grid_id, data in grid_cells.items():
        risk_1d = data["risk_1d"]
        risk_3d = data["risk_3d"]
        risk_7d = data["risk_7d"]
        max_risk = data["max_risk"]

        if risk_1d >= ALERT_P1_RISK or risk_3d >= ALERT_P1_RISK:
            priority = "P1"
            reason = f"高风险区域：1天风险 {risk_1d:.2f}, 3天风险 {risk_3d:.2f}"
        else:
            priority = "P2"
            reason = f"中高风险区域：1天风险 {risk_1d:.2f}, 3天风险 {risk_3d:.2f}"

        lat, lon = grid_id_to_center(grid_id)
        risk_level = risk_value_to_level(max_risk)

        alerts.append(
            Alert(
                alert_id=f"alert_{date}_{grid_id}",
                grid_id=grid_id,
                region="武汉市",
                street=f"Grid {grid_id}",
                latitude=lat,
                longitude=lon,
                risk_value=max_risk,
                risk_level=risk_level,
                priority=priority,
                reason=reason,
                timestamp=datetime.now().isoformat(),
                forecast_time=f"{date}T00:00:00"
            )
        )

    # Phase 3: sort by priority then descending risk, cap at MAX_ALERTS
    alerts.sort(key=lambda x: (0 if x.priority == "P1" else 1, -x.risk_value))
    return alerts[:MAX_ALERTS]


async def generate_alerts_for_date(date: str) -> List[Alert]:
    """Async accessor: run the cached heavy parser in a thread pool.

    Offloading the blocking json.load + per-feature aggregation keeps the
    event loop free. The lru_cache lives on the worker, so warm dates return
    near-instantly without re-parsing.
    """
    return await asyncio.to_thread(_generate_alerts_cached, date)


@router.get("", response_model=AlertResponse)
async def list_alerts(date: str | None = None, priority: str | None = None, min_risk: float | None = None):
    if date is not None and not validate_date_format(date):
        raise HTTPException(status_code=400, detail="Invalid date format. Use YYYYMMDD")
    if date is None:
        date = get_latest_date()

    alerts = await generate_alerts_for_date(date)

    if priority:
        alerts = [a for a in alerts if a.priority == priority]

    if min_risk is not None:
        alerts = [a for a in alerts if a.risk_value >= min_risk]

    return AlertResponse(
        alerts=alerts,
        total=len(alerts),
        timestamp=datetime.now().isoformat()
    )


@router.get("/{alert_id}", response_model=Alert)
async def get_alert(alert_id: str, date: str | None = None):
    if date is not None and not validate_date_format(date):
        raise HTTPException(status_code=400, detail="Invalid date format. Use YYYYMMDD")
    if date is None:
        date = get_latest_date()

    alerts = await generate_alerts_for_date(date)

    for alert in alerts:
        if alert.alert_id == alert_id:
            return alert

    raise HTTPException(status_code=404, detail=f"Alert {alert_id} not found")


@router.get("/priority/p1", response_model=AlertResponse)
async def get_p1_alerts(date: str | None = None):
    if date is not None and not validate_date_format(date):
        raise HTTPException(status_code=400, detail="Invalid date format. Use YYYYMMDD")
    if date is None:
        date = get_latest_date()

    alerts = await generate_alerts_for_date(date)
    p1_alerts = [a for a in alerts if a.priority == "P1"]

    return AlertResponse(
        alerts=p1_alerts,
        total=len(p1_alerts),
        timestamp=datetime.now().isoformat()
    )


@router.get("/priority/p2", response_model=AlertResponse)
async def get_p2_alerts(date: str | None = None):
    if date is not None and not validate_date_format(date):
        raise HTTPException(status_code=400, detail="Invalid date format. Use YYYYMMDD")
    if date is None:
        date = get_latest_date()

    alerts = await generate_alerts_for_date(date)
    p2_alerts = [a for a in alerts if a.priority == "P2"]

    return AlertResponse(
        alerts=p2_alerts,
        total=len(p2_alerts),
        timestamp=datetime.now().isoformat()
    )


@router.get("/grid/{grid_id}", response_model=AlertResponse)
async def get_grid_alerts(grid_id: str, date: str | None = None):
    if date is not None and not validate_date_format(date):
        raise HTTPException(status_code=400, detail="Invalid date format. Use YYYYMMDD")
    if date is None:
        date = get_latest_date()

    alerts = await generate_alerts_for_date(date)
    grid_alerts = [a for a in alerts if a.grid_id == grid_id]

    return AlertResponse(
        alerts=grid_alerts,
        total=len(grid_alerts),
        timestamp=datetime.now().isoformat()
    )