interface SwapArgs {
  amountIn: BN; // Input amount
  expectAmountOut: BN; // Expected output amount
  minReturn: BN; // Minimum return amount
  amounts: BN[]; // 1st level split amounts
  routes: Route[][]; // 2nd level split routes
}

interface Route {
  dexes: Dex[]; // DEX types for this route
  weights: number[]; // Weights for each DEX
}

enum Dex {
  SplTokenSwap,
  StableSwap,
  Whirlpool,
  MeteoraDynamicpool,
  RaydiumSwap,
  RaydiumStableSwap,
  RaydiumClmmSwap,
  // ... more DEX types
}

// Commission info encoding
const commissionDirection = true; // true: from input, false: from output
const commissionRate = 100; // Rate in basis points (0.01%)
const commissionInfo =
  (commissionDirection ? 1 << 31 : 0) | (commissionRate & ((1 << 30) - 1));

// Basic token exchange
const swapArgs = {
  amountIn: new BN(1000000), // 1 token (assuming 6 decimals)
  expectAmountOut: new BN(950000), // Expected output
  minReturn: new BN(900000), // Minimum return
  amounts: [new BN(1000000)], // Single split
  routes: [[{ dexes: [Dex.RaydiumSwap], weights: [100] }]], // Single route
};

const swapTx = await program.methods
  .swap(swapArgs, orderId)
  .accounts(swapAccounts)
  .rpc();

// Trading through proxy account
const proxySwapTx = await program.methods
  .proxySwap(swapArgs, orderId)
  .accounts(proxySwapAccounts)
  .rpc();

// Trading with commission collection
const commissionSwapArgs = {
  ...swapArgs,
  commissionRate: 100, // 1% commission
  commissionDirection: true, // Commission from input
};

const commissionSwapTx = await program.methods
  .commissionSplSwap(commissionSwapArgs, orderId)
  .accounts(commissionSwapAccounts)
  .rpc();

// Trading with platform fee collection
const platformFeeRate = 50; // 0.5% platform fee
const trimRate = 10; // 1% trim rate

const platformFeeSwapTx = await program.methods
  .platformFeeSolProxySwapV2(
    swapArgs,
    commissionInfo,
    platformFeeRate,
    trimRate,
    orderId
  )
  .accounts(platformFeeAccounts)
  .rpc();

// Swap with commission and optional platform fee
const commissionInfo =
  (commissionDirection ? 1 << 31 : 0) | (commissionRate & ((1 << 30) - 1));
const platformFeeRate = 50; // 0.5% platform fee
const trimRate = 10; // 1% trim rate

const swapToBTx = await program.methods
  .swapTobV3(swapArgs, commissionInfo, trimRate, platformFeeRate, orderId)
  .accounts(swapV3Accounts)
  .rpc();

// Swap with commission and platform fee (no trim)
const swapToCTx = await program.methods
  .swapV3(swapArgs, commissionInfo, platformFeeRate, orderId)
  .accounts(swapV3Accounts)
  .rpc();

// Complex routing with multiple hops and DEXs
const complexSwapArgs = {
  amountIn: new BN(1000000),
  expectAmountOut: new BN(950000),
  minReturn: new BN(900000),
  amounts: [
    new BN(600000), // 60% through route 1
    new BN(400000), // 40% through route 2
  ],
  routes: [
    [
      { dexes: [Dex.RaydiumSwap], weights: [100] },
      { dexes: [Dex.Whirlpool], weights: [100] },
    ],
    [{ dexes: [Dex.MeteoraDynamicpool], weights: [100] }],
  ],
};