"""Build and persist daily AI research reports."""

from __future__ import annotations

import json
from datetime import datetime
from typing import Any

from sqlalchemy import text

from app.db.database import get_db
from app.db import tables
from app.research.catalyst_agent import build_catalyst_summary
from app.research.feedback_agent import build_ranking_feedback
from app.research.market_agent import build_market_view
from app.research.ranking_agent import build_opportunity_cards
from app.research.risk_agent import build_risk_alerts
from app.research.sector_agent import build_theme_views, build_theme_views_async
from app.research.stock_research_agent import build_stock_research_notes, build_stock_research_notes_sync


def _latest_scan_from_result(result: dict, scan_session: str) -> dict:
    for item in result.get("scan_logs", []) or []:
        if item.get("stage") == "final_filter":
            return item
    return {
        "scan_session": scan_session,
        "scan_mode": result.get("scan_mode", ""),
        "status": "empty" if not result.get("recommendations") else "ok",
        "summary": "",
        "elimination_reasons": {},
        "created_at": datetime.now().isoformat(),
    }


def build_research_report(result: dict, scan_session: str) -> dict:
    """Build a report with deterministic stock notes.

    This remains available for fast API fallbacks and tests. Normal scans use
    build_research_report_async so the stock research notes can call the LLM.
    """
    return _assemble_research_report(
        result,
        scan_session,
        build_stock_research_notes_sync,
    )


async def build_research_report_async(result: dict, scan_session: str) -> dict:
    return await _assemble_research_report_async(result, scan_session)


def _common_inputs(result: dict, scan_session: str) -> tuple[Any, dict, list, list, dict, dict, list, dict, list]:
    market_temp = result.get("market_temp")
    strategy_profile = result.get("strategy_profile") or {}
    sectors = result.get("hot_sectors", []) or []
    recommendations = result.get("recommendations", []) or []
    latest_scan = result.get("latest_scan") or _latest_scan_from_result(result, scan_session)

    theme_views = build_theme_views(sectors)
    _calibrate_market_from_themes(market_temp, theme_views)
    market_view = build_market_view(market_temp, strategy_profile)
    catalyst = build_catalyst_summary(theme_views)
    risks = build_risk_alerts(recommendations, market_view, latest_scan)
    return market_temp, strategy_profile, sectors, recommendations, latest_scan, market_view, theme_views, catalyst, risks


def _assemble_research_report(result: dict, scan_session: str, notes_builder) -> dict:
    market_temp, _, _, recommendations, latest_scan, market_view, theme_views, catalyst, risks = _common_inputs(result, scan_session)
    stock_notes = notes_builder(recommendations, theme_views)
    return _finalize_research_report(result, scan_session, market_temp, recommendations, latest_scan, market_view, theme_views, catalyst, risks, stock_notes, None, None)


async def _assemble_research_report_async(result: dict, scan_session: str) -> dict:
    market_temp = result.get("market_temp")
    strategy_profile = result.get("strategy_profile") or {}
    sectors = result.get("hot_sectors", []) or []
    recommendations = result.get("recommendations", []) or []
    latest_scan = result.get("latest_scan") or _latest_scan_from_result(result, scan_session)

    theme_views = await build_theme_views_async(sectors)
    _calibrate_market_from_themes(market_temp, theme_views)
    market_view = build_market_view(market_temp, strategy_profile)
    catalyst = build_catalyst_summary(theme_views)
    risks = build_risk_alerts(recommendations, market_view, latest_scan)
    stock_notes = await build_stock_research_notes(recommendations, theme_views, risks)
    feedback = await build_ranking_feedback(days=60)
    data_quality = await _build_data_quality_report(market_view)
    return _finalize_research_report(result, scan_session, market_temp, recommendations, latest_scan, market_view, theme_views, catalyst, risks, stock_notes, feedback, data_quality)


