group_fqcd_jr/app/infrastructure/fund_market_adapter.py

"""东方财富基金行情适配器。

该模块只负责外部 HTTP 调用和供应商响应解析，不依赖 Agent、Controller 或数据库。
"""

import asyncio
import re
from datetime import date
from decimal import Decimal, InvalidOperation
from typing import Any, Protocol

import httpx

from app.core.errors import RecoverableAgentError

NAV_API = "https://api.fund.eastmoney.com/f10/lsjz"
RETURN_API = "https://api.fund.eastmoney.com/pinzhong/LJSYLZS"
QUOTE_API = "https://push2.eastmoney.com/api/qt/ulist.np/get"
DETAIL_API = "https://fund.eastmoney.com/pingzhongdata/{code}.js"
#: 费率只能从 f10 基金概况页抓。**没有可用的 JSON 接口** ——
#: `FundArchivesDatas.aspx?type=jjfl` 实测返回空（正文就一句 `var apidata=`），
#: 所以这里按 HTML 去标签后匹配字段名。
FEE_API = "https://fundf10.eastmoney.com/jbgk_{code}.html"
HEADERS = {"User-Agent": "Mozilla/5.0", "Referer": "https://fund.eastmoney.com/"}

#: 费率字段 → 概况页里的标签与取值模式。值形如「0.15」（百分号已剥离），
#: 页面写 `---` 表示该项不适用（如 ETF 没有申购费），统一映射成 `None`。
FEE_FIELD_PATTERNS: dict[str, str] = {
    "management_fee_rate": r"管理费率\s*([\d.]+)\s*%",
    "custodian_fee_rate": r"托管费率\s*([\d.]+)\s*%",
    "service_fee_rate": r"销售服务费率\s*([\d.]+)\s*%",
    "subscribe_fee_rate": r"最高申购费率\s*(--|[\d.]+)",
    "redeem_fee_rate": r"最高赎回费率\s*(--|[\d.]+)",
}


class FundMarketAdapter(Protocol):
    async def fetch_names(self, codes: list[str]) -> dict[str, str]: ...

    async def fetch_quotes(self, codes: list[str]) -> dict[str, dict[str, Any]]: ...

    async def fetch_history(self, code: str, target_date: date) -> dict[str, Any]: ...

    async def fetch_fees(self, codes: list[str]) -> dict[str, dict[str, Any]]: ...


