scope/cli/

market.rs

//! # Market Command
//!
//! Reports peg and order book health for stablecoin markets.
//! Fetches level-2 depth from CEX (Binance, Biconomy) or DEX (Ethereum, Solana) venues
//! and runs configurable health checks including volume and execution estimates.
//! Supports one-shot or repeated runs with configurable frequency and duration.

use crate::chains::ChainClientFactory;
use crate::cli::crawl::{self, Period};
use crate::config::Config;
use crate::error::{Result, ScopeError};
use crate::market::{
    BiconomyClient, BinanceClient, HealthThresholds, MarketSummary, MarketVenue, OrderBook,
    OrderBookClient, order_book_from_analytics,
};
use clap::{Args, Subcommand};
use std::time::Duration;

/// Default interval between summary runs when in repeat mode (60 seconds).
pub const DEFAULT_EVERY_SECS: u64 = 60;

/// Default total duration when in repeat mode (1 hour).
pub const DEFAULT_DURATION_SECS: u64 = 3600;

/// Market subcommands.
#[derive(Debug, Subcommand)]
pub enum MarketCommands {
    /// One-screen peg and order book health summary.
    ///
    /// Displays best bid/ask, mid price, spread, order book levels,
    /// and configurable health checks (peg safety, bid/ask ratio, depth thresholds).
    ///
    /// Use --every and --duration to run repeatedly (e.g., every 30s for 1 hour).
    Summary(SummaryArgs),
}

/// Arguments for `scope market summary`.
///
/// Default thresholds (min_levels, min_depth, peg_range) originated from the
/// PUSD Hummingbot market-making config and are tunable for other markets.
#[derive(Debug, Args)]
pub struct SummaryArgs {
    /// Base token symbol (e.g., USDC, PUSD). Quote is USDT.
    #[arg(default_value = "USDC", value_name = "SYMBOL")]
    pub pair: String,

    /// Market venue: binance, biconomy, eth, solana.
    #[arg(long, default_value = "binance", value_name = "VENUE")]
    pub market_venue: MarketVenue,

    /// Chain for DEX venues (ethereum or solana). Ignored for CEX.
    #[arg(long, default_value = "ethereum", value_name = "CHAIN")]
    pub chain: String,

    /// Biconomy API URL (only when venue is biconomy; for testing or custom deployment).
    #[arg(long, value_name = "URL")]
    pub biconomy_api_url: Option<String>,

    /// Peg target (e.g., 1.0 for USD stablecoins).
    #[arg(long, default_value = "1.0", value_name = "TARGET")]
    pub peg: f64,

    /// Minimum order book levels per side (default from PUSD Hummingbot config).
    #[arg(long, default_value = "6", value_name = "N")]
    pub min_levels: usize,

    /// Minimum depth per side in quote terms, e.g. USDT (default from PUSD Hummingbot config).
    #[arg(long, default_value = "3000", value_name = "USDT")]
    pub min_depth: f64,

    /// Peg range for outlier filtering (orders outside peg ± range×5 excluded).
    /// E.g., 0.001 = ±0.5% around peg.
    #[arg(long, default_value = "0.001", value_name = "RANGE")]
    pub peg_range: f64,

    /// Min bid/ask depth ratio (warn if ratio below this).
    #[arg(long, default_value = "0.2", value_name = "RATIO")]
    pub min_bid_ask_ratio: f64,

    /// Max bid/ask depth ratio (warn if ratio above this).
    #[arg(long, default_value = "5.0", value_name = "RATIO")]
    pub max_bid_ask_ratio: f64,

    /// Output format.
    #[arg(short, long, default_value = "text")]
    pub format: SummaryFormat,

    /// Run repeatedly at this interval (e.g., 30s, 5m, 1h).
    /// Default when in repeat mode: 60s.
    #[arg(long, value_name = "INTERVAL")]
    pub every: Option<String>,

    /// Run for this total duration (e.g., 10m, 1h, 24h).
    /// Default when in repeat mode: 1h.
    #[arg(long, value_name = "DURATION")]
    pub duration: Option<String>,

    /// Save markdown report to file (one-shot mode) or final report (repeat mode).
    #[arg(long, value_name = "PATH")]
    pub report: Option<std::path::PathBuf>,

    /// Append time-series CSV of peg/spread/depth to this path (repeat mode only).
    #[arg(long, value_name = "PATH")]
    pub csv: Option<std::path::PathBuf>,
}

