"""
Algorithm Framework 完整示例

本示例演示如何使用 Lean Framework 构建模块化策略：
1. Alpha Model - 交易信号生成
2. Portfolio Construction Model - 组合构建
3. Execution Model - 订单执行
4. Risk Management Model - 风险控制
5. Universe Selection Model - 证券选择
"""

from AlgorithmImports import *
from datetime import timedelta, datetime

# ========== Alpha Models ==========

class RsiAlphaModel(AlphaModel):
    """
    RSI Alpha 模型

    基于 RSI 指标生成交易信号：
    - RSI < 30: 超卖，生成买入信号
    - RSI > 70: 超买，生成卖出信号
    """

    def __init__(self, period=14, oversold=30, overbought=70):
        self.period = period
        self.oversold = oversold
        self.overbought = overbought
        self.rsi_indicators = {}
        self.insight_period = TimeSpan.FromDays(7)  # 信号有效期7天

    def Update(self, algorithm, data):
        """
        生成交易信号

        Returns:
            List[Insight]: 交易信号列表
        """
        insights = []

        for symbol, rsi in self.rsi_indicators.items():
            if not rsi.IsReady:
                continue

            rsi_value = rsi.Current.Value

            # 超卖：买入信号
            if rsi_value < self.oversold:
                # Magnitude: 超卖越深，信号强度越大
                magnitude = (self.oversold - rsi_value) / self.oversold

                insight = Insight.Price(
                    symbol,
                    self.insight_period,
                    InsightDirection.Up,
                    magnitude=magnitude,
                    confidence=magnitude
                )
                insights.append(insight)

            # 超买：卖出信号
            elif rsi_value > self.overbought:
                # Magnitude: 超买越深，信号强度越大
                magnitude = (rsi_value - self.overbought) / (100 - self.overbought)

                insight = Insight.Price(
                    symbol,
                    self.insight_period,
                    InsightDirection.Down,
                    magnitude=magnitude,
                    confidence=magnitude
                )
                insights.append(insight)

        return insights

    def OnSecuritiesChanged(self, algorithm, changes):
        """
        证券变化时更新指标

        添加新证券时创建 RSI 指标
        移除证券时清理指标
        """
        # 添加新证券
        for added in changes.AddedSecurities:
            symbol = added.Symbol
            if symbol not in self.rsi_indicators:
                self.rsi_indicators[symbol] = algorithm.RSI(
                    symbol,
                    self.period,
                    Resolution.Daily
                )
                algorithm.Debug(f"[Alpha] Created RSI for {symbol}")

        # 移除旧证券
        for removed in changes.RemovedSecurities:
            if removed.Symbol in self.rsi_indicators:
                del self.rsi_indicators[removed.Symbol]
                algorithm.Debug(f"[Alpha] Removed RSI for {removed.Symbol}")


class MacdAlphaModel(AlphaModel):
    """
    MACD Alpha 模型

    基于 MACD 指标生成交易信号：
    - MACD 上穿信号线: 买入
    - MACD 下穿信号线: 卖出
    """

    def __init__(self, fast_period=12, slow_period=26, signal_period=9):
        self.fast_period = fast_period
        self.slow_period = slow_period
        self.signal_period = signal_period
        self.macd_indicators = {}
        self.previous_values = {}  # 记录上次的值用于判断交叉
        self.insight_period = TimeSpan.FromDays(5)

    def Update(self, algorithm, data):
        """生成交易信号"""
        insights = []

        for symbol, macd in self.macd_indicators.items():
            if not macd.IsReady:
                continue

            current_value = macd.Current.Value
            signal_value = macd.Signal.Current.Value

            # 检查是否有历史记录
            if symbol not in self.previous_values:
                self.previous_values[symbol] = {
                    'macd': current_value,
                    'signal': signal_value
                }
                continue

            previous_macd = self.previous_values[symbol]['macd']
            previous_signal = self.previous_values[symbol]['signal']

            # 金叉：MACD 从下方上穿信号线
            if (previous_macd <= previous_signal and
                current_value > signal_value):
                magnitude = min(abs(current_value - signal_value) / signal_value, 1)
                insights.append(Insight.Price(
                    symbol,
                    self.insight_period,
                    InsightDirection.Up,
                    magnitude=magnitude
                ))

            # 死叉：MACD 从上方下穿信号线
            elif (previous_macd >= previous_signal and
                  current_value < signal_value):
                magnitude = min(abs(current_value - signal_value) / signal_value, 1)
                insights.append(Insight.Price(
                    symbol,
                    self.insight_period,
                    InsightDirection.Down,
                    magnitude=magnitude
                ))

            # 更新历史值
            self.previous_values[symbol] = {
                'macd': current_value,
                'signal': signal_value
            }

        return insights

    def OnSecuritiesChanged(self, algorithm, changes):
        """更新指标"""
        for added in changes.AddedSecurities:
            symbol = added.Symbol
            if symbol not in self.macd_indicators:
                self.macd_indicators[symbol] = algorithm.MACD(
                    symbol,
                    self.fast_period,
                    self.slow_period,
                    self.signal_period,
                    MovingAverageType.Exponential,
                    Resolution.Daily
                )

        for removed in changes.RemovedSecurities:
            if removed.Symbol in self.macd_indicators:
                del self.macd_indicators[removed.Symbol]
            if removed.Symbol in self.previous_values:
                del self.previous_values[removed.Symbol]


