Tracking Crypto Derivatives

# Crypto Derivatives Tracker Configuration
# ==========================================

# General settings
general:
  # Default output format: console or json
  default_format: console

  # Default symbols to track
  default_symbols:
    - BTC
    - ETH

  # Cache TTL in seconds
  cache_ttl: 300

  # Request timeout in seconds
  request_timeout: 30

# Exchange configuration
exchanges:
  # Enabled exchanges for data collection
  enabled:
    - binance
    - bybit
    - okx
    - deribit
    - bitmex

  # Primary exchange for each data type
  primary:
    funding: binance
    open_interest: binance
    liquidations: binance
    options: deribit
    basis: binance

  # Rate limits (requests per minute)
  rate_limits:
    binance: 1200
    bybit: 120
    okx: 60
    deribit: 100
    bitmex: 30

# Funding rate settings
funding:
  # Interpretation thresholds (8-hour rate as percentage)
  thresholds:
    extreme: 0.08    # Above this is extreme
    strong: 0.03     # Above this is strong
    neutral: 0.005   # Below this is neutral

  # Minimum spread for arbitrage alerts (percentage)
  min_arb_spread: 0.02

  # Alert on extreme funding
  alert_extreme: true

# Open interest settings
open_interest:
  # Trend detection thresholds (24h change percentage)
  thresholds:
    strong_change: 10.0    # >10% is strong move
    moderate_change: 5.0   # >5% is moderate

  # Divergence detection minimum change
  divergence_min_change: 2.0

# Liquidation settings
liquidations:
  # Cascade risk thresholds (USD within 5% of price)
  cascade_thresholds:
    critical: 500000000   # $500M
    high: 200000000       # $200M
    medium: 100000000     # $100M

  # Minimum liquidation size to track (USD)
  min_liquidation_size: 100000

  # Large liquidation threshold (USD)
  large_liquidation_threshold: 1000000

# Options settings
options:
  # IV interpretation thresholds (percentage)
  iv_thresholds:
    high: 70.0
    low: 40.0

  # Put/call ratio interpretation
  pcr_thresholds:
    bearish: 1.2    # Above this is bearish
    bullish: 0.7    # Below this is bullish

  # Days until expiry for pressure levels
  expiry_pressure:
    high: 2      # <= 2 days
    medium: 7    # <= 7 days

# Basis settings
basis:
  # Structure interpretation thresholds (annualized percentage)
  structure_thresholds:
    strong: 5.0      # >5% annualized is strong
    moderate: 2.0    # >2% is moderate

  # Minimum yield for carry trade alerts
  min_carry_yield: 5.0

# Output formatting
formatting:
  # Console width
  console_width: 70

  # Number of decimal places
  decimals:
    rate: 4
    percentage: 2
    currency: 0

  # Currency formatting
  currency:
    symbol: "$"
    thousands_separator: ","
    decimal_separator: "."

# Alerts and notifications
alerts:
  # Enable alerts
  enabled: false

  # Alert conditions
  conditions:
    extreme_funding: true
    high_cascade_risk: true
    large_liquidation: true
    oi_divergence: true

  # Webhook URL for alerts (optional)
  webhook_url: ""

# Logging
logging:
  # Log level: DEBUG, INFO, WARNING, ERROR
  level: INFO

  # Log file path (optional)
  file: ""

  # Log format
  format: "%(asctime)s - %(name)s - %(levelname)s - %(message)s"

#!/usr/bin/env python3
"""
Basis and spread calculator.

Calculates futures basis and spreads with:
- Spot-futures basis tracking
- Annualized basis yield
- Term structure analysis
- Contango/backwardation detection
"""

from dataclasses import dataclass
from decimal import Decimal
from typing import Dict, List, Optional
from datetime import datetime, date

from exchange_client import ExchangeClient, BasisData, Exchange


@dataclass
class BasisAnalysis:
    """Comprehensive basis analysis."""

    symbol: str
    spot_price: Decimal
    basis_data: List[BasisData]
    avg_basis_pct: float
    avg_annualized: float
    market_structure: str          # "contango", "backwardation", "mixed"
    structure_strength: str        # "strong", "moderate", "weak"
    best_carry_expiry: Optional[str]
    best_carry_yield: float
    timestamp: datetime


@dataclass
class CarryOpportunity:
    """Cash-and-carry arbitrage opportunity."""

    symbol: str
    exchange: str
    expiry: str
    spot_price: Decimal
    futures_price: Decimal
    basis_pct: float
    days_to_expiry: int
    annualized_yield: float
    direction: str                 # "long_basis" or "short_basis"
    strategy: str                  # Trade description
    risk_notes: str