#[derive(Debug, Clone, Copy, Default, clap::ValueEnum)]
pub enum SummaryFormat {
    /// Human-readable text report (default).
    #[default]
    Text,
    /// JSON for programmatic consumption.
    Json,
}

/// Run the market command.
pub async fn run(
    args: MarketCommands,
    _config: &Config,
    factory: &dyn ChainClientFactory,
) -> Result<()> {
    match args {
        MarketCommands::Summary(summary_args) => run_summary(summary_args, factory).await,
    }
}

/// Parse duration strings like "30s", "5m", "1h", "24h" into seconds.
/// Extract base symbol from pair (e.g. "PUSD_USDT" -> "PUSD", "USDCUSDT" -> "USDC", "USDC" -> "USDC").
fn base_symbol_from_pair(pair: &str) -> &str {
    let p = pair.trim();
    if let Some(i) = p.find("_USDT") {
        return &p[..i];
    }
    if let Some(i) = p.find("_usdt") {
        return &p[..i];
    }
    if let Some(i) = p.find("/USDT") {
        return &p[..i];
    }
    if p.to_uppercase().ends_with("USDT") && p.len() > 4 {
        return &p[..p.len() - 4];
    }
    p
}

fn parse_duration(s: &str) -> Result<u64> {
    let s = s.trim();
    if s.is_empty() {
        return Err(ScopeError::Chain("Empty duration".to_string()));
    }
    let (num_str, unit) = s
        .char_indices()
        .find(|(_, c)| !c.is_ascii_digit() && *c != '.')
        .map(|(i, _)| (&s[..i], s[i..].trim()))
        .unwrap_or((s, "s"));

    let num: f64 = num_str
        .parse()
        .map_err(|_| ScopeError::Chain(format!("Invalid duration number: {}", num_str)))?;

    if num <= 0.0 {
        return Err(ScopeError::Chain("Duration must be positive".to_string()));
    }

    let secs = match unit.to_lowercase().as_str() {
        "s" | "sec" | "secs" | "second" | "seconds" => num,
        "m" | "min" | "mins" | "minute" | "minutes" => num * 60.0,
        "h" | "hr" | "hrs" | "hour" | "hours" => num * 3600.0,
        "d" | "day" | "days" => num * 86400.0,
        _ => {
            return Err(ScopeError::Chain(format!(
                "Unknown duration unit: {}",
                unit
            )));
        }
    };

    Ok(secs as u64)
}

/// Builds markdown report content for a market summary.
fn market_summary_to_markdown(summary: &MarketSummary, venue: &str, pair: &str) -> String {
    let bid_dev = summary
        .best_bid
        .map(|b| (b - summary.peg_target) / summary.peg_target * 100.0);
    let ask_dev = summary
        .best_ask
        .map(|a| (a - summary.peg_target) / summary.peg_target * 100.0);
    let volume_row = summary
        .volume_24h
        .map(|v| format!("| Volume (24h) | {:.0} USDT |  \n", v))
        .unwrap_or_default();
    let exec_buy = summary
        .execution_10k_buy
        .as_ref()
        .map(|e| {
            if e.fillable {
                format!("{:.2} bps", e.slippage_bps)
            } else {
                "insufficient".to_string()
            }
        })
        .unwrap_or_else(|| "-".to_string());
    let exec_sell = summary
        .execution_10k_sell
        .as_ref()
        .map(|e| {
            if e.fillable {
                format!("{:.2} bps", e.slippage_bps)
            } else {
                "insufficient".to_string()
            }
        })
        .unwrap_or_else(|| "-".to_string());
    let mut md = format!(
        "# Market Health Report: {}  \n\
        **Venue:** {}  \n\
        **Generated:** {}  \n\n\
        ## Peg & Spread  \n\
        | Metric | Value |  \n\
        |--------|-------|  \n\
        | Peg Target | {:.4} |  \n\
        | Best Bid | {} |  \n\
        | Best Ask | {} |  \n\
        | Mid Price | {} |  \n\
        | Spread | {} |  \n\
        {}\
        | 10k Buy Slippage | {} |  \n\
        | 10k Sell Slippage | {} |  \n\
        | Bid Depth | {:.0} |  \n\
        | Ask Depth | {:.0} |  \n\
        | Healthy | {} |  \n\n\
        ## Health Checks  \n",
        pair,
        venue,
        chrono::Utc::now().format("%Y-%m-%d %H:%M:%S UTC"),
        summary.peg_target,
        summary
            .best_bid
            .map(|b| format!("{:.4} ({:+.3}%)", b, bid_dev.unwrap_or(0.0)))
            .unwrap_or_else(|| "-".to_string()),
        summary
            .best_ask
            .map(|a| format!("{:.4} ({:+.3}%)", a, ask_dev.unwrap_or(0.0)))
            .unwrap_or_else(|| "-".to_string()),
        summary
            .mid_price
            .map(|m| format!("{:.4}", m))
            .unwrap_or_else(|| "-".to_string()),
        summary
            .spread
            .map(|s| format!("{:.4}", s))
            .unwrap_or_else(|| "-".to_string()),
        volume_row,
        exec_buy,
        exec_sell,
        summary.bid_depth,
        summary.ask_depth,
        if summary.healthy { "✓" } else { "✗" }
    );
    for check in &summary.checks {
        let (icon, msg) = match check {
            crate::market::HealthCheck::Pass(m) => ("✓", m.as_str()),
            crate::market::HealthCheck::Fail(m) => ("✗", m.as_str()),
        };
        md.push_str(&format!("- {} {}\n", icon, msg));
    }
    md.push_str(&crate::display::report::report_footer());
    md
}