class CompositeAlphaModel(AlphaModel):
    """
    复合 Alpha 模型

    结合多个 Alpha 模型的信号
    """

    def __init__(self):
        self.alpha_models = []

    def AddModel(self, model):
        """添加子模型"""
        self.alpha_models.append(model)
        return self

    def Update(self, algorithm, data):
        """聚合所有模型的信号"""
        all_insights = []

        for alpha_model in self.alpha_models:
            insights = alpha_model.Update(algorithm, data)
            all_insights.extend(insights)

        # 可以在这里添加信号聚合逻辑
        # 例如：多数投票、加权平均等

        return all_insights

    def OnSecuritiesChanged(self, algorithm, changes):
        """传递给所有子模型"""
        for alpha_model in self.alpha_models:
            alpha_model.OnSecuritiesChanged(algorithm, changes)


# ========== Portfolio Construction Models ==========

class EqualWeightingPortfolioConstructionModel(PortfolioConstructionModel):
    """
    等权重组合构建模型

    所有 Insight 获得相同的资金分配
    """

    def __init__(self, portfolio_bias=PortfolioBias.LongShort):
        self.portfolio_bias = portfolio_bias

    def CreateTargets(self, algorithm, insights):
        """
        创建组合目标

        Returns:
            List[PortfolioTarget]: 目标持仓列表
        """
        targets = []

        if not insights:
            return targets

        # 按方向分组
        long_insights = [i for i in insights if i.Direction == InsightDirection.Up]
        short_insights = [i for i in insights if i.Direction == InsightDirection.Down]

        # 计算权重
        long_weight = 1.0 / len(long_insights) if long_insights else 0
        short_weight = 1.0 / len(short_insights) if short_insights else 0

        # 根据偏见调整
        if self.portfolio_bias == PortfolioBias.Long:
            short_weight = 0
            long_weight = 1.0 / len(long_insights) if long_insights else 0

        elif self.portfolio_bias == PortfolioBias.Short:
            long_weight = 0
            short_weight = 1.0 / len(short_insights) if short_insights else 0

        # 创建多头目标
        for insight in long_insights:
            targets.append(PortfolioTarget.Percent(
                insight.Symbol,
                long_weight * insight.Magnitude if long_weight > 0 else 0
            ))

        # 创建空头目标
        for insight in short_insights:
            targets.append(PortfolioTarget.Percent(
                insight.Symbol,
                -short_weight * insight.Magnitude if short_weight > 0 else 0
            ))

        return targets


