#!/usr/bin/env npx tsx
// Cancel orders on Hyperliquid

import { getClient } from '../core/client.js';
import { formatUsd, parseArgs } from '../core/utils.js';

function printUsage() {
  console.log(`
Open Broker - Cancel Orders
===========================

Cancel open orders.

Usage:
  npx tsx scripts/operations/cancel.ts [--coin <COIN>] [--oid <ORDER_ID>] [--all]

Options:
  --coin      Cancel orders for specific coin only
  --oid       Cancel specific order by ID
  --all       Cancel all open orders
  --fast      Fast cancel (mempool-prioritized). Rejected by the API for
              trigger orders (TP/SL) - use only on plain resting limits
  --dry       Dry run - show what would be cancelled

Examples:
  npx tsx scripts/operations/cancel.ts --all                    # Cancel all orders
  npx tsx scripts/operations/cancel.ts --coin ETH               # Cancel all ETH orders
  npx tsx scripts/operations/cancel.ts --coin ETH --oid 123456  # Cancel specific order
  npx tsx scripts/operations/cancel.ts --all --dry              # Show all orders (dry run)
`);
}

async function main() {
  const args = parseArgs(process.argv.slice(2));

  const coin = args.coin as string | undefined;
  const oid = args.oid ? parseInt(args.oid as string) : undefined;
  const all = args.all as boolean;
  const fast = args.fast as boolean;
  const dryRun = args.dry as boolean;

  // Must specify something to cancel
  if (!coin && !oid && !all) {
    printUsage();
    process.exit(1);
  }

  const client = getClient();

  console.log('Open Broker - Cancel Orders');
  console.log('===========================\n');

  try {
    // Get open orders
    const orders = await client.getOpenOrders();

    // Filter orders based on arguments
    let targetOrders = orders;
    if (coin) {
      targetOrders = orders.filter(o => o.coin === coin);
    }
    if (oid) {
      targetOrders = orders.filter(o => o.oid === oid);
    }

    if (targetOrders.length === 0) {
      if (oid) {
        console.log(`No order found with ID ${oid}`);
      } else if (coin) {
        console.log(`No open orders for ${coin}`);
      } else {
        console.log('No open orders to cancel');
      }
      return;
    }

    // Display orders to be cancelled
    console.log('Orders to Cancel');
    console.log('----------------');
    console.log('Coin     | Side | Size       | Price      | Order ID');
    console.log('---------|------|------------|------------|----------');

    for (const order of targetOrders) {
      const side = order.side === 'B' ? 'BUY ' : 'SELL';
      console.log(
        `${order.coin.padEnd(8)} | ${side} | ${parseFloat(order.sz).toFixed(4).padStart(10)} | ` +
        `${formatUsd(parseFloat(order.limitPx)).padStart(10)} | ${order.oid}`
      );
    }

    console.log(`\nTotal: ${targetOrders.length} order(s)`);

    if (dryRun) {
      console.log('\n🔍 Dry run - orders not cancelled');
      return;
    }

    console.log('\nCancelling...');

    let successCount = 0;
    let failCount = 0;

    for (const order of targetOrders) {
      try {
        const response = await client.cancel(order.coin, order.oid, { fast });
        if (response.status === 'ok') {
          console.log(`✅ Cancelled ${order.coin} order ${order.oid}`);
          successCount++;
        } else {
          console.log(`❌ Failed to cancel ${order.coin} order ${order.oid}`);
          failCount++;
        }
      } catch (err) {
        console.log(`❌ Error cancelling ${order.coin} order ${order.oid}: ${err}`);
        failCount++;
      }
    }

    console.log(`\nResult: ${successCount} cancelled, ${failCount} failed`);

  } catch (error) {
    console.error('Error:', error);
    process.exit(1);
  }
}

main();