2026FIFAWorldCup/platform/backend/app/main.py

import asyncio
import json
import logging
import os
import contextlib
from collections import defaultdict
from datetime import datetime
from typing import Any, Mapping
from uuid import uuid4

from sqlalchemy import asc, desc, select, func
from sqlalchemy.orm import aliased
from sqlalchemy.exc import SQLAlchemyError


from fastapi import FastAPI, HTTPException, WebSocket, WebSocketDisconnect
from pydantic import BaseModel, Field
from redis.asyncio import Redis
from .db.base import SessionFactory
from .db.models import Bookmaker, Match, OddsHistory, SmartMoneyFlow, Team, Venue

from .analytics import (
  BacktestTradeRecord,
  KellyResult,
  PropMetric,
  StrategyFilter,
  EnsembleModelArtifact,
  FEATURE_COLUMNS,
  LedgerSummary,
  MatchConditionSignal,
  ProofOfYieldStore,
  ProofYieldRecord,
  build_default_ensemble_artifact,
  calculate_model_edges,
  evaluate_match_conditions,
  evaluate_reverse_line_movement,
  model_predict_probabilities,
  normalize_feature_payload,
  train_match_outcome_ensemble,
  calculate_kelly_fraction,
  evaluate_top_edge,
  filter_trades,
  PlayerPropsProfile,
  run_flat_stake_backtest,
  simulate_player_prop_probability,
  PoissonMatchPredictor,
)

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger('fifa2026-ws')


class ConnectionManager:
  def __init__(self) -> None:
    self.match_rooms: dict[str, set[WebSocket]] = defaultdict(set)
    self.all_connections: set[WebSocket] = set()

  async def connect(self, websocket: WebSocket, match_id: str) -> None:
    await websocket.accept()
    self.match_rooms[match_id].add(websocket)
    self.all_connections.add(websocket)

  async def disconnect(self, websocket: WebSocket, match_id: str) -> None:
    self.match_rooms[match_id].discard(websocket)
    self.all_connections.discard(websocket)
    if not self.match_rooms[match_id]:
      self.match_rooms.pop(match_id, None)

  async def broadcast_to_match(self, match_id: str, message: str) -> None:
    disconnected: list[WebSocket] = []
    for ws in list(self.match_rooms.get(match_id, set())):
      try:
        await ws.send_text(message)
      except Exception:
        disconnected.append(ws)
    for ws in disconnected:
      await self.disconnect(ws, match_id)

  async def broadcast_to_all(self, message: str) -> None:
    disconnected: list[WebSocket] = []
    for ws in list(self.all_connections):
      try:
        await ws.send_text(message)
      except Exception:
        disconnected.append(ws)
    for ws in disconnected:
      for match_id, sockets in list(self.match_rooms.items()):
        if ws in sockets:
          await self.disconnect(ws, match_id)


app = FastAPI(title='2026 FIFA Real-Time Bus', version='1.0.0')
manager = ConnectionManager()
ML_MODELS: dict[str, EnsembleModelArtifact] = {'default': build_default_ensemble_artifact()}
PROOF_OF_YIELD_STORE = ProofOfYieldStore()

REDIS_URL = os.environ.get('REDIS_URL', 'redis://localhost:6379/0')
WS_REDIS_CHANNELS = ('channel:live_odds', 'channel:match_events')


class PlayerPropsRequest(BaseModel):
  player_id: str = Field(..., min_length=1, description='球員唯一識別碼')
  player_name: str | None = None
  metric: PropMetric
  baseline_mean: float = Field(..., gt=0)
  line: float = Field(..., gt=0)
  match_minutes: int = Field(default=90, ge=1, le=130)
  team_attack_factor: float = Field(default=1.0, ge=0.2, le=3.0)
  opponent_defence_factor: float = Field(default=1.0, ge=0.2, le=3.0)
  weather_fatigue_factor: float = Field(default=1.0, ge=0.2, le=2.0)
  bookmaker_over_odds: float | None = Field(default=None, gt=1)
  simulations: int = Field(default=10000, ge=100, le=200000)


class PlayerPropsResponse(BaseModel):
  metric: str
  line: float
  over_probability: float
  under_probability: float
  expected_count: float
  p5: float
  p50: float
  p95: float
  simulation_runs: int
  edge: float | None = None
  top_edge: bool = False
  bookmaker_over_odds: float | None = None
  implied_prob: float | None = None


class KellyRequest(BaseModel):
  odds: float = Field(..., gt=1)
  true_prob: float = Field(..., ge=0, le=1)
  bankroll: float = Field(..., gt=0)
  fractional_kelly_factor: float = Field(default=1.0, ge=0, le=5)
  risk_tolerance_factor: float = Field(default=1.0, ge=0, le=2)


class KellyResponse(BaseModel):
  odds: float
  true_prob: float
  bankroll: float
  raw_kelly_fraction: float
  fractional_kelly_factor: float
  risk_tolerance_factor: float
  recommended_fraction: float
  recommended_stake: float


class BacktestTrade(BaseModel):
  trade_id: str = Field(..., min_length=1)
  settled_at: datetime
  odds: float = Field(..., gt=1)
  is_win: bool
  stake: float = Field(default=100.0, gt=0)
  altitude_meters: int | None = None
  handicap: float | None = None
  weather: str | None = None
  recent_form_win_rate: float | None = Field(default=None, ge=0, le=1)
  market_type: str = '1x2'
  selection: str = 'home'


class BacktestFilter(BaseModel):
  weather: str | None = None
  altitude_min_meters: int | None = None
  altitude_max_meters: int | None = None
  handicap_min: float | None = None
  handicap_max: float | None = None
  recent_win_rate_min: float | None = Field(default=None, ge=0, le=1)
  recent_win_rate_max: float | None = Field(default=None, ge=0, le=1)
  market_types: list[str] | None = None
  start_at: datetime | None = None
  end_at: datetime | None = None


class BacktestRequest(BaseModel):
  initial_capital: float = Field(default=10000, gt=0)
  strategy: BacktestFilter = Field(default_factory=BacktestFilter)
  historical_trades: list[BacktestTrade]