class InsightWeightingPortfolioConstructionModel(PortfolioConstructionModel):
    """
    基于 Insight Magnitude 的加权模型

    信号强度越大，分配的资金越多
    """

    def CreateTargets(self, algorithm, insights):
        """创建目标"""
        targets = []

        if not insights:
            return targets

        # 按方向分组
        long_insights = [i for i in insights if i.Direction == InsightDirection.Up]
        short_insights = [i for i in insights if i.Direction == InsightDirection.Down]

        # 计算总权重
        long_magnitude_sum = sum(i.Magnitude for i in long_insights)
        short_magnitude_sum = sum(i.Magnitude for i in short_insights)

        # 创建目标
        for insight in insights:
            if insight.Direction == InsightDirection.Up and long_magnitude_sum > 0:
                weight = insight.Magnitude / long_magnitude_sum
                targets.append(PortfolioTarget.Percent(insight.Symbol, weight))

            elif insight.Direction == InsightDirection.Down and short_magnitude_sum > 0:
                weight = insight.Magnitude / short_magnitude_sum
                targets.append(PortfolioTarget.Percent(insight.Symbol, -weight))

        return targets


# ========== Execution Models ==========

class ImmediateExecutionModel(ExecutionModel):
    """
    立即执行模型

    收到目标后立即以市价单执行
    """

    def Execute(self, algorithm, targets):
        """
        执行目标

        Args:
            algorithm: QCAlgorithm
            targets: List[PortfolioTarget]
        """
        for target in targets:
            # 检查证券是否存在
            if not algorithm.Portfolio.ContainsKey(target.Symbol):
                continue

            holdings = algorithm.Portfolio[target.Symbol]
            current_quantity = holdings.Quantity

            # 计算目标数量
            if algorithm.Securities[target.Symbol].Price == 0:
                continue

            # 目标数量减去当前持仓，得到需要交易的数量
            # 注意：PortfolioTarget.Quantity 是目标股数；
            # CalculateOrderQuantity 的第二参是目标持仓百分比，勿混用
            quantity = target.Quantity - current_quantity

            if quantity != 0:
                # 执行市价单
                algorithm.MarketOrder(target.Symbol, quantity)
                algorithm.Debug(f"[Execution] MarketOrder: {target.Symbol} Qty: {quantity}")


class VwapExecutionModel(ExecutionModel):
    """
    VWAP 执行模型

    在指定时间段内分批执行，追求接近 VWAP 价格
    """

    def __init__(self, period=TimeSpan.FromMinutes(30), slices=5):
        self.period = period
        self.slices = slices
        self.targets = {}
        self.slice_times = {}

    def Execute(self, algorithm, targets):
        """执行目标"""
        current_time = algorithm.Time

        for target in targets:
            symbol = target.Symbol

            # 新目标
            if symbol not in self.targets:
                self.targets[symbol] = {
                    'target': target,
                    'remaining': target.Quantity,
                    'start_time': current_time,
                    'total_quantity': target.Quantity
                }
                self.slice_times[symbol] = 0

            # 检查是否已完成
            if self.targets[symbol]['remaining'] <= 0:
                continue

            # 检查是否超时
            elapsed = (current_time - self.targets[symbol]['start_time'])
            if elapsed >= self.period:
                # 立即完成剩余
                quantity = self.targets[symbol]['remaining']
            else:
                # 计算本切片应该执行的数量
                # algorithm.Time 相减与 TimeSpan.FromMinutes 均为 .NET TimeSpan，
                # 用 TotalSeconds 属性（Python datetime 的 timedelta 才是 total_seconds()）
                progress = elapsed.TotalSeconds / self.period.TotalSeconds
                target_slice = int(self.targets[symbol]['total_quantity'] * progress)
                executed_slice = self.targets[symbol]['total_quantity'] - self.targets[symbol]['remaining']

                quantity = target_slice - executed_slice

            if quantity != 0:
                algorithm.MarketOrder(symbol, quantity)
                self.targets[symbol]['remaining'] -= quantity


# ========== Risk Management Models ==========

