JUKUAN/Lib/Options/deep_itm_bull_spread_strategy.py

# 深度实值买购和卖购组合的牛差策略
# 策略说明：使用深度实值买购期权替代ETF持仓，结合卖购期权构建牛差组合
# 参考资料：基于加百列分享中的50ETF期权备兑认购策略改进

import jqdata
from jqdata import *
import pandas as pd
import numpy as np
import datetime
import matplotlib.pyplot as plt
import os
from enum import Enum

plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False

class StrategyType(Enum):
    """策略类型枚举"""
    BULL_SPREAD = "bull_spread"  # 牛差组合策略（深度实值买购+卖购）

class DeepITMBullSpreadStrategy:
    """深度实值买购和卖购组合的牛差策略"""
    
    def __init__(self, underlying_symbol='510300.XSHG', start_date='2024-01-01', end_date='2024-12-31'):
        """初始化策略参数"""
        self.underlying_symbol = underlying_symbol
        self.start_date = start_date
        self.end_date = end_date
        
        # 策略参数设置 - 对应README.md中的阈值设定
        self.config = {
            'contract_size': 30,  # 一组张数
            'min_premium': {'510300': 0.03, '510050': 0.05, '159915': 0.03},  # 最小权利金
            'min_days_to_expiry': 15,  # 最少开仓日期(距离到期日)
            'call_time_value_threshold': 0.015,  # 买购时间价值阈值(README中为0.015)
            'put_close_premium_threshold': 0.005,  # 卖购平仓权利金阈值(README中为50单位，转换为0.005)
            'max_days_before_expiry': 3,  # 合约到期移仓日期最大(交易日)
            'min_days_before_expiry': 1,  # 合约到期移仓日期最小(交易日)
            'add_position_threshold': {'510300': 0.2, '510050': 0.1, '159915': 0.15},  # 加仓窗口阈值
            'max_add_positions': 2,  # 加仓次数上限
            'max_profit_close_threshold': 0.83
        }
        
        # 持仓和交易记录
        self.positions = []
        self.trade_records = []
        
        # CSV文件输出设置
        self.transaction_csv_path = 'transaction.csv'
        self.position_csv_path = 'position.csv'
        
        # 验证合约数量
        self._validate_contract_size()
        self.daily_positions = []  # 每日持仓记录
        
        # 账户管理器回调（用于通知账户管理器更新汇总）
        self.account_manager_callback = None
        
        # 获取交易日历和月度分割点
        self.trade_days = pd.Series(index=jqdata.get_trade_days(start_date, end_date))
        self.trade_days.index = pd.to_datetime(self.trade_days.index)
        self.month_split = list(self.trade_days.resample('M', label='left').mean().index) + [pd.to_datetime(end_date)]
        
        # 调试输出：显示月份分割点
        # print(f"Month split 计算结果 ({len(self.month_split)}个分割点):")
        for i, split_date in enumerate(self.month_split):
            # print(f"  索引{i}: {split_date.strftime('%Y-%m-%d')}")
            if i < len(self.month_split) - 1:
                next_split = self.month_split[i + 1]
                # print(f"    月份{i}覆盖范围: {split_date.strftime('%Y-%m-%d')} 到 {next_split.strftime('%Y-%m-%d')}")
        
        # 用于存储前一日ETF价格，计算当日涨幅
        self.previous_etf_price = None
    
    def _validate_contract_size(self):
        """验证合约数量的有效性"""
        contract_size = self.config.get('contract_size', 30)
        if not isinstance(contract_size, (int, float)) or contract_size <= 0:
            print(f"警告: 合约数量无效({contract_size})，重置为默认值30张")
            self.config['contract_size'] = 30
        elif contract_size > 200:  # 设置一个合理的上限
            print(f"警告: 合约数量过大({contract_size})，限制为200张")
            self.config['contract_size'] = 200
        else:
            # 确保为整数
            self.config['contract_size'] = int(contract_size)
    
    def get_safe_contract_size(self):
        """安全获取合约数量，确保返回有效值"""
        contract_size = self.config.get('contract_size', 30)
        if not isinstance(contract_size, (int, float)) or contract_size <= 0:
            print(f"警告: 运行时检测到合约数量无效({contract_size})，使用默认值30张")
            contract_size = 30
            self.config['contract_size'] = 30
        elif contract_size > 200:
            print(f"警告: 运行时检测到合约数量过大({contract_size})，限制为200张")
            contract_size = 200
            self.config['contract_size'] = 200
        return int(contract_size)
    
    def get_underlying_code(self):
        """获取标的ETF的简化代码"""
        if '510300' in self.underlying_symbol:
            return '510300'
        elif '510050' in self.underlying_symbol:
            return '510050'
        elif '159915' in self.underlying_symbol:
            return '159915'
        return '510300'  # 默认
    
    def get_option_contracts(self, trade_date, month_idx, contract_type='CO'):
        """获取指定月份的期权合约信息"""
        underlying_code = self.get_underlying_code()
        
        # 根据标的ETF代码动态确定交易所代码
        if underlying_code in ['510050', '510300']:
            exchange_code = 'XSHG'  # 上海交易所
        elif underlying_code in ['159915']:
            exchange_code = 'XSHE'  # 深圳交易所
        else:
            exchange_code = 'XSHG'  # 默认上海交易所
        
        print(f"  期权筛选: 标的代码={underlying_code}, 交易所={exchange_code}")
        
        # 基于自然月份计算期权筛选范围
        query_date = trade_date.date() if hasattr(trade_date, 'date') else trade_date
        current_year = query_date.year
        current_month = query_date.month
        print(f"  期权筛选调试: month_idx={month_idx}, query_date={query_date}, 当前年月={current_year}-{current_month:02d}")
        
        # 计算目标月份
        if month_idx == 0:
            # 当月期权：到期日在当前月份
            target_year = current_year
            target_month = current_month
        elif month_idx == 1:
            # 下月期权：到期日在下个月份
            if current_month == 12:
                target_year = current_year + 1
                target_month = 1
            else:
                target_year = current_year
                target_month = current_month + 1
        else:
            # 其他月份：使用原来的month_split逻辑作为后备
            start_date = self.month_split[month_idx].date() if hasattr(self.month_split[month_idx], 'date') else self.month_split[month_idx]
            end_date = self.month_split[month_idx + 1].date() if hasattr(self.month_split[month_idx + 1], 'date') else self.month_split[month_idx + 1]
            print(f"  使用month_split后备逻辑: 月份索引{month_idx}, 范围{start_date}到{end_date}")
        
        if month_idx <= 1:
            # 计算目标月份的完整范围
            start_date = pd.to_datetime(f'{target_year}-{target_month:02d}-01').date()
            if target_month == 12:
                end_date = pd.to_datetime(f'{target_year + 1}-01-01').date() - pd.Timedelta(days=1)
            else:
                end_date = pd.to_datetime(f'{target_year}-{target_month + 1:02d}-01').date() - pd.Timedelta(days=1)
            
            # print(f"  月份索引{month_idx}({target_year}-{target_month:02d})期权筛选范围: {start_date} 到 {end_date}")
        
        q_contract_info = query(
            opt.OPT_CONTRACT_INFO.code,
                  opt.OPT_CONTRACT_INFO.trading_code,
                  opt.OPT_CONTRACT_INFO.name,
                  opt.OPT_CONTRACT_INFO.exercise_price,
                  opt.OPT_CONTRACT_INFO.last_trade_date,
                  opt.OPT_CONTRACT_INFO.list_date
                 ).filter(
                     opt.OPT_CONTRACT_INFO.contract_type == contract_type,
            opt.OPT_CONTRACT_INFO.exchange_code == exchange_code,
            opt.OPT_CONTRACT_INFO.last_trade_date >= start_date,
            opt.OPT_CONTRACT_INFO.last_trade_date <= end_date,
            opt.OPT_CONTRACT_INFO.list_date < query_date
        )
        
        contract_info = opt.run_query(q_contract_info)
        contract_info = contract_info[contract_info['trading_code'].str[:6] == underlying_code]
        
        # 调试输出：显示筛选到的期权到期日
        if not contract_info.empty:
            print(f"  筛选到{len(contract_info)}个期权，到期日范围：{contract_info['last_trade_date'].min()} 到 {contract_info['last_trade_date'].max()}")
        else:
            print(f"  未筛选到任何期权")
        
        return contract_info
    
    def get_monthly_option_candidates(self, trade_date, month_idx, silent=False):
        """获取指定月份的所有认购期权候选信息
        返回: (contract_info, month_info, failure_reason) - contract_info为期权列表，month_info为月份信息，failure_reason为失败原因（成功时为None）
        """
        # if not silent:
        #     print(f"{trade_date.strftime('%Y-%m-%d')} 获取月份索引 {month_idx} 的认购期权候选信息")
        
        # 获取期权合约信息
        contract_info = self.get_option_contracts(trade_date, month_idx, 'CO')
        # print(f"contract_info: {contract_info}")
        
        if contract_info.empty:
            failure_reason = "无可用认购期权合约"
            if not silent:
                print(f"  月份索引 {month_idx} {failure_reason}")
                # 增加调试信息，显示查询的时间范围
                if month_idx < len(self.month_split) - 1:
                    start_date = self.month_split[month_idx].date() if hasattr(self.month_split[month_idx], 'date') else self.month_split[month_idx]
                    end_date = self.month_split[month_idx + 1].date() if hasattr(self.month_split[month_idx + 1], 'date') else self.month_split[month_idx + 1]
                    print(f"    查询时间范围: {start_date} 到 {end_date}")
                    print(f"    查询日期: {trade_date}")
                    print(f"    标的代码: {self.get_underlying_code()}")
                    print(f"    month_split总长度: {len(self.month_split)}")
            return None, None, failure_reason
        
        # 获取月份信息
        underlying_code = self.get_underlying_code()
        min_days_to_expiry = self.config['min_days_to_expiry']
        
        # 为每个合约添加额外信息
        query_date = trade_date.date() if hasattr(trade_date, 'date') else trade_date
        candidates = []
        
        # 统计失败原因
        expiry_rejected_count = 0
        price_missing_count = 0
        price_error_count = 0
        
        # if not silent:
        #     print(f"  查询到 {len(contract_info)} 个认购期权合约，开始获取价格信息：")
        
        for idx, contract in contract_info.iterrows():
            # 检查到期日
            expiry_date = pd.to_datetime(contract['last_trade_date'])
            trade_date_obj = trade_date.date() if hasattr(trade_date, 'date') else trade_date
            days_to_expiry = len(get_trade_days(trade_date_obj, expiry_date.date())) - 1
            
            if days_to_expiry < min_days_to_expiry:
                expiry_rejected_count += 1
                # if not silent:
                #     print(f"    行权价 {contract['exercise_price']:.3f}: 到期时间不足 ({days_to_expiry} < {min_days_to_expiry})")
                continue
            
            # 查询期权价格
            try:
                q_price = query(opt.OPT_DAILY_PRICE.close).filter(
                    opt.OPT_DAILY_PRICE.code == contract['code'],
                    opt.OPT_DAILY_PRICE.date == query_date
                )
                price_result = opt.run_query(q_price)
                if price_result.empty:
                    price_missing_count += 1
                    if not silent:
                        print(f"    行权价 {contract['exercise_price']:.3f}: 无价格数据")
                    continue
                
                option_price = price_result['close'].iloc[0]
                
                candidate = {
                    'code': contract['code'],
                    'exercise_price': contract['exercise_price'],
                    'price': option_price,
                    'expiry_date': contract['last_trade_date'],
                    'days_to_expiry': days_to_expiry,
                    'contract_info': contract
                }
                candidates.append(candidate)
                
                if not silent:
                    print(f"    行权价 {contract['exercise_price']:.3f}: 期权价格 {option_price:.4f}, 剩余天数 {days_to_expiry}")
                    
            except Exception as e:
                price_error_count += 1
                if not silent:
                    print(f"    行权价 {contract['exercise_price']:.3f}: 价格查询失败 ({str(e)})")
                continue
        
        if not candidates:
            # 构建详细的失败原因
            total_contracts = len(contract_info)
            failure_parts = []
            if expiry_rejected_count > 0:
                failure_parts.append(f"到期时间不足{expiry_rejected_count}个")
            if price_missing_count > 0:
                failure_parts.append(f"无价格数据{price_missing_count}个")
            if price_error_count > 0:
                failure_parts.append(f"价格查询失败{price_error_count}个")
            
            if failure_parts:
                failure_reason = f"共{total_contracts}个期权合约，但均不符合条件：" + "、".join(failure_parts)
            else:
                failure_reason = f"共{total_contracts}个期权合约，但均不符合基本条件"
            
            # if not silent:
            #     print(f"  月份索引 {month_idx} 无符合基本条件的期权候选")
            return None, None, failure_reason
        
        month_info = {
            'month_idx': month_idx,
            'underlying_code': underlying_code,
            'min_days_to_expiry': min_days_to_expiry,
            'query_date': query_date
        }
        
        if not silent:
            print(f"  成功获取 {len(candidates)} 个有效期权候选")
            # print(f"  月份索引 {month_idx} 的认购期权候选信息: {candidates}")
        
        return candidates, month_info, None
    
    def select_sell_call_from_candidates(self, candidates, etf_price, min_premium, silent=False):
        """从候选期权中选择卖购期权（虚值期权）
        返回: (selected_call, reason) - selected_call为期权信息或None，reason为失败原因或None
        """
        # if not silent:
        #     print(f"  从 {len(candidates)} 个候选中筛选虚值卖购期权（行权价 > ETF价格 {etf_price:.4f}）：")
        
        # 筛选虚值期权（行权价 > ETF价格）
        otm_candidates = [c for c in candidates if c['exercise_price'] > etf_price]
        
        if not otm_candidates:
            reason = f"无虚值期权：所有{len(candidates)}个期权的行权价都 <= ETF价格{etf_price:.4f}"
            if not silent:
                print(f"    筛选结果：无虚值期权（所有期权行权价都 <= ETF价格）")
                for c in candidates:
                    option_type = "虚值" if c['exercise_price'] > etf_price else "实值"
                    print(f"      行权价: {c['exercise_price']:.3f} ({option_type})")
            return None, reason
        
        if not silent:
            print(f"    etf价格为{etf_price:.4f}时，筛选出 {len(otm_candidates)} 个虚值期权：")
            for c in otm_candidates:
                price_spread = c['exercise_price'] - etf_price
                print(f"      行权价: {c['exercise_price']:.3f}, 价差: {price_spread:.4f}, 价格: {c['price']:.4f}")
        
        # 按行权价排序，选择最接近ETF价格的虚值期权（行权价最小的）
        otm_candidates.sort(key=lambda x: x['exercise_price'])
        closest_otm = otm_candidates[0]
        
        if not silent:
            print(f"    选择最接近的虚值期权：行权价 {closest_otm['exercise_price']:.3f}, 价格 {closest_otm['price']:.4f}")
        
        # 检查权利金要求
        if closest_otm['price'] >= min_premium:
            if not silent:
                print(f"    ✓ 满足权利金要求 ({closest_otm['price']:.4f} >= {min_premium:.4f})")
            
            # 构建返回结果
            selected_call = {
                'code': closest_otm['code'],
                'exercise_price': closest_otm['exercise_price'],
                'price': closest_otm['price'],
                'expiry_date': closest_otm['expiry_date'],
                'price_spread': closest_otm['exercise_price'] - etf_price,
                'days_to_expiry': closest_otm['days_to_expiry']
            }
            return selected_call, None
        else:
            reason = f"期权权利金不足：{closest_otm['price']:.4f} < {min_premium:.4f}"
            if not silent:
                print(f"    ✗ 权利金不足 ({closest_otm['price']:.4f} < {min_premium:.4f})")
            return None, reason
    
    def select_buy_call_from_candidates(self, candidates, etf_price, time_value_threshold, trade_date, silent=False):
        """从候选期权中选择深度实值买购期权
        返回: (selected_call, reason) - selected_call为期权信息或None，reason为失败原因或None
        """
        if not silent:
            print(f"  从 {len(candidates)} 个候选中筛选深度实值买购期权（行权价 < ETF价格 {etf_price:.4f}）：")
        
        # 筛选深度实值期权（行权价 < ETF价格）
        itm_candidates = [c for c in candidates if c['exercise_price'] < etf_price]
        
        if not itm_candidates:
            reason = f"无深度实值期权：所有{len(candidates)}个期权的行权价都 >= ETF价格{etf_price:.4f}"
            if not silent:
                print(f"    筛选结果：无深度实值期权（所有期权行权价都 >= ETF价格）")
                for c in candidates:
                    option_type = "实值" if c['exercise_price'] < etf_price else "虚值"
                    print(f"      行权价: {c['exercise_price']:.3f} ({option_type})")
            return None, reason
        
        if not silent:
            print(f"    筛选出 {len(itm_candidates)} 个深度实值期权：")
            for c in itm_candidates:
                print(f"      行权价: {c['exercise_price']:.3f}, 价格: {c['price']:.4f}")
        
        # 按行权价与ETF价格的差异排序（升序，最接近的在前）
        itm_candidates.sort(key=lambda x: abs(x['exercise_price'] - etf_price))
        
        if not silent:
            print(f"    按距离ETF价格的差异排序，检查时间价值（阈值: {time_value_threshold:.4f}）：")
        
        # 检查时间价值
        for candidate in itm_candidates:
            intrinsic_value = etf_price - candidate['exercise_price']
            time_value = round(max(0, candidate['price'] - intrinsic_value), 4)
            
            if not silent:
                print(f"      行权价 {candidate['exercise_price']:.3f}: 内在价值 {intrinsic_value:.4f}, 时间价值 {time_value:.4f}")
            
            if time_value < time_value_threshold:
                if not silent:
                    print(f"        ✓ 满足时间价值要求 (< {time_value_threshold:.4f})")
                
                # 构建返回结果
                selected_call = {
                    'code': candidate['code'],
                    'exercise_price': candidate['exercise_price'],
                    'price': candidate['price'],
                    'time_value': time_value,
                    'expiry_date': candidate['expiry_date'],
                    'price_diff': abs(candidate['exercise_price'] - etf_price),
                    'days_to_expiry': candidate['days_to_expiry']
                }
                return selected_call, None
            else:
                if not silent:
                    print(f"        ✗ 时间价值过高 ({time_value:.4f} >= {time_value_threshold:.4f})")
        
        reason = f"所有{len(itm_candidates)}个深度实值期权的时间价值都过高（需<{time_value_threshold:.4f}）"
        if not silent:
            print(f"    深度实值买购期权选择失败：所有期权时间价值都过高")
        return None, reason
    
    def try_bull_spread_for_month(self, trade_date, etf_price, month_idx, is_current_month=True, silent=False):
        """尝试指定月份的牛差策略
        返回: (buy_call, sell_call, reason) - 成功返回两个期权，失败返回None和原因
        """
        month_type = "当月" if is_current_month else "下月"
        underlying_code = self.get_underlying_code()
        base_premium = self.config['min_premium'][underlying_code]
        min_premium = base_premium * 0.6 if is_current_month else base_premium
        time_value_threshold = self.config['call_time_value_threshold']
        
        if not silent:
            print(f"{trade_date.strftime('%Y-%m-%d')} 尝试{month_type}牛差策略（月份索引：{month_idx}）")
            print(f"  权利金阈值: {min_premium:.4f}，时间价值阈值: {time_value_threshold:.4f}")
        
        # 1. 获取月份期权候选
        candidates, month_info, failure_reason = self.get_monthly_option_candidates(trade_date, month_idx, silent)
        if not candidates:
            reason = f"{month_type}期权候选获取失败：{failure_reason}"
            if not silent:
                print(f"  {month_type}牛差策略失败：{reason}")
            return None, None, reason
        
        # 2. 选择卖购期权
        sell_call, sell_reason = self.select_sell_call_from_candidates(candidates, etf_price, min_premium, silent)
        if not sell_call:
            reason = f"{month_type}卖购期权选择失败：{sell_reason}"
            if not silent:
                print(f"  {month_type}牛差策略失败：{reason}")
            return None, None, reason
        
        # 3. 选择买购期权（必须与卖购期权到期日一致）
        buy_call, buy_reason = self.select_buy_call_from_candidates(candidates, etf_price, time_value_threshold, trade_date, silent)
        if not buy_call:
            reason = f"{month_type}买购期权选择失败：{buy_reason}"
            if not silent:
                print(f"  {month_type}牛差策略失败：{reason}")
            return None, None, reason
        
        # 4. 验证到期日是否一致
        sell_expiry = pd.to_datetime(sell_call['expiry_date'])
        buy_expiry = pd.to_datetime(buy_call['expiry_date'])
        if buy_expiry != sell_expiry:
            reason = f"买购和卖购期权到期日不一致：买购到期{buy_expiry.strftime('%Y-%m-%d')} vs 卖购到期{sell_expiry.strftime('%Y-%m-%d')}"
            if not silent:
                print(f"  {month_type}牛差策略失败：{reason}")
            return None, None, reason
        
        if not silent:
            print(f"  {month_type}牛差策略匹配成功：")
            print(f"    卖购期权：行权价 {sell_call['exercise_price']:.3f}, 价格 {sell_call['price']:.4f}")
            print(f"    买购期权：行权价 {buy_call['exercise_price']:.3f}, 价格 {buy_call['price']:.4f}")
            print(f"    到期日：{sell_expiry.strftime('%Y-%m-%d')}")
        
        return buy_call, sell_call, None
    
    def calculate_bull_spread_profit(self, buy_call, sell_call, contract_size=None):
        """计算牛差组合的盈利情况"""
        if contract_size is None:
            contract_size = self.get_safe_contract_size()
            
        # 单张最大盈利 = (卖购行权价 - 买购行权价 - 买购权利金 + 卖购权利金) * 10000
        max_profit_per_contract = (
            sell_call['exercise_price'] - buy_call['exercise_price'] 
            - buy_call['price'] + sell_call['price']
        ) * 10000
        
        # 最小盈利（卖购权利金）
        min_profit_per_contract = sell_call['price'] * 10000
        
        return {
            'max_profit_per_contract': max_profit_per_contract,
            'min_profit_per_contract': min_profit_per_contract,
            'total_max_profit': max_profit_per_contract * contract_size,
            'total_min_profit': min_profit_per_contract * contract_size
        }

    def _create_bull_spread_position(self, trade_date, etf_price, buy_call, sell_call, position_type='main', silent=False, save_to_csv=True):
        """直接使用已选择的期权信息创建牛差仓位，避免重复期权选择"""
        # 输出期权选择成功的信息
        if not silent:
            print(f"{trade_date.strftime('%Y-%m-%d')} 卖购期权选择成功，sell_call: {sell_call}")
            print(f"{trade_date.strftime('%Y-%m-%d')} 检查买购期权选择，buy_call: {buy_call}")
        
        # 安全获取合约数量
        contract_size = self.get_safe_contract_size()
        print(f"合约数量: {contract_size}")
        
        # 计算盈利信息
        profit_info = self.calculate_bull_spread_profit(buy_call, sell_call, contract_size)
        
        # 创建仓位记录
        position = {
            'open_date': trade_date,
            'etf_price': etf_price,
            'buy_call': buy_call,
            'sell_call': sell_call,
            'contract_size': contract_size,
            'profit_info': profit_info,
            'position_type': position_type,
            'status': 'open',
            'strategy_type': StrategyType.BULL_SPREAD,  # 标记策略类型
            'add_position_trigger_price': etf_price - self.config['add_position_threshold'][self.get_underlying_code()] if position_type == 'main' else None
        }

        self.positions.append(position)

        # 记录交易（内存）
        trade_record = {
            '交易日期': trade_date,
            '交易类型': '开仓',
            '仓位类型': position_type,
            '策略类型': StrategyType.BULL_SPREAD.value,  # 新增字段
            'ETF标的': self.underlying_symbol,
            '买购期权价格': buy_call['price'],
            '买购期权行权价': buy_call['exercise_price'],
            '买购期权到期日': buy_call['expiry_date'],
            '卖购期权价格': sell_call['price'],
            '卖购期权行权价': sell_call['exercise_price'],
            '卖购期权到期日': sell_call['expiry_date'],
            '合约数量': contract_size,
            'ETF价格': etf_price,
            '单张最大盈利': profit_info['max_profit_per_contract'],
            '单张最小盈利': profit_info['min_profit_per_contract'],
            '总最大盈利': profit_info['total_max_profit'],
            '总最小盈利': profit_info['total_min_profit']
        }
        self.trade_records.append(trade_record)
        
        # 保存交易记录到CSV（如果需要）
        if save_to_csv:
            self.save_transaction_to_csv(trade_record)

        return position

    def try_bull_spread_strategy(self, trade_date, etf_price, month_idx, position_type='main', silent=False, save_to_csv=True):
        """尝试牛差策略：深度实值买购+卖购期权"""
        
        # 1. 先尝试当月牛差策略
        buy_call, sell_call, reason = self.try_bull_spread_for_month(trade_date, etf_price, month_idx, is_current_month=True, silent=silent)
        
        if buy_call and sell_call:
            if not silent:
                print(f"  当月牛差策略匹配成功，执行开仓")
            return self._create_bull_spread_position(trade_date, etf_price, buy_call, sell_call, position_type, silent, save_to_csv), None
        
        # 2. 当月失败，尝试下月牛差策略
        # 计算下个月的月份索引
        trade_date_obj = trade_date.date() if hasattr(trade_date, 'date') else trade_date
        current_year = trade_date_obj.year
        current_month = trade_date_obj.month
        
        # 计算下个月
        if current_month == 12:
            next_year = current_year + 1
            next_month = 1
        else:
            next_year = current_year
            next_month = current_month + 1
        
        # 下个月第一天和最后一天
        next_month_start = pd.to_datetime(f'{next_year}-{next_month:02d}-01').date()
        if next_month == 12:
            next_month_end = pd.to_datetime(f'{next_year + 1}-01-01').date() - pd.Timedelta(days=1)
        else:
            next_month_end = pd.to_datetime(f'{next_year}-{next_month + 1:02d}-01').date() - pd.Timedelta(days=1)
        
        # 查找对应的月份索引
        next_month_idx = None
        for i, month_date in enumerate(self.month_split[:-1]):
            month_start = month_date.date() if hasattr(month_date, 'date') else month_date
            month_end = self.month_split[i + 1].date() if hasattr(self.month_split[i + 1], 'date') else self.month_split[i + 1]
            
            # 检查下月范围是否与month_split中的某个月份重叠
            if (next_month_start <= month_end and next_month_end >= month_start):
                next_month_idx = i
                break
        
        if next_month_idx is None:
            if not silent:
                print(f"  无法找到下月({next_year}-{next_month:02d})对应的月份索引")
            return None, f"牛差策略失败: 当月原因({reason})，且无下月期权可用"
        
        buy_call_next, sell_call_next, reason_next = self.try_bull_spread_for_month(trade_date, etf_price, next_month_idx, is_current_month=False, silent=silent)
        
        if buy_call_next and sell_call_next:
            if not silent:
                print(f"  下月牛差策略匹配成功，执行开仓")
            return self._create_bull_spread_position(trade_date, etf_price, buy_call_next, sell_call_next, position_type, silent, save_to_csv), None
  
        # 两个月份都失败
        combined_reason = f"当月失败({reason})，下月失败({reason_next})"
        return None, f"牛差策略失败: {combined_reason}"

    def open_position(self, trade_date, etf_price, position_type='main', silent=False, save_to_csv=True):
        """开仓方法 - 牛差策略（深度实值买购+卖购）"""
        # 确定月份索引
        month_idx = 0
        for i, month_date in enumerate(self.month_split[:-1]):
            if trade_date >= month_date:
                month_idx = i
        
        # 先输出开始尝试的日志，确保顺序正确
        if not silent:
            print(f"{trade_date.strftime('%Y-%m-%d')} 开始尝试牛差策略")
        
        # 尝试牛差策略（深度实值买购+卖购）
        result, reason = self.try_bull_spread_strategy(trade_date, etf_price, month_idx, position_type, silent, save_to_csv)
        if result is not None:
            return result
        
        # 牛差策略失败，输出详细原因
        print(f"{trade_date.strftime('%Y-%m-%d')} 牛差策略开仓失败，原因：{reason}")
        return None

    def should_close_position(self, position, current_date, etf_price):
        """判断是否应该平仓 - 支持两种策略类型"""
        if position['status'] != 'open':
            return False, None
        
        # 获取策略类型，兼容旧版本数据
        strategy_type = position.get('strategy_type', StrategyType.BULL_SPREAD)
        
        # 检查合约到期时间
        expiry_date = pd.to_datetime(position['sell_call']['expiry_date'])
        # 确保日期格式正确
        current_date_obj = current_date.date() if hasattr(current_date, 'date') else current_date
        expiry_date_obj = expiry_date.date() if hasattr(expiry_date, 'date') else expiry_date
        days_to_expiry = len(get_trade_days(current_date_obj, expiry_date_obj)) - 1
        
        # 到期日临近（对所有策略类型都适用）
        if days_to_expiry <= self.config['max_days_before_expiry']:
            return True, '过期时间平仓'
        
        # 获取卖购行权价
        sell_call_strike = position['sell_call']['exercise_price']
        
        # 牛差策略的平仓逻辑：根据ETF价格与卖购行权价关系选择条件
        if etf_price >= sell_call_strike:
            # ETF价格大于等于卖购行权价时，检查最大盈利平仓条件
            return self._check_max_profit_close_condition(position, current_date, etf_price, sell_call_strike)
        else:
            # ETF价格小于卖购行权价时，检查卖购权利金剩余平仓条件
            return self._check_sell_call_close_condition(position, current_date, etf_price, sell_call_strike)

        return False, None
    

    
    def _check_max_profit_close_condition(self, position, current_date, etf_price, sell_call_strike):
        """检查最大盈利平仓条件（牛差策略专用）"""
        try:
            query_date = current_date.date() if hasattr(current_date, 'date') else current_date
            
            # 获取买购期权价格
            q_buy_price = query(opt.OPT_DAILY_PRICE.close).filter(
                opt.OPT_DAILY_PRICE.code == position['buy_call']['code'],
                opt.OPT_DAILY_PRICE.date == query_date
            )
            buy_price_result = opt.run_query(q_buy_price)
            
            # 获取卖购期权价格
            q_sell_price = query(opt.OPT_DAILY_PRICE.close).filter(
                opt.OPT_DAILY_PRICE.code == position['sell_call']['code'],
                opt.OPT_DAILY_PRICE.date == query_date
            )
            sell_price_result = opt.run_query(q_sell_price)
            
            if not buy_price_result.empty and not sell_price_result.empty:
                current_buy_call_price = buy_price_result['close'].iloc[0]
                current_sell_call_price = sell_price_result['close'].iloc[0]

                # 计算当前盈利
                buy_call_pnl = (current_buy_call_price - position['buy_call']['price']) * 10000
                sell_call_pnl = (position['sell_call']['price'] - current_sell_call_price) * 10000
                current_pnl_per_contract = buy_call_pnl + sell_call_pnl
                
                # 获取最大盈利
                max_profit_per_contract = position['profit_info']['max_profit_per_contract']
                
                # 判断是否达到平仓阈值
                if max_profit_per_contract > 0 and current_pnl_per_contract >= max_profit_per_contract * self.config['max_profit_close_threshold']:
                    print(f"{current_date.strftime('%Y-%m-%d')} 触发最大盈利平仓: 当前盈利: {current_pnl_per_contract:.2f}, 最大盈利: {max_profit_per_contract:.2f}")
                    return True, '最大盈利平仓'

        except Exception as e:
            print(f"{current_date.strftime('%Y-%m-%d')} 检查最大盈利平仓条件时出错: {e}")
        
        return False, None
    
    def _check_sell_call_close_condition(self, position, current_date, etf_price, sell_call_strike):
        """检查卖购权利金剩余平仓条件（两种策略共用）"""
        try:
            query_date = current_date.date() if hasattr(current_date, 'date') else current_date
            q_price = query(opt.OPT_DAILY_PRICE.close).filter(
                opt.OPT_DAILY_PRICE.code == position['sell_call']['code'],
                opt.OPT_DAILY_PRICE.date == query_date
            )
            price_result = opt.run_query(q_price)
            if not price_result.empty:
                current_sell_call_price = price_result['close'].iloc[0]
                if current_sell_call_price < self.config['put_close_premium_threshold']:
                    print(f"{current_date.strftime('%Y-%m-%d')} 触发卖购权利金平仓: 卖购期权价格{current_sell_call_price:.4f}")
                    return True, '卖购权利金平仓'
        except Exception as e:
            print(f"{current_date.strftime('%Y-%m-%d')} 检查卖购权利金平仓条件时出错: {e}")
        
        return False, None
    

    


    def close_position(self, position, current_date, etf_price, reason):
        """平仓操作 - 支持两种策略类型"""
        try:
            # 获取策略类型，兼容旧版本数据
            strategy_type = position.get('strategy_type', StrategyType.BULL_SPREAD)
            
            query_date = current_date.date() if hasattr(current_date, 'date') else current_date
            
            # 获取卖购期权当前价格（两种策略都需要）
            q_sell_price = query(opt.OPT_DAILY_PRICE.close).filter(
                opt.OPT_DAILY_PRICE.code == position['sell_call']['code'],
                opt.OPT_DAILY_PRICE.date == query_date
            )
            sell_price_result = opt.run_query(q_sell_price)
            if sell_price_result.empty:
                raise Exception(f"无法获取卖购期权{position['sell_call']['code']}在{query_date}的价格数据")
            sell_call_close_price = sell_price_result['close'].iloc[0]
            
            # 计算卖购期权盈亏
            sell_call_pnl = (position['sell_call']['price'] - sell_call_close_price) * position['contract_size'] * 10000
            
            # 获取买购期权当前价格
            q_buy_price = query(opt.OPT_DAILY_PRICE.close).filter(
                opt.OPT_DAILY_PRICE.code == position['buy_call']['code'],
                opt.OPT_DAILY_PRICE.date == query_date
            )
            buy_price_result = opt.run_query(q_buy_price)
            if buy_price_result.empty:
                raise Exception(f"无法获取买购期权{position['buy_call']['code']}在{query_date}的价格数据")
            buy_call_close_price = buy_price_result['close'].iloc[0]
            
            buy_call_pnl = (buy_call_close_price - position['buy_call']['price']) * position['contract_size'] * 10000
            total_pnl = buy_call_pnl + sell_call_pnl - 10  # 两种策略都扣除相同手续费
            
            # 牛差策略平仓详情输出
            print(f"{current_date.strftime('%Y-%m-%d')} 牛差策略平仓详情：")
            print(f"  深度实值买购：开仓价格{position['buy_call']['price']:.4f} -> 平仓价格{buy_call_close_price:.4f}")
            print(f"  深度实值买购盈亏：({buy_call_close_price:.4f} - {position['buy_call']['price']:.4f}) × {position['contract_size']} × 10000 = {buy_call_pnl:.2f}元")
            print(f"  卖购期权：开仓价格{position['sell_call']['price']:.4f} -> 平仓价格{sell_call_close_price:.4f}")
            print(f"  卖购期权盈亏：({position['sell_call']['price']:.4f} - {sell_call_close_price:.4f}) × {position['contract_size']} × 10000 = {sell_call_pnl:.2f}元")
            print(f"  手续费：-10元")
            print(f"  组合总盈亏：{buy_call_pnl:.2f} + {sell_call_pnl:.2f} - 10 = {total_pnl:.2f}元")
            
            # 更新仓位状态
            position['status'] = 'closed'
            position['close_date'] = current_date
            position['close_etf_price'] = etf_price
            position['close_reason'] = reason
            position['buy_call_close_price'] = buy_call_close_price
            position['sell_call_close_price'] = sell_call_close_price
            position['pnl'] = total_pnl

            # 记录交易（内存）- 两种策略都有买购期权信息
            trade_record = {
                '交易日期': current_date,
                '交易类型': '平仓',
                '仓位类型': position['position_type'],
                '策略类型': strategy_type.value,  # 策略类型字段
                'ETF标的': self.underlying_symbol,
                '买购期权价格': position['buy_call']['price'],  # 两种策略都有买购期权
                '买购期权行权价': position['buy_call']['exercise_price'],
                '买购期权到期日': position['buy_call']['expiry_date'],
                '卖购期权价格': position['sell_call']['price'],
                '卖购期权行权价': position['sell_call']['exercise_price'],
                '卖购期权到期日': position['sell_call']['expiry_date'],
                '合约数量': position['contract_size'],
                'ETF价格': etf_price,
                '买购期权收盘价': buy_call_close_price,
                '卖购期权收盘价': sell_call_close_price,
                '开仓日期': position['open_date'],
                '开仓ETF价格': position['etf_price'],
                '买购期权盈亏': buy_call_pnl,
                '卖购期权盈亏': sell_call_pnl,
                '总盈亏': total_pnl,
                '平仓原因': reason,
                '单张最大盈利': '',  # 平仓时不需要，保持字段一致性
                '单张最小盈利': '',  # 平仓时不需要，保持字段一致性
                '总最大盈利': '',   # 平仓时不需要，保持字段一致性
                '总最小盈利': ''    # 平仓时不需要，保持字段一致性
            }
            self.trade_records.append(trade_record)
            
            # 保存交易记录到CSV
            self.save_transaction_to_csv(trade_record)

        except Exception as e:
            print(f"平仓时出错: {e}")
            position['status'] = 'error'

    def should_add_position(self, current_date, etf_price):
        """判断是否应该加仓"""
        # 检查是否有主仓位
        main_positions = [p for p in self.positions if p['position_type'] == 'main' and p['status'] == 'open']
        if not main_positions:
            return False

        # 获取最新主仓位
        latest_main_position = main_positions[-1]

        # 检查加仓次数是否超限
        add_positions = [p for p in self.positions if p['position_type'] == 'add' and p['status'] == 'open']
        if len(add_positions) >= self.config['max_add_positions']:
            return False
        
        # 检查是否触发加仓条件
        trigger_price = latest_main_position['add_position_trigger_price']
        
        if trigger_price and etf_price <= trigger_price:
                return True

        return False

    def save_transaction_to_csv(self, transaction_data):
        """保存交易记录到CSV文件"""
        try:
            # 数据验证 - 确保必需字段存在
            required_fields = ['交易日期', '交易类型', '仓位类型', 'ETF标的', '合约数量', 'ETF价格']
            for field in required_fields:
                if field not in transaction_data or transaction_data[field] is None:
                    print(f"警告: 交易记录缺少必需字段 {field}，跳过保存")
                    return
            
            # 数据验证 - 确保数据类型正确
            if not isinstance(transaction_data.get('合约数量'), (int, float)) or transaction_data.get('合约数量') <= 0:
                print(f"警告: 合约数量无效 {transaction_data.get('合约数量')}，跳过保存")
                return
            
            if not isinstance(transaction_data.get('ETF价格'), (int, float)) or transaction_data.get('ETF价格') <= 0:
                print(f"警告: ETF价格无效 {transaction_data.get('ETF价格')}，跳过保存")
                return
            
            # 复制数据并标准化格式
            data_copy = transaction_data.copy()
            
            # 定义完整的字段顺序，确保开仓和平仓记录字段一致
            standard_fields = [
                '交易日期', '交易类型', '仓位类型', '策略类型', 'ETF标的',  # 新增策略类型字段
                '买购期权价格', '买购期权行权价', '买购期权到期日',
                '卖购期权价格', '卖购期权行权价', '卖购期权到期日',
                '合约数量', 'ETF价格',
                '单张最大盈利', '单张最小盈利', '总最大盈利', '总最小盈利',
                '买购期权收盘价', '卖购期权收盘价', '开仓日期', '开仓ETF价格',
                '买购期权盈亏', '卖购期权盈亏', '总盈亏', '平仓原因'
            ]
            
            # 确保所有字段都存在，缺失的用空字符串填充
            standardized_data = {}
            for field in standard_fields:
                standardized_data[field] = data_copy.get(field, '')
            
            # 转换日期字段为YYYY-MM-DD格式
            date_fields = ['交易日期', '买购期权到期日', '卖购期权到期日', '开仓日期']
            for field in date_fields:
                if standardized_data[field] and standardized_data[field] != '':
                    try:
                        if hasattr(standardized_data[field], 'strftime'):
                            standardized_data[field] = standardized_data[field].strftime('%Y-%m-%d')
                        elif hasattr(standardized_data[field], 'date'):
                            standardized_data[field] = standardized_data[field].date().strftime('%Y-%m-%d')
                        else:
                            # 如果是字符串，尝试解析后转换
                            date_obj = pd.to_datetime(standardized_data[field])
                            standardized_data[field] = date_obj.strftime('%Y-%m-%d')
                    except:
                        print(f"警告: 无法转换日期字段 {field}: {standardized_data[field]}")
                        pass  # 保持原值
            
            # 检查文件是否存在
            file_exists = os.path.exists(self.transaction_csv_path)
            
            # 转换为DataFrame，保持字段顺序
            df = pd.DataFrame([standardized_data], columns=standard_fields)
            
            # 保存到CSV
            if file_exists:
                df.to_csv(self.transaction_csv_path, mode='a', header=False, index=False, encoding='utf-8-sig')
            else:
                df.to_csv(self.transaction_csv_path, mode='w', header=True, index=False, encoding='utf-8-sig')
                
        except Exception as e:
            print(f"保存交易记录到CSV时出错: {e}")
            print(f"问题数据: {transaction_data}")
    
    def save_daily_position_to_csv(self, position_data):
        """保存每日持仓记录到CSV文件"""
        try:
            # 复制数据并标准化日期格式
            data_copy = position_data.copy()
            
            # 转换日期字段为YYYY-MM-DD格式（使用中文字段名）
            if '交易日期' in data_copy and data_copy['交易日期'] is not None:
                if hasattr(data_copy['交易日期'], 'strftime'):
                    data_copy['交易日期'] = data_copy['交易日期'].strftime('%Y-%m-%d')
                elif hasattr(data_copy['交易日期'], 'date'):
                    data_copy['交易日期'] = data_copy['交易日期'].date().strftime('%Y-%m-%d')
                else:
                    # 如果是字符串，尝试解析后转换
                    try:
                        date_obj = pd.to_datetime(data_copy['交易日期'])
                        data_copy['交易日期'] = date_obj.strftime('%Y-%m-%d')
                    except:
                        pass  # 保持原值
            
            # 处理持仓详情字段 - 将列表转换为字符串
            if '持仓详情' in data_copy and isinstance(data_copy['持仓详情'], list):
                if data_copy['持仓详情']:  # 如果列表不为空
                    detail_strings = []
                    for detail in data_copy['持仓详情']:
                        detail_str = f"{detail['期权类别']}:{detail['持仓标的代码']}@{detail['行权价格']:.2f}×{detail['合约数量']}(盈亏{detail['盈亏金额']:.2f})"
                        detail_strings.append(detail_str)
                    data_copy['持仓详情'] = '; '.join(detail_strings)
                else:
                    data_copy['持仓详情'] = '无持仓'
            
            # 添加到每日持仓列表
            self.daily_positions.append(data_copy)
            
            # 创建DataFrame，排除列表类型的复杂字段
            csv_data = {k: v for k, v in data_copy.items() if not isinstance(v, list)}
            df = pd.DataFrame([csv_data])
            
            # 检查文件是否存在
            file_exists = os.path.exists(self.position_csv_path)
            
            # 保存到CSV
            if file_exists:
                df.to_csv(self.position_csv_path, mode='a', header=False, index=False, encoding='utf-8-sig')
            else:
                df.to_csv(self.position_csv_path, mode='w', header=True, index=False, encoding='utf-8-sig')
                
        except Exception as e:
            print(f"保存持仓记录到CSV时出错: {e}")
            print(f"问题数据: {position_data}")

    def record_daily_positions(self, trade_date, etf_price):
        """记录每日持仓状况"""
        # 获取当前所有开仓状态的持仓
        open_positions = [p for p in self.positions if p['status'] == 'open']
        
        if not open_positions:
            # 如果没有持仓，记录一条空仓记录
            position_record = {
                '交易日期': trade_date,
                'ETF价格': etf_price,
                '总仓位数': 0,
                '主仓位数': 0,
                '加仓仓位数': 0,
                '总合约数': 0,
                '总组合盈亏': 0,
                '总卖购盈亏': 0,
                '总买购盈亏': 0,
                '持仓详情': []
            }
            self.save_daily_position_to_csv(position_record)
            return
        
        # 统计持仓信息
        main_positions = [p for p in open_positions if p['position_type'] == 'main']
        add_positions = [p for p in open_positions if p['position_type'] == 'add']
        total_contracts = sum(p['contract_size'] for p in open_positions)
        
        # 记录详细持仓信息
        position_details = []
        total_combo_pnl = 0
        total_sell_call_pnl = 0
        total_buy_call_pnl = 0
        
        for i, pos in enumerate(open_positions):
            # 获取策略类型，兼容旧版本数据
            strategy_type = pos.get('strategy_type', StrategyType.BULL_SPREAD)
            
            # 获取当前期权价值（尽量获取，失败则使用开仓价格）
            try:
                query_date = trade_date.date() if hasattr(trade_date, 'date') else trade_date
                
                # 获取卖购期权当前价格（两种策略都需要）
                q_sell_price = query(opt.OPT_DAILY_PRICE.close).filter(
                    opt.OPT_DAILY_PRICE.code == pos['sell_call']['code'],
                    opt.OPT_DAILY_PRICE.date == query_date
                )
                sell_price_result = opt.run_query(q_sell_price)
                if sell_price_result.empty:
                    raise Exception("无法获取卖购期权价格数据")
                sell_call_current_price = sell_price_result['close'].iloc[0]
                
                # 计算卖购期权盈亏
                sell_call_pnl = (pos['sell_call']['price'] - sell_call_current_price) * pos['contract_size'] * 10000
                
                # 两种策略都有买购期权，需要计算买购期权盈亏
                q_buy_price = query(opt.OPT_DAILY_PRICE.close).filter(
                    opt.OPT_DAILY_PRICE.code == pos['buy_call']['code'],
                    opt.OPT_DAILY_PRICE.date == query_date
                )
                buy_price_result = opt.run_query(q_buy_price)
                if buy_price_result.empty:
                    raise Exception("无法获取买购期权价格数据")
                buy_call_current_price = buy_price_result['close'].iloc[0]
                
                buy_call_pnl = (buy_call_current_price - pos['buy_call']['price']) * pos['contract_size'] * 10000
                combo_pnl = buy_call_pnl + sell_call_pnl
                
            except:
                # 两种策略都有买购期权，异常处理相同
                buy_call_current_price = pos['buy_call']['price']
                sell_call_current_price = pos['sell_call']['price']
                buy_call_pnl = 0
                sell_call_pnl = 0
                combo_pnl = 0
            
            # 累计总盈亏
            total_combo_pnl += combo_pnl
            total_sell_call_pnl += sell_call_pnl
            total_buy_call_pnl += buy_call_pnl
            
            # 牛差策略：记录深度实值买购和卖购期权
            buy_call_detail = {
                '持仓标的代码': pos['buy_call']['code'],
                '期权类别': '买购（牛差）',
                '合约数量': pos['contract_size'],
                '行权价格': pos['buy_call']['exercise_price'],
                '成本价格': pos['buy_call']['price'],
                '当前价格': buy_call_current_price,
                '盈亏金额': buy_call_pnl,
                '仓位类型': pos['position_type'],
                '策略类型': '牛差组合',
                '开仓日期': pos['open_date']
            }
            
            sell_call_detail = {
                '持仓标的代码': pos['sell_call']['code'],
                '期权类别': '卖购（牛差）',
                '合约数量': pos['contract_size'],
                '行权价格': pos['sell_call']['exercise_price'],
                '成本价格': pos['sell_call']['price'],
                '当前价格': sell_call_current_price,
                '盈亏金额': sell_call_pnl,
                '仓位类型': pos['position_type'],
                '策略类型': '牛差组合',
                '开仓日期': pos['open_date']
            }
            
            position_details.extend([buy_call_detail, sell_call_detail])
        
        # 记录每日持仓汇总
        position_record = {
            '交易日期': trade_date,
            'ETF价格': etf_price,
            '总仓位数': len(open_positions),
            '主仓位数': len(main_positions),
            '加仓仓位数': len(add_positions),
            '总合约数': total_contracts,
            '总组合盈亏': total_combo_pnl,
            '总卖购盈亏': total_sell_call_pnl,
            '总买购盈亏': total_buy_call_pnl,
            '持仓详情': position_details
        }
        
        self.save_daily_position_to_csv(position_record)
        
        # 注释掉单独的账户管理器回调，改为在多标的管理器中统一处理
        # 通知账户管理器更新每日汇总
        # if self.account_manager_callback:
        #     try:
        #         self.account_manager_callback(trade_date)
        #     except Exception as e:
        #         print(f"{trade_date.strftime('%Y-%m-%d')} 更新账户汇总回调出错: {e}")

    def run_strategy(self):
        """运行策略主逻辑"""
        print("开始运行深度实值买购和卖购组合的牛差策略...")
        
        for i, trade_date in enumerate(self.trade_days.index):
            # 获取ETF价格
            try:
                price_data = get_price(self.underlying_symbol, trade_date, trade_date, fields=['close'])['close']
                # print(f"{trade_date.strftime('%Y-%m-%d')} 获取ETF价格: {price_data.iloc[0]:.4f}")
                if price_data.empty:
                    print(f"{trade_date.strftime('%Y-%m-%d')} 获取ETF价格失败，因为price_data为空")
                    continue
                etf_price = price_data.iloc[0]
            except:
                print(f"{trade_date.strftime('%Y-%m-%d')} 获取ETF价格失败，因为获取{self.underlying_symbol}价格失败")
                continue

            # 记录每日持仓状况
            self.record_daily_positions(trade_date, etf_price)
            
            # 标记是否有交易发生
            has_trading = False
            
            # 检查是否需要平仓
            if len(self.positions) > 0:
                for position in self.positions:
                    should_close, reason = self.should_close_position(position, trade_date, etf_price)
                    # print(f"{trade_date.strftime('%Y-%m-%d')} 检查是否需要平仓: {should_close}, 平仓原因: {reason}")
                    if should_close:
                        self.close_position(position, trade_date, etf_price, reason)
                        print(f"{trade_date.strftime('%Y-%m-%d')} 平仓: {reason}, ETF价格: {etf_price:.4f}")
                        has_trading = True

            # 检查是否需要开新仓（首次开仓或平仓后重新开仓）
            open_positions = [p for p in self.positions if p['status'] == 'open']
            if not open_positions:
                new_position = self.open_position(trade_date, etf_price, 'main')  # 使用新的统一开仓方法
                if new_position:
                    max_profit = new_position['profit_info']['total_max_profit']
                    contract_size = new_position['contract_size']
                    
                    # 牛差策略输出
                    strategy_desc = f"牛差组合: 深度实值买购{new_position['buy_call']['exercise_price']:.2f}@{new_position['buy_call']['price']:.4f}, 卖购{new_position['sell_call']['exercise_price']:.2f}@{new_position['sell_call']['price']:.4f}"
                    profit_desc = f"最大牛差收益: {max_profit:.2f}元"
                    
                    # 获取资金信息（如果有的话）
                    if hasattr(self, 'config') and 'allocated_capital' in self.config:
                        allocated_capital = self.config.get('allocated_capital', 0)
                        estimated_margin = contract_size * 1000  # 每张约1000元保证金（粗略估算）
                        print(f"{trade_date.strftime('%Y-%m-%d')} 开仓主仓位: {strategy_desc}, ETF价格: {etf_price:.4f}, 合约数量: {contract_size}张, {profit_desc}, 可用资金: {allocated_capital:.0f}元, 预估保证金: {estimated_margin:.0f}元")
                    else:
                        print(f"{trade_date.strftime('%Y-%m-%d')} 开仓主仓位: {strategy_desc}, ETF价格: {etf_price:.4f}, 合约数量: {contract_size}张, {profit_desc}")
                    has_trading = True
            
            # 检查是否需要加仓
            elif self.should_add_position(trade_date, etf_price):
                add_position = self.open_position(trade_date, etf_price, 'add', silent=False)  # 使用新的统一开仓方法
                if add_position:
                    max_profit = add_position['profit_info']['total_max_profit']
                    contract_size = add_position['contract_size']
                    
                    # 牛差策略输出
                    strategy_desc = f"牛差组合: 深度实值买购{add_position['buy_call']['exercise_price']:.2f}@{add_position['buy_call']['price']:.4f}, 卖购{add_position['sell_call']['exercise_price']:.2f}@{add_position['sell_call']['price']:.4f}"
                    profit_desc = f"最大牛差收益: {max_profit:.2f}元"
                    
                    # 获取资金信息（如果有的话）
                    if hasattr(self, 'config') and 'allocated_capital' in self.config:
                        allocated_capital = self.config.get('allocated_capital', 0)
                        estimated_margin = contract_size * 1000  # 每张约1000元保证金（粗略估算）
                        print(f"{trade_date.strftime('%Y-%m-%d')} 加仓: {strategy_desc}, ETF价格: {etf_price:.4f}, 合约数量: {contract_size}张, {profit_desc}, 可用资金: {allocated_capital:.0f}元, 预估保证金: {estimated_margin:.0f}元")
                    else:
                        print(f"{trade_date.strftime('%Y-%m-%d')} 加仓: {strategy_desc}, ETF价格: {etf_price:.4f}, 合约数量: {contract_size}张, {profit_desc}")
                    has_trading = True
            
            # 更新前一日ETF价格，用于下一天计算涨幅
            self.previous_etf_price = etf_price
        
        print("策略运行完成!")
    
    def get_performance_summary(self):
        """获取策略表现总结"""
        if not self.trade_records:
            return "没有交易记录"
        
        closed_positions = [p for p in self.positions if p['status'] == 'closed']
        if not closed_positions:
            return "没有已平仓的交易"
        
        total_pnl = sum(p['pnl'] for p in closed_positions)
        winning_trades = len([p for p in closed_positions if p['pnl'] > 0])
        total_trades = len(closed_positions)
        win_rate = winning_trades / total_trades if total_trades > 0 else 0
        
        summary = f"""
策略表现总结:
=============
总交易次数: {total_trades}
获利交易: {winning_trades}
胜率: {win_rate:.2%}
总盈亏: {total_pnl:.2f}元
平均每笔盈亏: {total_pnl/total_trades:.2f}元
        """
        return summary
    
    def plot_results(self):
        """绘制策略结果"""
        if not self.daily_positions:
            print("没有持仓数据可以绘制")
            return

        # 使用每日持仓记录绘制盈亏曲线
        position_df = pd.DataFrame(self.daily_positions)
        
        # 过滤有持仓的记录（排除空仓记录，但保留盈亏为0的记录用于显示完整曲线）
        position_data = position_df.copy()
        
        if position_data.empty:
            print("没有持仓数据可以绘制")
            return
        
        # 确保交易日期是datetime格式
        position_data['交易日期'] = pd.to_datetime(position_data['交易日期'])
        position_data = position_data.sort_values('交易日期')
        
        # 确保盈亏字段为数值类型
        position_data['总组合盈亏'] = pd.to_numeric(position_data['总组合盈亏'], errors='coerce').fillna(0)
        position_data['总卖购盈亏'] = pd.to_numeric(position_data['总卖购盈亏'], errors='coerce').fillna(0)
        
        # 绘图
        fig, ax = plt.subplots(1, 1, figsize=(12, 8))
        
        # 绘制两条盈亏曲线
        ax.plot(position_data['交易日期'], position_data['总组合盈亏'], 
                label='每日组合浮动盈亏（买购+卖购）', color='blue', linewidth=2)
        ax.plot(position_data['交易日期'], position_data['总卖购盈亏'], 
                label='每日卖购浮动盈亏', color='red', linewidth=2, linestyle='--')
        
        # 添加零线
        ax.axhline(y=0, color='black', linestyle='-', alpha=0.3)
        
        ax.set_title(f'{self.get_underlying_code()}策略每日浮动盈亏对比', fontsize=14)
        ax.set_ylabel('浮动盈亏 (元)', fontsize=12)
        ax.set_xlabel('日期', fontsize=12)
        ax.legend(fontsize=10)
        ax.grid(True, alpha=0.3)
        
        # 格式化日期显示
        import matplotlib.dates as mdates
        ax.xaxis.set_major_formatter(mdates.DateFormatter('%Y-%m-%d'))
        ax.xaxis.set_major_locator(mdates.MonthLocator())
        plt.xticks(rotation=45)
        
        # 添加数据标注
        if len(position_data) > 0:
            final_combo_pnl = position_data['总组合盈亏'].iloc[-1]
            final_sell_pnl = position_data['总卖购盈亏'].iloc[-1]
            max_combo_pnl = position_data['总组合盈亏'].max()
            min_combo_pnl = position_data['总组合盈亏'].min()
            
            ax.text(0.02, 0.98, 
                   f'当前组合浮盈: {final_combo_pnl:.2f}元\n'
                   f'当前卖购浮盈: {final_sell_pnl:.2f}元\n'
                   f'最大组合浮盈: {max_combo_pnl:.2f}元\n'
                   f'最大组合浮亏: {min_combo_pnl:.2f}元', 
                   transform=ax.transAxes, fontsize=10, verticalalignment='top',
                   bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.8))

        plt.tight_layout()
        plt.show()