class BacktestPoint(BaseModel):
  ts: str
  capital: float


class BacktestResponse(BaseModel):
  matched: int
  total: int
  hit_count: int
  win_rate: float
  final_capital: float
  net_profit: float
  roi_percent: float
  max_drawdown_percent: float
  equity_curve: list[BacktestPoint]


class MlTrainingRow(BaseModel):
  home_rest_days: float = Field(..., description='主隊休息天數')
  away_rest_days: float = Field(..., description='客隊休息天數')
  home_travel_distance_km: float = Field(..., description='主隊旅行距離（km）')
  away_travel_distance_km: float = Field(..., description='客隊旅行距離（km）')
  recent_5_xg_home: float = Field(..., description='主隊近5場 xG')
  recent_5_xg_away: float = Field(..., description='客隊近5場 xG')
  match_result: str = Field(..., description='home / draw / away')


class MlTrainRequest(BaseModel):
  model_id: str | None = None
  rows: list[MlTrainingRow]


class MlTrainResponse(BaseModel):
  model_id: str
  status: str
  training_size: int
  is_fallback: bool
  accuracy: float | None


class MlEdgeRequest(BaseModel):
  model_id: str | None = 'default'
  match_id: str = Field(...)
  home_rest_days: float
  away_rest_days: float
  home_travel_distance_km: float
  away_travel_distance_km: float
  recent_5_xg_home: float
  recent_5_xg_away: float
  home_implied_odds: float = Field(..., gt=1)
  draw_implied_odds: float = Field(..., gt=1)
  away_implied_odds: float = Field(..., gt=1)


class MlModelEdge(BaseModel):
  model_prob: float
  implied_prob: float
  edge: float
  strong_buy: bool


class MlEdgeResponse(BaseModel):
  match_id: str
  model_id: str
  is_fallback_model: bool
  model_probs: dict[str, float]
  edges: dict[str, MlModelEdge]
  strong_buy: bool
  strongest_outcome: str
  strongest_edge_percent: float
  feature_columns: list[str]
  training_size: int


class MatchConditionRequest(BaseModel):
  match_id: str = Field(...)
  avg_yellow_cards: float
  penalties_per_game: float
  cards_ou_line: float
  temp_c: float
  humidity_pct: float
  venue_altitude_meters: int = Field(..., ge=0)
  home_second_half_attack: float = Field(..., gt=0)
  away_second_half_attack: float = Field(..., gt=0)


class MatchConditionResponse(BaseModel):
  match_id: str
  strictness_index: float
  heat_index: float
  cards_pressure_alert: bool
  second_half_home_attack: float
  second_half_away_attack: float
  second_half_under_recommendation: bool
  attacker_direction: str


class RlmRequest(BaseModel):
  match_id: str = Field(...)
  market_type: str = '1x2'
  selection: str = 'home'
  ticket_threshold: float = Field(default=80, ge=0, le=100)
  odds_change_threshold: float = Field(default=0.05, ge=0, le=1)


class RlmAlertResponse(BaseModel):
  match_id: str
  market_type: str
  selection: str
  opening_odds: float
  current_odds: float
  ticket_pct: float
  handle_pct: float
  odds_change_pct: float
  smart_money_to: str
  is_triggered: bool
  rationale: str


class RlmResponse(BaseModel):
  alerts: list[RlmAlertResponse]
  total: int


class ProofOfYieldSettleItem(BaseModel):
  recommendation_id: str | None = None
  match_id: str
  market_type: str = '1x2'
  selection: str = 'home'
  stake: float = Field(..., gt=0)
  recommended_odds: float = Field(..., gt=1)
  closing_odds: float = Field(..., gt=0)
  is_win: bool
  settled_at: str | None = None


class ProofOfYieldSettleRequest(BaseModel):
  items: list[ProofOfYieldSettleItem]


class ProofOfYieldRecordResponse(BaseModel):
  recommendation_id: str
  match_id: str
  market_type: str
  selection: str
  stake: float
  recommended_odds: float
  closing_odds: float
  is_win: bool
  settled_at: str
  clv_percent: float | None
  pnl: float


class ProofOfYieldSummaryResponse(BaseModel):
  total_recommendations: int
  hit_count: int
  win_rate_percent: float
  total_stake: float
  total_pnl: float
  roi_percent: float
  avg_clv_percent: float


class ProofOfYieldLedgerResponse(BaseModel):
  summary: ProofOfYieldSummaryResponse
  records: list[ProofOfYieldRecordResponse]


class UserBet(BaseModel):
  market_type: str = Field(default='unknown', min_length=1)
  parlay_type: str | None = None
  odds: float | None = Field(default=None, gt=1)
  stake: float = Field(..., gt=0)
  recommended_odds: float | None = Field(default=None, gt=1)
  closing_odds: float | None = Field(default=None, gt=0)
  is_settled: bool = True
  is_win: bool = False
  match_stage: str | None = None
  stage: str | None = None


class PortfolioLeaksRequest(BaseModel):
  user_bets: list[UserBet]


class PortfolioLeakCluster(BaseModel):
  market_type: str
  bet_type: str
  odds_bucket: str
  match_stage: str
  bet_count: int
  total_stake: float
  closed_count: int
  win_count: int
  total_pnl: float
  avg_clv_percent: float
  roi_percent: float
  hit_rate_percent: float
  status: str


class PortfolioHardTruth(BaseModel):
  title: str
  message: str
  cluster: dict[str, str | int | float]


class PortfolioLeaksResponse(BaseModel):
  total_bet_count: int
  settled_bet_count: int
  total_stake: float
  total_pnl: float
  overall_roi_percent: float
  overall_hit_rate_percent: float
  clusters: list[PortfolioLeakCluster]
  hard_truths: list[PortfolioHardTruth]


class HedgeRequest(BaseModel):
  original_stake: float = Field(..., gt=0)
  parlay_total_odds: float = Field(..., gt=1)
  final_leg_hedge_odds: float = Field(..., gt=1)


