Profeto/src/llm/context_builder.py

"""上下文构建器:数据切片 + 拼接。

架构:
  - match_header: 比赛基础信息(对阵双方/联赛/时间)
  - 切片函数: 每个领域 agent 一个数据切片(h2h / form / standings / injuries / xg)
  - build_context: 单 agent 路径,拼接全部切片(行为与旧版一致)

multi-agent 路径由 agents/orchestrator.py 调用切片函数,每个专家只拿自己的切片。
"""
from __future__ import annotations

import logging
from dataclasses import dataclass

from sqlalchemy import select
from sqlalchemy.orm import selectinload

from src.db.base import AsyncSessionLocal
from src.db.models import Match

logger = logging.getLogger(__name__)


def _outcome(home_goals: int, away_goals: int, side: str) -> str:
    """从某队视角看赛果: W/D/L。"""
    if home_goals is None or away_goals is None:
        return "?"
    if side == "home":
        return "W" if home_goals > away_goals else ("D" if home_goals == away_goals else "L")
    return "W" if away_goals > home_goals else ("D" if away_goals == home_goals else "L")


@dataclass
class MatchContext:
    match_id: int
    text: str
    has_stats: bool
    has_injuries: bool
    match_dt: object | None = None  # 比赛时间(回测防泄漏 + 快照用)


@dataclass
class MatchHeader:
    """比赛基础信息(所有 agent 共享)。"""
    match_id: int
    home_name: str
    away_name: str
    league_name: str
    season: str | None
    match_date: str
    match_dt: object  # 原始 datetime,回测防泄漏用
    stage: str | None
    home_team_id: int
    away_team_id: int
    league_id: int


async def load_match_header(match_id: int) -> MatchHeader:
    """加载比赛头信息(各 agent 共用)。"""
    async with AsyncSessionLocal() as db:
        m = await _load_match(db, match_id)
        return _to_header(m)


def _to_header(m: Match) -> MatchHeader:
    return MatchHeader(
        match_id=m.id,
        home_name=m.home_team.name_zh or m.home_team.name,
        away_name=m.away_team.name_zh or m.away_team.name,
        league_name=m.league.name if m.league else "?",
        season=m.season,
        match_date=m.match_date.strftime("%Y-%m-%d %H:%M UTC") if m.match_date else "?",
        match_dt=m.match_date,
        stage=m.match_stage,
        home_team_id=m.home_team_id,
        away_team_id=m.away_team_id,
        league_id=m.league_id,
    )


def header_text(h: MatchHeader) -> str:
    stage = f" {h.stage}" if h.stage else ""
    return (
        f"对阵: {h.home_name} vs {h.away_name} | {h.league_name} {h.season or '?'}{stage} | {h.match_date}"
    )


# ============================================================
# 切片函数: 每个领域 agent 一个
# ============================================================

async def h2h_slice(header: MatchHeader, *, limit: int = 8, before=None) -> str:
    """E - 历史交锋切片: 过去数年 + 近期交手数据,提取交手规律。before=match_date 用于回测。"""
    async with AsyncSessionLocal() as db:
        h2h = await _get_h2h(db, header.home_team_id, header.away_team_id, before=before, limit=limit)
    lines = [f"── 历史交锋(近 {limit} 次) ──"]
    if h2h:
        home_wins = draws = away_wins = 0
        for hm in h2h:
            d = hm.match_date.strftime("%Y-%m") if hm.match_date else "?"
            if hm.home_goals is not None:
                if hm.home_goals > hm.away_goals: home_wins += 1
                elif hm.home_goals == hm.away_goals: draws += 1
                else: away_wins += 1
                lines.append(f"  {d}: {hm.home_team.name} {hm.home_goals}-{hm.away_goals} {hm.away_team.name}")
            else:
                lines.append(f"  {d}: {hm.home_team.name} vs {hm.away_team.name} (无比分)")
        total = home_wins + draws + away_wins
        if total:
            lines.append(f"  总计 {total} 场: 主队 {home_wins}胜 {draws}平 {away_wins}负")
    else:
        lines.append("  无数据")
    return "\n".join(lines)


async def form_slice(header: MatchHeader, *, limit: int = 5, before=None) -> str:
    """A - 近期状态切片: 两队近 N 场赛果、关键事件、走势判断。before=match_date 用于回测。"""
    async with AsyncSessionLocal() as db:
        home_form = await _get_form(db, header.home_team_id, before=before, limit=limit)
        away_form = await _get_form(db, header.away_team_id, before=before, limit=limit)
    lines = []
    for label, name, form, side in (
        ("主队", header.home_name, home_form, "home"),
        ("客队", header.away_name, away_form, "away"),
    ):
        lines.append(f"── {label}近况({name},近 {limit} 场) ──")
        if form:
            wins = draws = losses = 0
            for fm in form:
                o = _outcome(fm.home_goals, fm.away_goals, side)
                if o == "W": wins += 1
                elif o == "D": draws += 1
                else: losses += 1
                score = f"{fm.home_goals}-{fm.away_goals}" if fm.home_goals is not None else "vs"
                xg = ""
                if fm.stats and fm.stats.home_xg is not None:
                    own = fm.stats.home_xg if side == "home" else fm.stats.away_xg
                    xg = f" (xG {own:.1f})"
                opp = fm.away_team.name if side == "home" else fm.home_team.name
                lines.append(f"  {o} {score} vs {opp}{xg}")
            lines.append(f"  近 {len(form)} 场: {wins}胜 {draws}平 {losses}负")
        else:
            lines.append("  无数据")
    return "\n".join(lines)