# 策略配置类
class StrategyConfig:
    """策略配置管理"""
    
    def __init__(self):
        # ETF标的配置字典
        self.etf_symbols = {
            # '50ETF': '510050.XSHG',    # 上证50ETF
            # '300ETF': '510300.XSHG',   # 沪深300ETF
            '创业板ETF': '159915.XSHE'    # 创业板ETF
        }
        
        # 时间范围配置
        self.time_config = {
            'start_date': '2024-06-01',
            'end_date': '2024-08-31'
        }
        
        # 资金配置
        self.capital_config = {
            'total_capital': 1000000,  # 总资金额度（100万）
            'capital_allocation': {    # 不同标的资金分配比例
                '50ETF': 0.3,   # 50ETF 30%
                '300ETF': 0.5,  # 300ETF 50%
                '创业板ETF': 0.2   # 创业板ETF 20%
            },
            'capital_usage_limit': 0.8,  # 资金使用上限80%
            'bull_spread_margin_discount': 30,  # 牛差组合策略保证金优惠（每单位组合加收30元）
            'contract_unit': 10000,  # 合约单位（1张期权代表10000份标的）
            'margin_params': {  # 保证金计算参数
                'volatility_factor': 0.12,  # 波动率因子12%
                'min_margin_factor': 0.07   # 最小保证金因子7%
            }
        }
    
    def get_allocated_capital(self, etf_code):
        """获取指定ETF的分配资金"""
        total_usable = self.capital_config['total_capital'] * self.capital_config['capital_usage_limit']
        
        # 获取实际存在的ETF列表
        available_etfs = list(self.etf_symbols.keys())
        
        # 计算实际存在ETF的原始比例总和
        original_allocation = self.capital_config['capital_allocation']
        available_ratio_sum = sum(original_allocation.get(etf, 0) for etf in available_etfs)
        
        if available_ratio_sum == 0:
            print(f"警告: 无可用ETF或比例配置错误，{etf_code}分配资金为0")
            return 0
        
        # 获取当前ETF的原始比例
        original_ratio = original_allocation.get(etf_code, 0)
        
        if original_ratio == 0:
            print(f"警告: {etf_code}未在capital_allocation中配置，分配资金为0")
            return 0
        
        # 重新调整比例：当前ETF比例 / 实际存在ETF的比例总和
        adjusted_ratio = original_ratio / available_ratio_sum
        
        allocated_capital = total_usable * adjusted_ratio
        
        print(f"资金分配调整 - {etf_code}: 原始比例{original_ratio:.1%}, 调整后比例{adjusted_ratio:.1%}, 分配资金{allocated_capital:,.0f}元")
        
        return allocated_capital
    
    def calculate_option_margin(self, option_type, settlement_price, underlying_price, strike_price):
        """
        计算单张期权的保证金
        :param option_type: 'call' 或 'put'
        :param settlement_price: 合约前结算价
        :param underlying_price: 标的证券前收盘价
        :param strike_price: 行权价
        :return: 单张期权保证金
        """
        contract_unit = self.capital_config['contract_unit']
        volatility_factor = self.capital_config['margin_params']['volatility_factor']
        min_margin_factor = self.capital_config['margin_params']['min_margin_factor']
        
        if option_type == 'call':
            # 认购期权虚值 = max(行权价 - 标的价格, 0)
            out_of_money = max(strike_price - underlying_price, 0)
            margin = (settlement_price + max(
                volatility_factor * underlying_price - out_of_money,
                min_margin_factor * underlying_price
            )) * contract_unit
        elif option_type == 'put':
            # 认沽期权虚值 = max(标的价格 - 行权价, 0)
            out_of_money = max(underlying_price - strike_price, 0)
            margin = min(
                settlement_price + max(
                    volatility_factor * underlying_price - out_of_money,
                    min_margin_factor * strike_price
                ),
                strike_price
            ) * contract_unit
        else:
            raise ValueError("option_type must be 'call' or 'put'")
        
        return margin
    
    def calculate_bull_spread_margin(self, buy_call_info, sell_call_info, underlying_price):
        """
        计算牛差组合的保证金
        :param buy_call_info: 买入认购期权信息
        :param sell_call_info: 卖出认购期权信息
        :param underlying_price: 标的价格
        :return: 牛差组合保证金
        """
        # 计算行权价差
        strike_diff = sell_call_info['exercise_price'] - buy_call_info['exercise_price']
        contract_unit = self.capital_config['contract_unit']
        margin_discount = self.capital_config['bull_spread_margin_discount']
        
        # 判断组合类型
        if strike_diff > 0:
            # 传统牛差组合（买购行权价 < 卖购行权价）
            # 保证金 = 行权价差 * 合约单位 + 保证金优惠
            bull_spread_margin = strike_diff * contract_unit + margin_discount
        else:
            # 其他情况的保证金计算
            # 使用净权利金作为保证金基础
            net_premium = buy_call_info['price'] - sell_call_info['price']
            if net_premium > 0:
                # 需要支付净权利金
                bull_spread_margin = abs(net_premium) * contract_unit + margin_discount
            else:
                # 收取净权利金，使用估算保证金
                estimated_margin = max(sell_call_info['price'] * contract_unit * 0.1, 1000)  # 最少1000元保证金
                bull_spread_margin = estimated_margin
        
        return bull_spread_margin
    
    def calculate_contract_size(self, etf_code, etf_price, buy_call_info=None, sell_call_info=None):
        """
        计算可开仓的合约数量
        :param etf_code: ETF代码
        :param etf_price: ETF价格
        :param buy_call_info: 买入认购期权信息（可选，用于牛差组合计算）
        :param sell_call_info: 卖出认购期权信息（可选，用于牛差组合计算）
        """
        allocated_capital = self.get_allocated_capital(etf_code)
        
        if buy_call_info and sell_call_info:
            # 牛差组合保证金计算
            margin_per_contract = self.calculate_bull_spread_margin(buy_call_info, sell_call_info, etf_price)
        else:
            # 单一期权保证金估算（使用卖出认购期权）
            estimated_settlement_price = etf_price * 0.02  # 估算权利金为标的价格的2%
            estimated_strike_price = etf_price * 1.05  # 估算行权价为标的价格的105%
            margin_per_contract = self.calculate_option_margin('call', estimated_settlement_price, etf_price, estimated_strike_price)
        
        # 边界条件检查
        if allocated_capital <= 0:
            print(f"警告: {etf_code} 分配资金无效({allocated_capital})，返回默认合约数量30张")
            return 30
        
        if margin_per_contract <= 0:
            print(f"警告: {etf_code} 保证金计算结果无效({margin_per_contract})，返回默认合约数量30张")
            return 30
        
        max_contracts = int(allocated_capital / margin_per_contract)
        
        # 确保结果为正数
        if max_contracts <= 0:
            print(f"警告: {etf_code} 合约数量计算结果无效({max_contracts})，返回默认合约数量30张")
            return 30
        
        return min(max_contracts, 100)  # 限制最大100张