class HedgeResponse(BaseModel):
  hedge_stake: float
  locked_profit: float
  parlay_net_after_hedge_if_win: float
  hedge_net_if_win: float


class DailyCardLeg(BaseModel):
  match_id: str
  selection: str
  odds: float = Field(..., gt=1)


class DailyCardItem(BaseModel):
  match_id: str
  match_label: str
  market_type: str
  selection: str
  target_odds: float = Field(..., gt=1)
  win_prob: float
  ev_percent: float
  stake_units: float = Field(..., ge=0)
  recommendation: str
  rationale: str
  legs: list[DailyCardLeg] | None = None


class DailyCardResponse(BaseModel):
  date: str
  total_daily_unit_recommendation: float
  summary: str
  safe_singles: list[DailyCardItem]
  high_risk_singles: list[DailyCardItem]
  safe_parlays: list[DailyCardItem]
  sgp_lotteries: list[DailyCardItem]
  matched_matches: int
  stage_distribution: dict[str, int]


class MatchListItem(BaseModel):
  match_id: str
  home_team: str
  away_team: str
  kickoff_utc: datetime
  status: str
  venue_name: str | None = None
  venue_city: str | None = None
  venue_country: str | None = None


class MatchOddsPoint(BaseModel):
  recorded_at: str
  bookmaker: str
  bookmaker_id: str
  market_type: str
  selection: str
  decimal_odds: float
  implied_probability: float


class MatchPoissonOutput(BaseModel):
  expected_home_goals: float
  expected_away_goals: float
  score_matrix: list[list[float]]
  one_x_two: dict[str, float]
  over_under_2_5: dict[str, float]


class MatchConditionReadout(BaseModel):
  strictness_index: float
  heat_index: float
  cards_pressure_alert: bool
  second_half_home_attack: float
  second_half_away_attack: float
  second_half_under_recommendation: bool
  attacker_direction: str


class MatchDetailResponse(BaseModel):
  match_id: str
  home_team: str
  away_team: str
  home_xg: float
  away_xg: float
  match_time_utc: str
  status: str
  venue_name: str
  venue_city: str
  venue_country: str
  venue_altitude_meters: int | None
  odds_series: list[MatchOddsPoint]
  poisson: MatchPoissonOutput
  conditions: MatchConditionReadout
  quant_summary: str


@app.get('/health')
async def health() -> dict[str, str]:
  return {
    'ok': 'true',
    'service': 'fifa2026-websocket',
  }


def _odds_to_prob(odds: float) -> float:
  return 1.0 / odds


def _build_model_row_payload(req: MlEdgeRequest) -> dict[str, float]:
  return {
    'match_id': req.match_id,
    'home_rest_days': req.home_rest_days,
    'away_rest_days': req.away_rest_days,
    'home_travel_distance_km': req.home_travel_distance_km,
    'away_travel_distance_km': req.away_travel_distance_km,
    'recent_5_xg_home': req.recent_5_xg_home,
    'recent_5_xg_away': req.recent_5_xg_away,
  }


def _to_date(value: str) -> datetime.date:
  try:
    return datetime.strptime(value, '%Y-%m-%d').date()
  except ValueError as exc:
    raise HTTPException(status_code=400, detail='日期格式必須為 YYYY-MM-DD') from exc


def _safe_float(value: Any, default: float = 0.0) -> float:
  try:
    return float(value)
  except (TypeError, ValueError):
    return default


def _safe_int(value: Any, default: int | None = None) -> int | None:
  try:
    return int(value)
  except (TypeError, ValueError):
    return default


def _build_quant_summary(
  home_team: str,
  away_team: str,
  home_xg: float,
  away_xg: float,
  one_x_two: dict[str, float],
  over_under: dict[str, float],
) -> str:
  """用 Poisson 核心輸出構造 300 字上下的賽前量化摘要。"""

  home_win = _safe_float(one_x_two.get('home_win'))
  draw = _safe_float(one_x_two.get('draw'))
  away_win = _safe_float(one_x_two.get('away_win'))
  under = _safe_float(over_under.get('under'))
  over = _safe_float(over_under.get('over'))

  return (
    f'【資料驅動預測摘要】{home_team} vs {away_team} 的 xG 組合顯示，{home_team} 預估主場進球 {home_xg:.2f}，\
{away_team} 進球 {away_xg:.2f}，主勝機率約 {home_win:.1%}、平局 {draw:.1%}、客勝 {away_win:.1%}。\
依 2.5 球門檻，走 Under 機率約 {under:.1%}，Over 機率約 {over:.1%}，\
若模型判斷到賽中節奏偏中後段上升，建議關注亞盤與大小球組合與 Sharp Money 的偏移。\
該筆預測建議以「盤口變動」與「賠率修正」為主軸，避免盲追單一 1X2 方向。\
實盤可將本場解讀為偏向策略化下注：若盤口未按預估修正，應提高風險控管，等待第二次確認訊號。'
  )


async def _query_match_list(limit: int = 200) -> list[dict[str, Any]]:
  home_team = aliased(Team)
  away_team = aliased(Team)

  async with SessionFactory() as session:
    stmt = (
      select(
        Match.id,
        home_team.name,
        away_team.name,
        Match.match_time_utc,
        Match.status,
        Venue.name,
        Venue.city,
        Venue.country,
      )
      .join(home_team, Match.home_team_id == home_team.id)
      .join(away_team, Match.away_team_id == away_team.id)
      .join(Venue, Match.venue_id == Venue.id)
      .order_by(Match.match_time_utc.asc())
      .limit(limit)
    )

    result = await session.execute(stmt)
    rows = result.all()

    return [
      {
        'match_id': match_id,
        'home_team': home_name,
        'away_team': away_name,
        'kickoff_utc': kickoff_utc,
        'status': str(status.value if hasattr(status, 'value') else status),
        'venue_name': venue_name,
        'venue_city': venue_city,
        'venue_country': venue_country,
      }
      for match_id, home_name, away_name, kickoff_utc, status, venue_name, venue_city, venue_country in rows
    ]


