"""
V5.3 策略适配器（SafeLoader）

所有策略必须继承此适配器，统一接口规范。
"""
from typing import Dict, Optional, Tuple
from datetime import datetime
from pandas import DataFrame
from freqtrade.strategy import IStrategy
from freqtrade.persistence import Trade

import sys
import os
from pathlib import Path

# 添加 guardian 模块路径
# 获取 user_data 目录（策略文件所在目录的父目录）
user_data_dir = Path(__file__).parent.parent
guardian_path = user_data_dir / "guardian"

# 确保 guardian 目录在 Python 路径中
if str(user_data_dir) not in sys.path:
    sys.path.insert(0, str(user_data_dir))

# 尝试导入 guardian 模块
try:
    from guardian.allocator import Bucket
    from guardian.regime_fsm import Regime
except ImportError:
    # 如果导入失败，尝试添加绝对路径
    abs_user_data = user_data_dir.resolve()
    if str(abs_user_data) not in sys.path:
        sys.path.insert(0, str(abs_user_data))
    from guardian.allocator import Bucket
    from guardian.regime_fsm import Regime


class V5_3_Adapter(IStrategy):
    """
    V5.3 策略适配器基类
    
    职责：
    1. 统一策略接口（信号 + SL）
    2. Regime Whitelist 检查
    3. 与 Guardian 系统集成
    4. Backtest 模式支持
    """
    
    INTERFACE_VERSION = 3
    
    # === 必须由子类声明的属性 ===
    # 策略桶分类
    bucket: Bucket = Bucket.TREND
    
    # 允许运行的 Regime 列表
    allowed_regimes: list = [Regime.SIDEWAYS]  # 默认仅允许震荡市
    
    # 单次请求风险（R）
    r_request: float = 0.25  # 默认 0.25R
    
    # 策略名称（用于日志）
    strategy_name: str = "Unknown"
    
    # === 可选配置 ===
    # 最小置信度（0.0-1.0）
    min_confidence: float = 0.5
    
    def __init__(self, config: dict) -> None:
        super().__init__(config)
        
        # Guardian 系统引用（由外部注入）
        self.guardian = None
        
        # Backtest 模式标志
        self.is_backtest = config.get("runmode") in ["backtest", "hyperopt"]
        
        # 启动检查
        if not self.is_backtest:
            self._startup_check()
    
    def _startup_check(self):
        """启动时检查配置"""
        assert self.bucket in Bucket, f"策略 {self.strategy_name} 必须声明有效的 bucket"
        assert isinstance(self.allowed_regimes, list) and len(self.allowed_regimes) > 0, \
            f"策略 {self.strategy_name} 必须声明 allowed_regimes"
        assert 0 < self.r_request <= 0.5, \
            f"策略 {self.strategy_name} 的 r_request 必须在 (0, 0.5] 范围内"
    
    def set_guardian(self, guardian):
        """设置 Guardian 系统引用（由外部调用）"""
        self.guardian = guardian
    
    def _check_regime_allowed(self, current_regime: Optional[Regime]) -> bool:
        """检查当前 Regime 是否允许运行"""
        if current_regime is None:
            return False
        return current_regime in self.allowed_regimes
    
    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        """
        子类必须实现此方法，计算指标
        """
        raise NotImplementedError("子类必须实现 populate_indicators")
    
    def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        """
        子类必须实现此方法，输出信号
        
        输出格式：
        - enter_long / enter_short: 1 或 0
        - enter_tag: "StrategyName|RegimeAtEntry"
        - proposed_sl_price: 建议的止损价格（可选，用于计算 SL%）
        - confidence: 0.0-1.0（可选）
        """
        raise NotImplementedError("子类必须实现 populate_entry_trend")
    
    def custom_stake_amount(
        self,
        pair: str,
        current_time: datetime,
        current_rate: float,
        proposed_stake: float,
        min_stake: Optional[float],
        max_stake: float,
        leverage: float,
        entry_tag: Optional[str],
        side: str,
        **kwargs,
    ) -> float:
        """
        自定义仓位大小（与 Guardian 集成）
        
        注意：在 Backtest 模式下，使用简化逻辑
        """
        if self.is_backtest:
            # Backtest 模式：使用默认逻辑或简化版本
            return proposed_stake
        
        if self.guardian is None:
            # Guardian 未初始化，使用默认
            return proposed_stake
        
        # 获取策略信号中的 SL 信息
        dataframe, _ = self.dp.get_analyzed_dataframe(pair, self.timeframe)
        try:
            df = dataframe.loc[dataframe["date"] <= current_time]
            last = df.iloc[-1] if not df.empty else dataframe.iloc[-1]
        except Exception:
            last = dataframe.iloc[-1]
        
        # 提取 proposed_sl_price（如果存在）
        proposed_sl_price = last.get("proposed_sl_price")
        if proposed_sl_price is None or proposed_sl_price == 0:
            # 使用默认 SL（策略的 stoploss）
            strategy_sl_pct = abs(self.stoploss) if self.stoploss < 0 else 0.02
        else:
            # 计算 SL%
            if side == "long":
                strategy_sl_pct = abs((proposed_sl_price - current_rate) / current_rate)
            else:  # short
                strategy_sl_pct = abs((current_rate - proposed_sl_price) / current_rate)
        
        # 提取 confidence
        confidence = last.get("confidence", 1.0)
        if confidence is None:
            confidence = 1.0
        
        # 调用 Guardian 检查
        direction = "LONG" if side == "long" else "SHORT"
        result = self.guardian.check_trade_request(
            pair=pair,
            direction=direction,
            strategy_name=self.strategy_name,
            bucket=self.bucket,
            r_request=self.r_request,
            strategy_sl_pct=strategy_sl_pct,
            confidence=confidence,
        )
        
        if not result["allowed"]:
            # 不允许开仓，返回 0
            # 记录 reason_code（可通过日志系统）
            return 0.0
        
        # 使用 Guardian 计算的仓位大小
        position_value = result["position_value"]
        
        # 转换为 freqtrade 的 stake_amount（考虑杠杆）
        stake_amount = position_value / leverage if leverage > 0 else position_value
        
        return min(stake_amount, max_stake)
    
    def adjust_trade_position(
        self,
        trade: Trade,
        current_time: datetime,
        current_rate: float,
        current_profit: float,
        min_stake: Optional[float],
        max_stake: float,
        current_entry_rate: float,
        current_exit_rate: float,
        current_entry_profit: float,
        current_exit_profit: float,
        **kwargs,
    ) -> Optional[float]:
        """
        禁止策略自行加仓（由 Guardian 统一管理）
        """
        return None
    
    def confirm_trade_entry(
        self,
        pair: str,
        order_type: str,
        amount: float,
        rate: float,
        time_in_force: str,
        current_time: datetime,
        entry_tag: Optional[str],
        side: str,
        **kwargs,
    ) -> bool:
        """
        确认开仓（记录到 Guardian）
        """
        if not self.is_backtest and self.guardian:
            # 获取实际分配的仓位信息（需要从 custom_stake_amount 的结果中获取）
            # 简化：这里只做确认，实际记录在 custom_stake_amount 中完成
            pass
        
        return True
    
    def confirm_trade_exit(
        self,
        pair: str,
        trade: Trade,
        order_type: str,
        amount: float,
        rate: float,
        time_in_force: str,
        exit_reason: str,
        current_time: datetime,
        **kwargs,
    ) -> bool:
        """
        确认平仓（记录到 Guardian）
        """
        if not self.is_backtest and self.guardian:
            # 计算盈亏百分比
            profit_pct = trade.calc_profit_ratio(rate)
            
            # 记录到 Guardian
            self.guardian.record_trade_closed(
                pair=pair,
                bucket=self.bucket,
                profit_pct=profit_pct,
            )
        
        return True