# オーダーブックから抽出する特徴量
orderbook_features = {
    'bid_ask_spread': 'ビッド・アスクスプレッド',
    'depth_imbalance': '買い板と売り板の不均衡度',
    'weighted_mid_price': '加重平均価格',
    'liquidity_score': '流動性スコア',
    'wall_detection': '大口注文（壁）の検出',
    'order_book_velocity': '板の変化速度',
    'micro_price': 'マイクロプライス（板の厚みを考慮した価格）'
}

# Binance Futures オーダーブックストリーム
binance_orderbook_url = "wss://fstream.binance.com/ws/{symbol}@depth20@100ms"
# 100ミリ秒更新、上下20レベルの板情報

# Hyperliquid L2 Book
hyperliquid_subscription = {
    "method": "subscribe",
    "subscription": {"type": "l2Book", "coin": "ETH"}
}

microstructure_features = {
    'order_flow_toxicity': '有毒な注文流（アドバースセレクション）',
    'kyle_lambda': 'カイルのラムダ（価格インパクト係数）',
    'pin': 'PIN（情報トレーダーの確率）',
    'vpin': 'VPIN（ボリューム同期PIN）',
    'realized_spread': '実効スプレッド',
    'price_improvement': '価格改善率'
}

cross_exchange_features = {
    'price_divergence': '取引所間の価格乖離率',
    'volume_distribution': '出来高の偏り',
    'lead_lag_correlation': 'リード・ラグ相関',
    'arbitrage_opportunity': '裁定機会の検出',
    'exchange_dominance': '価格主導権を持つ取引所'
}

volatility_features = {
    'garch_forecast': 'GARCH予測ボラティリティ',
    'realized_volatility': '実現ボラティリティ',
    'jump_detection': '価格ジャンプの検出',
    'volatility_clustering': 'ボラティリティクラスタリング',
    'vol_of_vol': 'ボラティリティのボラティリティ'
}

regime_features = {
    'hmm_state': '隠れマルコフモデル状態',
    'regime_probability': 'レジーム確率',
    'transition_probability': '状態遷移確率',
    'market_phase': '市場フェーズ（トレンド/レンジ/ボラタイル）'
}

defi_metrics = {
    'defi_rates': 'DeFi金利（Compound, Aave等）',
    'stablecoin_supply': 'ステーブルコイン供給量',
    'tvl': 'Total Value Locked',
    'gas_fees': 'ガス代（Ethereum）',
    'funding_rates': '資金調達率（永久先物）'
}

sentiment_sources = {
    'social_media': 'Twitter/Reddit感情分析',
    'google_trends': 'Google検索トレンド',
    'fear_greed_index': 'Fear & Greedインデックス',
    'news_sentiment': 'ニュース感情分析',
    'whale_alerts': 'クジラアラート（大口送金）'
}

class OrderBookFeatures:
    """オーダーブック特徴量抽出クラス"""

    def __init__(self, depth_levels=20):
        self.depth_levels = depth_levels

    def calculate_spread(self, orderbook):
        """ビッド・アスクスプレッド計算"""
        return orderbook['asks'][0][0] - orderbook['bids'][0][0]

    def calculate_imbalance(self, orderbook, levels=5):
        """板の不均衡度計算"""
        bid_volume = sum([bid[1] for bid in orderbook['bids'][:levels]])
        ask_volume = sum([ask[1] for ask in orderbook['asks'][:levels]])
        return (bid_volume - ask_volume) / (bid_volume + ask_volume)

    def calculate_weighted_mid_price(self, orderbook):
        """加重平均価格計算"""
        best_bid = orderbook['bids'][0]
        best_ask = orderbook['asks'][0]
        return (best_bid[0] * best_ask[1] + best_ask[0] * best_bid[1]) / (best_bid[1] + best_ask[1])

    def detect_walls(self, orderbook, threshold_multiplier=10):
        """大口注文（壁）検出"""
        avg_size = np.mean([order[1] for order in orderbook['bids'][:10] + orderbook['asks'][:10]])
        walls = {
            'bid_walls': [(price, size) for price, size in orderbook['bids'] if size > avg_size * threshold_multiplier],
            'ask_walls': [(price, size) for price, size in orderbook['asks'] if size > avg_size * threshold_multiplier]
        }
        return walls