def _build_over_under_payload(under: float, over: float) -> dict[str, float]:
  return {
    'under': max(0.0, min(1.0, _safe_float(under))),
    'over': max(0.0, min(1.0, _safe_float(over))),
  }


async def _query_match_preview(match_id: str) -> dict[str, Any] | None:
  home_team = aliased(Team)
  away_team = aliased(Team)

  async with SessionFactory() as session:
    stmt = (
      select(Match, home_team, away_team, Venue)
      .join(home_team, Match.home_team_id == home_team.id)
      .join(away_team, Match.away_team_id == away_team.id)
      .join(Venue, Match.venue_id == Venue.id)
      .where(Match.id == match_id)
    )

    result = await session.execute(stmt)
    row = result.first()
    if not row:
      return None

    match = row[0]
    home = row[1]
    away = row[2]
    venue = row[3]

    home_xg = _safe_float(match.home_xg, 1.1)
    away_xg = _safe_float(match.away_xg, 1.0)

    odds_stmt = (
      select(
        OddsHistory.recorded_at,
        OddsHistory.market_type,
        OddsHistory.selection,
        OddsHistory.decimal_odds,
        OddsHistory.implied_probability,
        Bookmaker.id,
        Bookmaker.name,
      )
      .join(Bookmaker, OddsHistory.bookmaker_id == Bookmaker.id)
      .where(OddsHistory.match_id == match_id)
      .order_by(OddsHistory.recorded_at.asc(), OddsHistory.id.asc())
    )

    odds_result = await session.execute(odds_stmt)
    odds_rows = odds_result.all()

    odds_points: list[MatchOddsPoint] = [
      MatchOddsPoint(
        recorded_at=point_recorded.strftime('%Y-%m-%dT%H:%M:%SZ') if hasattr(point_recorded, 'strftime') else str(point_recorded),
        bookmaker=str(name),
        bookmaker_id=str(bookmaker_id),
        market_type=market_type,
        selection=selection,
        decimal_odds=float(odds),
        implied_probability=float(implied_prob),
      )
      for point_recorded, market_type, selection, odds, implied_prob, bookmaker_id, name in odds_rows
    ]

    if len(odds_points) == 0:
      fallback_now = datetime.utcnow().isoformat() + 'Z'
      odds_points = [
        MatchOddsPoint(
          recorded_at=fallback_now,
          bookmaker='sample-bookmaker',
          bookmaker_id='sample',
          market_type='1x2',
          selection='home',
          decimal_odds=round(1.90 + (_safe_float(1.0) * 0.0), 2),
          implied_probability=0.52,
        ),
      ]

    predictor = PoissonMatchPredictor(
      home_attack_strength=max(0.35, home_xg),
      home_defense_strength=max(0.35, 1.0 + ((venue.altitude_meters or 0) / 5000.0)),
      away_attack_strength=max(0.35, away_xg),
      away_defense_strength=max(0.35, 1.0),
      league_avg_home_goals=1.35,
    )
    expected_home_xg, expected_away_xg = predictor.calculate_expected_goals()
    score_matrix = predictor.predict_exact_score_matrix(max_goals=5).tolist()
    one_x_two = predictor.predict_1x2_probabilities()
    under_prob, over_prob = predictor.predict_over_under_prob(2.5)

    conditions = evaluate_match_conditions(
      avg_yellow_cards=4.0 + (1 if (venue.altitude_meters or 0) > 1000 else 0),
      penalties_per_game=0.18,
      cards_ou_line=4.5,
      temp_c=28.0 + ((venue.altitude_meters or 0) / 3000.0),
      humidity_pct=52.0 + min(20.0, (venue.altitude_meters or 0) / 150.0 * 0.1),
      venue_altitude_meters=venue.altitude_meters or 0,
      home_second_half_attack=expected_home_xg * 1.08,
      away_second_half_attack=expected_away_xg * 1.02,
    )

    quant_summary = _build_quant_summary(
      home_team=home.name,
      away_team=away.name,
      home_xg=expected_home_xg,
      away_xg=expected_away_xg,
      one_x_two=one_x_two,
      over_under={'under': under_prob, 'over': over_prob},
    )

    return {
      'match_id': match.id,
      'home_team': home.name,
      'away_team': away.name,
      'home_xg': expected_home_xg,
      'away_xg': expected_away_xg,
      'match_time_utc': (match.match_time_utc.isoformat() if match.match_time_utc else datetime.utcnow().isoformat()),
      'status': str(match.status.value if hasattr(match.status, 'value') else match.status),
      'venue_name': venue.name,
      'venue_city': venue.city,
      'venue_country': venue.country,
      'venue_altitude_meters': venue.altitude_meters,
      'odds_series': odds_points,
      'poisson': {
        'expected_home_goals': expected_home_xg,
        'expected_away_goals': expected_away_xg,
        'score_matrix': score_matrix,
        'one_x_two': one_x_two,
        'over_under_2_5': _build_over_under_payload(under_prob, over_prob),
      },
      'conditions': {
        'strictness_index': conditions.strictness_index,
        'heat_index': conditions.heat_index,
        'cards_pressure_alert': conditions.cards_pressure_alert,
        'second_half_home_attack': conditions.second_half_home_attack,
        'second_half_away_attack': conditions.second_half_away_attack,
        'second_half_under_recommendation': conditions.second_half_under_recommendation,
        'attacker_direction': conditions.attacker_direction,
      },
      'quant_summary': quant_summary,
    }


def _build_daily_card_fallback(matches_on_date: list[dict[str, Any]]) -> list[dict[str, Any]]:
  if matches_on_date:
    return matches_on_date

  return [
    {
      'match_id': 'm1',
      'home_team': '德國',
      'away_team': '西班牙',
      'odds_home': 1.92,
      'odds_away': 4.05,
      'home_xg': 1.45,
      'away_xg': 0.95,
    },
    {
      'match_id': 'm2',
      'home_team': '巴西',
      'away_team': '法國',
      'odds_home': 2.05,
      'odds_away': 3.6,
      'home_xg': 1.32,
      'away_xg': 1.25,
    },
  ]


