graph LR
    subgraph "アービトラージの仕組み"
        A[取引所A<br/>BTC: $40,000] -->|買い| B[トレーダー]
        B -->|売り| C[取引所B<br/>BTC: $40,200]
        B -->|利益| D[$200/BTC<br/>（手数料前）]
    end
    
    style A fill:#ffcdd2
    style C fill:#c8e6c9
    style D fill:#fff9c4

# arbitrage/detector.py
import numpy as np
from typing import Dict, List, Optional
from datetime import datetime
import pandas as pd

class ArbitrageDetector:
    """アービトラージ検出システム
    
    複数の取引所間で価格差を監視し、利益機会を自動検出します。
    手数料やスプレッドを考慮した実利益計算も行います。
    """
    
    def __init__(self, data_manager, min_profit_pct: float = 0.3):
        """
        Args:
            data_manager: データ管理クラス
            min_profit_pct: 最小利益率（%）。これ以下の機会は無視
        """
        self.data_manager = data_manager
        self.min_profit_pct = min_profit_pct
        self.opportunities = []  # 検出した機会を保存
        
        # 取引所別の手数料（%）
        self.trading_fees = {
            'binance': 0.1,      # 0.1%
            'coinbase': 0.5,     # 0.5%
            'bybit': 0.1,        # 0.1%
            'kraken': 0.26,      # 0.26%
            'bitfinex': 0.2      # 0.2%
        }
        
        # 送金手数料（概算）
        self.transfer_fees = {
            'BTC': 0.0005,       # 0.0005 BTC
            'ETH': 0.005,        # 0.005 ETH
            'USDT': 1.0          # 1 USDT
        }
    
    async def detect_opportunities(self, symbols: List[str]) -> List[Dict]:
        """アービトラージ機会を検出
        
        すべての取引所ペアで価格差をチェックし、
        利益が出る組み合わせを探します。
        
        Args:
            symbols: チェックする銘柄リスト
            
        Returns:
            検出された機会のリスト
        """
        opportunities = []
        
        # 最新価格を取得
        latest_prices = self.data_manager.get_latest_prices(symbols)
        
        for symbol in symbols:
            if symbol not in latest_prices:
                continue
            
            # 取引所別の価格データを収集
            exchange_prices = []
            for exchange, price_data in latest_prices[symbol].items():
                if price_data and 'bid_price' in price_data and 'ask_price' in price_data:
                    exchange_prices.append({
                        'exchange': exchange,
                        'bid': price_data['bid_price'],  # 売り注文価格
                        'ask': price_data['ask_price'],  # 買い注文価格
                        'timestamp': price_data['timestamp']
                    })
            
            # 最低2つの取引所のデータが必要
            if len(exchange_prices) < 2:
                continue
            
            # すべての取引所ペアをチェック
            for i in range(len(exchange_prices)):
                for j in range(i + 1, len(exchange_prices)):
                    opportunity = self._calculate_arbitrage(
                        symbol,
                        exchange_prices[i],
                        exchange_prices[j]
                    )
                    
                    if opportunity:
                        opportunities.append(opportunity)
        
        # 利益率でソート（降順）
        opportunities.sort(key=lambda x: x['net_profit_pct'], reverse=True)
        
        # 履歴に追加
        self.opportunities.extend(opportunities)
        
        return opportunities
    
    def _calculate_arbitrage(self, symbol: str, exchange1_data: Dict, 
                           exchange2_data: Dict) -> Optional[Dict]:
        """2つの取引所間のアービトラージを計算
        
        実際の取引を想定して、以下を考慮します：
        1. スプレッド（bid/askの差）
        2. 取引手数料
        3. 最小利益率
        
        Args:
            symbol: 取引銘柄
            exchange1_data: 取引所1の価格データ
            exchange2_data: 取引所2の価格データ
            
        Returns:
            利益がある場合は機会の詳細、なければNone
        """
        # ケース1: exchange1で買い、exchange2で売る
        buy_price_1 = exchange1_data['ask']  # 買うときはask価格
        sell_price_2 = exchange2_data['bid']  # 売るときはbid価格
        profit_1 = sell_price_2 - buy_price_1
        profit_pct_1 = (profit_1 / buy_price_1) * 100
        
        # ケース2: exchange2で買い、exchange1で売る
        buy_price_2 = exchange2_data['ask']
        sell_price_1 = exchange1_data['bid']
        profit_2 = sell_price_1 - buy_price_2
        profit_pct_2 = (profit_2 / buy_price_2) * 100
        
        # より利益の大きい方を選択
        if profit_pct_1 > profit_pct_2:
            buy_exchange = exchange1_data['exchange']
            sell_exchange = exchange2_data['exchange']
            buy_price = buy_price_1
            sell_price = sell_price_2
            gross_profit_pct = profit_pct_1
        else:
            buy_exchange = exchange2_data['exchange']
            sell_exchange = exchange1_data['exchange']
            buy_price = buy_price_2
            sell_price = sell_price_1
            gross_profit_pct = profit_pct_2
        
        # 手数料を計算
        buy_fee_pct = self.trading_fees.get(buy_exchange, 0.2)
        sell_fee_pct = self.trading_fees.get(sell_exchange, 0.2)
        total_fee_pct = buy_fee_pct + sell_fee_pct
        
        # 純利益を計算
        net_profit_pct = gross_profit_pct - total_fee_pct
        
        # 最小利益率をクリアしているかチェック
        if net_profit_pct < self.min_profit_pct:
            return None
        
        # スプレッドを計算（市場の流動性指標）
        spread_1 = ((exchange1_data['ask'] - exchange1_data['bid']) / 
                   exchange1_data['ask']) * 100
        spread_2 = ((exchange2_data['ask'] - exchange2_data['bid']) / 
                   exchange2_data['ask']) * 100
        
        # 実行可能性スコアを計算
        feasibility_score = self._calculate_feasibility_score(
            net_profit_pct, spread_1, spread_2
        )
        
        return {
            'symbol': symbol,
            'buy_exchange': buy_exchange,
            'sell_exchange': sell_exchange,
            'buy_price': buy_price,
            'sell_price': sell_price,
            'gross_profit_pct': gross_profit_pct,
            'buy_fee_pct': buy_fee_pct,
            'sell_fee_pct': sell_fee_pct,
            'total_fee_pct': total_fee_pct,
            'net_profit_pct': net_profit_pct,
            'spread_buy': spread_1 if buy_exchange == exchange1_data['exchange'] else spread_2,
            'spread_sell': spread_2 if sell_exchange == exchange2_data['exchange'] else spread_1,
            'feasibility_score': feasibility_score,
            'timestamp': datetime.now()
        }
    
    def _calculate_feasibility_score(self, net_profit_pct: float, 
                                   spread_1: float, spread_2: float) -> float:
        """実行可能性スコアを計算
        
        利益率が高く、スプレッドが狭いほど高スコアになります。
        
        Returns:
            0-10のスコア（10が最高）
        """
        # 利益率スコア（最大5点）
        profit_score = min(net_profit_pct * 2, 5)
        
        # スプレッドスコア（最大5点）
        avg_spread = (spread_1 + spread_2) / 2
        spread_score = max(0, 5 - avg_spread * 10)
        
        return round(profit_score + spread_score, 1)
    
    def calculate_actual_profit(self, opportunity: Dict, 
                              investment_amount: float) -> Dict:
        """実際の利益を計算
        
        投資額に基づいて、具体的な利益額を計算します。
        
        Args:
            opportunity: アービトラージ機会
            investment_amount: 投資額（USD）
            
        Returns:
            詳細な利益計算結果
        """
        # 購入数量を計算
        quantity = investment_amount / opportunity['buy_price']
        
        # 売却額を計算
        gross_revenue = quantity * opportunity['sell_price']
        
        # 手数料を計算
        buy_fee = investment_amount * (opportunity['buy_fee_pct'] / 100)
        sell_fee = gross_revenue * (opportunity['sell_fee_pct'] / 100)
        total_fees = buy_fee + sell_fee
        
        # 純利益を計算
        net_profit = gross_revenue - investment_amount - total_fees
        
        return {
            'investment_amount': investment_amount,
            'quantity': quantity,
            'gross_revenue': gross_revenue,
            'buy_fee': buy_fee,
            'sell_fee': sell_fee,
            'total_fees': total_fees,
            'net_profit': net_profit,
            'roi_pct': (net_profit / investment_amount) * 100
        }