async fn fetch_book_and_volume(
    args: &SummaryArgs,
    factory: &dyn ChainClientFactory,
) -> Result<(OrderBook, Option<f64>)> {
    let base = base_symbol_from_pair(&args.pair).to_string();

    if args.market_venue.is_cex() {
        let client: Box<dyn OrderBookClient> = match args.market_venue {
            MarketVenue::Biconomy if args.biconomy_api_url.is_some() => {
                Box::new(BiconomyClient::new(args.biconomy_api_url.as_ref().unwrap()))
            }
            _ => args
                .market_venue
                .create_client()
                .ok_or_else(|| ScopeError::Chain("No CEX client for venue".to_string()))?,
        };
        let pair = args.market_venue.format_pair(&base);
        let book = client.fetch_order_book(&pair).await?;

        let volume = match args.market_venue {
            MarketVenue::Binance => {
                let binance = BinanceClient::default_url();
                binance.fetch_24h_volume(&pair).await.ok().flatten()
            }
            MarketVenue::Biconomy => None,
            _ => None,
        };
        Ok((book, volume))
    } else {
        let chain = match args.market_venue {
            MarketVenue::Ethereum => "ethereum",
            MarketVenue::Solana => "solana",
            _ => &args.chain,
        };
        let analytics =
            crawl::fetch_analytics_for_input(&base, chain, Period::Hour24, 10, factory).await?;
        if analytics.dex_pairs.is_empty() {
            return Err(ScopeError::Chain(format!(
                "No DEX pairs found for {} on {}",
                base, chain
            )));
        }
        let best_pair = analytics
            .dex_pairs
            .iter()
            .max_by(|a, b| {
                a.liquidity_usd
                    .partial_cmp(&b.liquidity_usd)
                    .unwrap_or(std::cmp::Ordering::Equal)
            })
            .unwrap();
        let book = order_book_from_analytics(chain, best_pair, &analytics.token.symbol);
        let volume = Some(best_pair.volume_24h);
        Ok((book, volume))
    }
}

async fn run_summary_once(
    args: &SummaryArgs,
    factory: &dyn ChainClientFactory,
    thresholds: &HealthThresholds,
    run_num: Option<u64>,
) -> Result<MarketSummary> {
    if let Some(n) = run_num {
        let ts = chrono::Utc::now().format("%H:%M:%S");
        eprintln!("  --- Run #{} at {} ---\n", n, ts);
    }

    let (book, volume_24h) = fetch_book_and_volume(args, factory).await?;
    let summary = MarketSummary::from_order_book(&book, args.peg, thresholds, volume_24h);

    let venue_label = format!("{:?}", args.market_venue).to_lowercase();

    match args.format {
        SummaryFormat::Text => {
            print!("{}", summary.format_text(Some(&venue_label)));
        }
        SummaryFormat::Json => {
            let json = serde_json::json!({
                "run": run_num,
                "venue": venue_label,
                "pair": summary.pair,
                "peg_target": summary.peg_target,
                "best_bid": summary.best_bid,
                "best_ask": summary.best_ask,
                "mid_price": summary.mid_price,
                "spread": summary.spread,
                "volume_24h": summary.volume_24h,
                "execution_10k_buy": summary.execution_10k_buy.as_ref().map(|e| serde_json::json!({
                    "fillable": e.fillable,
                    "slippage_bps": e.slippage_bps
                })),
                "execution_10k_sell": summary.execution_10k_sell.as_ref().map(|e| serde_json::json!({
                    "fillable": e.fillable,
                    "slippage_bps": e.slippage_bps
                })),
                "ask_depth": summary.ask_depth,
                "bid_depth": summary.bid_depth,
                "ask_levels": summary.asks.len(),
                "bid_levels": summary.bids.len(),
                "healthy": summary.healthy,
                "checks": summary.checks.iter().map(|c| match c {
                    crate::market::HealthCheck::Pass(m) => serde_json::json!({"status": "pass", "message": m}),
                    crate::market::HealthCheck::Fail(m) => serde_json::json!({"status": "fail", "message": m}),
                }).collect::<Vec<_>>(),
            });
            println!("{}", serde_json::to_string_pretty(&json)?);
        }
    }

    Ok(summary)
}