async def _query_match_day_snapshot(target_date: datetime.date) -> list[dict[str, Any]]:
  home_team = aliased(Team)
  away_team = aliased(Team)

  async with SessionFactory() as session:
    stmt = (
      select(
        Match.id,
        Match.home_xg,
        Match.away_xg,
        Match.match_time_utc,
        home_team.name,
        away_team.name,
      )
      .join(home_team, Match.home_team_id == home_team.id)
      .join(away_team, Match.away_team_id == away_team.id)
      .where(func.date(Match.match_time_utc) == target_date)
      .order_by(Match.match_time_utc.asc())
    )

    result = await session.execute(stmt)
    rows = result.all()

    matches_payload: list[dict[str, Any]] = []
    for row in rows:
      match_id, home_xg, away_xg, match_time_utc, home_name, away_name = row
      opening_home, current_home = await _query_opening_odds(session, match_id, '1x2', 'home')
      opening_away, current_away = await _query_opening_odds(session, match_id, '1x2', 'away')
      current_home = current_home if current_home is not None else opening_home
      current_away = current_away if current_away is not None else opening_away

      if current_home is not None and current_away is not None:
        matches_payload.append(
          {
            'match_id': match_id,
            'home_team': home_name,
            'away_team': away_name,
            'home_xg': float(home_xg or 1.0),
            'away_xg': float(away_xg or 1.0),
            'odds_home': float(current_home),
            'odds_away': float(current_away),
            'kickoff_utc': match_time_utc,
          },
        )

    return _build_daily_card_fallback(matches_payload)


async def _query_latest_smart_money(
  session: Any,
  match_id: str,
  market_type: str,
  selection: str,
) -> Any:
  latest_stmt = (
    select(SmartMoneyFlow)
    .where(
      SmartMoneyFlow.match_id == match_id,
      SmartMoneyFlow.market_type == market_type,
      SmartMoneyFlow.selection == selection,
    )
    .order_by(desc(SmartMoneyFlow.recorded_at))
    .limit(1)
  )
  latest = await session.execute(latest_stmt)
  return latest.scalar_one_or_none()


def _safe_float(value: Any, *, default: float | None = None) -> float | None:
  try:
    return float(value)
  except (TypeError, ValueError):
    return default


async def _query_latest_smart_money_from_cache(
  redis_conn: Redis,
  match_id: str,
  market_type: str,
  selection: str,
) -> SmartMoneyFlow | None:
  cache_keys = (
    f'smart_money:{match_id}:{market_type}:{selection}',
    f'smart-money:{match_id}:{market_type}:{selection}',
    f'match:{match_id}:{market_type}:{selection}:smart_money',
  )

  for key in cache_keys:
    raw = await redis_conn.get(key)
    if not raw:
      continue
    try:
      parsed = json.loads(raw.decode() if isinstance(raw, bytes) else raw)
    except (TypeError, json.JSONDecodeError):
      continue

    if not isinstance(parsed, Mapping):
      continue

    ticket_pct = _safe_float(parsed.get('ticket_pct'))
    handle_pct = _safe_float(parsed.get('handle_pct'))
    if ticket_pct is None or handle_pct is None:
      continue

    return SmartMoneyFlow(
      id=0,
      match_id=match_id,
      market_type=market_type,
      selection=selection,
      ticket_pct=ticket_pct,
      handle_pct=handle_pct,
      sharp_indicator=bool(parsed.get('sharp_indicator', False)),
      recorded_at=datetime.utcnow(),
    )
  return None


async def _query_opening_current_odds_from_cache(
  redis_conn: Redis,
  match_id: str,
  market_type: str,
  selection: str,
) -> tuple[float | None, float | None]:
  opening_key = f'odds_open:{match_id}:{market_type}:{selection}'
  current_key = f'odds_current:{match_id}:{market_type}:{selection}'
  opening_raw = await redis_conn.get(opening_key)
  current_raw = await redis_conn.get(current_key)

  opening_odds = _safe_float(
    opening_raw.decode() if isinstance(opening_raw, bytes) else opening_raw,
    default=None,
  )
  current_odds = _safe_float(
    current_raw.decode() if isinstance(current_raw, bytes) else current_raw,
    default=None,
  )

  if opening_odds is not None and current_odds is not None:
    return opening_odds, current_odds

  # fallback: decode live snapshot 列表
  live_raw = await redis_conn.get(f'live:{match_id}:odds')
  if not live_raw:
    return None, None

  try:
    live_payload = json.loads(live_raw.decode() if isinstance(live_raw, bytes) else live_raw)
  except (TypeError, json.JSONDecodeError):
    return None, None

  if not isinstance(live_payload, list):
    return None, None

  filtered = [
    row for row in live_payload
    if isinstance(row, Mapping)
    and str(row.get('match_id', match_id)) == str(match_id)
    and str(row.get('market_type')) == str(market_type)
    and str(row.get('selection')) == str(selection)
    and _safe_float(row.get('decimal_odds'), default=None) is not None
  ]
  if not filtered:
    return None, None

  values = [
    (_safe_float(row.get('recorded_at'), default=None), _safe_float(row.get('decimal_odds'), default=None))
    for row in filtered
  ]

  values = [item for item in values if item[1] is not None]
  if not values:
    return None, None

  values.sort(key=lambda item: item[0] if item[0] is not None else 0)
  opening = float(values[0][1])
  current = float(values[-1][1])
  return opening, current


async def _query_opening_odds(
  session: Any,
  match_id: str,
  market_type: str,
  selection: str,
) -> tuple[float | None, float | None]:
  opening_stmt = (
    select(OddsHistory.decimal_odds)
    .join(Match, Match.id == OddsHistory.match_id)
    .where(
      OddsHistory.match_id == match_id,
      OddsHistory.market_type == market_type,
      OddsHistory.selection == selection,
    )
    .order_by(asc(OddsHistory.recorded_at))
    .limit(1)
  )
  current_stmt = (
    select(OddsHistory.decimal_odds)
    .where(
      OddsHistory.match_id == match_id,
      OddsHistory.market_type == market_type,
      OddsHistory.selection == selection,
    )
    .order_by(desc(OddsHistory.recorded_at))
    .limit(1)
  )

  opening_result = await session.execute(opening_stmt)
  current_result = await session.execute(current_stmt)
  opening_row = opening_result.scalar_one_or_none()
  current_row = current_result.scalar_one_or_none()
  return (
    float(opening_row) if opening_row is not None else None,
    float(current_row) if current_row is not None else None,
  )