class BasisCalculator:
    """
    Calculates and analyzes futures basis.

    Features:
    - Multi-expiry analysis
    - Term structure visualization
    - Carry trade identification
    - Contango/backwardation detection
    """

    # Structure interpretation
    STRONG_BASIS = 5.0             # >5% annualized is strong
    MODERATE_BASIS = 2.0           # >2% is moderate

    def __init__(
        self,
        client: Optional[ExchangeClient] = None,
    ):
        """
        Initialize basis calculator.

        Args:
            client: Exchange client for data fetching
        """
        self.client = client or ExchangeClient(use_mock=True)

    def analyze(
        self,
        symbol: str,
        spot_price: Optional[Decimal] = None,
        exchanges: Optional[List[Exchange]] = None,
    ) -> BasisAnalysis:
        """
        Analyze basis for a symbol.

        Args:
            symbol: Trading symbol (e.g., "BTC")
            spot_price: Current spot price
            exchanges: Exchanges to include

        Returns:
            BasisAnalysis with all metrics
        """
        # Set default spot price if not provided
        if spot_price is None:
            if symbol == "BTC":
                spot_price = Decimal("67500")
            elif symbol == "ETH":
                spot_price = Decimal("2500")
            else:
                spot_price = Decimal("100")

        # Fetch basis data
        basis_list = self.client.get_all_basis(symbol, spot_price, exchanges)

        if not basis_list:
            raise ValueError(f"No basis data available for {symbol}")

        # Calculate averages
        avg_basis = sum(b.basis_pct for b in basis_list) / len(basis_list)
        avg_annual = sum(b.annualized_pct for b in basis_list) / len(basis_list)

        # Determine market structure
        structure, strength = self._analyze_structure(basis_list)

        # Find best carry opportunity
        best_carry = max(basis_list, key=lambda b: b.annualized_pct)

        return BasisAnalysis(
            symbol=symbol,
            spot_price=spot_price,
            basis_data=basis_list,
            avg_basis_pct=round(avg_basis, 3),
            avg_annualized=round(avg_annual, 2),
            market_structure=structure,
            structure_strength=strength,
            best_carry_expiry=best_carry.expiry,
            best_carry_yield=best_carry.annualized_pct,
            timestamp=datetime.now(),
        )

    def _analyze_structure(
        self,
        basis_list: List[BasisData],
    ) -> tuple:
        """
        Analyze term structure from basis data.

        Returns:
            (structure, strength) tuple
        """
        positive = sum(1 for b in basis_list if b.basis_pct > 0)
        negative = sum(1 for b in basis_list if b.basis_pct < 0)
        total = len(basis_list)

        # Determine structure
        if positive == total:
            structure = "contango"
        elif negative == total:
            structure = "backwardation"
        elif positive > negative:
            structure = "contango"  # Mostly contango
        elif negative > positive:
            structure = "backwardation"
        else:
            structure = "mixed"

        # Determine strength from magnitude
        avg_abs = sum(abs(b.annualized_pct) for b in basis_list) / total
        if avg_abs >= self.STRONG_BASIS:
            strength = "strong"
        elif avg_abs >= self.MODERATE_BASIS:
            strength = "moderate"
        else:
            strength = "weak"

        return structure, strength

    def find_carry_opportunities(
        self,
        symbols: List[str],
        min_yield: float = 5.0,
    ) -> List[CarryOpportunity]:
        """
        Find cash-and-carry arbitrage opportunities.

        Strategy:
        - Contango: Buy spot, sell futures, collect basis
        - Backwardation: Sell spot (if possible), buy futures

        Args:
            symbols: Symbols to scan
            min_yield: Minimum annualized yield (%)

        Returns:
            List of carry opportunities
        """
        opportunities = []

        for symbol in symbols:
            try:
                analysis = self.analyze(symbol)

                for basis in analysis.basis_data:
                    if abs(basis.annualized_pct) >= min_yield:
                        if basis.basis_pct > 0:
                            # Contango - long basis trade
                            direction = "long_basis"
                            strategy = (
                                f"Buy {symbol} spot at ${float(analysis.spot_price):,.0f}, "
                                f"sell {basis.expiry} futures at ${float(basis.futures_price):,.0f}"
                            )
                            risk_notes = "Funding costs may reduce yield; early liquidation risk"
                        else:
                            # Backwardation - short basis trade
                            direction = "short_basis"
                            strategy = (
                                f"Short {symbol} spot (borrow), "
                                f"buy {basis.expiry} futures at ${float(basis.futures_price):,.0f}"
                            )
                            risk_notes = "Borrowing costs apply; squeeze risk in tight markets"

                        opportunities.append(CarryOpportunity(
                            symbol=symbol,
                            exchange=basis.exchange,
                            expiry=basis.expiry,
                            spot_price=analysis.spot_price,
                            futures_price=basis.futures_price,
                            basis_pct=basis.basis_pct,
                            days_to_expiry=basis.days_to_expiry,
                            annualized_yield=basis.annualized_pct,
                            direction=direction,
                            strategy=strategy,
                            risk_notes=risk_notes,
                        ))
            except Exception:
                continue

        # Sort by yield descending
        opportunities.sort(key=lambda x: abs(x.annualized_yield), reverse=True)
        return opportunities

    def get_term_structure(
        self,
        symbol: str,
        spot_price: Optional[Decimal] = None,
    ) -> List[Dict]:
        """
        Get term structure data for visualization.

        Args:
            symbol: Trading symbol
            spot_price: Current spot price

        Returns:
            List of expiry data points
        """
        analysis = self.analyze(symbol, spot_price)

        # Sort by days to expiry
        sorted_basis = sorted(
            analysis.basis_data,
            key=lambda b: b.days_to_expiry
        )

        return [
            {
                "expiry": b.expiry,
                "days": b.days_to_expiry,
                "futures_price": float(b.futures_price),
                "basis_pct": b.basis_pct,
                "annualized_pct": b.annualized_pct,
                "exchange": b.exchange,
            }
            for b in sorted_basis
        ]

    def calculate_implied_rate(
        self,
        spot: Decimal,
        futures: Decimal,
        days: int,
    ) -> Dict:
        """
        Calculate implied interest rate from basis.

        Args:
            spot: Spot price
            futures: Futures price
            days: Days to expiry

        Returns:
            Dict with rate calculations
        """
        if days <= 0:
            return {"error": "Days must be positive"}

        basis = float(futures - spot)
        basis_pct = basis / float(spot) * 100
        annualized = basis_pct * 365 / days

        return {
            "spot": float(spot),
            "futures": float(futures),
            "days_to_expiry": days,
            "basis_usd": round(basis, 2),
            "basis_pct": round(basis_pct, 3),
            "annualized_rate": round(annualized, 2),
            "structure": "contango" if basis > 0 else "backwardation",
        }


def demo():
    """Demonstrate basis calculator."""
    calc = BasisCalculator()

    print("=" * 70)
    print("BASIS CALCULATOR")
    print("=" * 70)

    # Analyze BTC basis
    analysis = calc.analyze("BTC", Decimal("67500"))

    print(f"\n📈 {analysis.symbol} BASIS ANALYSIS")
    print(f"   Spot Price: ${analysis.spot_price:,}")
    print("-" * 60)

    print(f"\n{'Expiry':<12} {'Futures':>12} {'Basis':>10} {'Annual':>10} {'Days':>6}")
    print("-" * 60)

    for basis in sorted(analysis.basis_data, key=lambda b: b.days_to_expiry):
        print(
            f"{basis.expiry:<12} "
            f"${float(basis.futures_price):>10,.0f} "
            f"{basis.basis_pct:>+9.2f}% "
            f"{basis.annualized_pct:>+9.1f}% "
            f"{basis.days_to_expiry:>6}"
        )

    print("-" * 60)
    print(f"\nMarket Structure: {analysis.structure_strength.title()} {analysis.market_structure.title()}")
    print(f"Average Basis: {analysis.avg_basis_pct:+.2f}%")
    print(f"Average Annualized: {analysis.avg_annualized:+.1f}%")
    print(f"Best Carry: {analysis.best_carry_expiry} ({analysis.best_carry_yield:+.1f}% annualized)")

    # Term structure
    print("\n" + "-" * 60)
    print("TERM STRUCTURE")
    print("-" * 60)

    structure = calc.get_term_structure("BTC", Decimal("67500"))
    for point in structure:
        bar = "+" * min(int(abs(point["annualized_pct"]) / 2), 20)
        direction = "▲" if point["annualized_pct"] > 0 else "▼"
        print(f"{point['expiry']:<12} {direction} {bar} {point['annualized_pct']:+.1f}%")

    # Carry opportunities
    print("\n" + "=" * 70)
    print("CARRY TRADE SCANNER")
    print("=" * 70)

    opportunities = calc.find_carry_opportunities(["BTC", "ETH"], min_yield=5.0)
    if opportunities:
        print(f"\n{'Symbol':<6} {'Expiry':<12} {'Basis':>8} {'Annual':>10} {'Direction':<12}")
        print("-" * 60)
        for opp in opportunities[:5]:
            print(
                f"{opp.symbol:<6} "
                f"{opp.expiry:<12} "
                f"{opp.basis_pct:>+7.2f}% "
                f"{opp.annualized_yield:>+9.1f}% "
                f"{opp.direction:<12}"
            )

        print("\nTop Opportunity:")
        top = opportunities[0]
        print(f"   Strategy: {top.strategy}")
        print(f"   Risk: {top.risk_notes}")
    else:
        print("\nNo carry opportunities found above threshold")


