fund_data_service.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
基金数据服务层 - 专业版
基于天天基金、东方财富等公开API获取真实金融数据

功能：
- 基金基本信息（类型、规模、经理等）
- 历史净值走势（真实数据）
- 股票持仓明细（季度报告）
- 风险指标计算（夏普比率、最大回撤等）
- 同类基金对比排名
"""

from __future__ import annotations

import json
import math
import random
import re
import time
from datetime import datetime, timedelta
from typing import Any, Dict, List, Optional

import numpy as np
import requests

from utils.logger import logger


class FundDataService:
    """专业级基金数据服务"""

    # API配置
    BASE_URL_TTJJ = "https://fundgz.1234567.com.cn"
    BASE_URL_EASTMONEY = "https://fund.eastmoney.com"
    BASE_URL_EASTMONEY_API = "https://fundmobapi.eastmoney.com"

    # 请求头（模拟浏览器）
    HEADERS = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 '
                      '(KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
        'Referer': 'http://fund.eastmoney.com/',
        'Accept': 'application/json, text/plain, */*',
        'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8',
    }

    def __init__(self):
        self.session = requests.Session()
        self.session.headers.update(self.HEADERS)

    def get_fund_basic_info(self, fund_code: str) -> Dict[str, Any]:
        """
        获取基金完整基本信息

        Args:
            fund_code: 基金代码（6位数字）

        Returns:
            包含以下字段的字典：
            - fund_code: 基金代码
            - name: 基金全称
            - fund_type: 基金类型
            - scale: 基金规模（亿元）
            - establish_date: 成立日期
            - manager: 基金经理
            - management_fee: 管理费率
            - custodian_fee: 托管费率
            - nav: 最新净值
            - accumulated_nav: 累计净值
            - nav_date: 净值日期
            - estimated_nav: 估算净值
            - estimated_change: 估算涨跌幅
            - one_year_return: 近1年收益率
            - three_year_return: 近3年收益率
            - since_established: 成立以来收益率
            - benchmark: 业绩比较基准
        """
        result = {
            'fund_code': fund_code,
            'name': '',
            'fund_type': '',
            'scale': '',
            'establish_date': '',
            'manager': '',
            'management_fee': '',
            'custodian_fee': '',
            'nav': 0.0,
            'accumulated_nav': 0.0,
            'nav_date': '',
            'estimated_nav': '',
            'estimated_change': '',
            'one_year_return': 0.0,
            'three_year_return': 0.0,
            'since_established': 0.0,
            'benchmark': ''
        }

        try:
            # 方法1：从天天基金实时API获取基础估值信息
            url = f"{self.BASE_URL_TTJJ}/js/{fund_code}.js"
            response = self.session.get(url, timeout=10)

            if response.status_code == 200:
                text = response.text
                start = text.index('{')
                end = text.rindex('}') + 1
                data = json.loads(text[start:end])

                result['name'] = data.get('name', '')
                result['nav'] = float(data.get('dwjz', 0))
                result['nav_date'] = data.get('jzrq', '')
                result['estimated_nav'] = data.get('gsz', '')
                result['estimated_change'] = data.get('gszzl', '')

            # 方法2：从东方财富API获取详细信息
            detail_url = (
                f"{self.BASE_URL_EASTMONEY_API}/FundMNewApi/FundMNFInfo"
                f"?pageIndex=1&pageSize=3&plat=Android&appType=ttjj"
                f"&product=EFund&Version=1&deviceid=1&Ession=1"
                f"&Fcodes={fund_code}"
            )
            resp_detail = self.session.get(detail_url, timeout=15)

            if resp_detail.status_code == 200:
                detail_data = resp_detail.json()

                # 安全检查：确保 Datas 存在且为非空列表
                datas_list = detail_data.get('Datas')
                if datas_list and isinstance(datas_list, list) and len(datas_list) > 0:
                    fund_info = datas_list[0]

                    # 提取详细信息
                    result['fund_type'] = fund_info.get('FUNDTYPE', '') or self._guess_fund_type(fund_code)
                    result['scale'] = fund_info.get('NZSCALE', '') or self._format_scale(fund_info.get('DJZJZ', 0))
                    result['establish_date'] = str(fund_info.get('ESTABLISHDATE', '') or '')[:10]
                    result['manager'] = fund_info.get('MANAGERNAME', '') or '未知'
                    result['management_fee'] = fund_info.get('MANAGEMFEE', '') or '1.50%'
                    result['custodian_fee'] = fund_info.get('CUSTODIANFEE', '') or '0.25%'
                    result['benchmark'] = fund_info.get('BENCHMARK', '') or '--'

                    # 收益率数据
                    returns = fund_info.get('SYL_1N', '')
                    if returns and str(returns).replace('%', '').replace('--', ''):
                        try:
                            result['one_year_return'] = float(str(returns).replace('%', '')) / 100
                        except (ValueError, TypeError):
                            pass

                    returns_3y = fund_info.get('SYL_3N', '')
                    if returns_3y and str(returns_3y).replace('%', '').replace('--', ''):
                        try:
                            result['three_year_return'] = float(str(returns_3y).replace('%', '')) / 100
                        except (ValueError, TypeError):
                            pass

                    since_return = fund_info.get('SYL_JRSG', '')
                    if since_return and str(since_return).replace('%', '').replace('--', ''):
                        try:
                            result['since_established'] = float(str(since_return).replace('%', '')) / 100
                        except (ValueError, TypeError):
                            pass

            logger.info(f"成功获取基金{fund_code}基本信息")

        except Exception as e:
            logger.error(f"获取基金{fund_code}基本信息失败: {e}")
            # 使用备用数据填充
            result.update({
                'fund_type': self._guess_fund_type(fund_code),
                'manager': '未知',
                'management_fee': '1.50%',
                'custodian_fee': '0.25%',
                'scale': '--',
                'establish_date': '--'
            })
            result['data_source'] = 'fallback'  # 标记为备用数据

        # 如果没有设置数据来源，标记为真实API
        if 'data_source' not in result:
            result['data_source'] = 'real_api'

        return result

    def get_fund_history_nav(self, fund_code: str, days: int = 365) -> List[Dict[str, Any]]:
        """
        获取历史净值数据（真实数据）

        Args:
            fund_code: 基金代码
            days: 获取最近多少天的数据（默认365天）

        Returns:
            列表，每项包含 {'date': str, 'nav': float}
        """
        nav_data = []

        try:
            end_date = datetime.now().strftime('%Y-%m-%d')
            start_date = (datetime.now() - timedelta(days=days)).strftime('%Y-%m-%d')

            # 东方财富历史净值API
            url = (
                f"{self.BASE_URL_EASTMONEY_API}/FundMNewApi/FundMNHistoryList"
                f"?pageIndex=1&pageSize={days}&plat=Android"
                f"&appType=ttjj&product=EFund&Version=1"
                f"&deviceid=1&Ession=1"
                f"&Fcode={fund_code}"
                f"&sdate={start_date}&edate={end_date}"
            )

            response = self.session.get(url, timeout=20)

            if response.status_code == 200:
                data = response.json()

                # 安全检查：确保 Datas 存在且为列表
                datas_list = data.get('Datas')
                if datas_list and isinstance(datas_list, list):
                    for item in reversed(datas_list):  # 反转为时间升序
                        date_str = str(item.get('FSRQ', '') or '')[:10]
                        try:
                            nav_value = float(item.get('DWJZ', 0) or 0)
                        except (ValueError, TypeError):
                            nav_value = 0

                        if date_str and nav_value > 0:
                            nav_data.append({
                                'date': date_str,
                                'nav': round(nav_value, 4)
                            })

                    logger.info(f"✅ 成功获取基金{fund_code}历史净值: {len(nav_data)}条 (数据源: 东方财富API)")
                    return nav_data

            # 如果东方财富失败，尝试天天基金备用接口
            logger.warning("⚠️ 东方财富API失败，尝试备用接口...")
            nav_data = self._get_history_from_ttjj(fund_code, days)
            if nav_data:
                logger.info(f"✅ 成功获取基金{fund_code}历史净值: {len(nav_data)}条 (数据源: 天天基金备用)")
                return nav_data
            else:
                logger.error("❌ 备用接口也失败，返回空数据")

        except Exception as e:
            logger.error(f"❌ 获取基金{fund_code}历史净值失败: {e}")

        return nav_data

    def get_fund_holdings(self, fund_code: str) -> Dict[str, Any]:
        """
        获取基金股票持仓数据（最新季度）

        Returns:
            包含以下字段的字典：
            - holdings: 持仓列表 [{code, name, percent, shares, market_value}]
            - stock_percent: 股票仓位比例
            - bond_percent: 债券仓位比例
            - cash_percent: 现金仓位比例
            - report_date: 报告期截止日期
            - total_holdings: 持有股票数量
        """
        result = {
            'holdings': [],
            'stock_percent': 0.0,
            'bond_percent': 0.0,
            'cash_percent': 0.0,
            'report_date': '',
            'total_holdings': 0
        }

        try:
            # 东方财富持仓明细API
            url = (
                f"{self.BASE_URL_EASTMONEY_API}/FundMNewApi/FundMNHoldInfo"
                f"?pageIndex=1&pageSize=10&plat=Android"
                f"&appType=ttjj&product=EFund&Version=1"
                f"&deviceid=1&Ession=1"
                f"&Fcode={fund_code}"
            )

            response = self.session.get(url, timeout=15)

            if response.status_code == 200:
                data = response.json()

                # 安全检查：确保 Datas 存在且为列表
                stocks_list = data.get('Datas')
                if stocks_list and isinstance(stocks_list, list):
                    for i, stock in enumerate(stocks_list[:10], 1):
                        try:
                            percent_val = float(stock.get('JZBL', 0) or 0) * 100
                        except (ValueError, TypeError):
                            percent_val = 0.0

                        holding = {
                            'rank': i,
                            'code': stock.get('GPDM', '') or '',
                            'name': stock.get('GPJC', '') or '',
                            'percent': percent_val,  # 占净值比(%)
                            'shares': stock.get('GPSL', '') or '',  # 持股数(万股)
                            'market_value': stock.get('GMZJE', '') or ''  # 持仓市值(万元)
                        }
                        result['holdings'].append(holding)

                    result['report_date'] = str(stocks_list[0].get('FSRQ', '') or '')[:10] if stocks_list else ''
                    result['total_holdings'] = len(result['holdings'])

                    # 计算总股票仓位
                    if result['holdings']:
                        top10_percent = sum(h['percent'] for h in result['holdings'])
                        result['stock_percent'] = min(top10_percent * 1.2, 95)  # 估算总仓位

                    logger.info(f"成功获取基金{fund_code}持仓: {len(result['holdings'])}只")

            # 获取资产配置比例
            config_url = (
                f"{self.BASE_URL_EASTMONEY_API}/FundMNewApi/FundMNAssetAllocation"
                f"?pageIndex=1&pageSize=20&plat=Android"
                f"&appType=ttjj&product=EFund&Version=1"
                f"&deviceid=1&Ession=1"
                f"&Fcode={fund_code}"
            )
            config_resp = self.session.get(config_url, timeout=15)

            if config_resp.status_code == 200:
                config_data = config_resp.json()
                if 'Datas' in config_data:
                    for item in config_data['Datas']:
                        asset_type = item.get('ZCLX', '')
                        percent = float(item.get('SZBL', 0)) * 100

                        if '股票' in asset_type or '权益' in asset_type:
                            result['stock_percent'] = max(result['stock_percent'], percent)
                        elif '债券' in asset_type or '固定收益' in asset_type:
                            result['bond_percent'] = percent
                        elif '现金' in asset_type or '银行存款' in asset_type:
                            result['cash_percent'] = percent

            # 标记数据来源
            if result['holdings']:
                result['data_source'] = 'real_api'
                logger.info(f"✅ 成功获取基金{fund_code}持仓: {result['total_holdings']}只股票")
            else:
                result['data_source'] = 'empty'
                logger.warning("⚠️ 未获取到持仓数据")

        except Exception as e:
            logger.error(f"❌ 获取基金{fund_code}持仓失败: {e}")
            result['data_source'] = 'failed'

        # 确保各项比例合理
        remaining = 100 - result['stock_percent'] - result['bond_percent']
        if result['cash_percent'] <= 0:
            result['cash_percent'] = max(0, remaining)
        elif remaining < 0:
            result['stock_percent'] += remaining

        return result

    def calculate_risk_metrics(self, nav_history: List[Dict[str, Any]],
                               risk_free_rate: float = 0.03) -> Dict[str, Any]:
        """
        计算风险指标（专业金融分析）

        Args:
            nav_history: 历史净值数据列表
            risk_free_rate: 无风险利率（默认3%）

        Returns:
            包含以下风险指标的字典：
            - annualized_return: 年化收益率
            - volatility: 年化波动率（标准差）
            - sharpe_ratio: 夏普比率
            - max_drawdown: 最大回撤
            - max_drawdown_duration: 最大回撤持续天数
            - calmar_ratio: 卡玛比率
            - sortino_ratio: 索提诺比率
            - beta: 贝塔系数（相对基准）
            - alpha: 阿尔法系数（超额收益）
            - win_rate: 正收益日占比
            - avg_daily_return: 平均日收益率
        """
        metrics = {
            'annualized_return': 0.0,
            'volatility': 0.0,
            'sharpe_ratio': 0.0,
            'max_drawdown': 0.0,
            'max_drawdown_duration': 0,
            'calmar_ratio': 0.0,
            'sortino_ratio': 0.0,
            'beta': 1.0,
            'alpha': 0.0,
            'win_rate': 0.0,
            'avg_daily_return': 0.0
        }

        if not nav_history or len(nav_history) < 30:
            return metrics

        try:
            # 提取净值序列
            navs = np.array([item['nav'] for item in nav_history])

            # 计算日收益率
            daily_returns = np.diff(navs) / navs[:-1]

            # 1. 年化收益率
            total_days = len(navs)
            total_return = (navs[-1] / navs[0]) - 1
            metrics['annualized_return'] = (1 + total_return) ** (252 / total_days) - 1

            # 2. 年化波动率
            daily_volatility = np.std(daily_returns)
            metrics['volatility'] = daily_volatility * math.sqrt(252)

            # 3. 夏普比率
            excess_return = metrics['annualized_return'] - risk_free_rate
            if metrics['volatility'] > 0:
                metrics['sharpe_ratio'] = excess_return / metrics['volatility']

            # 4. 最大回撤
            peak = navs[0]
            max_dd = 0
            max_dd_end = 0
            max_dd_start = 0

            for i, nav in enumerate(navs):
                if nav > peak:
                    peak = nav
                    current_dd_start = i
                drawdown = (peak - nav) / peak
                if drawdown > max_dd:
                    max_dd = drawdown
                    max_dd_end = i
                    max_dd_start = current_dd_start

            metrics['max_drawdown'] = max_dd
            metrics['max_drawdown_duration'] = max_dd_end - max_dd_start

            # 5. 卡玛比率（年化收益 / 最大回撤）
            if max_dd > 0:
                metrics['calmar_ratio'] = metrics['annualized_return'] / max_dd

            # 6. 索提诺比率（仅考虑下行风险）
            negative_returns = daily_returns[daily_returns < 0]
            if len(negative_returns) > 0:
                downside_deviation = np.std(negative_returns) * math.sqrt(252)
                if downside_deviation > 0:
                    metrics['sortino_ratio'] = excess_return / downside_deviation

            # 7. 胜率（正收益交易日占比）
            positive_days = sum(1 for r in daily_returns if r > 0)
            metrics['win_rate'] = positive_days / len(daily_returns)

            # 8. 平均日收益率
            metrics['avg_daily_return'] = np.mean(daily_returns)

            # 9. Alpha & Beta（简化计算，假设基准为沪深300指数年化8%）
            benchmark_return = 0.08
            covariance = np.cov(daily_returns, np.zeros_like(daily_returns))[0][1]
            variance_benchmark = 0.0004  # 假设基准方差

            if variance_benchmark > 0:
                metrics['beta'] = covariance / variance_benchmark

            expected_return = risk_free_rate + metrics['beta'] * (benchmark_return - risk_free_rate)
            metrics['alpha'] = metrics['annualized_return'] - expected_return

            logger.info(f"风险指标计算完成: Sharpe={metrics['sharpe_ratio']:.2f}, "
                        f"MaxDD={metrics['max_drawdown']:.2%}")

        except Exception as e:
            logger.error(f"计算风险指标失败: {e}")

        return metrics

    def compare_with_peers(self, fund_code: str, category: str = "") -> List[Dict[str, Any]]:
        """
        同类基金对比排名

        Args:
            fund_code: 基金代码
            category: 基金类别（可选，自动推断）

        Returns:
            排名列表，包含同类基金的收益率对比
        """
        peers = []

        try:
            # 根据基金代码推断类别
            if not category:
                category = self._infer_category(fund_code)

            # 东方财富同类基金排行API
            url = (
                f"{self.BASE_URL_EASTMONEY_API}/FundMNewApi/FundMNRankList"
                f"?pageIndex=1&pageSize=50&plat=Android"
                f"&appType=ttjj&product=EFund&Version=1"
                f"&deviceid=1&Ession=1"
                f"&Ftype={category}&Sort=syl_1n&IsAsc=false"
            )

            response = self.session.get(url, timeout=15)

            if response.status_code == 200:
                data = response.json()

                # 安全检查：确保 Datas 存在且为可迭代对象
                peers_list = data.get('Datas')
                if peers_list and isinstance(peers_list, (list, tuple)):
                    rank = 1
                    for fund in peers_list[:20]:
                        code = fund.get('FCODE', '') or ''
                        name = fund.get('SHORTNAME', '') or ''
                        return_1y_raw = fund.get('SYL_1N', '')

                        # 安全转换收益率
                        if code:
                            return_1y_clean = str(return_1y_raw or '').replace('%', '').replace('--', '')
                            if return_1y_clean:
                                try:
                                    return_1y_val = float(return_1y_clean) / 100
                                    is_current_fund = (code == fund_code)
                                    peers.append({
                                        'rank': rank,
                                        'code': code,
                                        'name': name,
                                        'return_1y': return_1y_val,
                                        'is_current': is_current_fund
                                    })
                                    rank += 1
                                except (ValueError, TypeError):
                                    continue

                    logger.info(f"获取同类基金对比: {len(peers)}只")

        except Exception as e:
            logger.error(f"获取同类基金对比失败: {e}")

        return peers

    # ==================== 私有辅助方法 ====================

    def _get_history_from_ttjj(self, fund_code: str, days: int) -> List[Dict]:
        """从天天基金获取历史净值（备用方法）"""
        nav_data = []

        try:
            # 天天基金历史净值页面
            url = "http://fund.eastmoney.com/f10/F10DataApi.aspx"
            params = {
                'type': 'LSJZ',
                'code': fund_code,
                'page': 1,
                'per': days,
                'sdate': (datetime.now() - timedelta(days=days)).strftime('%Y-%m-%d'),
                'edate': datetime.now().strftime('%Y-%m-%d'),
                'rt': round(time.time(), 3)
            }

            response = self.session.get(url, params=params, timeout=15)

            if response.status_code == 200:
                # 解析HTML表格
                pattern = r'<td[^>]*>([^<]+)</td>'
                matches = re.findall(pattern, response.text)

                # 每7个字段为一行记录：日期,净值,累计净值,增长率...
                for i in range(0, len(matches), 7):
                    if i + 1 < len(matches):
                        date_str = matches[i].strip()
                        nav_str = matches[i + 1].strip()

                        if date_str and nav_str:
                            try:
                                nav_value = float(nav_str)
                                nav_data.append({'date': date_str, 'nav': nav_value})
                            except ValueError:
                                continue

        except Exception as e:
            logger.warning(f"天天基金备用接口也失败: {e}")

        return nav_data

    def _generate_realistic_mock_data(self, fund_code: str, days: int) -> List[Dict]:
        """生成逼真的模拟数据（当所有API都失败时使用）"""
        import random
        random.seed(hash(fund_code) % (2**32))

        base_nav = 1.0
        trend = random.uniform(-0.05, 0.15)  # 整体趋势
        volatility = random.uniform(0.01, 0.04)  # 波动率

        nav_data = []
        for i in range(days):
            date = (datetime.now() - timedelta(days=days - i)).strftime('%Y-%m-%d')

            # 模拟带趋势的随机游走
            daily_change = random.gauss(trend / 252, volatility / math.sqrt(252))
            base_nav *= (1 + daily_change)
            base_nav = max(base_nav, 0.5)  # 不让净值过低

            nav_data.append({
                'date': date,
                'nav': round(base_nav, 4)
            })

        return nav_data

    def _generate_mock_holdings(self, fund_code: str) -> Dict:
        """生成模拟持仓数据"""
        mock_stocks = [
            ('600519', '贵州茅台', 9.85),
            ('300750', '宁德时代', 7.32),
            ('601318', '中国平安', 6.54),
            ('000858', '五粮液', 5.87),
            ('002475', '立讯精密', 4.23),
            ('600036', '招商银行', 3.98),
            ('002594', '比亚迪', 3.76),
            ('601888', '中国中免', 3.45),
            ('000333', '美的集团', 3.21),
            ('600900', '长江电力', 2.89)
        ]

        holdings = []
        for i, (code, name, percent) in enumerate(mock_stocks, 1):
            holdings.append({
                'rank': i,
                'code': code,
                'name': name,
                'percent': percent,
                'shares': f"{random.randint(100, 500)}",
                'market_value': f"{random.randint(5000, 50000)}"
            })

        return {
            'holdings': holdings,
            'stock_percent': 87.5,
            'bond_percent': 8.2,
            'cash_percent': 4.3,
            'report_date': (datetime.now() - timedelta(days=90)).strftime('%Y-%m-%d'),
            'total_holdings': 10
        }

    def _generate_peer_comparison(self, fund_code: str) -> List[Dict]:
        """生成模拟同类对比数据"""
        import random
        random.seed(42)

        peers = []
        names = [
            '易方达蓝筹精选', '兴全合润混合', '景顺长城新兴成长',
            '富国天惠精选', '中欧时代先锋', '汇添富消费行业',
            '嘉实优质企业', '广发稳健增长', '南方绩优成长', '华夏回报混合'
        ]
        codes = ['005827', '163406', '260108', '161005', '001938',
                 '000083', '217002', '270002', '202005', '002001']

        # 将目标基金插入到随机位置
        target_pos = random.randint(3, 7)
        returns = sorted([random.uniform(-0.1, 0.4) for _ in range(len(names))],
                         reverse=True)
        returns.insert(target_pos, random.uniform(0.1, 0.25))  # 目标基金表现中等偏上
        names.insert(target_pos, '当前基金')
        codes.insert(target_pos, fund_code)

        for i, (code, name, ret) in enumerate(zip(codes, names, returns), 1):
            peers.append({
                'rank': i,
                'code': code,
                'name': name,
                'return_1y': ret,
                'is_current': (code == fund_code)
            })

        return peers

    def _guess_fund_type(self, fund_code: str) -> str:
        """根据基金代码推测类型"""
        code_prefix = fund_code[:3]

        type_map = {
            '000': '股票型基金',
            '001': '混合型基金',
            '002': '混合型基金',
            '003': '债券型基金',
            '004': '指数型基金',
            '005': '混合型基金',
            '006': '债券型基金',
            '007': '灵活配置',
            '159': 'ETF基金',
            '160': 'LOF基金',
            '510': 'ETF指数',
            '512': 'ETF行业',
            '513': 'ETF跨境',
            '516': 'ETF主题',
        }

        return type_map.get(code_prefix, '公募基金')

    def _infer_category(self, fund_code: str) -> str:
        """推断基金类别编码"""
        prefix = fund_code[:3]

        if prefix in ['000', '001', '002', '005']:
            return 'all'  # 混合型
        elif prefix in ['003', '006']:
            return 'zq'   # 债券型
        elif prefix in ['159', '510', '512']:
            return 'zs'   # 指数型
        else:
            return 'all'

    def _format_scale(self, raw_value) -> str:
        """格式化基金规模"""
        try:
            value = float(raw_value)
            if value >= 10000:
                return f"¥{value/10000:.2f}万亿"
            elif value >= 1:
                return f"¥{value:.2f}亿"
            else:
                return f"¥{value*10000:.0f}万"
        except (ValueError, TypeError):
            return "--"


# 全局单例实例
_fund_data_service: Optional[FundDataService] = None


def get_fund_data_service() -> FundDataService:
    """获取基金数据服务单例"""
    global _fund_data_service
    if _fund_data_service is None:
        _fund_data_service = FundDataService()
    return _fund_data_service