"""
参数优化完整示例

本示例演示如何创建可优化的策略，以及如何进行参数分析。
"""

from AlgorithmImports import *
from datetime import timedelta
import numpy as np

class OptimizableMovingAverageStrategy(QCAlgorithm):
    """
    可优化的双均线交叉策略

    优化参数：
    - fastPeriod: 快线周期 (5-30)
    - slowPeriod: 慢线周期 (40-100)
    - rsiFilter: 是否使用 RSI 过滤 (true/false)
    - rsiPeriod: RSI 周期 (10-20)
    - rsiOversold: RSI 超卖阈值 (20-35)
    - rsiOverbought: RSI 超买阈值 (65-80)
    """

    def Initialize(self):
        """初始化策略"""
        # ========== 基本设置 ==========
        self.SetStartDate(2020, 1, 1)
        self.SetEndDate(2023, 12, 31)
        self.SetCash(100000)

        # Portfolio 没有 StartingCash 属性，在此保存初始资金
        self.starting_cash = self.Portfolio.TotalPortfolioValue

        # ========== 添加证券 ==========
        self.spy = self.AddEquity("SPY", Resolution.Daily).Symbol

        # 设置数据归一化
        self.Securities[self.spy].SetDataNormalizationMode(
            DataNormalizationMode.Adjusted
        )

        # ========== 获取优化参数 ==========
        # GetParameter 返回 str，需自行转换类型；布尔参数用字符串比较
        self.fast_period = int(self.GetParameter("fastPeriod") or 20)
        self.slow_period = int(self.GetParameter("slowPeriod") or 50)
        self.use_rsi_filter = str(self.GetParameter("rsiFilter")).lower() == "true"
        self.rsi_period = int(self.GetParameter("rsiPeriod") or 14)
        self.rsi_oversold = int(self.GetParameter("rsiOversold") or 30)
        self.rsi_overbought = int(self.GetParameter("rsiOverbought") or 70)

        # ========== 参数验证 ==========
        if not self.ValidateParameters():
            self.Quit("Invalid parameters")

        # ========== 创建指标 ==========
        self.sma_fast = self.SMA(self.spy, self.fast_period)
        self.sma_slow = self.SMA(self.spy, self.slow_period)

        if self.use_rsi_filter:
            self.rsi = self.RSI(self.spy, self.rsi_period)

        # ========== 预热 ==========
        warmup_days = max(self.slow_period, self.rsi_period if self.use_rsi_filter else 0) + 10
        self.SetWarmUp(TimeSpan.FromDays(warmup_days))

        # ========== 记录变量 ==========
        self.trade_count = 0
        self.last_signal = 0  # 1=long, -1=short, 0=flat

        # ========== 输出配置 ==========
        self.Debug("=" * 60)
        self.Debug("OPTIMIZABLE MA CROSS STRATEGY")
        self.Debug("=" * 60)
        self.Debug(f"Fast Period: {self.fast_period}")
        self.Debug(f"Slow Period: {self.slow_period}")
        self.Debug(f"RSI Filter: {self.use_rsi_filter}")
        if self.use_rsi_filter:
            self.Debug(f"  RSI Period: {self.rsi_period}")
            self.Debug(f"  RSI Oversold: {self.rsi_oversold}")
            self.Debug(f"  RSI Overbought: {self.rsi_overbought}")
        self.Debug("=" * 60)

    def ValidateParameters(self):
        """验证参数有效性"""
        # 快线必须小于慢线
        if self.fast_period >= self.slow_period:
            self.Error(f"Invalid: fast ({self.fast_period}) >= slow ({self.slow_period})")
            return False

        # 确保 RSI 参数合理
        if self.use_rsi_filter:
            if self.rsi_oversold >= self.rsi_overbought:
                self.Error(f"Invalid: oversold ({self.rsi_oversold}) >= overbought ({self.rsi_overbought})")
                return False

            if self.rsi_oversold < 20 or self.rsi_oversold > 40:
                self.Error(f"Invalid oversold threshold: {self.rsi_oversold}")
                return False

            if self.rsi_overbought < 60 or self.rsi_overbought > 80:
                self.Error(f"Invalid overbought threshold: {self.rsi_overbought}")
                return False

        return True

    def OnData(self, data):
        """主数据处理"""
        # 等待指标准备
        if not self.sma_fast.IsReady:
            return

        if self.use_rsi_filter and not self.rsi.IsReady:
            return

        # 获取指标值
        fast = self.sma_fast.Current.Value
        slow = self.sma_slow.Current.Value

        # 获取当前价格
        price = self.Securities[self.spy].Price

        # 生成信号
        signal = 0

        # MA 金叉
        if fast > slow:
            if self.use_rsi_filter:
                rsi = self.rsi.Current.Value
                # RSI 不超买时买入
                if rsi < self.rsi_overbought:
                    signal = 1
            else:
                signal = 1

        # MA 死叉
        elif fast < slow:
            if self.use_rsi_filter:
                rsi = self.rsi.Current.Value
                # RSI 不超卖时卖出
                if rsi > self.rsi_oversold:
                    signal = -1
            else:
                signal = -1

        # 执行交易
        if signal == 1 and self.last_signal != 1:
            if not self.Portfolio[self.spy].IsLong:
                self.SetHoldings(self.spy, 1)
                self.trade_count += 1
                self.last_signal = 1
                self.Debug(f"[BUY] {self.Time.date()} | "
                          f"Price: ${price:.2f} | "
                          f"Fast: {fast:.2f} | Slow: {slow:.2f}")

        elif signal == -1 and self.last_signal != -1:
            if self.Portfolio[self.spy].IsLong:
                self.Liquidate(self.spy)
                self.trade_count += 1
                self.last_signal = -1
                self.Debug(f"[SELL] {self.Time.date()} | "
                          f"Price: ${price:.2f} | "
                          f"Fast: {fast:.2f} | Slow: {slow:.2f}")

    def OnEndOfAlgorithm(self):
        """输出详细结果"""
        # StatisticsResults 的数值指标位于 TotalPerformance.PortfolioStatistics
        stats = self.Statistics.TotalPerformance.PortfolioStatistics

        # 计算关键指标
        total_return = (self.Portfolio.TotalPortfolioValue /
                        self.starting_cash - 1)

        self.Debug("\n" + "=" * 60)
        self.Debug("BACKTEST RESULTS")
        self.Debug("=" * 60)
        self.Debug(f"Total Return: {total_return:.2%}")
        self.Debug(f"Annual Return: {stats.CompoundingAnnualReturn:.2%}")
        self.Debug(f"Sharpe Ratio: {stats.SharpeRatio:.2f}")
        self.Debug(f"Sortino Ratio: {stats.SortinoRatio:.2f}")
        self.Debug(f"Max Drawdown: {stats.Drawdown:.2%}")
        self.Debug(f"Win Rate: {stats.WinRate:.2%}")
        self.Debug(f"Total Trades: {self.trade_count}")
        self.Debug("=" * 60)

        # 过拟合警告
        if stats.SharpeRatio > 3:
            self.Log("High Sharpe Ratio - possible overfitting!")
        if self.trade_count < 20:
            self.Log("Low trade count - results may not be significant!")

        # 输出参数总结
        self.Debug("\n" + "=" * 60)
        self.Debug("PARAMETERS USED")
        self.Debug("=" * 60)
        self.Debug(f"fastPeriod={self.fast_period}")
        self.Debug(f"slowPeriod={self.slow_period}")
        self.Debug(f"rsiFilter={self.use_rsi_filter}")
        self.Debug(f"rsiPeriod={self.rsi_period}")
        self.Debug(f"rsiOversold={self.rsi_oversold}")
        self.Debug(f"rsiOverbought={self.rsi_overbought}")
        self.Debug("=" * 60)