def _finalize_research_report(
    result: dict,
    scan_session: str,
    market_temp: Any,
    recommendations: list,
    latest_scan: dict,
    market_view: dict,
    theme_views: list[dict],
    catalyst: dict,
    risks: list[dict],
    stock_notes: list[dict],
    feedback: dict | None,
    data_quality: dict | None,
) -> dict:
    opportunities = build_opportunity_cards(recommendations, stock_notes, risks, feedback)
    trade_date = getattr(market_temp, "trade_date", "") or datetime.now().strftime("%Y%m%d")

    if opportunities:
        no_trade_reason = {"has_scan": True, "reason": "", "blocked_by": []}
    else:
        elimination = latest_scan.get("elimination_reasons") or {}
        if elimination:
            reason = "；".join(f"{k} {v}只" for k, v in list(elimination.items())[:3])
        elif recommendations:
            reason = "候选存在，但机会卡被风险或动作分层过滤。"
        else:
            reason = "本轮扫描没有形成满足条件的交易候选。"
        no_trade_reason = {"has_scan": True, "reason": reason, "blocked_by": list(elimination.keys())[:5]}

    top_theme_names = [item["theme"] for item in theme_views[:3]]
    report = {
        "trade_date": trade_date,
        "scan_session": scan_session,
        "scan_mode": result.get("scan_mode", ""),
        "scanned_at": datetime.now().isoformat(),
        "market_view": market_view,
        "theme_views": theme_views,
        "industry_chain_map": [
            {
                "theme": item["theme"],
                "chain_nodes": item["chain_nodes"],
                "chain_items": item.get("chain_items", []),
                "leader_stocks": item.get("leader_stocks", []),
            }
            for item in theme_views
        ],
        "catalyst": catalyst,
        "stock_research_notes": stock_notes,
        "opportunity_cards": opportunities,
        "risk_alerts": risks,
        "ranking_feedback": feedback or {},
        "risk_summary": {
            "reject_count": sum(1 for item in risks if item.get("reject")),
            "warning_count": sum(1 for item in risks if not item.get("reject")),
            "types": sorted({item.get("risk_type", "") for item in risks if item.get("risk_type")}),
        },
        "data_quality": data_quality or _fallback_data_quality(market_view),
        "no_trade_reason": no_trade_reason,
        "summary": {
            "market": market_view["summary"],
            "theme": f"当前主线关注 {'、'.join(top_theme_names)}。" if top_theme_names else "暂未形成清晰主线。",
            "opportunity_count": len(opportunities),
            "risk_count": len(risks),
        },
    }
    return report


async def _build_data_quality_report(market_view: dict) -> dict:
    watched_sources = ("eastmoney", "tencent", "market_breadth")
    since = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
    issues = []
    async with get_db() as db:
        result = await db.execute(
            text(
                "SELECT source, level, message, created_at FROM error_logs "
                "WHERE created_at >= :since AND ("
                "source LIKE '%eastmoney%' OR source LIKE '%tencent%' OR source = 'market_breadth'"
                ") ORDER BY created_at DESC, id DESC LIMIT 20"
            ),
            {"since": since.strftime("%Y-%m-%d %H:%M:%S")},
        )
        for row in result.fetchall():
            item = dict(row._mapping)
            issues.append({
                "source": item.get("source", ""),
                "level": item.get("level", ""),
                "message": item.get("message", ""),
                "created_at": str(item.get("created_at") or ""),
            })

    warnings = []
    market_status = market_view.get("data_status") or "fresh"
    if market_status == "estimated":
        warnings.append("全市场涨跌停使用实时行情阈值估算，非涨跌停池精确口径。")
    if issues:
        warnings.append("今日存在行情源失败记录，盘中结论已降级处理。")

    status = "degraded" if warnings or issues else "ok"
    return {
        "status": status,
        "market_data_status": market_status,
        "market_source": market_view.get("source", ""),
        "limit_counts_reliable": bool(market_view.get("limit_counts_reliable", False)),
        "warnings": warnings,
        "issues": issues[:8],
    }


def _fallback_data_quality(market_view: dict) -> dict:
    market_status = market_view.get("data_status") or "fresh"
    warnings = []
    if market_status == "estimated":
        warnings.append("全市场涨跌停使用实时行情阈值估算。")
    return {
        "status": "degraded" if warnings else "ok",
        "market_data_status": market_status,
        "market_source": market_view.get("source", ""),
        "limit_counts_reliable": bool(market_view.get("limit_counts_reliable", False)),
        "warnings": warnings,
        "issues": [],
    }


def _calibrate_market_from_themes(market_temp: Any, theme_views: list[dict]) -> None:
    if not market_temp or not theme_views:
        return
    theme_limit_up = sum(max(int(item.get("limit_up_count") or 0), 0) for item in theme_views)
    if theme_limit_up <= int(getattr(market_temp, "limit_up_count", 0) or 0):
        return
    original_limit = int(getattr(market_temp, "limit_up_count", 0) or 0)
    original_temp = float(getattr(market_temp, "temperature", 0) or 0)
    market_temp.limit_up_count = theme_limit_up
    if original_limit == 0:
        market_temp.temperature = round(min(original_temp + min(theme_limit_up / 5, 8), 100), 1)
    if not getattr(market_temp, "limit_counts_reliable", False):
        market_temp.data_status = "estimated"
        detail = getattr(market_temp, "source_detail", "") or ""
        market_temp.source_detail = f"{detail};theme_limit_lower_bound"