def _to_summary(records: list[ProofYieldRecord]) -> LedgerSummary:
  return ProofOfYieldStore.summarize(records)


def _to_ledger_response(records: list[ProofYieldRecord]) -> list[ProofOfYieldRecordResponse]:
  return [
    ProofOfYieldRecordResponse(
      recommendation_id=row.recommendation_id,
      match_id=row.match_id,
      market_type=row.market_type,
      selection=row.selection,
      stake=row.stake,
      recommended_odds=row.recommended_odds,
      closing_odds=row.closing_odds or 0.0,
      is_win=row.is_win,
      settled_at=row.settled_at,
      clv_percent=row.clv_percent,
      pnl=row.pnl,
    )
    for row in records
  ]


async def relay_redis_events() -> None:
  redis = Redis.from_url(REDIS_URL, decode_responses=True)
  pubsub = redis.pubsub()
  await pubsub.subscribe(*WS_REDIS_CHANNELS)
  logger.info('Redis Pub/Sub 已啟動，監聽 %s', ','.join(WS_REDIS_CHANNELS))

  try:
    async for message in pubsub.listen():
      if message['type'] != 'message':
        continue
      raw = message['data']
      payload = raw if isinstance(raw, str) else str(raw)

      try:
        parsed = json.loads(payload)
      except ValueError:
        channel = message['channel']
        if isinstance(channel, bytes):
          channel = channel.decode('utf-8', errors='ignore')
        parsed = {'eventType': channel, 'payload': payload}

      match_id = (
        parsed.get('match_id')
        or parsed.get('matchId')
        or parsed.get('payload', {}).get('match_id')
        or parsed.get('payload', {}).get('matchId')
        or ''
      )

      message_str = json.dumps(parsed, ensure_ascii=False)
      if match_id:
        await manager.broadcast_to_match(str(match_id), message_str)
      else:
        await manager.broadcast_to_all(message_str)
  except asyncio.CancelledError:
    raise
  except Exception as exc:
    logger.error('Redis listener error: %s', exc)
  finally:
    await pubsub.unsubscribe(*WS_REDIS_CHANNELS)
    await pubsub.close()
    await redis.close()


@app.on_event('startup')
async def on_startup() -> None:
  app.state.redis_listener = asyncio.create_task(relay_redis_events())


@app.on_event('shutdown')
async def on_shutdown() -> None:
  listener = getattr(app.state, 'redis_listener', None)
  if listener:
    listener.cancel()
    with contextlib.suppress(asyncio.CancelledError):
      await listener


@app.websocket('/ws/matches/{match_id}')
async def websocket_endpoint(websocket: WebSocket, match_id: str) -> None:
  await manager.connect(websocket, match_id)
  try:
    await websocket.send_text(json.dumps({'eventType': 'connected', 'matchId': match_id, 'payload': {}}))
    while True:
      message = await websocket.receive_text()
      try:
        data = json.loads(message)
      except ValueError:
        await websocket.send_text(json.dumps({'eventType': 'error', 'payload': {'message': 'JSON 格式錯誤'}}))
        continue
      if data.get('action') == 'ping':
        await websocket.send_text(json.dumps({'eventType': 'pong', 'payload': {'matchId': match_id}}))
  except WebSocketDisconnect:
    await manager.disconnect(websocket, match_id)


@app.post('/analytics/player-props', response_model=PlayerPropsResponse)
async def analyze_player_prop(req: PlayerPropsRequest) -> dict[str, float | int | str | bool | None]:
  profile = PlayerPropsProfile(
    player_id=req.player_id,
    metric=req.metric,
    baseline_mean=req.baseline_mean,
    match_minutes=req.match_minutes,
    team_attack_factor=req.team_attack_factor,
    opponent_defence_factor=req.opponent_defence_factor,
    weather_fatigue_factor=req.weather_fatigue_factor,
  )

  if req.bookmaker_over_odds is None:
    result = simulate_player_prop_probability(
      profile,
      line=req.line,
      simulations=req.simulations,
    )
    response = result.to_dict()
    response.update({'edge': None, 'top_edge': False, 'bookmaker_over_odds': None, 'implied_prob': None})
    return response

  return evaluate_top_edge(
    profile,
    bookmaker_over_odds=req.bookmaker_over_odds,
    line=req.line,
    simulations=req.simulations,
  )


@app.post('/analytics/kelly', response_model=KellyResponse)
async def calculate_kelly(request: KellyRequest) -> KellyResponse:
  result: KellyResult = calculate_kelly_fraction(
    request.odds,
    request.true_prob,
    bankroll=request.bankroll,
    fractional_kelly_factor=request.fractional_kelly_factor,
    risk_tolerance_factor=request.risk_tolerance_factor,
  )

  return KellyResponse(
    odds=result.decimal_odds,
    true_prob=result.win_probability,
    bankroll=request.bankroll,
    raw_kelly_fraction=round(result.raw_kelly_fraction, 6),
    fractional_kelly_factor=result.fractional_kelly_factor,
    risk_tolerance_factor=result.risk_tolerance_factor,
    recommended_fraction=round(result.stake_fraction * 100, 6),
    recommended_stake=round(request.bankroll * result.stake_fraction, 2),
  )