class RobustOptimizationStrategy(QCAlgorithm):
    """
    防止过拟合的稳健优化策略

    特点：
    1. 简单参数逻辑
    2. 限制交易频率
    3. 参数约束验证
    4. 多目标评估
    """

    def Initialize(self):
        self.SetStartDate(2020, 1, 1)
        self.SetEndDate(2023, 12, 31)
        self.SetCash(100000)

        # Portfolio 没有 StartingCash 属性，在此保存初始资金
        self.starting_cash = self.Portfolio.TotalPortfolioValue

        self.spy = self.AddEquity("SPY", Resolution.Daily).Symbol

        # 获取参数（GetParameter 返回 str，需转换为数值）
        self.fast_period = int(self.GetParameter("fastPeriod") or 20)
        self.slow_period = int(self.GetParameter("slowPeriod") or 50)

        # 参数约束
        self.fast_period = max(10, min(self.fast_period, 40))
        self.slow_period = max(50, min(self.slow_period, 150))

        # 确保参数差异
        if self.slow_period / self.fast_period < 2:
            self.slow_period = self.fast_period * 2

        # 创建指标
        self.sma_fast = self.SMA(self.spy, self.fast_period)
        self.sma_slow = self.SMA(self.spy, self.slow_period)

        self.SetWarmUp(TimeSpan.FromDays(self.slow_period + 10))

        # 添加止损
        self.stop_loss_pct = 0.05  # 5% 止损
        self.entry_price = None

        # 记录变量
        self.daily_values = []
        self.trade_count = 0
        self.max_trades = 50  # 限制最大交易次数

    def OnData(self, data):
        # 限制交易次数
        if self.trade_count >= self.max_trades:
            return

        if not self.sma_fast.IsReady:
            return

        price = self.Securities[self.spy].Price

        # 记录每日组合价值
        self.daily_values.append(self.Portfolio.TotalPortfolioValue)

        # 检查止损
        if self.entry_price:
            return_pct = (price / self.entry_price - 1)
            if return_pct < -self.stop_loss_pct:
                self.Liquidate(self.spy)
                self.Debug(f"[STOP LOSS] Exit: ${price:.2f}, Loss: {return_pct:.2%}")
                self.entry_price = None
                self.trade_count += 1
                return

        # 交易逻辑
        if self.sma_fast.Current.Value > self.sma_slow.Current.Value:
            if not self.Portfolio[self.spy].IsLong:
                self.SetHoldings(self.spy, 1)
                self.entry_price = price
                self.trade_count += 1
                self.Debug(f"[BUY] {self.Time.date()} | Price: ${price:.2f}")

        else:
            if self.Portfolio[self.spy].IsLong:
                self.Liquidate(self.spy)
                self.entry_price = None
                self.trade_count += 1
                self.Debug(f"[SELL] {self.Time.date()} | Price: ${price:.2f}")

    def CalculateMetrics(self):
        """计算详细的性能指标"""
        if len(self.daily_values) < 2:
            return {}

        # 计算每日收益率
        returns = pd.Series(self.daily_values).pct_change().dropna()

        # 基本统计
        total_return = (self.Portfolio.TotalPortfolioValue /
                       self.starting_cash - 1)

        annual_return = returns.mean() * 252
        annual_vol = returns.std() * np.sqrt(252)

        # 夏普比率
        sharpe = annual_return / annual_vol if annual_vol > 0 else 0

        # 最大回撤
        cum_returns = (1 + returns).cumprod()
        running_max = cum_returns.cummax()
        drawdown = (cum_returns - running_max) / running_max
        max_dd = drawdown.min()

        # 胜率
        winning_days = (returns > 0).sum()
        total_days = len(returns)
        win_rate = winning_days / total_days if total_days > 0 else 0

        return {
            'total_return': total_return,
            'annual_return': annual_return,
            'annual_volatility': annual_vol,
            'sharpe_ratio': sharpe,
            'max_drawdown': max_dd,
            'win_rate': win_rate,
            'total_trades': self.trade_count
        }

    def OnEndOfAlgorithm(self):
        """输出结果"""
        metrics = self.CalculateMetrics()

        if not metrics:
            return

        self.Debug("\n" + "=" * 60)
        self.Debug("PERFORMANCE METRICS")
        self.Debug("=" * 60)
        for key, value in metrics.items():
            if isinstance(value, float):
                if 'rate' in key or 'return' in key or 'drawdown' in key:
                    self.Debug(f"{key}: {value:.2%}")
                else:
                    self.Debug(f"{key}: {value:.2f}")
            else:
                self.Debug(f"{key}: {value}")
        self.Debug("=" * 60)


