import numpy as np
import pandas as pd

def compute_lob_features(lob_df, levels=5):
    """
    从LOB数据中提取特征
    
    Parameters:
    -----------
    lob_df : DataFrame
        LOB数据，包含bid_price_1~5, bid_size_1~5, ask_price_1~5, ask_size_1~5
    levels : int
        使用的档位数
    
    Returns:
    --------
    features : DataFrame
        提取的特征
    """
    features = pd.DataFrame(index=lob_df.index)
    
    # 1. 买卖价差
    features['spread'] = lob_df['ask_price_1'] - lob_df['bid_price_1']
    
    # 2. 加权平均价格（VWAP）
    features['vwap_bid'] = np.sum(lob_df[[f'bid_price_{i}' for i in range(1, levels+1)]].values * 
                                 lob_df[[f'bid_size_{i}' for i in range(1, levels+1)]].values, axis=1) / \
                          np.sum(lob_df[[f'bid_size_{i}' for i in range(1, levels+1)]].values, axis=1)
    
    features['vwap_ask'] = np.sum(lob_df[[f'ask_price_{i}' for i in range(1, levels+1)]].values * 
                                 lob_df[[f'ask_size_{i}' for i in range(1, levels+1)]].values, axis=1) / \
                          np.sum(lob_df[[f'ask_size_{i}' for i in range(1, levels+1)]].values, axis=1)
    
    # 3. 订单不平衡（Order Imbalance）
    for i in range(1, levels+1):
        features[f'imbalance_{i}'] = (lob_df[f'bid_size_{i}'] - lob_df[f'ask_size_{i}']) / \
                                      (lob_df[f'bid_size_{i}'] + lob_df[f'ask_size_{i}'])
    
    # 4. 市场深度
    features['depth_bid'] = np.sum(lob_df[[f'bid_size_{i}' for i in range(1, levels+1)]].values, axis=1)
    features['depth_ask'] = np.sum(lob_df[[f'ask_size_{i}' for i in range(1, levels+1)]].values, axis=1)
    
    return features

# 使用示例
# features = compute_lob_features(lob_df, levels=5)

def compute_ofi(tick_data, window=10):
    """
    计算订单流不平衡指标
    
    Parameters:
    -----------
    tick_data : DataFrame
        逐笔成交数据，包含price, size, side（买/卖）
    window : int
        滚动窗口大小
    
    Returns:
    --------
    ofi : Series
        订单流不平衡指标
    """
    # 计算每笔订单的OFI贡献
    tick_data['ofi_contrib'] = np.where(tick_data['side'] == 'BUY', 
                                         tick_data['size'], 
                                         -tick_data['size'])
    
    # 滚动求和
    ofi = tick_data['ofi_contrib'].rolling(window=window).sum()
    
    return ofi

# 策略信号
# signal = 1 if OFI > threshold else -1 if OFI < -threshold else 0

def compute_volume_profile(tick_data, price_bins=100):
    """
    计算成交量分布
    
    Parameters:
    -----------
    tick_data : DataFrame
        逐笔成交数据，包含price, size
    price_bins : int
        价格分箱数量
    
    Returns:
    --------
    profile : DataFrame
        每个价格级别的成交量
    """
    # 价格分箱
    price_min = tick_data['price'].min()
    price_max = tick_data['price'].max()
    bins = np.linspace(price_min, price_max, price_bins)
    
    # 计算每个价格级别的成交量
    tick_data['price_bin'] = pd.cut(tick_data['price'], bins=bins, labels=False)
    profile = tick_data.groupby('price_bin')['size'].sum().reset_index()
    profile['price_level'] = bins[profile['price_bin'].values]
    
    # 计算POC和Value Area
    total_volume = profile['size'].sum()
    poc_idx = profile['size'].idxmax()
    poc_price = profile.loc[poc_idx, 'price_level']
    
    # Value Area (70%成交量)
    profile_sorted = profile.sort_values('size', ascending=False)
    cumulative_volume = profile_sorted['size'].cumsum()
    value_area_idx = cumulative_volume <= 0.7 * total_volume
    value_area = profile_sorted[value_area_idx]
    vah = value_area['price_level'].max()
    val = value_area['price_level'].min()
    
    return profile, poc_price, vah, val

# 交易信号
# 当价格离开Value Area时，倾向于回归；
# 当价格突破VAH/VAL时，倾向于趋势延续。

def detect_iceberg_orders(lob_snapshots, threshold=0.8):
    """
    检测冰山订单
    
    Parameters:
    -----------
    lob_snapshots : DataFrame
        LOB快照序列
    threshold : float
        冰山订单判定阈值（成交后补充的概率）
    
    Returns:
    --------
    iceberg_signals : list
        检测到的冰山订单列表
    """
    iceberg_signals = []
    
    for i in range(1, len(lob_snapshots)):
        prev = lob_snapshots.iloc[i-1]
        curr = lob_snapshots.iloc[i]
        
        for level in range(1, 6):  # 检查前5档
            prev_size = prev[f'bid_size_{level}']
            curr_size = curr[f'bid_size_{level}']
            prev_price = prev[f'bid_price_{level}']
            curr_price = curr[f'bid_price_{level}']
            
            # 条件：价格不变，订单被成交（size减少），然后立即补充
            if prev_price == curr_price and curr_size < prev_size:
                # 计算补充概率（简化版）
                replenish_prob = compute_replenish_probability(lob_snapshots, i, level)
                if replenish_prob > threshold:
                    iceberg_signals.append({
                        'timestamp': curr.name,
                        'price': curr_price,
                        'level': level,
                        'estimated_size': prev_size * 5  # 估计真实大小
                    })
    
    return iceberg_signals

class HFT_RiskManager:
    def __init__(self, max_position=1000, max_loss_per_trade=1000, max_daily_loss=10000):
        self.max_position = max_position  # 最大持仓
        self.max_loss_per_trade = max_loss_per_trade  # 单笔最大亏损
        self.max_daily_loss = max_daily_loss  # 每日最大亏损
        self.daily_pnl = 0  # 当日盈亏
        
    def check_pre_trade(self, order):
        """交易前检查"""
        # 1. 持仓限制
        if abs(self.current_position + order['size']) > self.max_position:
            return False, "Exceeds max position"
        
        # 2. 单笔亏损限制
        if order['estimated_loss'] > self.max_loss_per_trade:
            return False, "Exceeds max loss per trade"
        
        # 3. 每日亏损限制
        if self.daily_pnl + order['estimated_loss'] < -self.max_daily_loss:
            return False, "Exceeds max daily loss"
        
        return True, "Pass"
    
    def check_post_trade(self, execution_result):
        """交易后更新"""
        self.daily_pnl += execution_result['pnl']
        self.current_position += execution_result['filled_size']