@app.post('/analytics/backtest', response_model=BacktestResponse)
async def run_backtest(req: BacktestRequest) -> BacktestResponse:
  strategy_filter = StrategyFilter(
    weather=req.strategy.weather,
    altitude_min_meters=req.strategy.altitude_min_meters,
    altitude_max_meters=req.strategy.altitude_max_meters,
    handicap_min=req.strategy.handicap_min,
    handicap_max=req.strategy.handicap_max,
    recent_win_rate_min=req.strategy.recent_win_rate_min,
    recent_win_rate_max=req.strategy.recent_win_rate_max,
    market_types=req.strategy.market_types,
    start_at=req.strategy.start_at,
    end_at=req.strategy.end_at,
  )

  try:
    records = [
      BacktestTradeRecord(
        trade_id=item.trade_id,
        settled_at=item.settled_at,
        odds=item.odds,
        is_win=item.is_win,
        stake=item.stake,
        altitude_meters=item.altitude_meters,
        handicap=item.handicap,
        weather=item.weather,
        recent_form_win_rate=item.recent_form_win_rate,
        market_type=item.market_type,
        selection=item.selection,
      )
      for item in req.historical_trades
    ]
  except Exception as exc:
    raise HTTPException(status_code=400, detail=f'交易資料欄位不合法：{exc}') from exc

  filtered = filter_trades(records, strategy_filter)

  if not filtered:
    raise HTTPException(
      status_code=404,
      detail='無法符合條件的歷史資料；請放寬條件或增加歷史注單輸入',
    )

  summary = run_flat_stake_backtest(filtered, initial_capital=req.initial_capital)
  return BacktestResponse(
    matched=summary['trade_count'],
    total=len(records),
    hit_count=summary['hit_count'],
    win_rate=summary['win_rate'],
    final_capital=summary['final_capital'],
    net_profit=summary['net_profit'],
    roi_percent=summary['roi_percent'],
    max_drawdown_percent=summary['max_drawdown_percent'],
    equity_curve=[BacktestPoint(**point) for point in summary['equity_curve']],
  )


@app.post('/analytics/ml-edge/train', response_model=MlTrainResponse)
async def train_ml_model(req: MlTrainRequest) -> MlTrainResponse:
  if not req.rows:
    raise HTTPException(status_code=400, detail='訓練資料不能為空')

  prepared_rows = [
    {
      **normalize_feature_payload(row.model_dump()),
      'match_result': row.match_result.lower(),
    }
    for row in req.rows
  ]
  model_id = req.model_id or uuid4().hex

  try:
    model = train_match_outcome_ensemble(prepared_rows, model_id=model_id)
  except Exception as exc:
    raise HTTPException(status_code=400, detail=f'訓練失敗：{exc}') from exc

  ML_MODELS[model_id] = model
  return MlTrainResponse(
    model_id=model_id,
    status='trained',
    training_size=model.training_size,
    is_fallback=model.is_fallback,
    accuracy=model.training_accuracy,
  )


@app.post('/analytics/ml-edge', response_model=MlEdgeResponse)
async def predict_ml_edge(req: MlEdgeRequest) -> MlEdgeResponse:
  model = ML_MODELS.get(req.model_id or 'default')
  if model is None:
    raise HTTPException(status_code=404, detail='模型不存在，請先透過 /analytics/ml-edge/train 取得模型')

  payload = _build_model_row_payload(req)
  try:
    model_probs = model_predict_probabilities(model, payload)
  except Exception as exc:
    raise HTTPException(status_code=500, detail=f'模型推論失敗：{exc}') from exc

  implied = {
    'home': _odds_to_prob(req.home_implied_odds),
    'draw': _odds_to_prob(req.draw_implied_odds),
    'away': _odds_to_prob(req.away_implied_odds),
  }
  edge_map = calculate_model_edges(model_probs, implied)
  strong_edges = [outcome for outcome, values in edge_map.items() if bool(values['strong_buy'])]
  strongest_outcome = max(edge_map, key=lambda outcome: edge_map[outcome]['edge'])
  strongest_edge = edge_map[strongest_outcome]['edge']

  return MlEdgeResponse(
    match_id=req.match_id,
    model_id=model.model_id,
    is_fallback_model=model.is_fallback,
    model_probs={k: float(v['model_prob']) for k, v in edge_map.items()},
    edges={k: MlModelEdge(**v) for k, v in edge_map.items()},  # type: ignore[arg-type]
    strong_buy=len(strong_edges) > 0,
    strongest_outcome=strongest_outcome,
    strongest_edge_percent=round(strongest_edge * 100, 4),
    feature_columns=list(model.feature_columns),
    training_size=model.training_size,
  )


@app.post('/analytics/match-conditions', response_model=MatchConditionResponse)
async def analyze_match_conditions(req: MatchConditionRequest) -> MatchConditionResponse:
  result = evaluate_match_conditions(
    avg_yellow_cards=req.avg_yellow_cards,
    penalties_per_game=req.penalties_per_game,
    cards_ou_line=req.cards_ou_line,
    temp_c=req.temp_c,
    humidity_pct=req.humidity_pct,
    venue_altitude_meters=req.venue_altitude_meters,
    home_second_half_attack=req.home_second_half_attack,
    away_second_half_attack=req.away_second_half_attack,
  )

  return MatchConditionResponse(
    match_id=req.match_id,
    strictness_index=result.strictness_index,
    heat_index=result.heat_index,
    cards_pressure_alert=result.cards_pressure_alert,
    second_half_home_attack=result.second_half_home_attack,
    second_half_away_attack=result.second_half_away_attack,
    second_half_under_recommendation=result.second_half_under_recommendation,
    attacker_direction=result.attacker_direction,
  )