# dashboard/realtime_dashboard.py
import streamlit as st
import plotly.graph_objects as go
import plotly.express as px
from plotly.subplots import make_subplots
import pandas as pd
from datetime import datetime, timedelta
import time

class RealtimeTradingDashboard:
    """リアルタイムトレーディングダッシュボード
    
    価格データ、予測結果、アービトラージ機会を
    統合的に表示するWebアプリケーションです。
    """
    
    def __init__(self, data_manager, predictor, arbitrage_detector):
        self.data_manager = data_manager
        self.predictor = predictor
        self.arbitrage_detector = arbitrage_detector
        
        # Streamlitのページ設定
        st.set_page_config(
            page_title="高度な株価監視ダッシュボード",
            page_icon="📈",
            layout="wide",
            initial_sidebar_state="expanded"
        )
    
    def run(self):
        """ダッシュボードを実行"""
        # タイトルとヘッダー
        st.title("🚀 リアルタイム株価監視ダッシュボード")
        st.markdown("---")
        
        # サイドバーの設定
        self._setup_sidebar()
        
        # メインコンテンツの表示
        self._display_main_content()
        
        # 自動更新の設定
        if st.session_state.get('auto_refresh', False):
            time.sleep(st.session_state.get('refresh_interval', 10))
            st.experimental_rerun()
    
    def _setup_sidebar(self):
        """サイドバーの設定"""
        with st.sidebar:
            st.header("⚙️ 設定")
            
            # 監視銘柄の選択
            symbols = st.multiselect(
                "監視銘柄",
                options=["BTCUSDT", "ETHUSDT", "BNBUSDT", "ADAUSDT", "SOLUSDT"],
                default=["BTCUSDT", "ETHUSDT"],
                help="監視したい銘柄を選択してください"
            )
            st.session_state['symbols'] = symbols
            
            # 表示期間の選択
            time_range = st.selectbox(
                "表示期間",
                options=["1時間", "4時間", "24時間", "7日間"],
                index=2,
                help="チャートの表示期間を選択"
            )
            st.session_state['time_range'] = time_range
            
            # 自動更新の設定
            col1, col2 = st.columns(2)
            with col1:
                auto_refresh = st.checkbox(
                    "自動更新",
                    value=False,
                    help="データを自動的に更新します"
                )
                st.session_state['auto_refresh'] = auto_refresh
            
            with col2:
                if auto_refresh:
                    refresh_interval = st.number_input(
                        "更新間隔（秒）",
                        min_value=5,
                        max_value=300,
                        value=30,
                        step=5
                    )
                    st.session_state['refresh_interval'] = refresh_interval
            
            # アラート設定
            st.markdown("### 🔔 アラート設定")
            
            alert_arbitrage = st.checkbox(
                "アービトラージ検出時に通知",
                value=True
            )
            
            min_profit = st.slider(
                "最小利益率（%）",
                min_value=0.1,
                max_value=5.0,
                value=0.5,
                step=0.1,
                help="この利益率以上の機会のみ通知"
            )
            
            st.session_state['alert_settings'] = {
                'arbitrage': alert_arbitrage,
                'min_profit': min_profit
            }
    
    def _display_main_content(self):
        """メインコンテンツの表示"""
        # 3つのタブを作成
        tab1, tab2, tab3 = st.tabs(["📊 価格監視", "🤖 AI予測", "💰 アービトラージ"])
        
        with tab1:
            self._display_price_monitoring()
        
        with tab2:
            self._display_ai_predictions()
        
        with tab3:
            self._display_arbitrage_opportunities()
    
    def _display_price_monitoring(self):
        """価格監視タブの表示"""
        st.header("📊 リアルタイム価格監視")
        
        # メトリクスの表示
        symbols = st.session_state.get('symbols', ['BTCUSDT'])
        latest_prices = self.data_manager.get_latest_prices(symbols)
        
        # 価格カードを横並びで表示
        cols = st.columns(len(symbols))
        
        for idx, symbol in enumerate(symbols):
            with cols[idx]:
                if symbol in latest_prices:
                    # 複数の取引所から最新価格を取得
                    prices = []
                    for exchange, data in latest_prices[symbol].items():
                        if data:
                            prices.append({
                                'exchange': exchange,
                                'price': data.get('close_price', 0),
                                'change': data.get('price_change_pct_24h', 0)
                            })
                    
                    if prices:
                        # 平均価格を計算
                        avg_price = sum(p['price'] for p in prices) / len(prices)
                        avg_change = sum(p['change'] for p in prices) / len(prices)
                        
                        # メトリクスカード
                        st.metric(
                            label=symbol,
                            value=f"${avg_price:,.2f}",
                            delta=f"{avg_change:+.2f}%"
                        )
                        
                        # 取引所別価格
                        with st.expander("取引所別価格"):
                            for p in prices:
                                st.text(f"{p['exchange']}: ${p['price']:,.2f}")
        
        # 価格チャート
        st.subheader("価格チャート")
        selected_symbol = st.selectbox(
            "銘柄選択",
            options=symbols,
            key="chart_symbol"
        )
        
        if selected_symbol:
            self._display_price_chart(selected_symbol)
    
    def _display_price_chart(self, symbol: str):
        """価格チャートの表示"""
        # 時間範囲の取得
        time_range = st.session_state.get('time_range', '24時間')
        hours_map = {
            "1時間": 1,
            "4時間": 4,
            "24時間": 24,
            "7日間": 168
        }
        hours = hours_map[time_range]
        
        # データベースから価格データを取得
        df = self._get_price_data(symbol, hours)
        
        if not df.empty:
            # Plotlyでローソク足チャートを作成
            fig = make_subplots(
                rows=2, cols=1,
                shared_xaxes=True,
                vertical_spacing=0.03,
                row_heights=[0.7, 0.3],
                subplot_titles=("価格", "出来高")
            )
            
            # ローソク足
            fig.add_trace(
                go.Candlestick(
                    x=df['timestamp'],
                    open=df['open_price'],
                    high=df['high_price'],
                    low=df['low_price'],
                    close=df['close_price'],
                    name='価格'
                ),
                row=1, col=1
            )
            
            # 出来高
            fig.add_trace(
                go.Bar(
                    x=df['timestamp'],
                    y=df['volume_24h'],
                    name='出来高',
                    marker_color='rgba(0,123,255,0.5)'
                ),
                row=2, col=1
            )
            
            # レイアウト設定
            fig.update_layout(
                title=f"{symbol} - {time_range}",
                xaxis_title="時間",
                yaxis_title="価格 (USD)",
                hovermode='x unified',
                height=600,
                showlegend=False
            )
            
            # チャートを表示
            st.plotly_chart(fig, use_container_width=True)
        else:
            st.info("データがありません")
    
    def _display_ai_predictions(self):
        """AI予測タブの表示"""
        st.header("🤖 AI価格予測")
        
        symbols = st.session_state.get('symbols', ['BTCUSDT'])
        
        # 予測実行ボタン
        if st.button("予測を実行", type="primary"):
            with st.spinner("予測中..."):
                predictions = []
                
                for symbol in symbols:
                    # 予測実行（実際の実装では非同期で実行）
                    df = self._get_price_data(symbol, 24)
                    if len(df) >= 60:  # 最低必要なデータ数
                        try:
                            prediction = self.predictor.predict(df)
                            prediction['symbol'] = symbol
                            predictions.append(prediction)
                        except Exception as e:
                            st.error(f"{symbol}の予測に失敗: {e}")
                
                # 予測結果を表示
                if predictions:
                    st.success("予測完了！")
                    self._display_prediction_results(predictions)
                else:
                    st.warning("予測できませんでした")
    
    def _display_prediction_results(self, predictions: List[Dict]):
        """予測結果の表示"""
        # 予測結果をDataFrameに変換
        df_predictions = pd.DataFrame(predictions)
        
        # 予測サマリー
        st.subheader("予測サマリー")
        
        cols = st.columns(len(predictions))
        for idx, pred in enumerate(predictions):
            with cols[idx]:
                # 予測方向によって色を変更
                if pred['price_change_pct'] > 0:
                    color = "green"
                    icon = "📈"
                else:
                    color = "red"
                    icon = "📉"
                
                st.markdown(f"""
                <div style="background-color: #f0f2f6; padding: 20px; border-radius: 10px; text-align: center;">
                    <h3>{pred['symbol']} {icon}</h3>
                    <p style="font-size: 24px; color: {color}; margin: 10px 0;">
                        {pred['price_change_pct']:+.2f}%
                    </p>
                    <p>予測価格: ${pred['predicted_price']:,.2f}</p>
                    <p>信頼度: {pred['confidence']*100:.1f}%</p>
                </div>
                """, unsafe_allow_html=True)
        
        # 詳細テーブル
        st.subheader("詳細データ")
        st.dataframe(
            df_predictions[['symbol', 'current_price', 'predicted_price', 
                          'price_change_pct', 'confidence']],
            use_container_width=True
        )
    
    def _display_arbitrage_opportunities(self):
        """アービトラージタブの表示"""
        st.header("💰 アービトラージ機会")
        
        # アービトラージ検出実行
        if st.button("機会を検出", type="primary"):
            with st.spinner("検出中..."):
                symbols = st.session_state.get('symbols', ['BTCUSDT'])
                opportunities = asyncio.run(
                    self.arbitrage_detector.detect_opportunities(symbols)
                )
                
                if opportunities:
                    st.success(f"{len(opportunities)}個の機会を検出！")
                    self._display_arbitrage_results(opportunities)
                else:
                    st.info("現在、アービトラージ機会はありません")
    
    def _display_arbitrage_results(self, opportunities: List[Dict]):
        """アービトラージ結果の表示"""
        # 最も利益率の高い機会を強調表示
        best_opp = opportunities[0]
        
        st.markdown("### 🎯 最良の機会")
        col1, col2, col3 = st.columns(3)
        
        with col1:
            st.metric(
                "銘柄",
                best_opp['symbol'],
                f"{best_opp['buy_exchange']} → {best_opp['sell_exchange']}"
            )
        
        with col2:
            st.metric(
                "純利益率",
                f"{best_opp['net_profit_pct']:.2f}%",
                f"手数料込み"
            )
        
        with col3:
            st.metric(
                "実行可能性スコア",
                f"{best_opp['feasibility_score']}/10",
                "スプレッド考慮"
            )
        
        # 利益シミュレーター
        st.markdown("### 💵 利益シミュレーター")
        
        investment = st.number_input(
            "投資額 (USD)",
            min_value=100.0,
            max_value=100000.0,
            value=10000.0,
            step=1000.0
        )
        
        profit_calc = self.arbitrage_detector.calculate_actual_profit(
            best_opp, investment
        )
        
        col1, col2, col3, col4 = st.columns(4)
        
        with col1:
            st.metric("投資額", f"${profit_calc['investment_amount']:,.2f}")
        
        with col2:
            st.metric("手数料合計", f"${profit_calc['total_fees']:,.2f}")
        
        with col3:
            st.metric("純利益", f"${profit_calc['net_profit']:,.2f}")
        
        with col4:
            st.metric("ROI", f"{profit_calc['roi_pct']:.2f}%")
        
        # すべての機会のテーブル
        st.markdown("### 📋 すべての機会")
        
        df_opps = pd.DataFrame(opportunities)
        df_display = df_opps[[
            'symbol', 'buy_exchange', 'sell_exchange',
            'buy_price', 'sell_price', 'net_profit_pct',
            'feasibility_score'
        ]].round(2)
        
        st.dataframe(
            df_display,
            use_container_width=True,
            hide_index=True
        )
    
    def _get_price_data(self, symbol: str, hours: int) -> pd.DataFrame:
        """価格データを取得"""
        # 実際の実装ではデータベースから取得
        # ここではデモ用のダミーデータを返す
        return pd.DataFrame()  # 実装省略