# 多标的策略管理器
class MultiUnderlyingBullSpreadManager:
    """多标的牛差策略管理器"""
    
    def __init__(self, config: StrategyConfig):
        self.config = config
        self.strategies = {}
        self.daily_account_records = []  # 每日账户资金记录
        self.account_csv_path = 'account_summary.csv'
        self.cumulative_realized_pnl = 0  # 累积已实现盈亏
        self.previous_date_summary = None  # 前一天的账户汇总记录
        self.initialize_strategies()
    
    def initialize_strategies(self):
        """初始化各个标的的策略"""
        for etf_code, symbol in self.config.etf_symbols.items():
            allocated_capital = self.config.get_allocated_capital(etf_code)
            if allocated_capital > 0:
                strategy = DeepITMBullSpreadStrategy(
                    underlying_symbol=symbol,
                    start_date=self.config.time_config['start_date'],
                    end_date=self.config.time_config['end_date']
                )
                
                # 动态调整策略参数
                strategy.config['allocated_capital'] = allocated_capital
                strategy.config['etf_code'] = etf_code
                
                # 设置账户管理器回调
                strategy.account_manager_callback = self.record_daily_account_summary
                
                self.strategies[etf_code] = strategy
                
                print(f"初始化{etf_code}策略，分配资金: {allocated_capital:,.0f}元")
    
    def calculate_dynamic_contract_size(self, strategy, etf_price, buy_call_info=None, sell_call_info=None):
        """动态计算合约数量"""
        etf_code = strategy.config['etf_code']
        return self.config.calculate_contract_size(etf_code, etf_price, buy_call_info, sell_call_info)
    
    def calculate_used_capital(self, strategy):
        """计算策略已使用的资金 - 支持两种策略类型"""
        used_capital = 0
        open_positions = [p for p in strategy.positions if p['status'] == 'open']
        
        for position in open_positions:
            # 获取策略类型，兼容旧版本数据
            strategy_type = position.get('strategy_type', StrategyType.BULL_SPREAD)
            
            # 两种策略都有买购期权，资金使用计算相同
            # 资金使用 = (买购权利金 - 卖购权利金) * 合约数量 * 10000
            net_premium = position['buy_call']['price'] - position['sell_call']['price']
            position_capital = net_premium * position['contract_size'] * 10000
            
            used_capital += position_capital
        
        return used_capital
    
    def record_daily_account_summary(self, trade_date):
        """记录每日账户资金汇总"""
        initial_capital = self.config.capital_config['total_capital']
        total_used_capital = 0
        total_floating_pnl = 0
        total_current_market_value = 0  # 所有策略的当前市值总和
        
        strategy_details = {}
        
        # 计算当天的已实现盈亏（通过检查平仓交易）
        today_realized_pnl = 0
        for etf_code, strategy in self.strategies.items():
            # 检查当天是否有平仓交易
            for trade_record in strategy.trade_records:
                if (trade_record.get('交易类型') == '平仓' and 
                    trade_record.get('交易日期') and
                    trade_record.get('总盈亏') is not None):
                    
                    trade_date_record = trade_record.get('交易日期')
                    if hasattr(trade_date_record, 'date'):
                        trade_date_record = trade_date_record.date()
                    elif isinstance(trade_date_record, str):
                        try:
                            trade_date_record = pd.to_datetime(trade_date_record).date()
                        except:
                            continue
                    
                    target_date = trade_date.date() if hasattr(trade_date, 'date') else trade_date
                    
                    if trade_date_record == target_date:
                        today_realized_pnl += float(trade_record.get('总盈亏', 0))
        
        # 更新累积已实现盈亏
        self.cumulative_realized_pnl += today_realized_pnl
        
        # 汇总各策略的资金使用和浮动盈亏
        total_bull_spread_positions = 0
        
        for etf_code, strategy in self.strategies.items():
            used_capital = self.calculate_used_capital(strategy)
            open_positions = [p for p in strategy.positions if p['status'] == 'open']
            open_positions_count = len(open_positions)
            
            # 统计牛差策略仓位数量
            bull_spread_count = len([p for p in open_positions if p.get('strategy_type', StrategyType.BULL_SPREAD) == StrategyType.BULL_SPREAD])
            
            total_bull_spread_positions += bull_spread_count
            
            # 计算组合当前市值和浮动盈亏
            current_market_value = 0
            floating_pnl = 0
            
            if strategy.daily_positions:
                # 查找指定日期的持仓记录
                target_record = None
                for position_record in strategy.daily_positions:
                    record_date = position_record.get('交易日期')
                    if hasattr(record_date, 'date'):
                        record_date = record_date.date()
                    elif isinstance(record_date, str):
                        try:
                            record_date = pd.to_datetime(record_date).date()
                        except:
                            continue
                    
                    target_date = trade_date.date() if hasattr(trade_date, 'date') else trade_date
                    
                    if record_date == target_date:
                        target_record = position_record
                        break
                
                # 如果找到了对应日期的记录，计算当前市值和浮动盈亏
                if target_record:
                    floating_pnl = target_record.get('总组合盈亏', 0)
                    if isinstance(floating_pnl, str):
                        try:
                            floating_pnl = float(floating_pnl)
                        except:
                            floating_pnl = 0
                    
                    # 计算组合当前市值 = 初始投入成本 + 浮动盈亏
                    current_market_value = used_capital + floating_pnl
            
            total_used_capital += used_capital
            total_floating_pnl += floating_pnl
            total_current_market_value += current_market_value
            
            strategy_details[etf_code] = {
                '分配资金': strategy.config.get('allocated_capital', 0),
                '初始投入': used_capital,
                '当前市值': current_market_value,
                '浮动盈亏': floating_pnl,
                '持仓数量': open_positions_count,
                '牛差策略数量': bull_spread_count
            }
        
        # 修正后的计算逻辑：
        # 当前总资金 = 初始资金 + 累积已实现盈亏
        current_total_capital = initial_capital + self.cumulative_realized_pnl
        # 剩余现金 = 当前总资金 - 投入资金
        remaining_cash = current_total_capital - total_used_capital
        # 账户总价值 = 剩余现金 + 组合当前市值
        total_account_value = remaining_cash + total_current_market_value
        
        # 记录账户汇总
        account_record = {
            '交易日期': trade_date,
            '总资金': current_total_capital,  # 使用当前总资金而非初始资金
            '初始投入总额': total_used_capital,
            '剩余现金': remaining_cash,
            '组合当前市值': total_current_market_value,
            '总浮动盈亏': total_floating_pnl,
            '账户总价值': total_account_value,
            '累积已实现盈亏': self.cumulative_realized_pnl,  # 新增字段
            '当日已实现盈亏': today_realized_pnl,  # 新增字段
            '资金使用率': total_used_capital / current_total_capital if current_total_capital > 0 else 0,
            '收益率': (total_account_value - initial_capital) / initial_capital if initial_capital > 0 else 0,  # 修正收益率计算
            '牛差策略总数': total_bull_spread_positions,  # 新增字段

            '策略详情': strategy_details
        }
        
        self.daily_account_records.append(account_record)
        self.save_account_summary_to_csv(account_record)
        
        # 更新前一天的记录
        self.previous_date_summary = account_record
        
        # 输出整体账户汇总（只在有活动时输出）
        # if total_used_capital > 0 or total_floating_pnl != 0:
        #     print(f"{trade_date.strftime('%Y-%m-%d')} 【账户汇总】总资金{total_capital:.0f}元|已投入{total_used_capital:.0f}元|剩余现金{remaining_cash:.0f}元|组合市值{total_current_market_value:.0f}元|账户总值{total_account_value:.0f}元|总收益{total_floating_pnl:.0f}元|收益率{(total_floating_pnl/total_capital)*100:.2f}%")
    
    def save_account_summary_to_csv(self, account_data):
        """保存账户汇总到CSV文件"""
        try:
            # 复制数据并处理日期格式
            data_copy = account_data.copy()
            
            # 转换日期字段
            if '交易日期' in data_copy and data_copy['交易日期'] is not None:
                if hasattr(data_copy['交易日期'], 'strftime'):
                    data_copy['交易日期'] = data_copy['交易日期'].strftime('%Y-%m-%d')
                elif hasattr(data_copy['交易日期'], 'date'):
                    data_copy['交易日期'] = data_copy['交易日期'].date().strftime('%Y-%m-%d')
                else:
                    try:
                        date_obj = pd.to_datetime(data_copy['交易日期'])
                        data_copy['交易日期'] = date_obj.strftime('%Y-%m-%d')
                    except:
                        pass
            
            # 处理策略详情字段
            if '策略详情' in data_copy and isinstance(data_copy['策略详情'], dict):
                strategy_strings = []
                for etf_code, details in data_copy['策略详情'].items():
                    bull_count = details.get('牛差策略数量', 0)
                    strategy_str = f"{etf_code}(分配{details['分配资金']:.0f}|投入{details['初始投入']:.0f}|市值{details['当前市值']:.0f}|浮盈{details['浮动盈亏']:.0f}|持仓{details['持仓数量']}|牛差{bull_count})"
                    strategy_strings.append(strategy_str)
                data_copy['策略详情'] = '; '.join(strategy_strings)
            
            # 创建DataFrame，排除复杂字段
            csv_data = {k: v for k, v in data_copy.items() if not isinstance(v, dict)}
            df = pd.DataFrame([csv_data])
            
            # 检查文件是否存在
            file_exists = os.path.exists(self.account_csv_path)
            
            # 保存到CSV
            if file_exists:
                df.to_csv(self.account_csv_path, mode='a', header=False, index=False, encoding='utf-8-sig')
            else:
                df.to_csv(self.account_csv_path, mode='w', header=True, index=False, encoding='utf-8-sig')
                
        except Exception as e:
            print(f"保存账户汇总到CSV时出错: {e}")
            print(f"问题数据: {account_data}")
    
    def plot_account_summary(self):
        """绘制整体账户资金曲线"""
        if not self.daily_account_records:
            print("没有账户数据可以绘制")
            return
        
        # 转换为DataFrame
        account_df = pd.DataFrame(self.daily_account_records)
        
        if account_df.empty:
            print("没有账户数据可以绘制")
            return
        
        # print(f"账户数据记录数量: {len(account_df)}")
        # print(f"账户数据列: {account_df.columns.tolist()}")
        # print(f"前几行数据:\n{account_df.head()}")
        
        # 确保日期格式正确
        account_df['交易日期'] = pd.to_datetime(account_df['交易日期'], errors='coerce')
        account_df = account_df.dropna(subset=['交易日期']).sort_values('交易日期')
        
        if account_df.empty:
            print("日期转换后没有有效数据")
            return
        
        # 确保数值字段为数值类型，处理可能的字符串或其他类型
        numeric_columns = ['总资金', '初始投入总额', '剩余现金', '组合当前市值', '总浮动盈亏', '账户总价值', '资金使用率', '收益率', '牛差策略总数']
        
        for col in numeric_columns:
            if col in account_df.columns:
                # 先转换为字符串，移除可能的非数字字符
                account_df[col] = account_df[col].astype(str).str.replace('[^\d.-]', '', regex=True)
                # 再转换为数值类型
                account_df[col] = pd.to_numeric(account_df[col], errors='coerce').fillna(0)
                print(f"列 {col} 数据范围: {account_df[col].min()} 到 {account_df[col].max()}")
        
        # 检查是否有有效的数值数据
        if account_df[['总资金', '账户总价值']].isna().all().all():
            print("所有数值数据都无效，无法绘图")
            return
        
        # 绘图
        fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 10))
        
        try:
            # 上图：账户总价值曲线
            # 转换为numpy数组以确保数据类型
            dates = account_df['交易日期'].values
            total_values = account_df['账户总价值'].values.astype(float)
            initial_capitals = account_df['总资金'].values.astype(float)
            
            ax1.plot(dates, total_values, 
                    label='账户总价值', color='green', linewidth=2)
            ax1.plot(dates, initial_capitals, 
                    label='初始资金', color='gray', linewidth=1, linestyle='--')
            
            # 填充区域（只有在数据有效时）
            if len(total_values) > 0 and len(initial_capitals) > 0:
                profit_mask = total_values >= initial_capitals
                loss_mask = total_values < initial_capitals
                
                if profit_mask.any():
                    ax1.fill_between(dates, initial_capitals, total_values, 
                                    where=profit_mask, 
                                    color='green', alpha=0.3, label='盈利区域')
                if loss_mask.any():
                    ax1.fill_between(dates, initial_capitals, total_values, 
                                    where=loss_mask, 
                                    color='red', alpha=0.3, label='亏损区域')
            
            ax1.set_title('整体账户资金曲线', fontsize=14)
            ax1.set_ylabel('资金 (元)', fontsize=12)
            ax1.legend(fontsize=10)
            ax1.grid(True, alpha=0.3)
            
            # 下图：资金构成
            remaining_cash = account_df['剩余现金'].values.astype(float)
            current_market_value = account_df['组合当前市值'].values.astype(float)
            
            ax2.plot(dates, remaining_cash, 
                    label='剩余现金', color='blue', linewidth=2)
            ax2.plot(dates, current_market_value, 
                    label='组合当前市值', color='orange', linewidth=2, linestyle='--')
            
            ax2.axhline(y=0, color='black', linestyle='-', alpha=0.3)
            ax2.set_title('资金构成分析', fontsize=14)
            ax2.set_ylabel('金额 (元)', fontsize=12)
            ax2.set_xlabel('日期', fontsize=12)
            ax2.legend(fontsize=10)
            ax2.grid(True, alpha=0.3)
            
            # 格式化日期显示
            import matplotlib.dates as mdates
            for ax in [ax1, ax2]:
                ax.xaxis.set_major_formatter(mdates.DateFormatter('%Y-%m-%d'))
                ax.xaxis.set_major_locator(mdates.MonthLocator())
            
            plt.xticks(rotation=45)
            
            # 添加数据标注
            if len(total_values) > 0:
                final_value = float(total_values[-1])
                initial_capital = float(initial_capitals[0])
                total_return = final_value - initial_capital
                return_rate = total_return / initial_capital if initial_capital > 0 else 0
                max_value = float(np.max(total_values))
                min_value = float(np.min(total_values))
                
                # 获取最新的策略类型统计
                final_bull_count = account_df['牛差策略总数'].iloc[-1] if '牛差策略总数' in account_df.columns else 0
                
                ax1.text(0.02, 0.98, 
                        f'当前账户价值: {final_value:,.0f}元\n'
                        f'总收益: {total_return:,.0f}元\n'
                        f'收益率: {return_rate:.2%}\n'
                        f'最高价值: {max_value:,.0f}元\n'
                        f'最低价值: {min_value:,.0f}元\n'
                        f'当前持仓：牛差{final_bull_count}个', 
                        transform=ax1.transAxes, fontsize=10, verticalalignment='top',
                        bbox=dict(boxstyle='round', facecolor='lightblue', alpha=0.8))
            
            plt.tight_layout()
            plt.show()
            
        except Exception as e:
            print(f"绘图过程中出错: {e}")
            print(f"账户数据样本:\n{account_df[['交易日期', '总资金', '账户总价值', '剩余现金', '组合当前市值', '总浮动盈亏']].head()}")
            # 尝试简化版本的绘图
            try:
                fig2, ax = plt.subplots(1, 1, figsize=(10, 6))
                ax.plot(range(len(account_df)), account_df['账户总价值'].astype(float), 
                       label='账户总价值', color='green', linewidth=2)
                ax.set_title('简化版账户资金曲线')
                ax.set_ylabel('资金 (元)')
                ax.set_xlabel('交易日序号')
                ax.legend()
                ax.grid(True)
                plt.show()
            except Exception as e2:
                print(f"简化绘图也失败: {e2}")
    
    def run_all_strategies(self):
        """运行所有策略"""
        print("="*60)
        print("开始运行多标的深度实值买购和卖购组合的牛差策略")
        print("="*60)
        
        # 获取统一的交易日历（取第一个策略的交易日历作为基准）
        if not self.strategies:
            print("没有可运行的策略")
            return {}
        
        first_strategy = list(self.strategies.values())[0]
        trade_days = first_strategy.trade_days.index
        
        # 为每个策略设置动态合约数量计算方法
        for etf_code, strategy in self.strategies.items():
            original_open_method = strategy.open_position  # 使用新的统一开仓方法
            
            def make_dynamic_open_position(strat, orig_method):
                def dynamic_open_position(trade_date, etf_price, position_type='main', silent=False, save_to_csv=True):
                    # 首先用原方法获取期权信息，但不保存到CSV
                    original_contract_size = strat.config['contract_size']
                    strat.config['contract_size'] = 1  # 临时设置为1张以获取期权信息
                    
                    temp_result = orig_method(trade_date, etf_price, position_type, silent=True, save_to_csv=False)
                    
                    if temp_result:
                        # 根据策略类型获取期权信息进行动态计算
                        strategy_type = temp_result.get('strategy_type', StrategyType.BULL_SPREAD)
                        sell_call_info = temp_result['sell_call']
                        buy_call_info = temp_result['buy_call']  # 两种策略都有买购期权
                        
                        # 两种策略都使用买购和卖购期权信息
                        dynamic_size = self.calculate_dynamic_contract_size(strat, etf_price, buy_call_info, sell_call_info)
                        
                        # 验证动态合约数量，确保为正数
                        if dynamic_size <= 0:
                            print(f"  {strat.config['etf_code']}: 动态合约数量计算结果无效({dynamic_size})，使用默认值30张")
                            dynamic_size = 30  # 使用默认值
                        
                        # 更新合约数量并重新开仓
                        strat.config['contract_size'] = dynamic_size
                        strat._validate_contract_size()  # 验证合约数量
                        
                        # 移除临时仓位和交易记录
                        if strat.positions and strat.positions[-1] == temp_result:
                            strat.positions.pop()
                        if strat.trade_records and len(strat.trade_records) > 0:
                            # 检查最后一条记录是否是刚刚添加的临时记录
                            last_record = strat.trade_records[-1]
                            if (last_record.get('交易类型') == '开仓' and 
                                not last_record.get('平仓原因') and
                                last_record.get('合约数量') == 1):
                                strat.trade_records.pop()
                        
                        # 重新开仓，这次保存到CSV
                        result = orig_method(trade_date, etf_price, position_type, silent, save_to_csv)
                    else:
                        # 第一次调用失败，恢复原始合约数量设置，用传入的silent参数重新调用显示失败详情
                        strat.config['contract_size'] = original_contract_size
                        result = orig_method(trade_date, etf_price, position_type, silent, save_to_csv)
                        return result
                    
                    # 恢复原始设置
                    strat.config['contract_size'] = original_contract_size
                    return result
                return dynamic_open_position
            
            strategy.open_position = make_dynamic_open_position(strategy, original_open_method)  # 更新方法名
        
        # 按日期统一运行所有策略
        print(f"开始按日期统一运行策略，共{len(trade_days)}个交易日")
        
        for i, trade_date in enumerate(trade_days):
            # print(f"\n处理交易日 {trade_date.strftime('%Y-%m-%d')} ({i+1}/{len(trade_days)})")
            
            # 为每个策略处理当天的交易
            daily_has_activity = False
            
            for etf_code, strategy in self.strategies.items():
                try:
                    # 获取ETF价格
                    price_data = get_price(strategy.underlying_symbol, trade_date, trade_date, fields=['close'])['close']
                    if price_data.empty:
                        print(f"  {etf_code}: 获取ETF价格失败")
                        continue
                    etf_price = price_data.iloc[0]
                    
                    # 记录每日持仓状况（但不触发账户汇总回调）
                    strategy.record_daily_positions(trade_date, etf_price)
                    
                    # 检查是否需要平仓
                    if len(strategy.positions) > 0:
                        for position in strategy.positions:
                            should_close, reason = strategy.should_close_position(position, trade_date, etf_price)
                            if should_close:
                                strategy.close_position(position, trade_date, etf_price, reason)
                                print(f"  {etf_code}: 平仓 {reason}, ETF价格: {etf_price:.4f}")
                                daily_has_activity = True

                    # 检查是否需要开新仓（首次开仓或平仓后重新开仓）
                    open_positions = [p for p in strategy.positions if p['status'] == 'open']
                    if not open_positions:
                        new_position = strategy.open_position(trade_date, etf_price, 'main', silent=False)  # 使用新的统一开仓方法
                        if new_position:
                            max_profit = new_position['profit_info']['total_max_profit']
                            contract_size = new_position['contract_size']
                            
                            # 牛差策略输出
                            strategy_desc = f"牛差组合策略"
                            profit_desc = f"最大牛差收益: {max_profit:.2f}元"
                            
                            print(f"  {etf_code}: 开仓主仓位({strategy_desc})，ETF价格: {etf_price:.4f}, 合约数量: {contract_size}张, {profit_desc}")
                            daily_has_activity = True
                        # else:
                        #     print(f"  {etf_code}: 开仓失败，无法找到合适的期权组合，ETF价格: {etf_price:.4f}")
                    
                    # 检查是否需要加仓
                    elif strategy.should_add_position(trade_date, etf_price):
                        add_position = strategy.open_position(trade_date, etf_price, 'add', silent=False)  # 使用新的统一开仓方法
                        if add_position:
                            max_profit = add_position['profit_info']['total_max_profit']
                            contract_size = add_position['contract_size']
                            
                            # 牛差策略输出
                            strategy_desc = f"牛差组合策略"
                            profit_desc = f"最大牛差收益: {max_profit:.2f}元"
                            
                            print(f"  {etf_code}: 加仓({strategy_desc})，ETF价格: {etf_price:.4f}, 合约数量: {contract_size}张, {profit_desc}")
                            daily_has_activity = True
                    
                    # 更新策略的前一日ETF价格
                    strategy.previous_etf_price = etf_price
                            
                except Exception as e:
                    print(f"  {etf_code}: 处理失败 - {e}")
            
            # 统一记录当天的账户汇总（无论是否有交易活动）
            try:
                self.record_daily_account_summary(trade_date)
                if daily_has_activity:
                    print(f"  账户汇总已更新")
            except Exception as e:
                print(f"  记录账户汇总失败: {e}")
        
        # 收集所有策略的结果
        results = {}
        for etf_code, strategy in self.strategies.items():
            try:
                results[etf_code] = {
                    'strategy': strategy,
                    'summary': strategy.get_performance_summary(),
                    'allocated_capital': strategy.config['allocated_capital']
                }
                print(f"{etf_code}策略运行完成")
            except Exception as e:
                print(f"{etf_code}策略结果收集出错: {e}")
                results[etf_code] = {'error': str(e)}
        
        print("\n所有策略运行完成!")
        return results
    
    def generate_overall_report(self, results):
        """生成总体报告"""
        print("\n" + "="*60)
        print("多标的牛差策略总体报告")
        print("="*60)
        
        total_pnl = 0
        total_trades = 0
        total_winning_trades = 0
        
        for etf_code, result in results.items():
            if 'error' in result:
                print(f"\n{etf_code}: 策略执行出错 - {result['error']}")
                continue
            
            strategy = result['strategy']
            allocated_capital = result['allocated_capital']
            
            print(f"\n{etf_code} 策略结果:")
            print(f"分配资金: {allocated_capital:,.0f}元")
            print(result['summary'])
            
            # 统计总体数据
            closed_positions = [p for p in strategy.positions if p['status'] == 'closed']
            if closed_positions:
                strategy_pnl = sum(p['pnl'] for p in closed_positions)
                strategy_trades = len(closed_positions)
                strategy_winning = len([p for p in closed_positions if p['pnl'] > 0])
                
                total_pnl += strategy_pnl
                total_trades += strategy_trades
                total_winning_trades += strategy_winning
        
        # 总体统计
        if total_trades > 0:
            overall_win_rate = total_winning_trades / total_trades
            print(f"\n总体策略表现:")
            print(f"总交易次数: {total_trades}")
            print(f"总获利交易: {total_winning_trades}")
            print(f"总体胜率: {overall_win_rate:.2%}")
            print(f"总盈亏: {total_pnl:.2f}元")
            print(f"平均每笔盈亏: {total_pnl/total_trades:.2f}元")
            print(f"总资金收益率: {total_pnl/self.config.capital_config['total_capital']:.2%}")