async fn run_summary(args: SummaryArgs, factory: &dyn ChainClientFactory) -> Result<()> {
    let thresholds = HealthThresholds {
        peg_target: args.peg,
        peg_range: args.peg_range,
        min_levels: args.min_levels,
        min_depth: args.min_depth,
        min_bid_ask_ratio: args.min_bid_ask_ratio,
        max_bid_ask_ratio: args.max_bid_ask_ratio,
    };

    let repeat_mode = args.every.is_some() || args.duration.is_some();

    if !repeat_mode {
        let summary = run_summary_once(&args, factory, &thresholds, None).await?;
        if let Some(ref report_path) = args.report {
            let venue_label = format!("{:?}", args.market_venue).to_lowercase();
            let md = market_summary_to_markdown(&summary, &venue_label, &args.pair);
            std::fs::write(report_path, md)?;
            eprintln!("\nReport saved to: {}", report_path.display());
        }
        return Ok(());
    }

    let every_secs = args
        .every
        .as_ref()
        .map(|s| parse_duration(s))
        .transpose()?
        .unwrap_or(DEFAULT_EVERY_SECS);

    let duration_secs = args
        .duration
        .as_ref()
        .map(|s| parse_duration(s))
        .transpose()?
        .unwrap_or(DEFAULT_DURATION_SECS);

    if every_secs == 0 {
        return Err(ScopeError::Chain("Interval must be positive".to_string()));
    }

    let every = Duration::from_secs(every_secs);
    let start = std::time::Instant::now();
    let duration = Duration::from_secs(duration_secs);

    eprintln!(
        "Running market summary every {}s for {}s (Ctrl+C to stop early)\n",
        every_secs, duration_secs
    );

    let mut run_num: u64 = 1;
    #[allow(unused_assignments)]
    let mut last_summary: Option<MarketSummary> = None;

    // Initialize CSV if requested
    if let Some(ref csv_path) = args.csv {
        let header =
            "timestamp,run,best_bid,best_ask,mid_price,spread,bid_depth,ask_depth,healthy\n";
        std::fs::write(csv_path, header)?;
    }

    loop {
        let summary = run_summary_once(&args, factory, &thresholds, Some(run_num)).await?;
        last_summary = Some(summary.clone());

        // Append CSV row
        if let Some(ref csv_path) = args.csv {
            let ts = chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ");
            let bid = summary
                .best_bid
                .map(|v| v.to_string())
                .unwrap_or_else(|| "-".to_string());
            let ask = summary
                .best_ask
                .map(|v| v.to_string())
                .unwrap_or_else(|| "-".to_string());
            let mid = summary
                .mid_price
                .map(|v| v.to_string())
                .unwrap_or_else(|| "-".to_string());
            let spread = summary
                .spread
                .map(|v| v.to_string())
                .unwrap_or_else(|| "-".to_string());
            let row = format!(
                "{},{},{},{},{},{},{},{},{}\n",
                ts,
                run_num,
                bid,
                ask,
                mid,
                spread,
                summary.bid_depth,
                summary.ask_depth,
                summary.healthy
            );
            let mut f = std::fs::OpenOptions::new().append(true).open(csv_path)?;
            use std::io::Write;
            f.write_all(row.as_bytes())?;
        }

        if start.elapsed() >= duration {
            eprintln!("\nCompleted {} run(s) over {}s.", run_num, duration_secs);
            break;
        }

        run_num += 1;

        let remaining = duration.saturating_sub(start.elapsed());
        let sleep_duration = if remaining < every { remaining } else { every };
        tokio::time::sleep(sleep_duration).await;
    }

    // Save final report if requested (last_summary always set when loop runs)
    if let (Some(ref report_path), Some(summary)) = (args.report, last_summary.as_ref()) {
        let venue_label = format!("{:?}", args.market_venue).to_lowercase();
        let md = market_summary_to_markdown(summary, &venue_label, &args.pair);
        std::fs::write(report_path, md)?;
        eprintln!("Report saved to: {}", report_path.display());
    }
    if let Some(ref csv_path) = args.csv {
        eprintln!("Time-series CSV saved to: {}", csv_path.display());
    }

    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::chains::DefaultClientFactory;

    #[tokio::test]
    async fn test_run_summary_with_mock_orderbook() {
        let mut server = mockito::Server::new_async().await;
        let orderbook_body = r#"{"asks":[["1.0001","500"],["1.0002","300"]],"bids":[["0.9999","600"],["0.9998","400"]]}"#;
        let _mock = server
            .mock(
                "GET",
                mockito::Matcher::Regex(r"^/api/v1/depth\?symbol=.*$".to_string()),
            )
            .with_status(200)
            .with_header("content-type", "application/json")
            .with_body(orderbook_body)
            .create();

        let args = SummaryArgs {
            pair: "PUSD".to_string(),
            market_venue: MarketVenue::Biconomy,
            chain: "ethereum".to_string(),
            biconomy_api_url: Some(server.url()),
            peg: 1.0,
            min_levels: 2,
            min_depth: 100.0,
            peg_range: 0.001,
            min_bid_ask_ratio: 0.2,
            max_bid_ask_ratio: 5.0,
            format: SummaryFormat::Text,
            every: None,
            duration: None,
            report: None,
            csv: None,
        };

        let factory = DefaultClientFactory {
            chains_config: Default::default(),
        };
        let result = run_summary(args, &factory).await;
        assert!(result.is_ok());
    }

    #[tokio::test]
    async fn test_run_summary_json_format() {
        let mut server = mockito::Server::new_async().await;
        let orderbook_body = r#"{"asks":[["1.0001","100"]],"bids":[["0.9999","100"]]}"#;
        let _mock = server
            .mock(
                "GET",
                mockito::Matcher::Regex(r"^/api/v1/depth\?symbol=.*$".to_string()),
            )
            .with_status(200)
            .with_header("content-type", "application/json")
            .with_body(orderbook_body)
            .create();

        let args = SummaryArgs {
            pair: "PUSD".to_string(),
            market_venue: MarketVenue::Biconomy,
            chain: "ethereum".to_string(),
            biconomy_api_url: Some(server.url()),
            peg: 1.0,
            min_levels: 1,
            min_depth: 50.0,
            peg_range: 0.001,
            min_bid_ask_ratio: 0.1,
            max_bid_ask_ratio: 10.0,
            format: SummaryFormat::Json,
            every: None,
            duration: None,
            report: None,
            csv: None,
        };

        let factory = DefaultClientFactory {
            chains_config: Default::default(),
        };
        let result = run_summary(args, &factory).await;
        assert!(result.is_ok());
    }

    #[test]
    fn test_parse_duration_seconds() {
        assert_eq!(parse_duration("30s").unwrap(), 30);
        assert_eq!(parse_duration("1").unwrap(), 1);
        assert_eq!(parse_duration("60sec").unwrap(), 60);
    }

    #[test]
    fn test_parse_duration_minutes() {
        assert_eq!(parse_duration("5m").unwrap(), 300);
        assert_eq!(parse_duration("1min").unwrap(), 60);
        assert_eq!(parse_duration("2.5m").unwrap(), 150);
    }

    #[test]
    fn test_parse_duration_hours() {
        assert_eq!(parse_duration("1h").unwrap(), 3600);
        assert_eq!(parse_duration("24h").unwrap(), 86400);
    }

    #[test]
    fn test_parse_duration_invalid() {
        assert!(parse_duration("").is_err());
        assert!(parse_duration("abc").is_err());
        assert!(parse_duration("30x").is_err());
    }

    #[test]
    fn test_parse_duration_non_positive() {
        assert!(parse_duration("0").is_err());
        assert!(parse_duration("-5s").is_err());
    }
}