@app.post('/analytics/rlm', response_model=RlmResponse)
async def detect_reverse_line_movement(req: RlmRequest) -> RlmResponse:
  latest_money = None
  opening_odds: float | None = None
  current_odds: float | None = None

  async with SessionFactory() as session:
    try:
      latest_money = await _query_latest_smart_money(session, req.match_id, req.market_type, req.selection)
      opening_odds, current_odds = await _query_opening_odds(session, req.match_id, req.market_type, req.selection)
    except SQLAlchemyError as exc:
      logger.warning('RLM 查詢 DB 失敗，改用快取/預留資料：%s', exc)

  if (latest_money is None or opening_odds is None or current_odds is None):
    redis = Redis.from_url(REDIS_URL, decode_responses=False)
    try:
      if latest_money is None:
        latest_money = await _query_latest_smart_money_from_cache(redis, req.match_id, req.market_type, req.selection)

      if opening_odds is None or current_odds is None:
        opening_odds, current_odds = await _query_opening_current_odds_from_cache(
          redis,
          req.match_id,
          req.market_type,
          req.selection,
        )
    except Exception as exc:
      logger.warning('RLM 查詢 Redis 失敗：%s', exc)
    finally:
      await redis.close()

  alerts: list[RlmAlertResponse] = []
  if latest_money is not None and opening_odds is not None and current_odds is not None:
    alert = evaluate_reverse_line_movement(
      req.match_id,
      req.market_type,
      req.selection,
      opening_odds=opening_odds,
      current_odds=current_odds,
      ticket_pct=float(latest_money.ticket_pct),
      handle_pct=float(latest_money.handle_pct),
      ticket_threshold=req.ticket_threshold,
      odds_change_threshold=req.odds_change_threshold,
    )
    alerts.append(
      RlmAlertResponse(
        match_id=alert.match_id,
        market_type=alert.market_type,
        selection=alert.selection,
        opening_odds=alert.opening_odds,
        current_odds=alert.current_odds,
        ticket_pct=alert.ticket_pct,
        handle_pct=alert.handle_pct,
        odds_change_pct=alert.odds_change_pct,
        smart_money_to=alert.smart_money_to,
        is_triggered=alert.is_triggered,
        rationale=alert.rationale,
      ),
    )

  return RlmResponse(alerts=alerts, total=len(alerts))


@app.get('/analytics/proof-of-yield/ledger', response_model=ProofOfYieldLedgerResponse)
async def get_proof_of_yield_ledger(limit: int = 200) -> ProofOfYieldLedgerResponse:
  records = PROOF_OF_YIELD_STORE.query_ledger(limit=max(1, min(limit, 1000)))
  summary = _to_summary(records)
  return ProofOfYieldLedgerResponse(
    summary=ProofOfYieldSummaryResponse(**summary.__dict__),
    records=_to_ledger_response(records),
  )


@app.post('/analytics/proof-of-yield/settle', response_model=ProofOfYieldLedgerResponse)
async def settle_proof_of_yield_recommendations(
  req: ProofOfYieldSettleRequest,
) -> ProofOfYieldLedgerResponse:
  if not req.items:
    raise HTTPException(status_code=400, detail='請至少提供一筆建議明細')

  PROOF_OF_YIELD_STORE.upsert_settlements([item.model_dump() for item in req.items])
  records = PROOF_OF_YIELD_STORE.query_ledger(limit=1000)
  summary = _to_summary(records)
  return ProofOfYieldLedgerResponse(
    summary=ProofOfYieldSummaryResponse(**summary.__dict__),
    records=_to_ledger_response(records),
  )


@app.get('/analytics/matches', response_model=list[MatchListItem])
async def list_matches(limit: int = 500) -> list[MatchListItem]:
  rows = await _query_match_list(limit=max(1, min(limit, 1000)))
  if not rows:
    return []

  return [
    MatchListItem(
      match_id=match_payload['match_id'],
      home_team=match_payload['home_team'],
      away_team=match_payload['away_team'],
      kickoff_utc=match_payload['kickoff_utc'],
      status=str(match_payload['status']),
      venue_name=match_payload['venue_name'],
      venue_city=match_payload['venue_city'],
      venue_country=match_payload['venue_country'],
    )
    for match_payload in rows
  ]


@app.get('/analytics/matches/{match_id}', response_model=MatchDetailResponse)
async def get_match_detail_route(match_id: str) -> MatchDetailResponse:
  payload = await _query_match_preview(match_id)
  if payload is None:
    raise HTTPException(status_code=404, detail='賽事不存在')

  return MatchDetailResponse(
    match_id=payload['match_id'],
    home_team=payload['home_team'],
    away_team=payload['away_team'],
    home_xg=payload['home_xg'],
    away_xg=payload['away_xg'],
    match_time_utc=payload['match_time_utc'],
    status=payload['status'],
    venue_name=payload['venue_name'],
    venue_city=payload['venue_city'],
    venue_country=payload['venue_country'],
    venue_altitude_meters=payload['venue_altitude_meters'],
    odds_series=payload['odds_series'],
    poisson=payload['poisson'],
    conditions=payload['conditions'],
    quant_summary=payload['quant_summary'],
  )


@app.post('/analytics/portfolio/leaks', response_model=PortfolioLeaksResponse)
async def analyze_portfolio_leaks(req: PortfolioLeaksRequest) -> PortfolioLeaksResponse:
  payload = [bet.model_dump() for bet in req.user_bets]
  result = analyze_user_leaks(payload)

  return PortfolioLeaksResponse(
    total_bet_count=result['total_bet_count'],
    settled_bet_count=result['settled_bet_count'],
    total_stake=result['total_stake'],
    total_pnl=result['total_pnl'],
    overall_roi_percent=result['overall_roi_percent'],
    overall_hit_rate_percent=result['overall_hit_rate_percent'],
    clusters=[PortfolioLeakCluster(**item) for item in result['clusters']],
    hard_truths=[PortfolioHardTruth(**item) for item in result['hard_truths']],
  )


@app.post('/analytics/hedging', response_model=HedgeResponse)
async def calculate_hedge_signal(req: HedgeRequest) -> HedgeResponse:
  result = calculate_hedge_amount(
    original_stake=req.original_stake,
    parlay_total_odds=req.parlay_total_odds,
    final_leg_hedge_odds=req.final_leg_hedge_odds,
  )

  return HedgeResponse(**result)


@app.get('/analytics/daily-card/{target_date}', response_model=DailyCardResponse)
async def generate_daily_card_route(target_date: str) -> DailyCardResponse:
  card_date = _to_date(target_date)
  match_payload = await _query_match_day_snapshot(card_date)
  result = generate_daily_card(target_date, match_payload)
  return DailyCardResponse(**result)


if __name__ == '__main__':
  import uvicorn
  uvicorn.run('main:app', host='0.0.0.0', port=int(os.environ.get('PORT', '8000')))