Subscribing to Updates

use drift_rs::MarketId;

// Subscribe to specific markets
let markets = vec![
    MarketId::perp(0),  // SOL-PERP
    MarketId::perp(1),  // BTC-PERP
    MarketId::spot(0),  // USDC
    MarketId::spot(1),  // SOL
];

drift_client.subscribe_markets(&markets)
    .await
    .expect("Failed to subscribe to markets");

// Now queries use cached WebSocket data
let sol_perp_market = drift_client.get_perp_market_account(0).await?;
println!("SOL-PERP market: {:?}", sol_perp_market);

// Subscribe to all active perp markets
drift_client.subscribe_all_perp_markets().await?;

// Subscribe to all active spot markets
drift_client.subscribe_all_spot_markets().await?;

// Subscribe to all active markets (both perp and spot)
drift_client.subscribe_all_markets().await?;

use drift_rs::types::AccountUpdate;
use anchor_lang::AccountDeserialize;
use drift_rs::types::accounts::PerpMarket;
use std::time::Instant;

let start_time = Instant::now();

let market_callback = move |update: &AccountUpdate| {
    // Deserialize the market data
    match PerpMarket::try_deserialize(&mut &update.data[..]) {
        Ok(market) => {
            let elapsed = start_time.elapsed().as_secs();
            println!(
                "[{}s] Market {} updated: base_asset_amount = {}",
                elapsed,
                market.market_index,
                market.amm.base_asset_amount_with_amm
            );
        }
        Err(e) => eprintln!("Failed to deserialize market: {}", e),
    }
};

let markets = vec![MarketId::perp(0)];
drift_client
    .subscribe_markets_with_callback(&markets, market_callback)
    .await?;

use drift_rs::MarketId;

// Subscribe to oracle prices for specific markets
let markets = vec![
    MarketId::perp(0),  // SOL oracle
    MarketId::perp(1),  // BTC oracle
];

drift_client.subscribe_oracles(&markets).await?;

// Query oracle price (now uses cached data)
let sol_price = drift_client.oracle_price(MarketId::perp(0)).await?;
println!("SOL price: ${:.2}", sol_price as f64 / 1_000_000.0);

// Subscribe to all perp market oracles
drift_client.subscribe_all_perp_oracles().await?;

// Subscribe to all spot market oracles
drift_client.subscribe_all_spot_oracles().await?;

// Subscribe to all oracles
drift_client.subscribe_all_oracles().await?;

let oracle_callback = move |update: &AccountUpdate| {
    println!(
        "Oracle updated: pubkey={}, slot={}, lamports={}",
        update.pubkey, update.slot, update.lamports
    );
};

let markets = vec![MarketId::perp(0)];
drift_client
    .subscribe_oracles_with_callback(&markets, oracle_callback)
    .await?;

use drift_rs::Wallet;

// Subscribe to your own sub-account
let subaccount = wallet.default_sub_account();
drift_client.subscribe_account(&subaccount).await?;

// Query the account (uses cached data)
let user_account = drift_client.get_user_account(&subaccount).await?;
println!("User authority: {}", user_account.authority);

use std::time::Duration;

// Poll every 30 seconds
drift_client
    .subscribe_account_polled(
        &subaccount,
        Duration::from_secs(30)
    )
    .await?;

// Subscribe to blockhashes (polls every 2 seconds)
drift_client.subscribe_blockhashes().await?;

// Get latest blockhash from cache
let blockhash = drift_client.get_latest_blockhash().await?;

use drift_rs::{Context, DriftClient, RpcClient, Wallet, MarketId};
use std::time::{Duration, Instant};
use tokio::time::timeout;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();
    dotenv::dotenv().ok();
    
    // Initialize client
    let rpc_url = std::env::var("RPC_URL")
        .unwrap_or_else(|_| "https://api.mainnet-beta.solana.com".to_string());
    let dummy_wallet = Wallet::read_only(
        solana_sdk::pubkey!("11111111111111111111111111111111")
    );
    
    let client = DriftClient::new(
        Context::MainNet,
        RpcClient::new(rpc_url),
        dummy_wallet,
    )
    .await?;
    
    println!("✅ Connected to Drift protocol\n");
    
    // Get available markets
    let perp_markets = client.get_all_perp_market_ids();
    println!("📈 Found {} active perp markets", perp_markets.len());
    
    let start_time = Instant::now();
    
    // Set up callback for market updates
    let market_callback = move |update: &drift_rs::types::AccountUpdate| {
        use anchor_lang::AccountDeserialize;
        use drift_rs::types::accounts::PerpMarket;
        
        if let Ok(market) = PerpMarket::try_deserialize(&mut &update.data[..]) {
            let elapsed = start_time.elapsed().as_secs();
            println!(
                "[{}s] Market {}: base_asset_amount = {}",
                elapsed, market.market_index, market.amm.base_asset_amount_with_amm
            );
        }
    };
    
    // Subscribe to markets with callback
    client
        .subscribe_markets_with_callback(&perp_markets, market_callback)
        .await?;
    
    println!("⏰ Running for 30 seconds...\n");
    
    // Run for 30 seconds
    timeout(
        Duration::from_secs(30),
        tokio::signal::ctrl_c(),
    )
    .await
    .ok();
    
    // Cleanup
    client.unsubscribe().await?;
    println!("\n✅ Unsubscribed from all updates");
    
    Ok(())
}

// Unsubscribe from all subscriptions
drift_client.unsubscribe().await?;

// After unsubscribing, queries will use RPC again
let market = drift_client.get_perp_market_account(0).await?;