if __name__ == "__main__":
    demo()

#!/usr/bin/env python3
"""
Crypto Derivatives Tracker - Main CLI.

Comprehensive derivatives market analysis:
- Funding rate tracking
- Open interest analysis
- Liquidation monitoring
- Options flow analysis
- Basis/spread calculations
- Multi-asset dashboard

Usage:
    python derivatives_tracker.py funding BTC
    python derivatives_tracker.py oi BTC --format json
    python derivatives_tracker.py liquidations BTC
    python derivatives_tracker.py options BTC
    python derivatives_tracker.py basis BTC
    python derivatives_tracker.py dashboard BTC ETH
"""

import argparse
import sys
from decimal import Decimal
from typing import List, Optional

from exchange_client import ExchangeClient
from funding_tracker import FundingTracker
from oi_analyzer import OIAnalyzer
from liquidation_monitor import LiquidationMonitor
from options_analyzer import OptionsAnalyzer
from basis_calculator import BasisCalculator
from formatters import ConsoleFormatter, JSONFormatter, ReportGenerator


def cmd_funding(args):
    """Handle funding subcommand."""
    tracker = FundingTracker()
    console = ConsoleFormatter()
    json_fmt = JSONFormatter()

    print(console.header(f"{args.symbol} FUNDING RATE ANALYSIS"))

    analysis = tracker.analyze(args.symbol)

    if args.format == "json":
        print(json_fmt.funding_report(args.symbol, {
            "weighted_avg": analysis.weighted_avg,
            "annualized_avg": analysis.annualized_avg,
            "spread": analysis.spread,
            "sentiment": analysis.sentiment,
            "sentiment_strength": analysis.sentiment_strength,
            "arbitrage_opportunity": analysis.arbitrage_opportunity,
            "rates": [
                {
                    "exchange": r.exchange,
                    "rate": float(r.rate),
                    "annualized": r.annualized,
                    "next_payment": r.time_to_payment_str,
                }
                for r in analysis.rates
            ],
        }))
        return

    # Console format
    print(f"\n{'Exchange':<12} {'Current':>10} {'Annualized':>12} {'Next Payment':>14}")
    print("-" * 50)

    for rate in sorted(analysis.rates, key=lambda r: r.rate, reverse=True):
        print(
            f"{rate.exchange:<12} "
            f"{float(rate.rate):>+9.4%} "
            f"{rate.annualized:>+11.2f}% "
            f"{rate.time_to_payment_str:>14}"
        )

    print("-" * 50)
    print(f"\nWeighted Average: {analysis.weighted_avg:+.4%}")
    print(f"Annualized: {analysis.annualized_avg:+.2f}%")
    print(f"Spread (max-min): {analysis.spread:.4%}")
    print(f"\nSentiment: {console.sentiment_icon(analysis.sentiment)} "
          f"{analysis.sentiment_strength.title()} {analysis.sentiment.title()}")

    if analysis.is_extreme:
        print(f"\n⚠️  EXTREME FUNDING - Contrarian opportunity")

    if analysis.arbitrage_opportunity:
        print(f"\n💰 ARBITRAGE OPPORTUNITY")
        print(f"   Long on {analysis.min_rate.exchange} ({float(analysis.min_rate.rate):+.4%})")
        print(f"   Short on {analysis.max_rate.exchange} ({float(analysis.max_rate.rate):+.4%})")
        print(f"   Profit: {analysis.arbitrage_spread:.4%} per 8h")


def cmd_oi(args):
    """Handle open interest subcommand."""
    analyzer = OIAnalyzer()
    console = ConsoleFormatter()
    json_fmt = JSONFormatter()

    print(console.header(f"{args.symbol} OPEN INTEREST ANALYSIS"))

    analysis = analyzer.analyze(args.symbol)

    if args.format == "json":
        print(json_fmt.oi_report(args.symbol, {
            "total_oi_usd": float(analysis.total_oi_usd),
            "total_oi_contracts": float(analysis.total_oi_contracts),
            "avg_change_24h": analysis.avg_change_24h,
            "avg_change_7d": analysis.avg_change_7d,
            "weighted_long_ratio": analysis.weighted_long_ratio,
            "long_percentage": analysis.long_percentage,
            "dominant_exchange": analysis.dominant_exchange,
            "dominant_share": analysis.dominant_share,
            "trend": analysis.trend,
            "trend_strength": analysis.trend_strength,
            "exchanges": [
                {
                    "exchange": oi.exchange,
                    "oi_usd": float(oi.oi_usd),
                    "change_24h": oi.change_24h_pct,
                    "change_7d": oi.change_7d_pct,
                    "long_ratio": oi.long_ratio,
                }
                for oi in analysis.exchanges
            ],
        }))
        return

    # Console format
    print(f"\n{'Exchange':<12} {'OI (USD)':>14} {'24h Chg':>10} {'7d Chg':>10} {'Share':>8}")
    print("-" * 60)

    for oi in sorted(analysis.exchanges, key=lambda x: x.oi_usd, reverse=True):
        share = float(oi.oi_usd) / float(analysis.total_oi_usd) * 100
        print(
            f"{oi.exchange:<12} "
            f"${float(oi.oi_usd)/1e9:>12.2f}B "
            f"{oi.change_24h_pct:>+9.1f}% "
            f"{oi.change_7d_pct:>+9.1f}% "
            f"{share:>7.1f}%"
        )

    print("-" * 60)
    print(f"\nTotal OI: ${float(analysis.total_oi_usd)/1e9:.2f}B")
    print(f"24h Change: {analysis.avg_change_24h:+.1f}%")
    print(f"7d Change: {analysis.avg_change_7d:+.1f}%")
    print(f"\nLong/Short Ratio: {analysis.weighted_long_ratio:.2f} "
          f"({analysis.long_percentage:.1f}% long)")
    print(f"Trend: {analysis.trend_strength.title()} {analysis.trend.title()}")
    print(f"Dominant Exchange: {analysis.dominant_exchange} ({analysis.dominant_share:.1f}%)")

    # Check for divergence
    if args.price_change:
        print(console.section("DIVERGENCE ANALYSIS"))
        divergence = analyzer.detect_divergence(args.symbol, args.price_change)
        if divergence:
            print(f"\n🔍 Divergence Detected!")
            print(f"   OI:    {divergence.oi_direction} ({divergence.oi_change_pct:+.1f}%)")
            print(f"   Price: {divergence.price_direction} ({divergence.price_change_pct:+.1f}%)")
            print(f"   Signal: {divergence.signal.upper()}")
            print(f"   {divergence.description}")
            print(f"   Confidence: {divergence.confidence}")
        else:
            print("\nNo significant divergence detected")