async def save_research_report(report: dict) -> None:
    trade_date = str(report.get("trade_date") or "")
    scan_session = str(report.get("scan_session") or "manual")
    now = datetime.now()
    async with get_db() as db:
        await db.execute(text("DELETE FROM research_reports WHERE scan_session = :session"), {"session": scan_session})
        await db.execute(text("DELETE FROM theme_maps WHERE scan_session = :session"), {"session": scan_session})
        await db.execute(text("DELETE FROM theme_chain_nodes WHERE scan_session = :session"), {"session": scan_session})
        await db.execute(text("DELETE FROM stock_research_notes WHERE scan_session = :session"), {"session": scan_session})
        await db.execute(text("DELETE FROM risk_events WHERE scan_session = :session"), {"session": scan_session})
        await db.execute(text("DELETE FROM opportunity_cards WHERE scan_session = :session"), {"session": scan_session})

        await db.execute(tables.research_reports_table.insert().values(
            scan_session=scan_session,
            trade_date=trade_date,
            market_summary=report.get("summary", {}).get("market", ""),
            theme_summary=report.get("summary", {}).get("theme", ""),
            no_trade_reason=json.dumps(report.get("no_trade_reason", {}), ensure_ascii=False),
            report_json=json.dumps(report, ensure_ascii=False, default=str),
            created_at=now,
        ))

        for theme in report.get("theme_views", []):
            await db.execute(tables.theme_maps_table.insert().values(
                scan_session=scan_session,
                trade_date=trade_date,
                theme_name=theme.get("theme", ""),
                stage=theme.get("stage", ""),
                heat_score=theme.get("heat_score", 0),
                logic_summary=theme.get("logic", ""),
                lifecycle_status=theme.get("lifecycle_status", ""),
                created_at=now,
            ))
            for node in theme.get("chain_nodes", []) or ["未归类"]:
                chain_item = _chain_item_for_node(theme, node)
                await db.execute(tables.theme_chain_nodes_table.insert().values(
                    scan_session=scan_session,
                    trade_date=trade_date,
                    theme_name=theme.get("theme", ""),
                    chain_node=node,
                    related_stocks=json.dumps(chain_item.get("related_stocks", []), ensure_ascii=False, default=str),
                    leader_stocks=json.dumps(chain_item.get("leader_stocks", []) or theme.get("leader_stocks", []), ensure_ascii=False, default=str),
                    created_at=now,
                ))

        for note in report.get("stock_research_notes", []):
            await db.execute(tables.stock_research_notes_table.insert().values(
                scan_session=scan_session,
                trade_date=trade_date,
                ts_code=note.get("ts_code", ""),
                name=note.get("name", ""),
                theme=note.get("theme", "未归类"),
                chain_node=note.get("chain_node", "未归类"),
                logic_score=note.get("logic_score", 0),
                logic_summary=note.get("logic_summary", ""),
                evidence_json=json.dumps(note.get("evidence", []), ensure_ascii=False, default=str),
                uncertainty=note.get("uncertainty", ""),
                stock_role=note.get("stock_role", "待归类"),
                disagreement=note.get("disagreement", ""),
                invalid_condition=note.get("invalid_condition", ""),
                generated_by=note.get("generated_by", "rules"),
                created_at=now,
            ))

        for risk in report.get("risk_alerts", []):
            await db.execute(tables.risk_events_table.insert().values(
                scan_session=scan_session,
                trade_date=trade_date,
                ts_code=risk.get("ts_code", ""),
                risk_type=risk.get("risk_type", ""),
                severity=risk.get("severity", "warning"),
                reject=bool(risk.get("reject")),
                reason=risk.get("reason", ""),
                source=risk.get("source", "research_agent"),
                created_at=now,
            ))

        for card in report.get("opportunity_cards", []):
            await db.execute(tables.opportunity_cards_table.insert().values(
                scan_session=scan_session,
                trade_date=trade_date,
                ts_code=card.get("ts_code", ""),
                name=card.get("name", ""),
                theme=card.get("theme", ""),
                chain_node=card.get("chain_node", "未归类"),
                stock_role=card.get("stock_role", "待归类"),
                opportunity_type=card.get("opportunity_type", "观察"),
                score=card.get("adjusted_score", card.get("score", 0)),
                alpha_type=card.get("alpha_type", "观察线索"),
                alpha_score=card.get("alpha_score", 0),
                beta_dependency=card.get("beta_dependency", "中"),
                beta_dependency_score=card.get("beta_dependency_score", 0),
                ambush_score=card.get("ambush_score", 0),
                expectation_gap_score=card.get("expectation_gap_score", 0),
                risk_gate=card.get("risk_gate", "通过"),
                setup_quality=card.get("setup_quality", "仅观察"),
                alpha_reason=card.get("alpha_reason", ""),
                action_plan=card.get("action_plan", "观察"),
                trigger=card.get("trigger", ""),
                invalid_condition=card.get("invalid_condition", ""),
                created_at=now,
            ))
        await db.commit()


def _chain_item_for_node(theme: dict, node: str) -> dict:
    for item in theme.get("chain_items", []) or []:
        if item.get("chain_node") == node:
            return item
    return {}


async def load_latest_research_report() -> dict | None:
    async with get_db() as db:
        result = await db.execute(text("SELECT report_json FROM research_reports ORDER BY created_at DESC, id DESC LIMIT 1"))
        row = result.fetchone()
        if not row:
            return None
        try:
            return json.loads(row._mapping["report_json"] or "{}")
        except Exception:
            return None