class MaxDrawdownRiskManagementModel(RiskManagementModel):
    """
    最大回撤风险管理模型

    当组合回撤超过设定阈值时平仓
    """

    def __init__(self, max_drawdown_pct=0.15, liquidate=True):
        self.max_drawdown_pct = max_drawdown_pct
        self.liquidate = liquidate
        self.high_watermark = None

    def ManageRisk(self, algorithm, targets):
        """
        管理风险

        Returns:
            List[PortfolioTarget]: 调整后的目标
        """
        portfolio_value = algorithm.Portfolio.TotalPortfolioValue

        # 更新最高水位
        if self.high_watermark is None or portfolio_value > self.high_watermark:
            self.high_watermark = portfolio_value
            return targets  # 正常，返回原目标

        # 计算回撤
        drawdown = (self.high_watermark - portfolio_value) / self.high_watermark

        if drawdown > self.max_drawdown_pct:
            # QCAlgorithm 没有 Warn 方法，用 Log 或 Error
            algorithm.Log(f"Max drawdown exceeded: {drawdown:.2%}")

            if self.liquidate:
                # 平掉所有持仓
                algorithm.Liquidate()
                algorithm.Debug(f"[Risk] Max drawdown {drawdown:.2%} exceeded. Liquidated all positions.")
                return []  # 清空所有目标

        return targets


class MaxPositionSizeRiskModel(RiskManagementModel):
    """
    单股最大持仓风险管理模型

    限制单个证券的最大持仓占比
    """

    def __init__(self, max_position_size=0.25):
        self.max_position_size = max_position_size

    def ManageRisk(self, algorithm, targets):
        """管理风险"""
        filtered_targets = []

        for target in targets:
            # 计算目标持仓价值
            price = algorithm.Securities[target.Symbol].Price

            if price == 0:
                continue

            target_value = abs(target.Quantity) * price
            portfolio_value = algorithm.Portfolio.TotalPortfolioValue

            if portfolio_value > 0:
                position_size = target_value / portfolio_value

                if position_size > self.max_position_size:
                    # 超过限制，调整到最大值
                    adjusted_quantity = int(
                        (self.max_position_size * portfolio_value) / price
                    )

                    if target.Quantity < 0:
                        adjusted_quantity = -adjusted_quantity

                    algorithm.Debug(f"[Risk] Reduced {target.Symbol} position from "
                                  f"{position_size:.2%} to {self.max_position_size:.2%}")

                    target = PortfolioTarget(target.Symbol, adjusted_quantity)

            filtered_targets.append(target)

        return filtered_targets


class StopLossRiskModel(RiskManagementModel):
    """
    止损风险管理模型

    为每个持仓设置止损
    """

    def __init__(self, stop_loss_pct=0.05):
        self.stop_loss_pct = stop_loss_pct
        self.entry_prices = {}
        self.stop_prices = {}

    def ManageRisk(self, algorithm, targets):
        """管理风险"""
        # 检查现有持仓的止损
        for symbol, holdings in algorithm.Portfolio.items():
            if not holdings.Invested:
                continue

            current_price = algorithm.Securities[symbol].Price

            # 新持仓，记录入场价
            if symbol not in self.entry_prices:
                self.entry_prices[symbol] = holdings.AveragePrice
                if holdings.Quantity > 0:
                    self.stop_prices[symbol] = holdings.AveragePrice * (1 - self.stop_loss_pct)
                else:
                    self.stop_prices[symbol] = holdings.AveragePrice * (1 + self.stop_loss_pct)

            # 检查止损
            elif symbol in self.stop_prices:
                if holdings.Quantity > 0 and current_price < self.stop_prices[symbol]:
                    algorithm.Liquidate(symbol)
                    algorithm.Debug(f"[Risk] Stop loss triggered for {symbol} at ${current_price:.2f}")
                    del self.entry_prices[symbol]
                    del self.stop_prices[symbol]

                elif holdings.Quantity < 0 and current_price > self.stop_prices[symbol]:
                    algorithm.Liquidate(symbol)
                    algorithm.Debug(f"[Risk] Stop loss triggered for {symbol} at ${current_price:.2f}")
                    del self.entry_prices[symbol]
                    del self.stop_prices[symbol]

        return targets


# ========== 主策略类 ==========