def cmd_liquidations(args):
    """Handle liquidations subcommand."""
    monitor = LiquidationMonitor()
    console = ConsoleFormatter()
    json_fmt = JSONFormatter()

    price = Decimal(str(args.price)) if args.price else None
    summary = monitor.get_summary(args.symbol, price)

    print(console.header(f"{args.symbol} LIQUIDATION MONITOR"))

    if args.format == "json":
        print(json_fmt.format({
            "symbol": summary.symbol,
            "current_price": float(summary.current_price),
            "total_24h_usd": float(summary.total_24h_usd),
            "long_liquidations_usd": float(summary.long_liquidations_usd),
            "short_liquidations_usd": float(summary.short_liquidations_usd),
            "cascade_risk": summary.cascade_risk,
            "long_levels": [
                {
                    "price": float(l.price),
                    "total_value_usd": float(l.total_value_usd),
                    "density": l.density,
                }
                for l in summary.long_levels
            ],
            "short_levels": [
                {
                    "price": float(l.price),
                    "total_value_usd": float(l.total_value_usd),
                    "density": l.density,
                }
                for l in summary.short_levels
            ],
        }))
        return

    print(f"\n   Current Price: ${summary.current_price:,}")
    print("-" * 60)

    # 24h totals
    print(f"\n24h Liquidations:")
    print(f"   Total:  ${float(summary.total_24h_usd)/1e6:,.1f}M")
    print(f"   Longs:  ${float(summary.long_liquidations_usd)/1e6:,.1f}M")
    print(f"   Shorts: ${float(summary.short_liquidations_usd)/1e6:,.1f}M")

    # Cascade risk
    print(f"\nCascade Risk: {console.risk_icon(summary.cascade_risk)} "
          f"{summary.cascade_risk.upper()}")

    # Heatmap
    print(console.section("LIQUIDATION HEATMAP"))

    print(f"\nLONG LIQUIDATIONS (below ${summary.current_price:,}):")
    for level in summary.long_levels[:4]:
        bar_len = min(int(float(level.total_value_usd) / 10_000_000), 20)
        bar = "█" * bar_len
        density_mark = "⚠️ " if level.density in ["high", "critical"] else ""
        print(
            f"  ${float(level.price):>10,.0f} {bar} "
            f"${float(level.total_value_usd)/1e6:.0f}M "
            f"{density_mark}{level.density.upper()}"
        )

    print(f"\nSHORT LIQUIDATIONS (above ${summary.current_price:,}):")
    for level in summary.short_levels[:4]:
        bar_len = min(int(float(level.total_value_usd) / 10_000_000), 20)
        bar = "█" * bar_len
        density_mark = "⚠️ " if level.density in ["high", "critical"] else ""
        print(
            f"  ${float(level.price):>10,.0f} {bar} "
            f"${float(level.total_value_usd)/1e6:.0f}M "
            f"{density_mark}{level.density.upper()}"
        )

    # Large liquidations
    if args.large:
        print(console.section("RECENT LARGE LIQUIDATIONS"))
        large = monitor.get_recent_large_liquidations(
            args.symbol, min_value_usd=1_000_000, limit=5
        )
        if large:
            print(f"\n{'Exchange':<10} {'Side':<6} {'Price':>12} {'Value':>12} {'When':>10}")
            print("-" * 60)
            for l in large:
                print(
                    f"{l['exchange']:<10} "
                    f"{l['side']:<6} "
                    f"${l['price']:>10,.0f} "
                    f"${l['value_usd']/1e6:>10.1f}M "
                    f"{l['time_ago']:>10}"
                )


def cmd_options(args):
    """Handle options subcommand."""
    analyzer = OptionsAnalyzer()
    console = ConsoleFormatter()
    json_fmt = JSONFormatter()

    price = Decimal(str(args.price)) if args.price else None
    analysis = analyzer.analyze(args.symbol, current_price=price)

    print(console.header(f"{args.symbol} OPTIONS ANALYSIS"))

    if args.format == "json":
        print(json_fmt.format({
            "symbol": analysis.symbol,
            "expiry": analysis.snapshot.expiry,
            "atm_iv": analysis.snapshot.atm_iv,
            "iv_interpretation": analysis.iv_interpretation,
            "iv_percentile": analysis.iv_percentile,
            "put_call_ratio_volume": analysis.snapshot.put_call_ratio_volume,
            "put_call_ratio_oi": analysis.snapshot.put_call_ratio_oi,
            "sentiment_from_pcr": analysis.sentiment_from_pcr,
            "sentiment_from_skew": analysis.sentiment_from_skew,
            "overall_sentiment": analysis.overall_sentiment,
            "max_pain": float(analysis.snapshot.max_pain),
            "max_pain_distance_pct": analysis.max_pain_distance_pct,
            "expiry_pressure": analysis.expiry_pressure,
            "total_call_oi": float(analysis.snapshot.total_call_oi),
            "total_put_oi": float(analysis.snapshot.total_put_oi),
        }))
        return

    snap = analysis.snapshot
    print(f"\nExpiry: {snap.expiry}")
    print(f"Exchange: {snap.exchange}")

    print(f"\nImplied Volatility:")
    print(f"   ATM IV: {snap.atm_iv:.1f}%")
    print(f"   Interpretation: {analysis.iv_interpretation.upper()}")
    print(f"   IV Rank: {analysis.iv_percentile:.0f}th percentile")

    print(f"\nPut/Call Analysis:")
    print(f"   PCR (Volume): {snap.put_call_ratio_volume:.2f}")
    print(f"   PCR (OI): {snap.put_call_ratio_oi:.2f}")
    print(f"   Sentiment: {console.sentiment_icon(analysis.sentiment_from_pcr)} "
          f"{analysis.sentiment_from_pcr.upper()}")

    print(f"\nMax Pain:")
    print(f"   Price: ${snap.max_pain:,.0f}")
    print(f"   Distance: {analysis.max_pain_distance_pct:+.1f}% from current")

    print(f"\nOpen Interest:")
    print(f"   Calls: ${float(snap.total_call_oi)/1e9:.2f}B")
    print(f"   Puts:  ${float(snap.total_put_oi)/1e9:.2f}B")

    print(f"\nOverall Sentiment: {console.sentiment_icon(analysis.overall_sentiment)} "
          f"{analysis.overall_sentiment.upper()}")
    print(f"Expiry Pressure: {analysis.expiry_pressure.upper()}")

    # Max pain levels
    if args.max_pain:
        print(console.section("MAX PAIN BY EXPIRY"))
        levels = analyzer.get_max_pain_levels(args.symbol)
        print(f"\n{'Expiry':<12} {'Max Pain':>12} {'Call OI':>12} {'Put OI':>12} {'PCR':>6}")
        print("-" * 50)
        for lvl in levels:
            print(
                f"{lvl['expiry']:<12} "
                f"${lvl['max_pain']:>10,.0f} "
                f"${lvl['call_oi']/1e9:>10.1f}B "
                f"${lvl['put_oi']/1e9:>10.1f}B "
                f"{lvl['pcr_oi']:>5.2f}"
            )

    # Options flow
    if args.flow:
        print(console.section("OPTIONS FLOW (Simulated)"))
        flows = analyzer.generate_mock_flow(args.symbol, count=5)
        print(f"\n{'Type':<6} {'Strike':>10} {'Size':>8} {'Premium':>12} {'Interpretation':<25}")
        print("-" * 70)
        for flow in flows:
            print(
                f"{flow.option_type.upper():<6} "
                f"${float(flow.strike):>8,.0f} "
                f"{flow.size_contracts:>8} "
                f"${float(flow.premium_usd):>10,.0f} "
                f"{flow.interpretation:<25}"
            )