class EastmoneyFundAdapter:
    def __init__(
        self,
        client: httpx.AsyncClient | None = None,
        *,
        timeout_seconds: float = 12.0,
        retries: int = 2,
    ) -> None:
        self._client = client
        self._owns_client = client is None
        self.timeout_seconds = timeout_seconds
        self.retries = max(0, retries)

    async def fetch_names(self, codes: list[str]) -> dict[str, str]:
        result: dict[str, str] = {}
        for code in codes:
            try:
                response = await self._request("GET", DETAIL_API.format(code=code))
                match = re.search(r"var\s+fS_name\s*=\s*[\"']([^\"']+)", response.text)
                result[code] = match.group(1).strip() if match else f"基金 {code}"
            except RecoverableAgentError:
                result[code] = f"基金 {code}"
        return result

    async def fetch_quotes(self, codes: list[str]) -> dict[str, dict[str, Any]]:
        if not codes:
            return {}
        secids = ",".join(
            ("1." if code.startswith(("5", "6", "9")) else "0.") + code
            for code in codes
        )
        try:
            response = await self._request(
                "GET", QUOTE_API,
                params={"fltt": 2, "invt": 2, "fields": "f12,f2,f3", "secids": secids},
            )
            items = ((response.json().get("data") or {}).get("diff") or [])
        except (RecoverableAgentError, ValueError, TypeError):
            return {}
        result: dict[str, dict[str, Any]] = {}
        for item in items:
            code = str(item.get("f12")) if item.get("f12") else ""
            if code:
                result[code] = {
                    "nav": self._decimal(item.get("f2")),
                    "daily_change": self._decimal(item.get("f3")),
                }
        return result

    async def fetch_history(self, code: str, target_date: date) -> dict[str, Any]:
        try:
            response = await self._request(
                "GET", NAV_API,
                params={"fundCode": code, "pageIndex": 1, "pageSize": 30,
                        "startDate": "", "endDate": ""},
            )
            records = ((response.json().get("Data") or {}).get("LSJZList") or [])
        except (RecoverableAgentError, ValueError, TypeError):
            return {"degraded": True}
        selected = next(
            (item for item in records if item.get("FSRQ") == target_date.isoformat()), None
        )
        if selected is None and records:
            selected = records[0]
        if not selected:
            return {"degraded": True}
        return {
            "nav": self._decimal(selected.get("DWJZ")),
            "nav_date": self._date(selected.get("FSRQ")),
            "daily_change": self._decimal(selected.get("JZZZL")),
            "degraded": False,
        }

    async def fetch_fees(self, codes: list[str]) -> dict[str, dict[str, Any]]:
        """取每只基金的费率（管理费/托管费/销售服务费/申购费/赎回费）与基金全称。

        为什么单独留一个入口：费率是**长期稳定**字段，而概况页约 45KB/只，
        所以调用方应当按需刷新、不要每次问答都抓 —— `tools/fetch_live_quotes.py`
        就是按"需要时才拉"来用它的。

        取数失败的基金**不会出现在返回里**（而不是返回一个全 None 的 dict），
        免得调用方把"没抓到"误当成"该基金确实没有费率"。
        """
        results: dict[str, dict[str, Any]] = {}
        for code in codes:
            try:
                response = await self._request("GET", FEE_API.format(code=code))
            except RecoverableAgentError:
                continue
            parsed = self._parse_fees(response.text)
            if parsed is not None:
                results[code] = parsed
        return results

    @staticmethod
    def _parse_fees(html: str) -> dict[str, Any] | None:
        text = re.sub(r"\s+", " ", re.sub(r"<[^>]+>", " ", html))
        fees: dict[str, Any] = {}
        for field, pattern in FEE_FIELD_PATTERNS.items():
            match = re.search(pattern, text)
            value = match.group(1) if match else None
            fees[field] = (
                None if value in (None, "", "--") else EastmoneyFundAdapter._decimal(value)
            )
        # 一个字段都没解析出来，说明页面结构变了或该代码不存在 —— 返回 None 让调用方
        # 与"该基金确实没有费率"区分开。
        if all(value is None for value in fees.values()):
            return None
        name = re.search(r"基金全称\s*(\S{4,60}?(?:基金|集合资产管理计划))", text)
        fees["full_name"] = name.group(1) if name else None
        return fees

    async def _request(self, method: str, url: str, **kwargs: Any) -> httpx.Response:
        client = self._client or httpx.AsyncClient(headers=HEADERS)
        try:
            last_error: Exception | None = None
            for attempt in range(self.retries + 1):
                try:
                    response = await client.request(
                        method, url, timeout=self.timeout_seconds, **kwargs
                    )
                    response.raise_for_status()
                    return response
                except (httpx.HTTPError, TimeoutError) as exc:
                    last_error = exc
                    if attempt < self.retries:
                        await asyncio.sleep(0.2 * (2**attempt))
            raise RecoverableAgentError("基金行情数据源不可用") from last_error
        finally:
            if self._owns_client:
                await client.aclose()

    @staticmethod
    def _decimal(value: Any) -> Decimal | None:
        if value in (None, "", "-"):
            return None
        try:
            return Decimal(str(value).replace("%", ""))
        except (InvalidOperation, ValueError):
            return None

    @staticmethod
    def _date(value: Any) -> date | None:
        try:
            return date.fromisoformat(str(value))
        except (TypeError, ValueError):
            return None