async def stats_slice(header: MatchHeader, *, limit: int = 10, before=None) -> str:
    """B - 攻防数据切片: 进球、射门、控球,评估攻防强度。before=match_date 用于回测。"""
    async with AsyncSessionLocal() as db:
        home_form = await _get_form(db, header.home_team_id, before=before, limit=limit)
        away_form = await _get_form(db, header.away_team_id, before=before, limit=limit)
    lines = [f"── 攻防数据(近 {limit} 场) ──"]
    for label, name, form, side in (
        ("主队", header.home_name, home_form, "home"),
        ("客队", header.away_name, away_form, "away"),
    ):
        if form:
            gf = ga = shots = sot = poss = xg = xga = 0
            n = n_shots = n_poss = n_xg = 0
            for fm in form:
                if fm.home_goals is None: continue
                gf += fm.home_goals if side == "home" else fm.away_goals
                ga += fm.away_goals if side == "home" else fm.home_goals
                n += 1
                if fm.stats:
                    if fm.stats.home_shots is not None:
                        shots += fm.stats.home_shots if side == "home" else fm.stats.away_shots
                        sot += fm.stats.home_shots_on_target if side == "home" else fm.stats.away_shots_on_target
                        n_shots += 1
                    if fm.stats.home_possession is not None:
                        poss += fm.stats.home_possession if side == "home" else (100 - fm.stats.home_possession)
                        n_poss += 1
                    if fm.stats.home_xg is not None:
                        xg += fm.stats.home_xg if side == "home" else fm.stats.away_xg
                        xga += fm.stats.away_xg if side == "home" else fm.stats.home_xg
                        n_xg += 1
            if n > 0:
                lines.append(f"  {label} {name}:")
                lines.append(f"    场均进球 {gf/n:.2f}, 场均失球 {ga/n:.2f}")
                if n_shots: lines.append(f"    场均射门 {shots/n_shots:.1f}, 射正 {sot/n_shots:.1f}")
                if n_poss: lines.append(f"    平均控球 {poss/n_poss:.1f}%")
                if n_xg: lines.append(f"    场均 xG {xg/n_xg:.2f}, 场均被 xG {xga/n_xg:.2f}")
            else:
                lines.append(f"  {label} {name}: 无比分数据")
        else:
            lines.append(f"  {label} {name}: 无数据")
    return "\n".join(lines)


async def home_away_slice(header: MatchHeader, *, limit: int = 10, before=None) -> str:
    """C - 主客因素切片: 主场战绩 vs 客场战绩,评估地理优势影响。before=match_date 用于回测。"""
    async with AsyncSessionLocal() as db:
        home_home = await _get_home_away(db, header.home_team_id, "home", before=before, limit=limit)
        away_away = await _get_home_away(db, header.away_team_id, "away", before=before, limit=limit)
    lines = ["── 主客因素 ──"]
    for label, name, matches, side in (
        ("主队主场", header.home_name, home_home, "home"),
        ("客队客场", header.away_name, away_away, "away"),
    ):
        if matches:
            wins = draws = losses = gf = ga = 0
            for m in matches:
                if m.home_goals is None: continue
                o = _outcome(m.home_goals, m.away_goals, side)
                if o == "W": wins += 1
                elif o == "D": draws += 1
                else: losses += 1
                gf += m.home_goals if side == "home" else m.away_goals
                ga += m.away_goals if side == "home" else m.home_goals
            n = wins + draws + losses
            if n > 0:
                pct = wins / n * 100
                lines.append(f"  {label} {name}(近 {n} 场): {wins}胜 {draws}平 {losses}负, 胜率 {pct:.0f}%")
                lines.append(f"    场均进球 {gf/n:.2f}, 场均失球 {ga/n:.2f}")
            else:
                lines.append(f"  {label} {name}: 无比分数据")
        else:
            lines.append(f"  {label} {name}: 无数据")
    return "\n".join(lines)