def cmd_basis(args):
    """Handle basis subcommand."""
    calc = BasisCalculator()
    console = ConsoleFormatter()
    json_fmt = JSONFormatter()

    price = Decimal(str(args.price)) if args.price else None
    analysis = calc.analyze(args.symbol, price)

    print(console.header(f"{args.symbol} BASIS ANALYSIS"))

    if args.format == "json":
        print(json_fmt.format({
            "symbol": analysis.symbol,
            "spot_price": float(analysis.spot_price),
            "avg_basis_pct": analysis.avg_basis_pct,
            "avg_annualized": analysis.avg_annualized,
            "market_structure": analysis.market_structure,
            "structure_strength": analysis.structure_strength,
            "best_carry_expiry": analysis.best_carry_expiry,
            "best_carry_yield": analysis.best_carry_yield,
            "basis_data": [
                {
                    "expiry": b.expiry,
                    "futures_price": float(b.futures_price),
                    "basis_pct": b.basis_pct,
                    "annualized_pct": b.annualized_pct,
                    "days_to_expiry": b.days_to_expiry,
                }
                for b in analysis.basis_data
            ],
        }))
        return

    print(f"\n   Spot Price: ${analysis.spot_price:,}")
    print("-" * 60)

    print(f"\n{'Expiry':<12} {'Futures':>12} {'Basis':>10} {'Annual':>10} {'Days':>6}")
    print("-" * 60)

    for basis in sorted(analysis.basis_data, key=lambda b: b.days_to_expiry):
        print(
            f"{basis.expiry:<12} "
            f"${float(basis.futures_price):>10,.0f} "
            f"{basis.basis_pct:>+9.2f}% "
            f"{basis.annualized_pct:>+9.1f}% "
            f"{basis.days_to_expiry:>6}"
        )

    print("-" * 60)
    print(f"\nMarket Structure: {analysis.structure_strength.title()} "
          f"{analysis.market_structure.title()}")
    print(f"Average Basis: {analysis.avg_basis_pct:+.2f}%")
    print(f"Average Annualized: {analysis.avg_annualized:+.1f}%")
    print(f"Best Carry: {analysis.best_carry_expiry} "
          f"({analysis.best_carry_yield:+.1f}% annualized)")

    # Term structure
    print(console.section("TERM STRUCTURE"))
    structure = calc.get_term_structure(args.symbol, analysis.spot_price)
    for point in structure:
        bar = "+" * min(int(abs(point["annualized_pct"]) / 2), 20)
        direction = "▲" if point["annualized_pct"] > 0 else "▼"
        print(f"{point['expiry']:<12} {direction} {bar} {point['annualized_pct']:+.1f}%")

    # Carry scanner
    if args.carry:
        print(console.section("CARRY TRADE SCANNER"))
        opportunities = calc.find_carry_opportunities([args.symbol], min_yield=5.0)
        if opportunities:
            print(f"\n{'Expiry':<12} {'Basis':>8} {'Annual':>10} {'Direction':<12}")
            print("-" * 50)
            for opp in opportunities[:5]:
                print(
                    f"{opp.expiry:<12} "
                    f"{opp.basis_pct:>+7.2f}% "
                    f"{opp.annualized_yield:>+9.1f}% "
                    f"{opp.direction:<12}"
                )

            print("\nTop Opportunity:")
            top = opportunities[0]
            print(f"   Strategy: {top.strategy}")
            print(f"   Risk: {top.risk_notes}")
        else:
            print("\nNo carry opportunities found above threshold")


def cmd_dashboard(args):
    """Handle dashboard subcommand."""
    console = ConsoleFormatter()
    report_gen = ReportGenerator()

    funding_tracker = FundingTracker()
    oi_analyzer = OIAnalyzer()
    liq_monitor = LiquidationMonitor()

    print(console.header("CRYPTO DERIVATIVES DASHBOARD"))

    for symbol in args.symbols:
        print(f"\n{'=' * 70}")
        print(f" {symbol} ".center(70, "="))
        print("=" * 70)

        try:
            # Funding
            funding = funding_tracker.analyze(symbol)
            print(f"\n📊 FUNDING")
            print(f"   Rate: {funding.weighted_avg:+.4%} ({funding.annualized_avg:+.1f}% annual)")
            print(f"   Sentiment: {console.sentiment_icon(funding.sentiment)} "
                  f"{funding.sentiment.title()}")

            # OI
            oi = oi_analyzer.analyze(symbol)
            print(f"\n📈 OPEN INTEREST")
            print(f"   Total: ${float(oi.total_oi_usd)/1e9:.1f}B ({oi.avg_change_24h:+.1f}% 24h)")
            print(f"   Long/Short: {oi.weighted_long_ratio:.2f} ({oi.long_percentage:.0f}% long)")
            print(f"   Trend: {oi.trend_strength.title()} {oi.trend.title()}")

            # Liquidations
            liq = liq_monitor.get_summary(symbol)
            print(f"\n💥 LIQUIDATIONS (24h)")
            print(f"   Total: ${float(liq.total_24h_usd)/1e6:.1f}M")
            print(f"   Longs: ${float(liq.long_liquidations_usd)/1e6:.1f}M | "
                  f"Shorts: ${float(liq.short_liquidations_usd)/1e6:.1f}M")
            print(f"   Cascade Risk: {console.risk_icon(liq.cascade_risk)} "
                  f"{liq.cascade_risk.upper()}")

        except Exception as e:
            print(f"\n⚠️  Error fetching data for {symbol}: {e}")

    print(f"\n{'=' * 70}")
    print(f"Dashboard generated at: {console.H_LINE * 50}")