# アプリケーション起動
def run_dashboard():
    """ダッシュボードを起動"""
    # 各コンポーネントの初期化（実際の実装）
    # data_manager = DataManager(...)
    # predictor = LSTMPricePredictor(...)
    # arbitrage_detector = ArbitrageDetector(...)
    
    # dashboard = RealtimeTradingDashboard(
    #     data_manager, predictor, arbitrage_detector
    # )
    # dashboard.run()
    
    st.info("ダッシュボードのデモ版です。実際のデータ接続には設定が必要です。")

if __name__ == "__main__":
    run_dashboard()

# notifiers/multi_channel.py
from slack_sdk import WebClient
from discord_webhook import DiscordWebhook, DiscordEmbed
import smtplib
from email.mime.text import MIMEText
import asyncio

class MultiChannelNotifier:
    """マルチチャネル通知システム
    
    重要なイベントを複数のチャネルに通知します。
    """
    
    def __init__(self, config: Dict):
        """
        Args:
            config: 各チャネルの設定情報
        """
        self.config = config
        
        # Slack設定
        if config.get('slack', {}).get('enabled'):
            self.slack_client = WebClient(token=config['slack']['bot_token'])
            self.slack_channel = config['slack']['channel']
        else:
            self.slack_client = None
        
        # Discord設定
        if config.get('discord', {}).get('enabled'):
            self.discord_webhook_url = config['discord']['webhook_url']
        else:
            self.discord_webhook_url = None
    
    async def send_arbitrage_alert(self, opportunity: Dict):
        """アービトラージアラートを送信"""
        # メッセージを作成
        title = f"💰 アービトラージ機会検出: {opportunity['symbol']}"
        
        message = f"""
純利益率: {opportunity['net_profit_pct']:.2f}%
買い: {opportunity['buy_exchange']} @ ${opportunity['buy_price']:,.2f}
売り: {opportunity['sell_exchange']} @ ${opportunity['sell_price']:,.2f}
実行可能性スコア: {opportunity['feasibility_score']}/10
"""
        
        # 各チャネルに送信
        tasks = []
        
        if self.slack_client:
            tasks.append(self._send_to_slack(title, message))
        
        if self.discord_webhook_url:
            tasks.append(self._send_to_discord(title, message, opportunity))
        
        # 並行送信
        await asyncio.gather(*tasks, return_exceptions=True)
    
    async def _send_to_slack(self, title: str, message: str):
        """Slackに送信"""
        try:
            response = self.slack_client.chat_postMessage(
                channel=self.slack_channel,
                text=title,
                blocks=[
                    {
                        "type": "header",
                        "text": {"type": "plain_text", "text": title}
                    },
                    {
                        "type": "section",
                        "text": {"type": "mrkdwn", "text": message}
                    }
                ]
            )
            return response
        except Exception as e:
            print(f"Slack送信エラー: {e}")
    
    async def _send_to_discord(self, title: str, message: str, data: Dict):
        """Discordに送信"""
        try:
            webhook = DiscordWebhook(url=self.discord_webhook_url)
            
            # 埋め込みメッセージを作成
            embed = DiscordEmbed(
                title=title,
                description=message,
                color='03b2f8'
            )
            
            # フィールドを追加
            embed.add_embed_field(
                name="取引ペア",
                value=f"{data['buy_exchange']} → {data['sell_exchange']}",
                inline=True
            )
            embed.add_embed_field(
                name="利益率",
                value=f"{data['net_profit_pct']:.2f}%",
                inline=True
            )
            
            webhook.add_embed(embed)
            response = webhook.execute()
            return response
        except Exception as e:
            print(f"Discord送信エラー: {e}")