# Install ccxt if not already installed
!pip install ccxt --quiet

import time
import warnings
import ccxt
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.ticker as mtick
import seaborn as sns

warnings.filterwarnings('ignore')
pd.set_option('display.float_format', '{:.6f}'.format)
pd.set_option('display.max_columns', 20)
pd.set_option('display.width', 120)
sns.set_theme(style='darkgrid', palette='muted')

print(f"ccxt version  : {ccxt.__version__}")
print(f"pandas version: {pd.__version__}")
print("Environment status: Ready.")

EXCHANGES = ['binance', 'bybit', 'okx', 'kraken', 'kucoin']

SYMBOLS = [
    'BTC/USDT',
    'ETH/USDT',
    'SOL/USDT',
    'BNB/USDT',
    'XRP/USDT',
]

REQUEST_TIMEOUT_MS = 10_000  # 10 seconds per request

print("Configuration status: Loaded.")

def initialize_exchanges(exchange_ids: list) -> dict:
    """Instantiate and verify ccxt exchange objects.

    Args:
        exchange_ids (list): A list of exchange IDs (e.g., ['binance', 'bybit']).

    Returns:
        dict: A dictionary mapping exchange IDs to their initialized ccxt objects.
    """
    active_exchanges = {}
    for ex_id in exchange_ids:
        try:
            exchange_class = getattr(ccxt, ex_id)
            exchange = exchange_class({
                'timeout': REQUEST_TIMEOUT_MS,
                'enableRateLimit': True,
            })
            exchange.load_markets()
            active_exchanges[ex_id] = exchange
            print(f"  [OK]   {ex_id:<12} — {len(exchange.markets):>5} markets loaded")
        except Exception as e:
            print(f"  [FAIL] {ex_id:<12} — {type(e).__name__}: {e}")
    return active_exchanges


print("Initializing exchanges...")
exchanges = initialize_exchanges(EXCHANGES)
print(f"Active exchanges count: {len(exchanges)}")

def fetch_ticker_data(exchange_obj, symbol: str) -> dict | None:
    """Fetch ticker data for a single symbol from a single exchange.

    Args:
        exchange_obj: Initialized ccxt exchange object.
        symbol (str): Trading pair symbol (e.g., 'BTC/USDT').

    Returns:
        dict | None: A dictionary containing ticker data or None if an error occurs.
    """
    try:
        if symbol not in exchange_obj.markets:
            return None
        ticker = exchange_obj.fetch_ticker(symbol)
        bid  = ticker.get('bid')  or 0.0
        ask  = ticker.get('ask')  or 0.0
        last = ticker.get('last') or 0.0
        mid_price = (bid + ask) / 2 if (bid and ask) else last
        return {
            'symbol'    : symbol,
            'bid'       : bid,
            'ask'       : ask,
            'last'      : last,
            'volume_24h': ticker.get('baseVolume') or 0.0,
            'mid_price' : mid_price,
        }
    except Exception:
        return None


def compare_prices_across_exchanges(exchange_dict: dict, symbols: list) -> pd.DataFrame:
    """Aggregate bid/ask/mid prices across all exchanges for all target symbols.

    Args:
        exchange_dict (dict): Dictionary of initialized exchange objects.
        symbols (list): List of trading pair symbols.

    Returns:
        pd.DataFrame: DataFrame containing aggregated ticker data.

    Raises:
        RuntimeError: If no ticker data is retrieved.
    """
    records = []
    for ex_id, ex_obj in exchange_dict.items():
        for symbol in symbols:
            data = fetch_ticker_data(ex_obj, symbol)
            if data:
                data['exchange'] = ex_id
                records.append(data)
            time.sleep(0.1)

    if not records:
        raise RuntimeError("No ticker data retrieved. Verify exchange connectivity.")

    df = pd.DataFrame(records)
    col_order = ['exchange', 'symbol', 'bid', 'ask', 'mid_price', 'last', 'volume_24h']
    df = df[[c for c in col_order if c in df.columns]]
    return df.reset_index(drop=True)


print("Fetching price data from all active exchanges...")
price_df = compare_prices_across_exchanges(exchanges, SYMBOLS)

print(f"Records retrieved : {len(price_df)}")
print(f"Exchanges covered : {price_df['exchange'].unique().tolist()}")
print(f"Symbols covered   : {price_df['symbol'].unique().tolist()}")
print("Sample records of fetched data:")
print(price_df.head(10).to_string(index=False))

price_stats = (
    price_df
    .groupby('symbol')['mid_price']
    .agg(count='count', mean='mean', std='std', min_px='min', max_px='max')
)
price_stats['range']     = price_stats['max_px'] - price_stats['min_px']
price_stats['range_bps'] = (price_stats['range'] / price_stats['mean']) * 10_000
price_stats['cv_pct']    = (price_stats['std'] / price_stats['mean']) * 100

print("Cross-Exchange Price Summary (mid-price basis):")
print("=" * 75)
print(price_stats.round(4).to_string())

price_pivot = price_df.pivot_table(index='symbol', columns='exchange', values='mid_price')

price_normalized = price_pivot.apply(lambda row: (row / row.mean() - 1) * 100, axis=1)

fig, axes = plt.subplots(1, 2, figsize=(18, 6))
fig.suptitle('Cross-Exchange Price Comparison', fontsize=14, fontweight='bold', y=1.01)

ax1 = axes[0]
price_pivot.plot(kind='bar', ax=ax1, logy=True, width=0.7, edgecolor='white', linewidth=0.5)
ax1.set_title('Mid-Price by Exchange (Log Scale)', fontsize=12)
ax1.set_xlabel('Trading Pair')
ax1.set_ylabel('Mid-Price (USDT, log)')
ax1.legend(title='Exchange', bbox_to_anchor=(1.01, 1), loc='upper left')
ax1.tick_params(axis='x', rotation=30)
ax1.grid(axis='y', alpha=0.5)

ax2 = axes[1]
price_normalized.plot(kind='bar', ax=ax2, width=0.7, edgecolor='white', linewidth=0.5)
ax2.set_title('Price Deviation from Cross-Exchange Mean (%)', fontsize=12)
ax2.set_xlabel('Trading Pair')
ax2.set_ylabel('Deviation (%)')
ax2.axhline(0, color='red', linewidth=1.0, linestyle='--', label='Mean')
ax2.legend(title='Exchange', bbox_to_anchor=(1.01, 1), loc='upper left')
ax2.tick_params(axis='x', rotation=30)
ax2.yaxis.set_major_formatter(mtick.PercentFormatter(decimals=4))
ax2.grid(axis='y', alpha=0.5)

plt.tight_layout()
plt.savefig('92_price_comparison.png', dpi=150, bbox_inches='tight')