def main():
    """Main entry point."""
    parser = argparse.ArgumentParser(
        description="Crypto Derivatives Tracker",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
    %(prog)s funding BTC
    %(prog)s oi BTC --price-change 3.5
    %(prog)s liquidations BTC --large
    %(prog)s options BTC --flow --max-pain
    %(prog)s basis BTC --carry
    %(prog)s dashboard BTC ETH SOL
        """,
    )

    subparsers = parser.add_subparsers(dest="command", help="Available commands")

    # Funding subcommand
    funding_parser = subparsers.add_parser("funding", help="Analyze funding rates")
    funding_parser.add_argument("symbol", help="Trading symbol (e.g., BTC)")
    funding_parser.add_argument("--format", choices=["console", "json"],
                               default="console", help="Output format")

    # OI subcommand
    oi_parser = subparsers.add_parser("oi", help="Analyze open interest")
    oi_parser.add_argument("symbol", help="Trading symbol")
    oi_parser.add_argument("--price-change", type=float, dest="price_change",
                          help="24h price change %% for divergence analysis")
    oi_parser.add_argument("--format", choices=["console", "json"],
                          default="console", help="Output format")

    # Liquidations subcommand
    liq_parser = subparsers.add_parser("liquidations", help="Monitor liquidations")
    liq_parser.add_argument("symbol", help="Trading symbol")
    liq_parser.add_argument("--price", type=float, help="Current price override")
    liq_parser.add_argument("--large", action="store_true",
                           help="Show recent large liquidations")
    liq_parser.add_argument("--format", choices=["console", "json"],
                          default="console", help="Output format")

    # Options subcommand
    opt_parser = subparsers.add_parser("options", help="Analyze options market")
    opt_parser.add_argument("symbol", help="Trading symbol")
    opt_parser.add_argument("--price", type=float, help="Current price override")
    opt_parser.add_argument("--max-pain", action="store_true", dest="max_pain",
                           help="Show max pain by expiry")
    opt_parser.add_argument("--flow", action="store_true",
                           help="Show options flow")
    opt_parser.add_argument("--format", choices=["console", "json"],
                          default="console", help="Output format")

    # Basis subcommand
    basis_parser = subparsers.add_parser("basis", help="Calculate futures basis")
    basis_parser.add_argument("symbol", help="Trading symbol")
    basis_parser.add_argument("--price", type=float, help="Spot price override")
    basis_parser.add_argument("--carry", action="store_true",
                             help="Show carry opportunities")
    basis_parser.add_argument("--format", choices=["console", "json"],
                            default="console", help="Output format")

    # Dashboard subcommand
    dash_parser = subparsers.add_parser("dashboard", help="Multi-asset dashboard")
    dash_parser.add_argument("symbols", nargs="+", help="Trading symbols")

    args = parser.parse_args()

    if not args.command:
        parser.print_help()
        sys.exit(1)

    # Dispatch to command handler
    commands = {
        "funding": cmd_funding,
        "oi": cmd_oi,
        "liquidations": cmd_liquidations,
        "options": cmd_options,
        "basis": cmd_basis,
        "dashboard": cmd_dashboard,
    }

    try:
        commands[args.command](args)
    except KeyboardInterrupt:
        print("\nInterrupted")
        sys.exit(1)
    except Exception as e:
        print(f"\n❌ Error: {e}")
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Unified exchange client for derivatives data.

Provides consistent interface across multiple exchanges with:
- Rate limiting and retry logic
- Data normalization
- Mock data for simulation
"""

from dataclasses import dataclass
from datetime import datetime, timedelta
from decimal import Decimal
from enum import Enum
from typing import Dict, List, Optional
import random
import time


class Exchange(Enum):
    """Supported exchanges."""
    BINANCE = "binance"
    BYBIT = "bybit"
    OKX = "okx"
    DERIBIT = "deribit"
    BITMEX = "bitmex"


@dataclass
class FundingRate:
    """Funding rate data point."""
    exchange: str
    symbol: str
    rate: Decimal                   # Current 8-hour rate
    predicted_rate: Decimal         # Next predicted rate
    next_payment: datetime          # Time of next payment
    interval_hours: int = 8         # Funding interval

    @property
    def annualized(self) -> float:
        """Calculate annualized funding rate."""
        return float(self.rate) * (365 * 24 / self.interval_hours) * 100

    @property
    def time_to_payment(self) -> timedelta:
        """Time until next funding payment."""
        return self.next_payment - datetime.now()

    @property
    def time_to_payment_str(self) -> str:
        """Human-readable time to payment."""
        delta = self.time_to_payment
        hours = int(delta.total_seconds() // 3600)
        minutes = int((delta.total_seconds() % 3600) // 60)
        return f"{hours}h {minutes}m"


@dataclass
class OpenInterest:
    """Open interest data point."""
    exchange: str
    symbol: str
    oi_usd: Decimal                 # Total OI in USD
    oi_contracts: Decimal           # Total contracts
    change_1h_pct: float            # 1h change
    change_24h_pct: float           # 24h change
    change_7d_pct: float            # 7d change
    long_ratio: float               # Long/short ratio (1.0 = balanced)
    timestamp: datetime


@dataclass
class Liquidation:
    """Single liquidation event."""
    exchange: str
    symbol: str
    side: str                       # "long" or "short"
    price: Decimal
    quantity: Decimal
    value_usd: Decimal
    timestamp: datetime


@dataclass
class LiquidationLevel:
    """Aggregated liquidation level."""
    price: Decimal
    side: str                       # "long" or "short"
    total_value_usd: Decimal
    density: str                    # "low", "medium", "high", "critical"


@dataclass
class OptionsSnapshot:
    """Options market snapshot."""
    symbol: str
    exchange: str
    expiry: str
    atm_iv: float                   # At-the-money IV
    put_call_ratio_volume: float    # Put/call by volume
    put_call_ratio_oi: float        # Put/call by OI
    max_pain: Decimal               # Max pain price
    total_call_oi: Decimal
    total_put_oi: Decimal
    timestamp: datetime


@dataclass
class BasisData:
    """Basis/spread data."""
    symbol: str
    spot_price: Decimal
    perp_price: Decimal
    perp_basis_pct: float           # Perpetual basis
    quarterly_price: Optional[Decimal] = None
    quarterly_basis_pct: Optional[float] = None
    quarterly_expiry: Optional[str] = None
    annualized_yield: Optional[float] = None


class ExchangeClient:
    """
    Unified client for fetching derivatives data from exchanges.

    Uses mock data for demonstration. In production, replace with
    actual API calls.
    """

    # Rate limits by exchange
    RATE_LIMITS = {
        Exchange.BINANCE: {"rpm": 1200, "delay": 0.05},
        Exchange.BYBIT: {"rpm": 120, "delay": 0.5},
        Exchange.OKX: {"rpm": 60, "delay": 1.0},
        Exchange.DERIBIT: {"rpm": 100, "delay": 0.6},
        Exchange.BITMEX: {"rpm": 30, "delay": 2.0},
    }

    def __init__(self, use_mock: bool = True):
        """
        Initialize exchange client.

        Args:
            use_mock: Use mock data (True) or live APIs (False)
        """
        self.use_mock = use_mock
        self._last_request: Dict[Exchange, float] = {}

    def _rate_limit(self, exchange: Exchange):
        """Apply rate limiting for exchange."""
        delay = self.RATE_LIMITS[exchange]["delay"]
        last = self._last_request.get(exchange, 0)
        elapsed = time.time() - last
        if elapsed < delay:
            time.sleep(delay - elapsed)
        self._last_request[exchange] = time.time()

    # -------------------------------------------------------------------------
    # Funding Rate Methods
    # -------------------------------------------------------------------------

    def get_funding_rate(
        self,
        symbol: str,
        exchange: Exchange,
    ) -> Optional[FundingRate]:
        """Get funding rate for symbol on exchange."""
        if self.use_mock:
            return self._mock_funding_rate(symbol, exchange)

        self._rate_limit(exchange)
        # Production: implement actual API calls
        raise NotImplementedError("Live API not implemented")

    def get_all_funding_rates(
        self,
        symbol: str,
        exchanges: Optional[List[Exchange]] = None,
    ) -> List[FundingRate]:
        """Get funding rates from all exchanges."""
        if exchanges is None:
            exchanges = list(Exchange)

        rates = []
        for exchange in exchanges:
            rate = self.get_funding_rate(symbol, exchange)
            if rate:
                rates.append(rate)

        return rates

    def _mock_funding_rate(
        self,
        symbol: str,
        exchange: Exchange,
    ) -> FundingRate:
        """Generate mock funding rate."""
        # Base rates vary by exchange
        base_rates = {
            Exchange.BINANCE: 0.0150,
            Exchange.BYBIT: 0.0180,
            Exchange.OKX: 0.0130,
            Exchange.DERIBIT: 0.0200,
            Exchange.BITMEX: 0.0100,
        }

        base = base_rates.get(exchange, 0.0100)
        # Add some randomness
        rate = base + random.uniform(-0.005, 0.005)
        predicted = rate + random.uniform(-0.002, 0.002)

        # Next funding payment (8-hour intervals)
        now = datetime.now()
        # Find next 00:00, 08:00, or 16:00 UTC
        hours_since_midnight = now.hour
        next_funding_hour = ((hours_since_midnight // 8) + 1) * 8
        if next_funding_hour >= 24:
            next_funding_hour = 0
            next_payment = now.replace(hour=0, minute=0, second=0) + timedelta(days=1)
        else:
            next_payment = now.replace(hour=next_funding_hour, minute=0, second=0)
            if next_payment <= now:
                next_payment += timedelta(hours=8)

        return FundingRate(
            exchange=exchange.value,
            symbol=symbol,
            rate=Decimal(str(round(rate, 6))),
            predicted_rate=Decimal(str(round(predicted, 6))),
            next_payment=next_payment,
        )

    # -------------------------------------------------------------------------
    # Open Interest Methods
    # -------------------------------------------------------------------------

    def get_open_interest(
        self,
        symbol: str,
        exchange: Exchange,
    ) -> Optional[OpenInterest]:
        """Get open interest for symbol on exchange."""
        if self.use_mock:
            return self._mock_open_interest(symbol, exchange)

        self._rate_limit(exchange)
        raise NotImplementedError("Live API not implemented")

    def get_all_open_interest(
        self,
        symbol: str,
        exchanges: Optional[List[Exchange]] = None,
    ) -> List[OpenInterest]:
        """Get open interest from all exchanges."""
        if exchanges is None:
            exchanges = list(Exchange)

        oi_list = []
        for exchange in exchanges:
            oi = self.get_open_interest(symbol, exchange)
            if oi:
                oi_list.append(oi)

        return oi_list

    def _mock_open_interest(
        self,
        symbol: str,
        exchange: Exchange,
    ) -> OpenInterest:
        """Generate mock open interest data."""
        # Base OI varies by exchange (in billions USD)
        base_oi = {
            Exchange.BINANCE: 8.2,
            Exchange.BYBIT: 4.5,
            Exchange.OKX: 3.1,
            Exchange.DERIBIT: 1.2,
            Exchange.BITMEX: 1.5,
        }

        oi_usd = base_oi.get(exchange, 1.0) * 1_000_000_000
        # Add randomness
        oi_usd *= (1 + random.uniform(-0.1, 0.1))

        # Calculate contracts (assuming ~$67k BTC)
        if symbol == "BTC":
            price = 67500
        elif symbol == "ETH":
            price = 2500
            oi_usd *= 0.4  # ETH has ~40% of BTC OI
        else:
            price = 100
            oi_usd *= 0.1

        contracts = oi_usd / price

        return OpenInterest(
            exchange=exchange.value,
            symbol=symbol,
            oi_usd=Decimal(str(int(oi_usd))),
            oi_contracts=Decimal(str(int(contracts))),
            change_1h_pct=round(random.uniform(-2, 3), 2),
            change_24h_pct=round(random.uniform(-5, 8), 2),
            change_7d_pct=round(random.uniform(-10, 15), 2),
            long_ratio=round(1.0 + random.uniform(-0.2, 0.3), 2),
            timestamp=datetime.now(),
        )

    # -------------------------------------------------------------------------
    # Liquidation Methods
    # -------------------------------------------------------------------------

    def get_recent_liquidations(
        self,
        symbol: str,
        exchange: Optional[Exchange] = None,
        limit: int = 50,
        min_value_usd: float = 100000,
    ) -> List[Liquidation]:
        """Get recent liquidation events."""
        if self.use_mock:
            return self._mock_liquidations(symbol, limit, min_value_usd)

        raise NotImplementedError("Live API not implemented")

    def get_liquidation_levels(
        self,
        symbol: str,
        current_price: Decimal,
    ) -> List[LiquidationLevel]:
        """Get aggregated liquidation levels."""
        if self.use_mock:
            return self._mock_liquidation_levels(symbol, current_price)

        raise NotImplementedError("Live API not implemented")

    def _mock_liquidations(
        self,
        symbol: str,
        limit: int,
        min_value_usd: float,
    ) -> List[Liquidation]:
        """Generate mock liquidation events."""
        liquidations = []
        exchanges = [e.value for e in Exchange]

        if symbol == "BTC":
            base_price = 67500
        elif symbol == "ETH":
            base_price = 2500
        else:
            base_price = 100

        for i in range(limit):
            side = random.choice(["long", "short"])
            # Liquidation prices cluster around support/resistance
            if side == "long":
                price = base_price * (1 - random.uniform(0.01, 0.05))
            else:
                price = base_price * (1 + random.uniform(0.01, 0.05))

            value = random.uniform(min_value_usd, min_value_usd * 50)
            quantity = value / price

            liquidations.append(Liquidation(
                exchange=random.choice(exchanges),
                symbol=symbol,
                side=side,
                price=Decimal(str(round(price, 2))),
                quantity=Decimal(str(round(quantity, 4))),
                value_usd=Decimal(str(int(value))),
                timestamp=datetime.now() - timedelta(minutes=random.randint(1, 1440)),
            ))

        return sorted(liquidations, key=lambda x: x.timestamp, reverse=True)

    def _mock_liquidation_levels(
        self,
        symbol: str,
        current_price: Decimal,
    ) -> List[LiquidationLevel]:
        """Generate mock liquidation level clusters."""
        levels = []
        price = float(current_price)

        # Long liquidation levels (below current price)
        long_levels = [
            (price * 0.96, 125_000_000, "high"),
            (price * 0.93, 85_000_000, "medium"),
            (price * 0.89, 210_000_000, "critical"),
            (price * 0.85, 150_000_000, "high"),
        ]

        # Short liquidation levels (above current price)
        short_levels = [
            (price * 1.04, 95_000_000, "medium"),
            (price * 1.07, 145_000_000, "high"),
            (price * 1.11, 180_000_000, "high"),
            (price * 1.15, 120_000_000, "medium"),
        ]

        for lvl_price, value, density in long_levels:
            levels.append(LiquidationLevel(
                price=Decimal(str(int(lvl_price))),
                side="long",
                total_value_usd=Decimal(str(int(value * random.uniform(0.8, 1.2)))),
                density=density,
            ))

        for lvl_price, value, density in short_levels:
            levels.append(LiquidationLevel(
                price=Decimal(str(int(lvl_price))),
                side="short",
                total_value_usd=Decimal(str(int(value * random.uniform(0.8, 1.2)))),
                density=density,
            ))

        return sorted(levels, key=lambda x: x.price)

    # -------------------------------------------------------------------------
    # Options Methods
    # -------------------------------------------------------------------------

    def get_options_snapshot(
        self,
        symbol: str,
        expiry: Optional[str] = None,
    ) -> Optional[OptionsSnapshot]:
        """Get options market snapshot."""
        if self.use_mock:
            return self._mock_options_snapshot(symbol, expiry)

        raise NotImplementedError("Live API not implemented")

    def _mock_options_snapshot(
        self,
        symbol: str,
        expiry: Optional[str] = None,
    ) -> OptionsSnapshot:
        """Generate mock options snapshot."""
        if symbol == "BTC":
            max_pain = 67000
            atm_iv = 55 + random.uniform(-5, 10)
        elif symbol == "ETH":
            max_pain = 2500
            atm_iv = 60 + random.uniform(-5, 15)
        else:
            max_pain = 100
            atm_iv = 80 + random.uniform(-10, 20)

        if expiry is None:
            # Default to next Friday
            expiry = "2025-01-17"

        call_oi = random.uniform(1, 5) * 1_000_000_000
        put_oi = call_oi * random.uniform(0.6, 0.9)

        return OptionsSnapshot(
            symbol=symbol,
            exchange="deribit",
            expiry=expiry,
            atm_iv=round(atm_iv, 1),
            put_call_ratio_volume=round(random.uniform(0.5, 1.2), 2),
            put_call_ratio_oi=round(put_oi / call_oi, 2),
            max_pain=Decimal(str(max_pain)),
            total_call_oi=Decimal(str(int(call_oi))),
            total_put_oi=Decimal(str(int(put_oi))),
            timestamp=datetime.now(),
        )

    # -------------------------------------------------------------------------
    # Basis Methods
    # -------------------------------------------------------------------------

    def get_basis_data(
        self,
        symbol: str,
    ) -> BasisData:
        """Get basis/spread data."""
        if self.use_mock:
            return self._mock_basis_data(symbol)

        raise NotImplementedError("Live API not implemented")

    def _mock_basis_data(self, symbol: str) -> BasisData:
        """Generate mock basis data."""
        if symbol == "BTC":
            spot = 67500
        elif symbol == "ETH":
            spot = 2500
        else:
            spot = 100

        # Perpetual typically trades at small premium/discount
        perp_basis = random.uniform(-0.05, 0.15)
        perp_price = spot * (1 + perp_basis / 100)

        # Quarterly typically in contango
        quarterly_basis = random.uniform(1, 5)
        quarterly_price = spot * (1 + quarterly_basis / 100)

        # Annualized yield (assuming ~3 months to expiry)
        days_to_expiry = 90
        annualized = quarterly_basis * (365 / days_to_expiry)

        return BasisData(
            symbol=symbol,
            spot_price=Decimal(str(round(spot, 2))),
            perp_price=Decimal(str(round(perp_price, 2))),
            perp_basis_pct=round(perp_basis, 3),
            quarterly_price=Decimal(str(round(quarterly_price, 2))),
            quarterly_basis_pct=round(quarterly_basis, 3),
            quarterly_expiry="2025-03-28",
            annualized_yield=round(annualized, 2),
        )


def demo():
    """Demonstrate exchange client."""
    client = ExchangeClient(use_mock=True)

    print("=" * 60)
    print("EXCHANGE CLIENT DEMO")
    print("=" * 60)

    # Funding rates
    print("\n📊 BTC Funding Rates:")
    rates = client.get_all_funding_rates("BTC")
    for rate in rates:
        print(f"  {rate.exchange:<10} {float(rate.rate):+.4%} | "
              f"Annualized: {rate.annualized:+.2f}%")

    # Open interest
    print("\n📈 BTC Open Interest:")
    oi_list = client.get_all_open_interest("BTC")
    total = sum(float(oi.oi_usd) for oi in oi_list)
    for oi in sorted(oi_list, key=lambda x: x.oi_usd, reverse=True):
        share = float(oi.oi_usd) / total * 100
        print(f"  {oi.exchange:<10} ${float(oi.oi_usd)/1e9:.1f}B | "
              f"24h: {oi.change_24h_pct:+.1f}% | Share: {share:.1f}%")

    # Basis
    print("\n💱 BTC Basis:")
    basis = client.get_basis_data("BTC")
    print(f"  Spot:     ${basis.spot_price:,.2f}")
    print(f"  Perp:     ${basis.perp_price:,.2f} ({basis.perp_basis_pct:+.3f}%)")
    print(f"  Quarterly: ${basis.quarterly_price:,.2f} ({basis.quarterly_basis_pct:+.3f}%)")
    print(f"  Annualized: {basis.annualized_yield:+.2f}%")


if __name__ == "__main__":
    demo()