# 使用示例
def run_deep_itm_bull_spread_example():
    """运行深度实值买购和卖购组合牛差策略示例"""
    
    # 创建策略配置
    config = StrategyConfig()
    
    # 可以自定义配置
    config.time_config = {
        'start_date': '2025-06-15',
        'end_date': '2025-08-25'
    }
    
    config.capital_config.update({
        'total_capital': 1000000,  # 100万总资金
        'capital_allocation': {
            '50ETF': 0.5,   # 50ETF 50%
            '300ETF': 0.3,  # 300ETF 30%
            '创业板ETF': 0.2   # 创业板ETF 20%
        },
        'capital_usage_limit': 0.8,  # 使用80%资金
        'bull_spread_margin_discount': 30,  # 牛差组合策略保证金优惠（每单位组合加收30元）
        'contract_unit': 10000,  # 合约单位
        'margin_params': {  # 保证金计算参数（按交易所规定）
            'volatility_factor': 0.12,  # 波动率因子12%
            'min_margin_factor': 0.07   # 最小保证金因子7%
        }
    })
    
    # 创建多标的策略管理器
    manager = MultiUnderlyingBullSpreadManager(config)
    
    # 运行所有策略
    results = manager.run_all_strategies()
    
    # 生成报告
    manager.generate_overall_report(results)
    
    # 绘制整体账户资金曲线
    try:
        print(f"\n绘制整体账户资金曲线...")
        manager.plot_account_summary()
    except Exception as e:
        print(f"绘制整体账户资金曲线时出错: {e}")
    
    # 绘制各策略结果（可选）
    for etf_code, result in results.items():
        if 'strategy' in result:
            try:
                print(f"\n绘制{etf_code}策略结果...")
                result['strategy'].plot_results()
            except Exception as e:
                print(f"绘制{etf_code}图表时出错: {e}")