class WalkForwardOptimizationStrategy(QCAlgorithm):
    """
    滚动窗口优化策略

    每6个月重新训练参数
    """

    def Initialize(self):
        self.SetStartDate(2020, 1, 1)
        self.SetEndDate(2023, 12, 31)
        self.SetCash(100000)

        # Portfolio 没有 StartingCash 属性，在此保存初始资金
        self.starting_cash = self.Portfolio.TotalPortfolioValue

        self.spy = self.AddEquity("SPY", Resolution.Daily).Symbol

        # 默认参数
        self.fast_period = 20
        self.slow_period = 50

        self.sma_fast = self.SMA(self.spy, self.fast_period)
        self.sma_slow = self.SMA(self.spy, self.slow_period)

        self.SetWarmUp(TimeSpan.FromDays(60))

        # 优化相关
        self.last_optimization = self.Time
        self.optimization_interval = TimeSpan.FromDays(180)  # 6个月

        # 调度优化任务
        self.Schedule.On(
            self.DateRules.Every(DayOfWeek.Sunday),
            self.TimeRules.At(12, 0),
            self.CheckOptimization
        )

        self.Debug("Walk-Forward Optimization Strategy Initialized")

    def CheckOptimization(self):
        """检查是否需要重新优化"""
        if (self.Time - self.last_optimization) >= self.optimization_interval:
            self.OptimizeParameters()
            self.last_optimization = self.Time

    def OptimizeParameters(self):
        """
        简化的参数优化

        在实际使用中，这里应该调用完整的优化流程
        """
        self.Debug(f"\n[OPTIMIZATION] {self.Time.date()}")
        self.Debug("Running walk-forward optimization...")

        # 获取历史数据
        history = self.History(self.spy, TimeSpan.FromDays(252), Resolution.Daily)

        if history.empty:
            self.Debug("No history data for optimization")
            return

        # 简化的优化逻辑：测试几个参数组合
        best_sharpe = -float('inf')
        best_fast = 20
        best_slow = 50

        for fast in [10, 15, 20, 25, 30]:
            for slow in [40, 50, 60, 70, 80]:
                if fast >= slow:
                    continue

                # 计算该参数组合的夏普比率
                sharpe = self.TestParameters(history, fast, slow)

                if sharpe > best_sharpe:
                    best_sharpe = sharpe
                    best_fast = fast
                    best_slow = slow

        # 更新参数
        self.fast_period = best_fast
        self.slow_period = best_slow

        # 重建指标
        self.sma_fast = self.SMA(self.spy, self.fast_period)
        self.sma_slow = self.SMA(self.spy, self.slow_period)

        self.Debug(f"Optimized Parameters: Fast={best_fast}, Slow={best_slow}, Sharpe={best_sharpe:.2f}")

    def TestParameters(self, history, fast, slow):
        """测试特定参数组合"""
        closes = history['close']

        # 计算均线
        sma_fast = closes.rolling(fast).mean()
        sma_slow = closes.rolling(slow).mean()

        # 计算信号
        signals = (sma_fast > sma_slow).astype(int).shift(1)

        # 计算收益
        returns = closes.pct_change() * signals

        # 计算夏普比率
        mean_return = returns.mean()
        std_return = returns.std()
        sharpe = mean_return / std_return * np.sqrt(252) if std_return > 0 else 0

        return sharpe

    def OnData(self, data):
        if not self.sma_fast.IsReady:
            return

        if self.sma_fast.Current.Value > self.sma_slow.Current.Value:
            if not self.Portfolio[self.spy].IsLong:
                self.SetHoldings(self.spy, 1)
        else:
            if self.Portfolio[self.spy].IsLong:
                self.Liquidate(self.spy)

    def OnEndOfAlgorithm(self):
        """输出最终结果"""
        self.Debug("\n" + "=" * 60)
        self.Debug("WALK-FORWARD OPTIMIZATION RESULTS")
        self.Debug("=" * 60)
        self.Debug(f"Final Parameters: Fast={self.fast_period}, Slow={self.slow_period}")
        total_return = self.Portfolio.TotalPortfolioValue / self.starting_cash - 1
        self.Debug(f"Total Return: {total_return:.2%}")
        self.Debug(f"Sharpe Ratio: "
                  f"{self.Statistics.TotalPerformance.PortfolioStatistics.SharpeRatio:.2f}")
        self.Debug("=" * 60)
