"""
A股数据获取模块
使用Tushare Pro API获取A股市场数据
"""

import tushare as ts
import pandas as pd
import re
from typing import List, Optional, Union
from datetime import datetime, date, timedelta
import time
from loguru import logger
from functools import wraps
from src.utils.config_loader import config_loader


def retry_on_failure(retries: int = 3, delay: float = 1.0):
    """
    重试装饰器，用于网络请求失败时自动重试

    Args:
        retries: 重试次数
        delay: 重试间隔（秒）
    """
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            last_exception = None

            for attempt in range(retries + 1):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    last_exception = e
                    if attempt < retries:
                        logger.warning(f"{func.__name__} 第{attempt + 1}次调用失败: {e}, {delay}秒后重试...")
                        time.sleep(delay)
                    else:
                        logger.error(f"{func.__name__} 已重试{retries}次仍然失败: {e}")

            raise last_exception
        return wrapper
    return decorator


class TushareFetcher:
    """Tushare数据获取器"""

    def __init__(self, token: str = None):
        """
        初始化数据获取器

        Args:
            token: Tushare Pro token，如果为None则从配置文件读取
        """
        # 如果没有传入token，从配置文件读取
        if token is None:
            token = config_loader.get_tushare_token()
            if token:
                logger.info("✅ 从配置文件读取TuShare token成功")
            else:
                logger.warning("⚠️ 配置文件中未找到TuShare token")

        self.token = token
        if token:
            try:
                ts.set_token(token)
                self.pro = ts.pro_api()

                # 验证token是否有效
                test_data = self.pro.trade_cal(exchange='SSE', cal_date='20240101', limit=1)
                if not test_data.empty:
                    logger.info("✅ Tushare Pro客户端初始化完成，token验证成功")
                else:
                    logger.warning("⚠️ Tushare Pro token可能无效或权限不足")
            except Exception as e:
                logger.error(f"❌ Tushare Pro初始化失败: {e}")
                logger.warning("将回退到无Pro权限模式")
                self.pro = None
        else:
            logger.warning("未提供Tushare token，将使用免费接口")
            self.pro = None

        # 股票名称缓存机制
        self._stock_name_cache = {}
        self._stock_list_cache = None
        self._cache_timestamp = None
        self._cache_duration = 3600  # 缓存1小时

        # 分钟线接口调用频率控制（每分钟最多2次）
        self._minute_data_call_times = []
        self._minute_data_max_calls_per_minute = 2

    def clear_caches(self):
        """清除所有缓存"""
        self._stock_name_cache.clear()
        self._stock_list_cache = None
        self._cache_timestamp = None
        logger.info("🔄 已清除所有股票数据缓存")

    def get_stock_list(self, use_hot_stocks: bool = True, hot_limit: int = 100) -> pd.DataFrame:
        """
        获取股票列表

        Args:
            use_hot_stocks: 是否优先使用热门股票，默认True
            hot_limit: 热门股票数量限制，默认100

        Returns:
            股票列表DataFrame
        """
        import time
        current_time = time.time()

        # 检查缓存是否有效
        if (self._stock_list_cache is not None and
            self._cache_timestamp is not None and
            current_time - self._cache_timestamp < self._cache_duration):
            logger.debug(f"🔄 使用缓存的股票列表数据 ({len(self._stock_list_cache)} 只股票)")
            return self._stock_list_cache.copy()

        logger.info("📊 重新获取股票列表数据...")

        # 优先使用热门股票
        if use_hot_stocks:
            try:
                logger.info(f"🔥 优先获取同花顺热榜股票 (前{hot_limit}只)...")
                hot_stocks = self.get_combined_hot_stocks(
                    limit_per_source=hot_limit,
                    final_limit=hot_limit
                )

                if not hot_stocks.empty and 'stock_code' in hot_stocks.columns:
                    # 转换为标准格式
                    stock_list = hot_stocks.copy()

                    # 确保有必要的列
                    if 'full_stock_code' not in stock_list.columns:
                        stock_list['full_stock_code'] = stock_list['stock_code']

                    # 添加缺失的列
                    for col in ['area', 'industry', 'exchange', 'list_date']:
                        if col not in stock_list.columns:
                            stock_list[col] = ''

                    logger.info(f"✅ 获取热门股票成功，共{len(stock_list)}只股票")
                    if 'source' in stock_list.columns:
                        source_counts = stock_list['source'].value_counts().to_dict()
                        source_detail = " | ".join([f"{k}: {v}只" for k, v in source_counts.items()])
                        logger.info(f"📊 数据源分布: {source_detail}")

                    # 更新缓存
                    self._stock_list_cache = stock_list.copy()
                    self._cache_timestamp = current_time
                    return stock_list
                else:
                    logger.warning("热门股票数据为空，回退到全量股票列表")
            except Exception as e:
                logger.warning(f"获取热门股票失败: {e}，回退到全量股票列表")

        try:
            # 回退方案：获取全量股票列表
            logger.info("📊 获取全量A股股票列表...")
            if self.pro:
                # 使用Pro接口获取股票基本信息
                stock_list = self.pro.stock_basic(
                    exchange='',
                    list_status='L',
                    fields='ts_code,symbol,name,area,industry,market,list_date'
                )
                # 统一列名
                stock_list.rename(columns={
                    'ts_code': 'full_stock_code',
                    'symbol': 'stock_code',
                    'name': 'short_name',
                    'market': 'exchange'
                }, inplace=True)
            else:
                # 需要Pro权限才能获取股票列表
                logger.error("获取股票列表需要TuShare Pro权限，请提供有效token")
                return pd.DataFrame()

            logger.info(f"获取全量股票列表成功，共{len(stock_list)}只股票")
            # 更新缓存
            self._stock_list_cache = stock_list.copy()
            self._cache_timestamp = current_time
            return stock_list
        except Exception as e:
            logger.error(f"获取股票列表失败: {e}")
            return pd.DataFrame()

    def get_filtered_a_share_list(self, exclude_st: bool = True, exclude_bj: bool = True, min_market_cap: float = 2000000000) -> pd.DataFrame:
        """
        获取过滤后的A股股票列表

        Args:
            exclude_st: 是否排除ST股票
            exclude_bj: 是否排除北交所股票
            min_market_cap: 最小市值要求（元），默认20亿

        Returns:
            过滤后的股票列表DataFrame
        """
        try:
            # 获取完整股票列表
            all_stocks = self.get_stock_list()

            if all_stocks.empty:
                return pd.DataFrame()

            filtered_stocks = all_stocks.copy()
            original_count = len(filtered_stocks)

            # 排除北交所股票
            if exclude_bj:
                before_count = len(filtered_stocks)
                if 'exchange' in filtered_stocks.columns:
                    filtered_stocks = filtered_stocks[filtered_stocks['exchange'] != 'BJ']
                else:
                    # 根据股票代码判断
                    filtered_stocks = filtered_stocks[~filtered_stocks['stock_code'].str.startswith(('8', '43', '83'))]
                bj_excluded = before_count - len(filtered_stocks)
                logger.info(f"排除北交所股票: {bj_excluded}只")

            # 排除ST股票
            if exclude_st:
                before_count = len(filtered_stocks)
                # 使用(?:...)非捕获组避免警告
                st_pattern = r'(?:\*?ST|PT|退|暂停)'
                filtered_stocks = filtered_stocks[~filtered_stocks['short_name'].str.contains(st_pattern, na=False, case=False, regex=True)]
                st_excluded = before_count - len(filtered_stocks)
                logger.info(f"排除ST等风险股票: {st_excluded}只")

            # 基于市值筛选
            if min_market_cap > 0 and self.pro:
                before_count = len(filtered_stocks)
                filtered_stocks = self._filter_by_market_cap(filtered_stocks, min_market_cap)
                cap_excluded = before_count - len(filtered_stocks)
                logger.info(f"排除小市值股票: {cap_excluded}只")

            final_count = len(filtered_stocks)
            excluded_count = original_count - final_count

            if not filtered_stocks.empty:
                logger.info(f"✅ 获取过滤后A股列表成功")
                logger.info(f"📊 原始股票: {original_count}只 | 过滤后: {final_count}只 | 排除: {excluded_count}只")

            return filtered_stocks

        except Exception as e:
            logger.error(f"获取过滤A股列表失败: {e}")
            return pd.DataFrame()

    def _filter_by_market_cap(self, stock_df: pd.DataFrame, min_market_cap: float) -> pd.DataFrame:
        """
        基于市值筛选股票

        Args:
            stock_df: 股票列表DataFrame
            min_market_cap: 最小市值要求（元）

        Returns:
            过滤后的股票DataFrame
        """
        if stock_df.empty or not self.pro:
            return stock_df

        try:
            logger.info(f"开始基于市值筛选股票，阈值: {min_market_cap/100000000:.0f}亿元")

            # 获取股票基本信息包含市值
            ts_codes = stock_df['full_stock_code'].tolist() if 'full_stock_code' in stock_df.columns else []

            if not ts_codes:
                return stock_df

            # 分批获取市值数据（避免API限制）
            batch_size = 50
            valid_stocks = []

            for i in range(0, len(ts_codes), batch_size):
                batch_codes = ts_codes[i:i+batch_size]

                try:
                    # 获取每日基本面数据（包含市值）
                    trade_date = datetime.now().strftime('%Y%m%d')
                    daily_basic = self.pro.daily_basic(
                        ts_code=','.join(batch_codes),
                        trade_date=trade_date,
                        fields='ts_code,total_mv'
                    )

                    if not daily_basic.empty:
                        # 市值单位是万元，转换为元
                        daily_basic['market_cap'] = daily_basic['total_mv'] * 10000

                        # 筛选符合市值要求的股票
                        valid_codes = daily_basic[daily_basic['market_cap'] >= min_market_cap]['ts_code'].tolist()

                        # 添加到结果中
                        batch_stocks = stock_df[stock_df['full_stock_code'].isin(valid_codes)]
                        valid_stocks.append(batch_stocks)

                    time.sleep(0.2)  # API限制

                except Exception as e:
                    logger.debug(f"获取批次市值数据失败: {e}")
                    # 如果获取失败，保留原数据
                    batch_stocks = stock_df[stock_df['full_stock_code'].isin(batch_codes)]
                    valid_stocks.append(batch_stocks)

            if valid_stocks:
                result_df = pd.concat(valid_stocks, ignore_index=True)
                logger.info(f"✅ 市值筛选完成: {len(result_df)}/{len(stock_df)} 只股票符合要求")
                return result_df
            else:
                return stock_df

        except Exception as e:
            logger.error(f"市值筛选失败: {e}")
            return stock_df

    def get_realtime_data(self, stock_codes: Union[str, List[str]]) -> pd.DataFrame:
        """
        获取实时行情数据

        Args:
            stock_codes: 股票代码或代码列表

        Returns:
            实时行情DataFrame
        """
        try:
            if isinstance(stock_codes, str):
                stock_codes = [stock_codes]

            if self.pro:
                # 转换为tushare格式的代码
                ts_codes = []
                for code in stock_codes:
                    if '.' in code:
                        ts_codes.append(code)
                    else:
                        # 根据代码判断交易所
                        if code.startswith(('60', '68', '90')):
                            ts_codes.append(f"{code}.SH")
                        else:
                            ts_codes.append(f"{code}.SZ")

                # 使用Pro接口获取最新行情数据
                today = pd.Timestamp.now().strftime('%Y%m%d')
                realtime_data = self.pro.daily(
                    ts_code=','.join(ts_codes),
                    trade_date=today
                )
            else:
                logger.error("获取实时行情需要TuShare Pro权限，请提供有效token")
                return pd.DataFrame()

            logger.info(f"获取实时数据成功，股票数量: {len(stock_codes)}")
            return realtime_data
        except Exception as e:
            logger.error(f"获取实时数据失败: {e}")
            return pd.DataFrame()

    def get_historical_data(
        self,
        stock_code: str,
        start_date: Union[str, date],
        end_date: Union[str, date],
        period: str = "daily"
    ) -> pd.DataFrame:
        """
        获取历史行情数据

        Args:
            stock_code: 股票代码
            start_date: 开始日期
            end_date: 结束日期
            period: 数据周期 ('daily', 'weekly', 'monthly', '60min', '30min', '15min', '5min', '1min')

        Returns:
            历史行情DataFrame
        """
        try:
            # 转换日期格式
            if isinstance(start_date, date):
                start_date = start_date.strftime("%Y%m%d")
            else:
                start_date = start_date.replace('-', '')

            if isinstance(end_date, date):
                end_date = end_date.strftime("%Y%m%d")
            else:
                end_date = end_date.replace('-', '')

            # 转换为tushare格式的代码
            if '.' not in stock_code:
                if stock_code.startswith(('60', '68', '90')):
                    ts_code = f"{stock_code}.SH"
                else:
                    ts_code = f"{stock_code}.SZ"
            else:
                ts_code = stock_code

            if self.pro:
                # 使用Pro接口
                if period == 'daily':
                    hist_data = self.pro.daily(
                        ts_code=ts_code,
                        start_date=start_date,
                        end_date=end_date
                    )
                elif period == 'weekly':
                    hist_data = self.pro.weekly(
                        ts_code=ts_code,
                        start_date=start_date,
                        end_date=end_date
                    )
                elif period == 'monthly':
                    hist_data = self.pro.monthly(
                        ts_code=ts_code,
                        start_date=start_date,
                        end_date=end_date
                    )
                elif period in ('60min', '30min', '15min', '5min', '1min'):
                    # 使用分钟线数据接口
                    # 注意：分钟线数据需要特殊权限，且有调用限制：每分钟最多2次

                    # 频率限制检查
                    current_time = time.time()
                    # 清理60秒前的调用记录
                    self._minute_data_call_times = [t for t in self._minute_data_call_times if current_time - t < 60]

                    # 检查是否超过限制
                    if len(self._minute_data_call_times) >= self._minute_data_max_calls_per_minute:
                        wait_time = 60 - (current_time - self._minute_data_call_times[0])
                        logger.warning(f"分钟线接口频率限制：每分钟最多{self._minute_data_max_calls_per_minute}次，需等待 {wait_time:.1f} 秒")
                        time.sleep(wait_time + 1)  # 多等1秒确保安全
                        # 清理过期记录
                        current_time = time.time()
                        self._minute_data_call_times = [t for t in self._minute_data_call_times if current_time - t < 60]

                    # 调用接口
                    hist_data = self.pro.stk_mins(
                        ts_code=ts_code,
                        start_date=start_date,
                        end_date=end_date,
                        freq=period
                    )

                    # 记录调用时间
                    self._minute_data_call_times.append(time.time())
                else:
                    hist_data = self.pro.daily(
                        ts_code=ts_code,
                        start_date=start_date,
                        end_date=end_date
                    )

                if not hist_data.empty:
                    # 统一列名映射
                    field_mapping = {
                        'vol': 'volume',  # TuShare返回vol，策略期望volume
                        'ts_code': 'stock_code'  # 统一股票代码字段名
                    }

                    for old_name, new_name in field_mapping.items():
                        if old_name in hist_data.columns:
                            hist_data.rename(columns={old_name: new_name}, inplace=True)

                    # 转换日期格式并保持双格式兼容
                    if 'trade_date' in hist_data.columns:
                        hist_data['trade_date'] = pd.to_datetime(hist_data['trade_date']).dt.strftime('%Y-%m-%d')
                        hist_data['date'] = hist_data['trade_date']  # 同时提供date字段
                    elif 'date' in hist_data.columns:
                        hist_data['date'] = pd.to_datetime(hist_data['date']).dt.strftime('%Y-%m-%d')
                        hist_data['trade_date'] = hist_data['date']  # 同时提供trade_date字段

                    # 按日期升序排列
                    hist_data = hist_data.sort_values('date')
            else:
                # 需要Pro权限才能获取历史数据
                logger.error("获取历史数据需要TuShare Pro权限，请提供有效token")
                return pd.DataFrame()

            if not hist_data.empty:
                logger.info(f"获取{stock_code}历史数据成功，数据量: {len(hist_data)}")
            else:
                logger.warning(f"获取{stock_code}历史数据为空")

            return hist_data

        except Exception as e:
            logger.error(f"获取{stock_code}历史数据失败: {e}")
            return pd.DataFrame()

    def get_index_data(self, index_code: str = "000001.SH") -> pd.DataFrame:
        """
        获取指数数据

        Args:
            index_code: 指数代码

        Returns:
            指数数据DataFrame
        """
        try:
            if self.pro:
                # 转换指数代码格式
                if index_code == "000001.SH":
                    ts_code = "000001.SH"  # 上证指数
                elif index_code == "399001.SZ":
                    ts_code = "399001.SZ"  # 深证成指
                else:
                    ts_code = index_code

                index_data = self.pro.index_daily(
                    ts_code=ts_code,
                    trade_date=datetime.now().strftime('%Y%m%d')
                )
            else:
                # 需要Pro权限才能获取指数数据
                logger.error("获取指数数据需要TuShare Pro权限，请提供有效token")
                return pd.DataFrame()

            logger.info(f"获取指数{index_code}数据成功")
            return index_data
        except Exception as e:
            logger.error(f"获取指数数据失败: {e}")
            return pd.DataFrame()

    def get_financial_data(self, stock_code: str) -> pd.DataFrame:
        """
        获取财务数据

        Args:
            stock_code: 股票代码

        Returns:
            财务数据DataFrame
        """
        try:
            # 转换为tushare格式的代码
            if '.' not in stock_code:
                if stock_code.startswith(('60', '68', '90')):
                    ts_code = f"{stock_code}.SH"
                else:
                    ts_code = f"{stock_code}.SZ"
            else:
                ts_code = stock_code

            if self.pro:
                # 获取财务数据
                financial_data = self.pro.income(ts_code=ts_code, period='20231231')
            else:
                # 免费接口的财务数据
                financial_data = pd.DataFrame()

            logger.info(f"获取{stock_code}财务数据成功")
            return financial_data
        except Exception as e:
            logger.error(f"获取财务数据失败: {e}")
            return pd.DataFrame()

    def search_stocks(self, keyword: str) -> pd.DataFrame:
        """
        搜索股票

        Args:
            keyword: 搜索关键词

        Returns:
            搜索结果DataFrame
        """
        try:
            # 获取完整股票列表
            all_stocks = self.get_stock_list()
            if all_stocks.empty:
                return pd.DataFrame()

            # 在股票代码和名称中搜索关键词
            keyword = str(keyword).strip()
            if not keyword:
                return pd.DataFrame()

            # 支持按代码或名称模糊搜索
            mask = (
                all_stocks['stock_code'].str.contains(keyword, case=False, na=False) |
                all_stocks['short_name'].str.contains(keyword, case=False, na=False)
            )

            results = all_stocks[mask].copy()
            logger.info(f"搜索股票'{keyword}'成功，找到{len(results)}个结果")
            return results
        except Exception as e:
            logger.error(f"搜索股票失败: {e}")
            return pd.DataFrame()

    @retry_on_failure(retries=2, delay=1.0)
    def get_hot_stocks_ths(self, limit: int = 100, trade_date: str = None) -> pd.DataFrame:
        """
        获取同花顺热门股票

        Args:
            limit: 返回数量限制
            trade_date: 交易日期，格式YYYYMMDD，默认为当日

        Returns:
            热门股票DataFrame
        """
        try:
            if not self.pro:
                logger.error("需要Tushare Pro权限才能获取同花顺热股数据")
                return self._get_fallback_hot_stocks(limit)

            # 使用TuShare Pro的同花顺热榜接口
            params = {
                'market': '热股',
                'is_new': 'Y'
            }
            if trade_date:
                params['trade_date'] = trade_date

            df = self.pro.ths_hot(**params)

            if df.empty:
                logger.warning("同花顺热股数据为空，使用备用方法")
                return self._get_fallback_hot_stocks(limit)

            # 数据清洗和去重
            logger.info(f"原始数据: {len(df)} 条")

            # 1. 去除重复股票代码，保留第一个（排名最好的）
            if 'ts_code' in df.columns:
                df = df.drop_duplicates(subset=['ts_code'], keep='first')
                logger.info(f"去重后数据: {len(df)} 条")

            # 2. 过滤退市和ST股票
            if 'ts_name' in df.columns:
                before_filter = len(df)
                # 过滤包含以下关键词的股票：退市、ST、*ST、PT
                # 使用(?:...)非捕获组避免警告
                filter_pattern = r'(?:退市|^\*?ST|^ST|^PT|暂停)'
                df = df[~df['ts_name'].str.contains(filter_pattern, na=False, case=False, regex=True)]
                filtered_count = before_filter - len(df)
                if filtered_count > 0:
                    logger.info(f"过滤退市/ST股票: {filtered_count} 只")

            # 3. 按rank排序，处理排名异常
            if 'rank' in df.columns:
                df = df.sort_values('rank')
                # 重新分配连续排名
                df['original_rank'] = df['rank']  # 保留原始排名
                df['rank'] = range(1, len(df) + 1)  # 重新分配连续排名

            # 4. 统一列名格式（先改名，方便后续处理）
            if 'ts_code' in df.columns:
                df.rename(columns={'ts_code': 'stock_code', 'ts_name': 'short_name'}, inplace=True)

            # 5. 二次验证：通过TuShare API验证股票状态，过滤ST和退市股票
            # 为了确保最终有足够数量，验证更多股票
            if self.pro and 'stock_code' in df.columns:
                # 计算需要验证的数量：考虑约10%的过滤率，验证limit*1.15的股票
                verify_count = min(int(limit * 1.15), len(df))
                df_to_verify = df.head(verify_count)

                valid_stocks = []
                verified_count = 0

                for idx, row in df_to_verify.iterrows():
                    verified_count += 1
                    try:
                        stock_code = row['stock_code']
                        stock_info = self.pro.stock_basic(ts_code=stock_code, fields='ts_code,name,list_status')

                        if not stock_info.empty:
                            info = stock_info.iloc[0]
                            real_name = info['name']
                            list_status = info['list_status']

                            # 检查股票状态和名称
                            if list_status == 'L':  # 只保留正常上市的股票
                                # 检查真实名称是否包含ST/退市等
                                st_pattern = r'(退市|^\*?ST|^ST|^PT|暂停)'
                                if not re.search(st_pattern, real_name):
                                    valid_stocks.append(idx)
                                else:
                                    logger.debug(f"二次过滤: {stock_code} - {real_name}")
                            else:
                                logger.debug(f"二次过滤: {stock_code} - 状态:{list_status}")
                    except Exception as e:
                        logger.debug(f"验证股票{row['stock_code']}失败: {e}")
                        continue

                    # 如果已经有足够的有效股票，可以提前结束
                    if len(valid_stocks) >= limit:
                        break

                if valid_stocks:
                    df = df.loc[valid_stocks]
                    filtered_count = verified_count - len(valid_stocks)
                    logger.info(f"二次验证: 验证{verified_count}只，过滤{filtered_count}只，剩余{len(df)}只")

            # 6. 最终确保返回limit数量的股票
            if len(df) < limit:
                logger.warning(f"过滤后股票不足: 需要{limit}只，实际{len(df)}只")

            df = df.head(limit)

            # 8. 添加数据源标识和有用字段
            df['source'] = '同花顺热股'

            # 保留有用的原始字段
            useful_cols = ['stock_code', 'short_name', 'rank', 'source']
            for col in ['pct_change', 'current_price', 'hot', 'concept', 'original_rank']:
                if col in df.columns:
                    useful_cols.append(col)

            df = df[useful_cols]

            logger.info(f"获取同花顽热门股票成功，共{len(df)}只股票")
            return df

        except Exception as e:
            logger.error(f"获取同花顽热门股票失败: {e}")
            return self._get_fallback_hot_stocks(limit)

    @retry_on_failure(retries=2, delay=1.0)
    def get_popular_stocks_east(self, limit: int = 100, trade_date: str = None) -> pd.DataFrame:
        """
        获取东方财富人气股票

        Args:
            limit: 返回数量限制
            trade_date: 交易日期，格式YYYYMMDD，默认为当日

        Returns:
            人气股票DataFrame
        """
        try:
            if not self.pro:
                logger.error("需要Tushare Pro权限才能获取东财人气股数据")
                return self._get_fallback_hot_stocks(limit)

            # 使用TuShare Pro的东方财富热榜接口
            params = {
                'market': 'A股市场',
                'hot_type': '人气榜',
                'is_new': 'Y'
            }
            if trade_date:
                params['trade_date'] = trade_date

            df = self.pro.dc_hot(**params)

            if df.empty:
                logger.warning("东财人气股数据为空，使用备用方法")
                return self._get_fallback_hot_stocks(limit)

            # 数据处理和标准化
            # 1. 过滤退市和ST股票
            if 'ts_name' in df.columns:
                before_filter = len(df)
                # 使用(?:...)非捕获组避免警告
                filter_pattern = r'(?:退市|^\*?ST|^ST|^PT|暂停)'
                df = df[~df['ts_name'].str.contains(filter_pattern, na=False, case=False, regex=True)]
                filtered_count = before_filter - len(df)
                if filtered_count > 0:
                    logger.info(f"过滤退市/ST股票: {filtered_count} 只")

            # 2. 限制数量
            df = df.head(limit)

            # 3. 统一列名格式
            if 'ts_code' in df.columns:
                df.rename(columns={'ts_code': 'stock_code', 'ts_name': 'short_name'}, inplace=True)

            # 4. 添加数据源标识
            df['source'] = '东财人气榜'
            if 'rank' not in df.columns:
                df['rank'] = range(1, len(df) + 1)

            logger.info(f"获取东财人气股票成功，共{len(df)}只股票")
            return df

        except Exception as e:
            logger.error(f"获取东财人气股票失败: {e}")
            return self._get_fallback_hot_stocks(limit)

    def get_combined_hot_stocks(self, limit_per_source: int = 100, final_limit: int = 150) -> pd.DataFrame:
        """
        获取合并的热门股票（同花顽+东财）

        Args:
            limit_per_source: 每个数据源的股票数量
            final_limit: 最终返回的股票数量

        Returns:
            合并去重后的热门股票DataFrame
        """
        try:
            all_stocks = []

            # 1. 获取同花顽热股
            ths_stocks = self.get_hot_stocks_ths(limit_per_source)
            if not ths_stocks.empty:
                all_stocks.append(ths_stocks)
                logger.info(f"同花顽热股: {len(ths_stocks)}只")

            # 2. 获取东财人气股
            east_stocks = self.get_popular_stocks_east(limit_per_source)
            if not east_stocks.empty:
                all_stocks.append(east_stocks)
                logger.info(f"东财人气股: {len(east_stocks)}只")

            if not all_stocks:
                logger.warning("所有热门股票数据源都失败，使用备用股票池")
                return self._get_fallback_hot_stocks(final_limit)

            # 3. 合并数据（过滤空数据框）
            non_empty_stocks = [df for df in all_stocks if not df.empty]
            if not non_empty_stocks:
                logger.warning("没有有效的热门股票数据，使用备用股票池")
                return self._get_fallback_hot_stocks(final_limit)

            combined_df = pd.concat(non_empty_stocks, ignore_index=True)

            # 4. 去重（优先保留排名靠前的）
            combined_df = combined_df.sort_values(['rank', 'source'])
            unique_stocks = combined_df.drop_duplicates(subset=['stock_code'], keep='first')

            # 5. 限制最终数量
            result = unique_stocks.head(final_limit)

            # 6. 重新排序并添加最终排名
            result = result.reset_index(drop=True)
            result['final_rank'] = range(1, len(result) + 1)

            logger.info(f"合并热门股票成功: 原始{len(combined_df)}只，去重后{len(unique_stocks)}只，最终{len(result)}只")
            return result

        except Exception as e:
            logger.error(f"获取合并热门股票失败: {e}")
            return self._get_fallback_hot_stocks(final_limit)

    def get_stock_name(self, stock_code: str) -> str:
        """
        获取股票中文名称

        Args:
            stock_code: 股票代码

        Returns:
            股票中文名称
        """
        try:
            # 从缓存中查找
            if stock_code in self._stock_name_cache:
                return self._stock_name_cache[stock_code]

            # 直接通过TuShare Pro查询单个股票信息
            if self.pro:
                # 将股票代码转换为TuShare格式
                ts_code = stock_code
                if '.' not in stock_code:
                    # 如果没有后缀，根据代码前缀添加
                    if stock_code.startswith('6'):
                        ts_code = f"{stock_code}.SH"
                    elif stock_code.startswith(('0', '3')):
                        ts_code = f"{stock_code}.SZ"

                # 查询股票基本信息
                stock_info = self.pro.stock_basic(ts_code=ts_code, fields='ts_code,name')
                if not stock_info.empty and 'name' in stock_info.columns:
                    stock_name = stock_info.iloc[0]['name']
                    # 添加到缓存
                    self._stock_name_cache[stock_code] = stock_name
                    return stock_name

            # 如果Pro查询失败，返回股票代码本身
            self._stock_name_cache[stock_code] = stock_code
            return stock_code

        except Exception as e:
            logger.debug(f"获取股票{stock_code}名称失败: {e}")
            return stock_code

    def _get_fallback_hot_stocks(self, limit: int = 100) -> pd.DataFrame:
        """
        备用热门股票获取方法（当主要接口失败时使用）

        Args:
            limit: 返回股票数量

        Returns:
            热门股票DataFrame
        """
        try:
            logger.info("使用备用方法获取热门股票（基于成交量排序）")

            if self.pro:
                # 获取当日成交量排行
                trade_date = datetime.now().strftime('%Y%m%d')
                daily_data = self.pro.daily(trade_date=trade_date)

                if not daily_data.empty:
                    # 按成交量排序
                    hot_stocks = daily_data.sort_values('vol', ascending=False).head(limit)

                    # 统一列名
                    hot_stocks.rename(columns={'ts_code': 'stock_code'}, inplace=True)

                    # 添加股票名称
                    stock_list = self.get_stock_list()
                    if not stock_list.empty:
                        hot_stocks = hot_stocks.merge(
                            stock_list[['stock_code', 'short_name']],
                            left_on='stock_code',
                            right_on='stock_code',
                            how='left'
                        )

                    # 添加必要字段
                    hot_stocks['source'] = '成交量排序'
                    hot_stocks['rank'] = range(1, len(hot_stocks) + 1)

                    logger.info(f"备用方法获取热门股票成功，共{len(hot_stocks)}只股票")
                    return hot_stocks

            # 如果Pro接口也失败，返回预设的股票池
            return self._get_default_stock_pool(limit)

        except Exception as e:
            logger.error(f"备用热门股票获取失败: {e}")
            return self._get_default_stock_pool(limit)

    def _get_default_stock_pool(self, limit: int = 100) -> pd.DataFrame:
        """
        默认股票池（当所有数据获取方法都失败时使用）

        Args:
            limit: 返回股票数量

        Returns:
            默认股票池DataFrame
        """
        # 预设一些主要的大盘股和活跃股票
        default_stocks = [
            {'stock_code': '000001.SZ', 'short_name': '平安银行'},
            {'stock_code': '000002.SZ', 'short_name': '万科A'},
            {'stock_code': '000858.SZ', 'short_name': '五粮液'},
            {'stock_code': '600000.SH', 'short_name': '浦发银行'},
            {'stock_code': '600036.SH', 'short_name': '招商银行'},
            {'stock_code': '600519.SH', 'short_name': '贵州茅台'},
            {'stock_code': '600887.SH', 'short_name': '伊利股份'},
            {'stock_code': '002415.SZ', 'short_name': '海康威视'},
            {'stock_code': '300014.SZ', 'short_name': '亿纬锂能'},
            {'stock_code': '300059.SZ', 'short_name': '东方财富'},
            {'stock_code': '300750.SZ', 'short_name': '宁德时代'},
            {'stock_code': '000876.SZ', 'short_name': '新希望'},
            {'stock_code': '002594.SZ', 'short_name': 'BYD'},
            {'stock_code': '000895.SZ', 'short_name': '双汇发展'},
            {'stock_code': '600031.SH', 'short_name': '三一重工'},
            {'stock_code': '601318.SH', 'short_name': '中国平安'},
            {'stock_code': '601166.SH', 'short_name': '兴业银行'},
            {'stock_code': '600009.SH', 'short_name': '上海机场'},
            {'stock_code': '600276.SH', 'short_name': '恒瑞医药'},
            {'stock_code': '000063.SZ', 'short_name': '中兴通讯'},
        ]

        df = pd.DataFrame(default_stocks[:limit])
        df['source'] = '默认股票池'
        df['rank'] = range(1, len(df) + 1)

        logger.warning(f"使用默认股票池，包含{len(df)}只股票")
        return df

    def get_market_overview(self) -> dict:
        """
        获取市场概况

        Returns:
            市场概况字典
        """
        try:
            # 获取主要指数数据
            sh_index = self.get_index_data("000001.SH")  # 上证指数
            sz_index = self.get_index_data("399001.SZ")  # 深证成指
            cyb_index = self.get_index_data("399006.SZ") # 创业板指

            overview = {
                "update_time": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
                "shanghai": sh_index.iloc[0].to_dict() if not sh_index.empty else {},
                "shenzhen": sz_index.iloc[0].to_dict() if not sz_index.empty else {},
                "chinext": cyb_index.iloc[0].to_dict() if not cyb_index.empty else {}
            }

            logger.info("获取市场概况成功")
            return overview
        except Exception as e:
            logger.error(f"获取市场概况失败: {e}")
            return {}

    def get_sector_money_flow(self, trade_date: str = None) -> pd.DataFrame:
        """
        获取板块资金流向数据
        使用同花顺行业资金流向接口

        Args:
            trade_date: 交易日期，格式YYYYMMDD，默认为当日

        Returns:
            板块资金流向DataFrame，包含净流入金额等信息
        """
        try:
            if not self.pro:
                logger.error("需要Tushare Pro权限才能获取板块资金流向数据")
                return pd.DataFrame()

            # 如果未指定日期，使用最近交易日
            if trade_date is None:
                trade_date = datetime.now().strftime('%Y%m%d')

            # 获取同花顺行业资金流向数据
            df = self.pro.moneyflow_ind_ths(trade_date=trade_date)

            if df.empty:
                # 如果当日无数据，尝试获取前一交易日
                prev_date = (datetime.strptime(trade_date, '%Y%m%d') - timedelta(days=1)).strftime('%Y%m%d')
                df = self.pro.moneyflow_ind_ths(trade_date=prev_date)

            if not df.empty:
                # 重命名列以保持兼容性
                if 'industry' in df.columns:
                    df['name'] = df['industry']

                # 使用正确的净流入字段
                if 'net_amount' in df.columns:
                    df['net_amount'] = df['net_amount']
                else:
                    logger.warning("数据中未找到net_amount字段")
                    return pd.DataFrame()

                # 按净流入金额排序（从大到小）
                df = df.sort_values('net_amount', ascending=False)
                # 添加排名
                df['rank'] = range(1, len(df) + 1)

                # 确保有涨跌幅字段
                if 'pct_change' not in df.columns:
                    df['pct_change'] = 0

                logger.info(f"获取板块资金流向成功，共{len(df)}个板块")
            else:
                logger.warning(f"未获取到{trade_date}的板块资金流向数据")

            return df

        except Exception as e:
            logger.error(f"获取板块资金流向失败: {e}")
            return pd.DataFrame()

    def get_concept_money_flow(self, trade_date: str = None) -> pd.DataFrame:
        """
        获取概念板块资金流向数据
        使用同花顺概念板块资金流向接口

        Args:
            trade_date: 交易日期，格式YYYYMMDD，默认为当日

        Returns:
            概念板块资金流向DataFrame
        """
        try:
            if not self.pro:
                logger.error("需要Tushare Pro权限才能获取概念资金流向数据")
                return pd.DataFrame()

            if trade_date is None:
                trade_date = datetime.now().strftime('%Y%m%d')

            # 获取同花顺概念板块资金流向数据
            df = self.pro.moneyflow_cnt_ths(trade_date=trade_date)

            if df.empty:
                # 如果当日无数据，尝试获取前一交易日
                prev_date = (datetime.strptime(trade_date, '%Y%m%d') - timedelta(days=1)).strftime('%Y%m%d')
                df = self.pro.moneyflow_cnt_ths(trade_date=prev_date)

            if not df.empty:
                # 按净流入金额排序（从大到小）
                df = df.sort_values('net_amount', ascending=False)
                # 添加排名
                df['rank'] = range(1, len(df) + 1)
                logger.info(f"获取概念资金流向成功，共{len(df)}个概念")
            else:
                logger.warning(f"未获取到{trade_date}的概念资金流向数据")

            return df

        except Exception as e:
            logger.error(f"获取概念资金流向失败: {e}")
            return pd.DataFrame()

    def get_strongest_concept_boards(self, trade_date: str = None, ts_code: str = None) -> pd.DataFrame:
        """
        获取最强板块统计（涨停股票最多的概念板块）

        Args:
            trade_date: 交易日期，格式YYYYMMDD，默认为当日
            ts_code: 板块代码，可选

        Returns:
            最强板块统计DataFrame，包含以下字段：
            - ts_code: 板块代码
            - name: 板块名称
            - trade_date: 交易日期
            - days: 上榜天数
            - up_stat: 连板高度
            - cons_nums: 连板家数
            - up_nums: 涨停家数
            - pct_chg: 涨跌幅%
            - rank: 板块热点排名
        """
        try:
            if not self.pro:
                logger.error("需要Tushare Pro权限才能获取最强板块数据")
                return pd.DataFrame()

            # 设置查询参数
            params = {}
            if trade_date:
                params['trade_date'] = trade_date
            if ts_code:
                params['ts_code'] = ts_code

            # 调用Tushare接口
            df = self.pro.limit_cpt_list(**params)

            if df.empty:
                logger.warning(f"未获取到最强板块数据: {trade_date or '当日'}")
                return pd.DataFrame()

            # 按照涨停家数和涨跌幅排序
            df = df.sort_values(['up_nums', 'pct_chg'], ascending=[False, False])

            logger.info(f"获取最强板块数据成功: {len(df)}个板块，日期: {trade_date or '当日'}")
            return df

        except Exception as e:
            logger.error(f"获取最强板块统计失败: {e}")
            return pd.DataFrame()

    def get_concept_constituent_stocks(self, ts_code: str) -> pd.DataFrame:
        """
        获取概念板块的成分股票

        Args:
            ts_code: 概念板块代码

        Returns:
            成分股票DataFrame，包含股票代码、名称等信息
        """
        try:
            if not self.pro:
                logger.error("需要Tushare Pro权限才能获取概念成分股")
                return pd.DataFrame()

            # 获取概念成分股
            df = self.pro.concept_detail(id=ts_code)

            if df.empty:
                logger.warning(f"未获取到概念板块 {ts_code} 的成分股")
                return pd.DataFrame()

            logger.info(f"获取概念板块 {ts_code} 成分股成功: {len(df)}只股票")
            return df

        except Exception as e:
            logger.error(f"获取概念成分股失败: {e}")
            return pd.DataFrame()

    def get_strongest_concept_stocks(self, trade_date: str = None, top_boards: int = 5) -> dict:
        """
        获取最强板块中的股票（综合方法）

        Args:
            trade_date: 交易日期，格式YYYYMMDD，默认为当日
            top_boards: 选择前N个最强板块，默认5个

        Returns:
            包含最强板块及其成分股的字典
        """
        try:
            result = {
                'trade_date': trade_date or datetime.now().strftime('%Y%m%d'),
                'strongest_boards': pd.DataFrame(),
                'stocks_by_board': {},
                'all_stocks': pd.DataFrame(),
                'update_time': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
            }

            # 1. 获取最强板块列表
            strongest_boards = self.get_strongest_concept_boards(trade_date)
            if strongest_boards.empty:
                logger.warning("未获取到最强板块数据")
                return result

            # 取前N个最强板块
            top_boards_data = strongest_boards.head(top_boards)
            result['strongest_boards'] = top_boards_data

            # 2. 获取每个强势板块的成分股
            all_stocks_list = []
            for _, board in top_boards_data.iterrows():
                board_code = board['ts_code']
                board_name = board['name']

                # 获取该板块的成分股
                stocks = self.get_concept_constituent_stocks(board_code)
                if not stocks.empty:
                    # 添加板块信息到股票数据
                    stocks['board_code'] = board_code
                    stocks['board_name'] = board_name
                    stocks['board_up_nums'] = board['up_nums']
                    stocks['board_pct_chg'] = board['pct_chg']

                    result['stocks_by_board'][board_name] = stocks
                    all_stocks_list.append(stocks)

                    logger.info(f"板块 {board_name} 包含 {len(stocks)} 只股票")

                # 避免频繁调用API
                time.sleep(0.1)

            # 3. 合并所有股票数据
            if all_stocks_list:
                result['all_stocks'] = pd.concat(all_stocks_list, ignore_index=True)

                # 去重（一只股票可能属于多个概念）
                unique_stocks = result['all_stocks'].drop_duplicates(subset=['ts_code'])

                logger.info(f"最强板块股票获取完成:")
                logger.info(f"  - 强势板块数量: {len(top_boards_data)}")
                logger.info(f"  - 包含股票总数: {len(result['all_stocks'])}")
                logger.info(f"  - 去重后股票数: {len(unique_stocks)}")

            return result

        except Exception as e:
            logger.error(f"获取最强板块股票失败: {e}")
            return {
                'trade_date': trade_date or datetime.now().strftime('%Y%m%d'),
                'strongest_boards': pd.DataFrame(),
                'stocks_by_board': {},
                'all_stocks': pd.DataFrame(),
                'update_time': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                'error': str(e)
            }

    def get_leading_stocks_from_board(self, board_code: str, board_name: str = None,
                                    top_n: int = 3, min_price: float = 5.0,
                                    max_price: float = 300.0) -> pd.DataFrame:
        """
        从单个板块中筛选龙头股

        Args:
            board_code: 板块代码
            board_name: 板块名称
            top_n: 返回龙头股数量
            min_price: 最低股价过滤
            max_price: 最高股价过滤

        Returns:
            龙头股DataFrame，包含评分和排名
        """
        try:
            if not self.pro:
                logger.error("需要Tushare Pro权限才能筛选龙头股")
                return pd.DataFrame()

            # 1. 获取板块成分股
            constituent_stocks = self.get_concept_constituent_stocks(board_code)
            if constituent_stocks.empty:
                logger.warning(f"板块 {board_code} 没有成分股数据")
                return pd.DataFrame()

            # 2. 获取股票基本信息和当日行情
            trade_date = datetime.now().strftime('%Y%m%d')
            stock_codes = constituent_stocks['ts_code'].tolist()

            leading_candidates = []

            for stock_code in stock_codes[:50]:  # 限制查询数量避免超限
                try:
                    # 获取基本信息
                    basic_info = self.pro.stock_basic(ts_code=stock_code)
                    if basic_info.empty:
                        continue

                    # 获取当日行情
                    daily_data = self.pro.daily(ts_code=stock_code, trade_date=trade_date)
                    if daily_data.empty:
                        # 尝试获取最近一个交易日数据
                        recent_data = self.pro.daily(ts_code=stock_code, limit=1)
                        if not recent_data.empty:
                            daily_data = recent_data
                        else:
                            continue

                    stock_info = daily_data.iloc[0]
                    basic = basic_info.iloc[0]

                    # 价格过滤
                    current_price = stock_info['close']
                    if current_price < min_price or current_price > max_price:
                        continue

                    # 计算评分指标
                    candidate = {
                        'ts_code': stock_code,
                        'stock_code': stock_code,
                        'name': basic['name'],
                        'board_code': board_code,
                        'board_name': board_name or board_code,
                        'close': current_price,
                        'pct_chg': stock_info.get('pct_chg', 0),
                        'vol': stock_info.get('vol', 0),
                        'amount': stock_info.get('amount', 0),
                        'turnover_rate': stock_info.get('turnover_rate', 0),
                        'total_mv': stock_info.get('total_mv', 0),  # 总市值
                        'circ_mv': stock_info.get('circ_mv', 0),   # 流通市值
                    }

                    # 获取近5日数据计算连涨天数
                    recent_5d = self.pro.daily(ts_code=stock_code, limit=5)
                    if not recent_5d.empty:
                        # 计算连续上涨天数
                        consecutive_up = 0
                        for _, row in recent_5d.iterrows():
                            if row['pct_chg'] > 0:
                                consecutive_up += 1
                            else:
                                break
                        candidate['consecutive_up_days'] = consecutive_up

                        # 计算5日平均成交额
                        candidate['avg_amount_5d'] = recent_5d['amount'].mean()
                    else:
                        candidate['consecutive_up_days'] = 0
                        candidate['avg_amount_5d'] = candidate['amount']

                    leading_candidates.append(candidate)
                    time.sleep(0.1)  # 避免调用过于频繁

                except Exception as e:
                    logger.debug(f"处理股票 {stock_code} 时出错: {e}")
                    continue

            if not leading_candidates:
                logger.warning(f"板块 {board_code} 没有找到符合条件的龙头股")
                return pd.DataFrame()

            # 3. 计算龙头股评分
            df = pd.DataFrame(leading_candidates)
            df = self._calculate_leading_score(df)

            # 4. 排序并返回前N个
            df = df.sort_values('leading_score', ascending=False).head(top_n)
            df['rank'] = range(1, len(df) + 1)

            logger.info(f"板块 {board_name or board_code} 筛选出 {len(df)} 只龙头股")
            return df

        except Exception as e:
            logger.error(f"从板块 {board_code} 筛选龙头股失败: {e}")
            return pd.DataFrame()

    def _calculate_leading_score(self, df: pd.DataFrame) -> pd.DataFrame:
        """
        计算龙头股评分

        Args:
            df: 候选股票DataFrame

        Returns:
            包含评分的DataFrame
        """
        try:
            if df.empty:
                return df

            df = df.copy()

            # 标准化各项指标到0-100分
            # 1. 涨幅得分 (30%)
            df['pct_chg_score'] = self._normalize_score(df['pct_chg'], weight=30)

            # 2. 成交额得分 (25%)
            df['amount_score'] = self._normalize_score(df['avg_amount_5d'], weight=25)

            # 3. 连续上涨天数得分 (20%)
            df['consecutive_score'] = df['consecutive_up_days'] * 4  # 每天4分，最高20分
            df['consecutive_score'] = df['consecutive_score'].clip(upper=20)

            # 4. 换手率得分 (15%) - 适中的换手率更好
            optimal_turnover = 8  # 最优换手率8%
            df['turnover_score'] = 15 - abs(df['turnover_rate'] - optimal_turnover)
            df['turnover_score'] = df['turnover_score'].clip(lower=0, upper=15)

            # 5. 市值得分 (10%) - 流通市值适中更好
            # 50-500亿为最佳区间
            df['mv_score'] = df['circ_mv'].apply(lambda x: self._get_mv_score(x))

            # 综合评分
            df['leading_score'] = (
                df['pct_chg_score'] +
                df['amount_score'] +
                df['consecutive_score'] +
                df['turnover_score'] +
                df['mv_score']
            )

            # 添加评级
            df['leading_grade'] = df['leading_score'].apply(self._get_leading_grade)

            return df

        except Exception as e:
            logger.error(f"计算龙头股评分失败: {e}")
            return df

    def _normalize_score(self, series: pd.Series, weight: int = 100) -> pd.Series:
        """
        将数据标准化为指定权重的得分

        Args:
            series: 原始数据序列
            weight: 权重分数

        Returns:
            标准化后的得分序列
        """
        if series.empty or series.max() == series.min():
            return pd.Series([0] * len(series), index=series.index)

        # Min-Max标准化到0-1，然后乘以权重
        normalized = (series - series.min()) / (series.max() - series.min())
        return normalized * weight

    def _get_mv_score(self, market_value: float) -> float:
        """
        根据流通市值计算得分

        Args:
            market_value: 流通市值(万元)

        Returns:
            市值得分
        """
        if market_value <= 0:
            return 0

        # 转换为亿元
        mv_billion = market_value / 10000

        if 50 <= mv_billion <= 500:  # 最佳区间：50-500亿
            return 10
        elif 20 <= mv_billion < 50:  # 较小但可接受：20-50亿
            return 8
        elif 500 < mv_billion <= 1000:  # 较大但可接受：500-1000亿
            return 6
        elif 10 <= mv_billion < 20:  # 偏小：10-20亿
            return 4
        elif mv_billion > 1000:  # 太大：>1000亿
            return 2
        else:  # 太小：<10亿
            return 1

    def _get_leading_grade(self, score: float) -> str:
        """
        根据评分获取评级

        Args:
            score: 综合评分

        Returns:
            评级字符串
        """
        if score >= 80:
            return "A+ 超级龙头"
        elif score >= 70:
            return "A  优质龙头"
        elif score >= 60:
            return "B+ 潜力龙头"
        elif score >= 50:
            return "B  一般龙头"
        else:
            return "C  弱势股票"

    def get_leading_stocks_from_hot_boards(self, top_boards: int = 10,
                                         stocks_per_board: int = 2,
                                         min_score: float = 50.0) -> dict:
        """
        从热门板块中筛选龙头牛股（主要接口）

        Args:
            top_boards: 分析前N个热门板块
            stocks_per_board: 每个板块选择的龙头股数量
            min_score: 最低评分要求

        Returns:
            包含所有龙头股信息的字典
        """
        try:
            result = {
                'scan_time': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                'boards_analyzed': 0,
                'total_leading_stocks': 0,
                'leading_stocks_by_board': {},
                'all_leading_stocks': pd.DataFrame(),
                'top_leading_stocks': pd.DataFrame()
            }

            # 1. 获取最强板块
            logger.info(f"正在获取前 {top_boards} 个最强板块...")
            strongest_boards = self.get_strongest_concept_boards()

            if strongest_boards.empty:
                logger.warning("未能获取到强势板块数据")
                return result

            # 取前N个板块
            target_boards = strongest_boards.head(top_boards)
            result['boards_analyzed'] = len(target_boards)

            # 2. 逐个分析每个板块的龙头股
            all_leading_stocks = []

            for idx, (_, board) in enumerate(target_boards.iterrows(), 1):
                board_code = board['ts_code']
                board_name = board['name']
                board_up_nums = board.get('up_nums', 0)
                board_pct_chg = board.get('pct_chg', 0)

                logger.info(f"[{idx}/{len(target_boards)}] 分析板块: {board_name} (涨停{board_up_nums}只, 涨幅{board_pct_chg:.2f}%)")

                # 从该板块筛选龙头股
                board_leaders = self.get_leading_stocks_from_board(
                    board_code, board_name,
                    top_n=stocks_per_board
                )

                if not board_leaders.empty:
                    # 过滤低分股票
                    qualified_leaders = board_leaders[board_leaders['leading_score'] >= min_score]

                    if not qualified_leaders.empty:
                        # 添加板块信息
                        qualified_leaders['board_up_nums'] = board_up_nums
                        qualified_leaders['board_pct_chg'] = board_pct_chg
                        qualified_leaders['board_rank'] = idx

                        result['leading_stocks_by_board'][board_name] = qualified_leaders
                        all_leading_stocks.append(qualified_leaders)

                        logger.info(f"   ✅ 找到 {len(qualified_leaders)} 只龙头股")
                    else:
                        logger.info(f"   ❌ 无符合评分要求的龙头股")
                else:
                    logger.info(f"   ❌ 板块数据获取失败")

                # 避免API限制
                time.sleep(0.5)

            # 3. 汇总所有龙头股
            if all_leading_stocks:
                all_df = pd.concat(all_leading_stocks, ignore_index=True)
                result['all_leading_stocks'] = all_df
                result['total_leading_stocks'] = len(all_df)

                # 4. 获取综合排名前N的超级龙头
                top_leaders = all_df.nlargest(20, 'leading_score')
                top_leaders['overall_rank'] = range(1, len(top_leaders) + 1)
                result['top_leading_stocks'] = top_leaders

                logger.info(f"🎯 筛选完成! 共分析 {result['boards_analyzed']} 个板块，发现 {result['total_leading_stocks']} 只龙头股")
                logger.info(f"📈 TOP10 超级龙头:")
                for _, stock in top_leaders.head(10).iterrows():
                    logger.info(f"   {stock['overall_rank']}. {stock['stock_code']} {stock['name']} | {stock['board_name']} | 评分:{stock['leading_score']:.1f} | {stock['leading_grade']}")

            return result

        except Exception as e:
            logger.error(f"筛选热门板块龙头股失败: {e}")
            result['error'] = str(e)
            return result

    def get_top_money_flow_sectors(self, trade_date: str = None, top_n: int = 10) -> dict:
        """
        获取当日资金净流入最多的板块

        Args:
            trade_date: 交易日期，格式YYYYMMDD，默认为当日
            top_n: 返回前N个板块，默认10个

        Returns:
            包含行业板块和概念板块的字典
        """
        try:
            result = {
                'trade_date': trade_date or datetime.now().strftime('%Y%m%d'),
                'sectors': pd.DataFrame(),
                'concepts': pd.DataFrame(),
                'update_time': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
            }

            # 获取行业板块资金流向
            sectors_df = self.get_sector_money_flow(trade_date)
            if not sectors_df.empty:
                result['sectors'] = sectors_df.head(top_n)
                logger.info(f"获取行业板块TOP{top_n}成功")

            # 获取概念板块资金流向
            concepts_df = self.get_concept_money_flow(trade_date)
            if not concepts_df.empty:
                result['concepts'] = concepts_df.head(top_n)
                logger.info(f"获取概念板块TOP{top_n}成功")

            return result

        except Exception as e:
            logger.error(f"获取TOP资金流向板块失败: {e}")
            return {
                'trade_date': trade_date or datetime.now().strftime('%Y%m%d'),
                'sectors': pd.DataFrame(),
                'concepts': pd.DataFrame(),
                'update_time': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                'error': str(e)
            }


# ADataFetcher别名已移除，请直接使用TushareFetcher


if __name__ == "__main__":
    # 测试代码
    token = "0ed6419a00d8923dc19c0b58fc92d94c9a0696949ab91a13aa58a0cc"
    fetcher = TushareFetcher(token)

    # 测试获取股票列表
    print("测试获取股票列表...")
    stock_list = fetcher.get_stock_list()
    print(f"股票数量: {len(stock_list)}")
    if not stock_list.empty:
        print(stock_list.head())

    # 测试搜索功能
    print("\n测试搜索功能...")
    search_results = fetcher.search_stocks("平安")
    if not search_results.empty:
        print(search_results.head())