"""
AgomTradePro MCP Tools - Fund 基金分析工具

提供基金分析相关的 MCP 工具。
"""

from datetime import date
from typing import Any

from mcp.server.fastmcp import FastMCP

from agomtradepro import AgomTradeProClient


def register_fund_tools(server: FastMCP) -> None:
    """注册 Fund 相关的 MCP 工具"""

    @server.tool()
    def rank_funds(
        regime: str = "Recovery",
        max_count: int = 50,
    ) -> list[dict[str, Any]]:
        """
        获取基金排名。

        Args:
            regime: 宏观象限
            max_count: 返回数量上限

        Returns:
            基金排名列表
        """
        client = AgomTradeProClient()
        return client.fund.rank_funds(regime=regime, max_count=max_count)

    @server.tool()
    def screen_funds(
        regime: str | None = None,
        custom_types: list[str] | None = None,
        custom_styles: list[str] | None = None,
        min_scale: float | None = None,
        limit: int = 30,
    ) -> dict[str, Any]:
        """
        按当前 canonical fund screen 接口筛选基金。

        Args:
            regime: 宏观象限；为空时由后端按当前环境推断
            custom_types: 自定义基金类型列表
            custom_styles: 自定义投资风格列表
            min_scale: 最低基金规模
            limit: 返回数量上限

        Returns:
            fund screen 响应
        """
        client = AgomTradeProClient()
        return client.fund.screen_funds(
            regime=regime,
            custom_types=custom_types,
            custom_styles=custom_styles,
            min_scale=min_scale,
            limit=limit,
        )

    @server.tool()
    def get_fund_score(
        fund_code: str,
        as_of_date: str | None = None,
    ) -> dict[str, Any]:
        """
        获取基金评分

        Args:
            fund_code: 基金代码（如 000001.OF）
            as_of_date: 评分日期（ISO 格式，None 表示最新）

        Returns:
            基金评分信息

        Example:
            >>> score = get_fund_score("000001.OF")
        """
        client = AgomTradeProClient()
        parsed_date = date.fromisoformat(as_of_date) if as_of_date else None
        return client.fund.get_fund_score(fund_code, parsed_date)

    @server.tool()
    def list_funds(
        fund_type: str | None = None,
        min_score: float | None = None,
        limit: int = 50,
    ) -> list[dict[str, Any]]:
        """
        获取基金列表

        Args:
            fund_type: 基金类型过滤（equity/bond/mixed/ETF）
            min_score: 最低评分过滤（可选）
            limit: 返回数量限制

        Returns:
            基金列表

        Example:
            >>> funds = list_funds(fund_type="equity", min_score=60)
        """
        client = AgomTradeProClient()
        return client.fund.list_funds(fund_type=fund_type, min_score=min_score, limit=limit)

    @server.tool()
    def get_fund_detail(fund_code: str) -> dict[str, Any]:
        """
        获取基金详情

        Args:
            fund_code: 基金代码

        Returns:
            基金详情

        Example:
            >>> detail = get_fund_detail("000001.OF")
        """
        client = AgomTradeProClient()
        return client.fund.get_fund_detail(fund_code)

    @server.tool()
    def get_fund_recommendations(
        regime: str | None = None,
        fund_type: str | None = None,
        limit: int = 20,
    ) -> list[dict[str, Any]]:
        """
        获取基金推荐

        Args:
            regime: 宏观象限过滤（可选）
            fund_type: 基金类型过滤（可选）
            limit: 返回数量限制

        Returns:
            推荐基金列表

        Example:
            >>> recs = get_fund_recommendations(regime="Recovery", fund_type="equity")
        """
        client = AgomTradeProClient()
        return client.fund.get_recommendations(regime=regime, fund_type=fund_type, limit=limit)

    @server.tool()
    def analyze_fund(
        fund_code: str,
        report_date: str | None = None,
        as_of_date: str | None = None,
    ) -> dict[str, Any]:
        """
        分析基金

        Args:
            fund_code: 基金代码
            report_date: 报告日期（ISO 格式，优先）
            as_of_date: 分析日期兼容别名（ISO 格式，None 表示最新）

        Returns:
            基金分析结果

        Example:
            >>> analysis = analyze_fund("000001.OF")
        """
        client = AgomTradeProClient()
        effective_date = report_date or as_of_date
        parsed_date = date.fromisoformat(effective_date) if effective_date else None
        return client.fund.analyze_fund(fund_code, report_date=parsed_date)

    @server.tool()
    def get_fund_nav_history(
        fund_code: str,
        start_date: str | None = None,
        end_date: str | None = None,
        limit: int = 100,
    ) -> list[dict[str, Any]]:
        """
        获取基金净值历史

        Args:
            fund_code: 基金代码
            start_date: 开始日期（ISO 格式）
            end_date: 结束日期（ISO 格式）
            limit: 返回数量限制

        Returns:
            基金净值历史
        """
        client = AgomTradeProClient()
        parsed_start = date.fromisoformat(start_date) if start_date else None
        parsed_end = date.fromisoformat(end_date) if end_date else None
        return client.fund.get_nav_history(
            fund_code,
            start_date=parsed_start,
            end_date=parsed_end,
            limit=limit,
        )

    @server.tool()
    def get_fund_performance(
        fund_code: str,
        period: str = "1y",
    ) -> dict[str, Any]:
        """
        获取基金业绩

        Args:
            fund_code: 基金代码
            period: 统计周期（1m/3m/6m/1y/3y/5y/ytd/inception）

        Returns:
            业绩数据

        Example:
            >>> perf = get_fund_performance("000001.OF", period="1y")
        """
        client = AgomTradeProClient()
        return client.fund.get_performance(fund_code, period)

    @server.tool()
    def get_fund_holdings(
        fund_code: str,
        report_date: str | None = None,
        as_of_date: str | None = None,
    ) -> list[dict[str, Any]]:
        """
        获取基金持仓

        Args:
            fund_code: 基金代码
            report_date: 报告日期（ISO 格式，优先）
            as_of_date: 持仓日期兼容别名（ISO 格式，None 表示最新）

        Returns:
            持仓列表

        Example:
            >>> holdings = get_fund_holdings("000001.OF")
        """
        client = AgomTradeProClient()
        effective_date = report_date or as_of_date
        parsed_date = date.fromisoformat(effective_date) if effective_date else None
        return client.fund.get_holdings(fund_code, report_date=parsed_date)
