import numpy as np
import pandas as pd

class OrderFlowStrategy:
    def __init__(self, threshold=0.7):
        self.threshold = threshold
        self.position = 0
        
    def calculate_ofi(self, order_book_updates):
        """计算订单流不平衡指标"""
        ofi = 0
        for update in order_book_updates:
            if update['side'] == 'buy':
                ofi += update['size']
            else:
                ofi -= update['size']
        return ofi
    
    def generate_signal(self, ofi, threshold):
        """生成交易信号"""
        if ofi > threshold:
            return 1  # 买入信号
        elif ofi < -threshold:
            return -1  # 卖出信号
        else:
            return 0  # 中性
    
    def execute_trade(self, signal, current_price):
        """执行交易"""
        if signal == 1 and self.position <= 0:
            # 买入
            self.position = 1
            print(f"买入 @ {current_price}")
        elif signal == -1 and self.position >= 0:
            # 卖出
            self.position = -1
            print(f"卖出 @ {current_price}")

class MarketMakingStrategy:
    def __init__(self, spread_target=0.02, inventory_limit=100):
        self.spread_target = spread_target
        self.inventory_limit = inventory_limit
        self.inventory = 0
        
    def calculate_quotes(self, mid_price, volatility, time_to_expiry):
        """计算买卖报价"""
        # 使用Avellaneda-Stoikov模型
        sigma = volatility
        T = time_to_expiry
        
        # 风险溢价调整
        delta_bid = (sigma ** 2) * T + (1 / self.inventory_limit) * self.inventory
        delta_ask = (sigma ** 2) * T - (1 / self.inventory_limit) * self.inventory
        
        bid_price = mid_price - (self.spread_target / 2) - delta_bid
        ask_price = mid_price + (self.spread_target / 2) + delta_ask
        
        return bid_price, ask_price
    
    def adjust_for_inventory(self):
        """根据库存调整报价"""
        if self.inventory > self.inventory_limit:
            # 库存过多，降低买价，提高卖价，鼓励卖出
            pass
        elif self.inventory < -self.inventory_limit:
            # 库存不足，提高买价，降低卖价，鼓励买入
            pass

from statsmodels.tsa.stattools import coint
import yfinance as yf

class PairsTradingHF:
    def __init__(self, symbol1, symbol2, entry_zscore=2.0, exit_zscore=0.5):
        self.symbol1 = symbol1
        self.symbol2 = symbol2
        self.entry_zscore = entry_zscore
        self.exit_zscore = exit_zscore
        
    def test_cointegration(self, prices1, prices2):
        """检验协整关系"""
        score, pvalue, _ = coint(prices1, prices2)
        return pvalue < 0.05  # p值小于0.05，认为存在协整
    
    def calculate_spread(self, prices1, prices2):
        """计算价差（对冲比率通过回归得到）"""
        import statsmodels.api as sm
        X = sm.add_constant(prices2)
        model = sm.OLS(prices1, X).fit()
        hedge_ratio = model.params[1]
        
        spread = prices1 - hedge_ratio * prices2
        return spread
    
    def generate_signals(self, spread):
        """生成交易信号"""
        z_score = (spread - spread.mean()) / spread.std()
        
        signals = pd.Series(index=spread.index)
        signals[z_score > self.entry_zscore] = -1  # 价差过大，做空
        signals[z_score < -self.entry_zscore] = 1  # 价差过小，做多
        signals[abs(z_score) < self.exit_zscore] = 0  # 平仓
        
        return signals

class MomentumStrategy:
    def __init__(self, lookback=10, threshold=0.6):
        self.lookback = lookback
        self.threshold = threshold
        
    def calculate_momentum(self, order_flow):
        """计算订单流动量"""
        # 过去N笔订单的净方向
        momentum = order_flow['side'].rolling(window=self.lookback).apply(
            lambda x: sum(x == 'buy') - sum(x == 'sell')
        )
        return momentum
    
    def execute(self, momentum, current_price):
        """执行动量策略"""
        if momentum > self.threshold * self.lookback:
            # 强烈买入动量
            return 'BUY'
        elif momentum < -self.threshold * self.lookback:
            # 强烈卖出动量
            return 'SELL'
        else:
            return 'HOLD'