class FrameworkDemoAlgorithm(QCAlgorithm):
    """
    Framework 策略演示

    完整使用所有五个模型构建策略
    """

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

        # ========== Universe Selection ==========
        # 惯用入口是 AddUniverse（粗筛 + 精筛）；
        # FineFundamentalUniverse 无字符串名构造，
        # SetUniverseSelection 只接受 IUniverseSelectionModel
        self.AddUniverse(self.CoarseSelection, self.FineSelection)

        # ========== Alpha Model ==========
        # 创建复合 Alpha 模型
        composite_alpha = CompositeAlphaModel()
        composite_alpha.AddModel(RsiAlphaModel(period=14, oversold=30, overbought=70))
        composite_alpha.AddModel(MacdAlphaModel())

        self.SetAlpha(composite_alpha)

        # ========== Portfolio Construction ==========
        self.SetPortfolioConstruction(
            EqualWeightingPortfolioConstructionModel(portfolio_bias=PortfolioBias.Long)
        )

        # ========== Execution Model ==========
        self.SetExecution(ImmediateExecutionModel())

        # ========== Risk Management ==========
        # 组合多个风险模型
        self.SetRiskManagement(
            CompositeRiskManagementModel(
                MaxDrawdownRiskManagementModel(max_drawdown_pct=0.15),
                MaxPositionSizeRiskModel(max_position_size=0.2),
                StopLossRiskModel(stop_loss_pct=0.05)
            )
        )

        # ========== 其他设置 ==========
        self.SetWarmUp(TimeSpan.FromDays(60))

        # 调试输出
        self.Debug("=" * 60)
        self.Debug("Framework Strategy Initialized")
        self.Debug("Alpha: RSI + MACD")
        self.Debug("Portfolio Construction: Equal Weighting")
        self.Debug("Execution: Immediate")
        self.Debug("Risk: Max Drawdown + Max Position Size + Stop Loss")
        self.Debug("=" * 60)


    def CoarseSelection(self, coarse):
        """粗筛选"""
        # 基本筛选条件
        filtered = [c for c in coarse
                   if c.HasFundamentalData and
                   c.Price > 10 and
                   c.Volume > 1000000]

        # 按交易量排序，取前 200
        sorted_by_volume = sorted(
            filtered,
            key=lambda c: c.DollarVolume,
            reverse=True
        )

        return [c.Symbol for c in sorted_by_volume[:200]]


    def FineSelection(self, fine):
        """精筛选"""
        # 基本面筛选
        filtered = [f for f in fine
                   if 0 < f.ValuationRatios.PERatio < 30 and
                   f.OperationRatios.ROE.Value > 0]

        # 按 ROE 排序，取前 20
        sorted_by_roe = sorted(
            filtered,
            key=lambda f: f.OperationRatios.ROE.Value,
            reverse=True
        )

        selected = [f.Symbol for f in sorted_by_roe[:20]]

        self.Debug(f"[Universe] Selected {len(selected)} stocks")

        return selected


    def OnOrderEvent(self, orderEvent):
        """订单事件"""
        if orderEvent.Status == OrderStatus.Filled:
            self.Debug(f"[Order] {orderEvent.Symbol} | "
                      f"Qty: {orderEvent.FillQuantity} | "
                      f"Price: ${orderEvent.FillPrice:.2f}")


    def OnEndOfDay(self, symbol):
        """每日收盘"""
        # .NET Keys 集合没有 LINQ 的 First()，用 next(iter(...)) 取第一个
        if symbol == next(iter(self.Securities.Keys)):
            portfolio = self.Portfolio
            self.Debug(f"[EOD] Portfolio: ${portfolio.TotalPortfolioValue:,.2f} | "
                      f"Cash: ${portfolio.Cash:,.2f} | "
                      f"Invested: {portfolio.Invested}")


# ========== 简化版 Framework 策略 ==========

class SimpleFrameworkAlgorithm(QCAlgorithm):
    """
    简化的 Framework 策略

    只使用最基本的模型
    """

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

        # 手动添加股票
        symbols = ["AAPL", "MSFT", "GOOGL", "AMZN", "TSLA"]
        for symbol_str in symbols:
            self.AddEquity(symbol_str, Resolution.Daily)

        # 设置 Alpha
        self.SetAlpha(RsiAlphaModel())

        # 设置组合构建
        self.SetPortfolioConstruction(EqualWeightingPortfolioConstructionModel())

        # 设置执行
        self.SetExecution(ImmediateExecutionModel())

        # 设置风险管理
        self.SetRiskManagement(MaxDrawdownRiskManagementModel(0.1))

        self.SetWarmUp(TimeSpan.FromDays(30))