async def injuries_slice(header: MatchHeader, *, before=None) -> str:
    """D - 阵容完整性切片: 伤停与停赛名单,评估战力缺失程度。

    before=cutoff: 只使用 cutoff 之前已采集的伤停数据,防回测泄漏。
    """
    from src.data.injuries import get_injuries_for_match

    cutoff = before or header.match_dt
    async with AsyncSessionLocal() as db:
        home_injuries = await get_injuries_for_match(db, header.home_team_id, cutoff, as_of=cutoff)
        away_injuries = await get_injuries_for_match(db, header.away_team_id, cutoff, as_of=cutoff)

    lines = ["── 阵容完整性 ──"]
    has_data = False
    for label, injuries in (("主队", home_injuries), ("客队", away_injuries)):
        if injuries:
            has_data = True
            lines.append(f"  {label}伤停({len(injuries)}人):")
            for inj in injuries[:8]:  # 最多显示 8 条
                reason = inj.reason or inj.injury_type or "未知"
                lines.append(f"    - {inj.player_name}: {reason}")
            if len(injuries) > 8:
                lines.append(f"    ...及其他 {len(injuries) - 8} 人")
        else:
            lines.append(f"  {label}: 无伤停数据")

    if not has_data:
        return "── 阵容完整性 ──\n  无数据"

    return "\n".join(lines)


# ============================================================
# 单 agent 路径: 拼接全部切片(行为与旧版一致)
# ============================================================

async def build_context(match_id: int, *, form_last: int = 5, h2h_last: int = 5) -> MatchContext:
    """单 agent 路径的完整上下文: 拼接全部切片(before=比赛时间,防未来信息)。"""
    header = await load_match_header(match_id)
    parts = [header_text(header), ""]
    has_stats = False
    has_injuries = False

    form_text = await form_slice(header, limit=form_last, before=header.match_dt)
    if "无数据" not in form_text:
        has_stats = True
    parts.append(form_text)
    parts.append("")

    h2h_text = await h2h_slice(header, limit=h2h_last, before=header.match_dt)
    parts.append(h2h_text)
    parts.append("")

    stats_text = await stats_slice(header, before=header.match_dt)
    if "无数据" not in stats_text:
        has_stats = True
    parts.append(stats_text)
    parts.append("")

    home_away_text = await home_away_slice(header, before=header.match_dt)
    parts.append(home_away_text)
    parts.append("")

    injuries_text = await injuries_slice(header, before=header.match_dt)
    if "无数据" not in injuries_text:
        has_injuries = True
    parts.append(injuries_text)

    return MatchContext(
        match_id=match_id,
        text="\n".join(parts),
        has_stats=has_stats,
        has_injuries=has_injuries,
        match_dt=header.match_dt,
    )


# ============================================================
# 底层查询(切片函数共用)
# ============================================================

async def _load_match(db, match_id: int) -> Match:
    stmt = (
        select(Match)
        .where(Match.id == match_id)
        .options(
            selectinload(Match.league),
            selectinload(Match.home_team),
            selectinload(Match.away_team),
            selectinload(Match.stats),
        )
    )
    m = (await db.execute(stmt)).scalar_one_or_none()
    if m is None:
        raise ValueError(f"match {match_id} not found")
    return m


async def _get_form(db, team_id: int, before, *, limit: int = 5) -> list[Match]:
    """某队近 N 场(已完赛)。before=None 表示不限制(预测赛前的场景由调用方保证)。"""
    stmt = (
        select(Match)
        .where(Match.match_status == "finished")
        .where(Match.home_goals.is_not(None))
        .where((Match.home_team_id == team_id) | (Match.away_team_id == team_id))
        .order_by(Match.match_date.desc())
        .limit(limit)
    )
    if before is not None:
        stmt = stmt.where(Match.match_date < before)
    result = await db.execute(stmt)
    return list(result.scalars().all())


async def _get_h2h(db, home_id: int, away_id: int, before, *, limit: int = 5) -> list[Match]:
    """两队交锋史。"""
    stmt = (
        select(Match)
        .where(Match.match_status == "finished")
        .where(Match.home_goals.is_not(None))
        .where(
            ((Match.home_team_id == home_id) & (Match.away_team_id == away_id))
            | ((Match.home_team_id == away_id) & (Match.away_team_id == home_id))
        )
        .order_by(Match.match_date.desc())
        .limit(limit)
    )
    if before is not None:
        stmt = stmt.where(Match.match_date < before)
    result = await db.execute(stmt)
    return list(result.scalars().all())


async def _get_home_away(db, team_id: int, side: str, before, *, limit: int = 10) -> list[Match]:
    """某队主场/客场近 N 场。side='home' 取主场,'away' 取客场。"""
    stmt = (
        select(Match)
        .where(Match.match_status == "finished")
        .where(Match.home_goals.is_not(None))
        .order_by(Match.match_date.desc())
        .limit(limit)
    )
    if side == "home":
        stmt = stmt.where(Match.home_team_id == team_id)
    else:
        stmt = stmt.where(Match.away_team_id == team_id)
    if before is not None:
        stmt = stmt.where(Match.match_date < before)
    result = await db.execute(stmt)
    return list(result.scalars().all())