class MicrostructureAnalyzer:
    """マーケットマイクロストラクチャー分析クラス"""

    def calculate_kyle_lambda(self, trades, orderbook_snapshots):
        """カイルのラムダ（価格インパクト）計算"""
        price_changes = np.diff([t['price'] for t in trades])
        order_flows = [t['size'] * (1 if t['side'] == 'buy' else -1) for t in trades[1:]]

        # 回帰分析で価格インパクトを推定
        from sklearn.linear_model import LinearRegression
        model = LinearRegression()
        model.fit(np.array(order_flows).reshape(-1, 1), price_changes)
        return model.coef_[0]

    def calculate_pin(self, trades, time_window='1h'):
        """PIN（情報トレーダー確率）計算"""
        # Easley-O'Haraモデルに基づく実装
        buys = sum(1 for t in trades if t['side'] == 'buy')
        sells = sum(1 for t in trades if t['side'] == 'sell')

        # 簡略化された計算（実際はより複雑）
        order_imbalance = abs(buys - sells) / (buys + sells)
        return order_imbalance  # 0-1の範囲

    def calculate_vpin(self, trades, bucket_size=50):
        """VPIN（ボリューム同期PIN）計算"""
        # ボリュームバケットに基づく計算
        buckets = []
        current_bucket = {'buy_volume': 0, 'sell_volume': 0, 'total_volume': 0}

        for trade in trades:
            volume = trade['size']
            if trade['side'] == 'buy':
                current_bucket['buy_volume'] += volume
            else:
                current_bucket['sell_volume'] += volume
            current_bucket['total_volume'] += volume

            if current_bucket['total_volume'] >= bucket_size:
                buckets.append(current_bucket)
                current_bucket = {'buy_volume': 0, 'sell_volume': 0, 'total_volume': 0}

        # VPINの計算
        vpins = []
        for i in range(len(buckets) - 50):  # 50バケットのローリングウィンドウ
            window = buckets[i:i+50]
            total_buy = sum(b['buy_volume'] for b in window)
            total_sell = sum(b['sell_volume'] for b in window)
            vpin = abs(total_buy - total_sell) / (total_buy + total_sell)
            vpins.append(vpin)

        return np.mean(vpins) if vpins else 0

class EnsemblePredictor:
    """複数モデルを組み合わせた予測システム"""

    def __init__(self):
        self.models = {
            'lstm_base': LSTMModel(features=['price', 'volume']),
            'lstm_orderbook': LSTMModel(features=['orderbook']),
            'transformer': TransformerModel(),
            'xgboost': XGBoostModel(),
            'orderbook_nn': OrderBookNeuralNetwork()
        }
        self.weights = None

    def train(self, train_data):
        """各モデルの学習と重み付け最適化"""
        predictions = {}

        # 各モデルを学習
        for name, model in self.models.items():
            model.fit(train_data[name])
            predictions[name] = model.predict(train_data['validation'])

        # 最適な重み付けを学習
        self.weights = self.optimize_weights(predictions, train_data['validation']['y'])

    def predict(self, features):
        """アンサンブル予測"""
        predictions = []

        for name, model in self.models.items():
            pred = model.predict(features[name])
            predictions.append(pred * self.weights[name])

        return np.sum(predictions, axis=0)

def create_advanced_features(trades_df, orderbook_df, external_data):
    """高度な特徴量生成"""
    features = pd.DataFrame()

    # 1. オーダーフロー不均衡
    features['order_flow_imbalance'] = calculate_ofi(orderbook_df)

    # 2. マイクロストラクチャーノイズ
    features['microstructure_noise'] = estimate_noise(trades_df)

    # 3. 価格インパクト
    features['price_impact'] = calculate_price_impact(trades_df, orderbook_df)

    # 4. スマートマネー指標
    features['smart_money_flow'] = detect_smart_money(trades_df)

    # 5. 流動性指標
    features['liquidity_measures'] = calculate_liquidity(orderbook_df)

    # 6. クロスエクスチェンジ特徴
    features['cross_exchange_lead'] = calculate_lead_lag(external_data)

    # 7. センチメント特徴
    features['market_sentiment'] = external_data['sentiment_score']

    # 8. DeFi指標
    features['defi_metrics'] = external_data['defi_indicators']

    return features

class RealtimeFeatureEngine:
    """リアルタイム特徴量計算エンジン"""

    def __init__(self):
        self.feature_cache = {}
        self.rolling_windows = {}

    def update_incremental(self, new_data):
        """増分更新による高速計算"""
        # 新しいデータのみを処理
        for feature_name, calculator in self.feature_calculators.items():
            self.feature_cache[feature_name] = calculator.update(
                new_data, 
                self.feature_cache.get(feature_name)
            )

# PyTorch/TensorFlowでのGPU推論
class GPUInference:
    def __init__(self, model_path):
        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
        self.model = torch.load(model_path).to(self.device)

    def batch_predict(self, features_batch):
        with torch.no_grad():
            inputs = torch.tensor(features_batch).to(self.device)
            predictions = self.model(inputs)
        return predictions.cpu().numpy()

class TradingMetrics:
    """トレーディング評価指標"""

    def calculate_sharpe_ratio(self, returns, risk_free_rate=0):
        """シャープレシオ計算"""
        excess_returns = returns - risk_free_rate
        return np.mean(excess_returns) / np.std(excess_returns) * np.sqrt(252)

    def calculate_max_drawdown(self, equity_curve):
        """最大ドローダウン計算"""
        cumulative = np.cumprod(1 + equity_curve)
        running_max = np.maximum.accumulate(cumulative)
        drawdown = (cumulative - running_max) / running_max
        return np.min(drawdown)

    def calculate_profit_factor(self, returns):
        """プロフィットファクター計算"""
        gains = returns[returns > 0].sum()
        losses = abs(returns[returns < 0].sum())
        return gains / losses if losses > 0 else np.inf

    def calculate_win_rate(self, predictions, actuals):
        """勝率計算"""
        correct = np.sum((predictions > 0) == (actuals > 0))
        return correct / len(predictions)