Order Management

/**
 * Create a new order
 * @param symbol - Trading pair symbol (e.g., 'BTC/USDT')
 * @param type - Order type: 'limit', 'market', 'stop', 'stop_limit', etc.
 * @param side - Order side: 'buy' or 'sell'
 * @param amount - Order amount in base currency
 * @param price - Order price in quote currency (required for limit orders)
 * @param params - Additional order parameters
 * @returns Created order object
 */
createOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: number, params?: Dict): Promise<Order>;

/**
 * Create a limit buy order
 * @param symbol - Trading pair symbol
 * @param amount - Order amount in base currency
 * @param price - Limit price in quote currency
 * @param params - Additional order parameters
 * @returns Created order object
 */
createLimitBuyOrder(symbol: string, amount: number, price: number, params?: Dict): Promise<Order>;

/**
 * Create a limit sell order
 * @param symbol - Trading pair symbol
 * @param amount - Order amount in base currency
 * @param price - Limit price in quote currency
 * @param params - Additional order parameters
 * @returns Created order object
 */
createLimitSellOrder(symbol: string, amount: number, price: number, params?: Dict): Promise<Order>;

/**
 * Create a market buy order
 * @param symbol - Trading pair symbol
 * @param amount - Order amount in base currency
 * @param price - Current market price (for cost calculation, optional)
 * @param params - Additional order parameters
 * @returns Created order object
 */
createMarketBuyOrder(symbol: string, amount: number, price?: number, params?: Dict): Promise<Order>;

/**
 * Create a market sell order
 * @param symbol - Trading pair symbol
 * @param amount - Order amount in base currency
 * @param price - Current market price (for cost calculation, optional)
 * @param params - Additional order parameters
 * @returns Created order object
 */
createMarketSellOrder(symbol: string, amount: number, price?: number, params?: Dict): Promise<Order>;

/**
 * Create a stop order (stop-loss or take-profit)
 * @param symbol - Trading pair symbol
 * @param side - Order side: 'buy' or 'sell'
 * @param amount - Order amount in base currency
 * @param price - Limit price (for stop-limit orders)
 * @param stopPrice - Stop trigger price
 * @param params - Additional order parameters
 * @returns Created order object
 */
createStopOrder(symbol: string, side: OrderSide, amount: number, price: number, stopPrice: number, params?: Dict): Promise<Order>;

type OrderType = 'limit' | 'market' | 'stop' | 'stop_limit' | 'trailing_stop' | 'fill_or_kill' | 'immediate_or_cancel' | 'good_till_canceled' | 'good_till_time' | 'post_only';
type OrderSide = 'buy' | 'sell';

interface Order {
  id: string;                    // Exchange-specific order identifier
  clientOrderId?: string;        // Client-specified order identifier
  timestamp: number;             // Order creation timestamp in milliseconds
  datetime: string;              // Order creation datetime in ISO format
  lastTradeTimestamp?: number;   // Last trade timestamp for this order
  symbol: string;                // Trading pair symbol
  type: OrderType;               // Order type
  side: OrderSide;               // Order side
  amount: number;                // Original order amount
  price?: number;                // Order price (limit orders)
  stopPrice?: number;            // Stop trigger price (stop orders)
  triggerPrice?: number;         // Alternative name for stop price
  average?: number;              // Average fill price
  filled: number;                // Filled amount
  remaining: number;             // Remaining amount
  cost: number;                  // Total cost (filled amount * average price)
  trades?: Trade[];              // Array of trades that filled this order
  fee?: {                        // Order fee information
    currency: string;            // Fee currency
    cost: number;                // Fee amount
    rate?: number;               // Fee rate
  };
  fees?: Array<{                 // Multiple fees (some exchanges)
    currency: string;
    cost: number;
    rate?: number;
  }>;
  status: OrderStatus;           // Current order status
  timeInForce?: TimeInForce;     // Time in force instruction
  postOnly?: boolean;            // Whether order is post-only
  reduceOnly?: boolean;          // Whether order is reduce-only (derivatives)
  info: any;                     // Raw exchange-specific order data
}

type OrderStatus = 'open' | 'closed' | 'canceled' | 'expired' | 'rejected' | 'pending';
type TimeInForce = 'GTC' | 'IOC' | 'FOK' | 'PO' | 'GTD';

// Create limit buy order
const limitBuyOrder = await exchange.createLimitBuyOrder('BTC/USDT', 0.001, 50000);
console.log(`Created limit buy order: ${limitBuyOrder.id}`);

// Create market sell order
const marketSellOrder = await exchange.createMarketSellOrder('BTC/USDT', 0.001);
console.log(`Created market sell order: ${marketSellOrder.id}`);

// Create stop-loss order
const stopLossOrder = await exchange.createStopOrder('BTC/USDT', 'sell', 0.001, 45000, 48000);
console.log(`Created stop-loss order: ${stopLossOrder.id}`);

// Create order with advanced parameters
const advancedOrder = await exchange.createOrder('BTC/USDT', 'limit', 'buy', 0.001, 50000, {
  timeInForce: 'IOC',        // Immediate or Cancel
  postOnly: true,            // Post-only order
  clientOrderId: 'my-order-123',  // Custom order ID
  reduceOnly: false,         // For derivatives
});

// Create order with custom parameters (exchange-specific)
const customOrder = await exchange.createOrder('BTC/USDT', 'limit', 'buy', 0.001, 50000, {
  'test': true,              // Binance: test order (won't execute)
  'newOrderRespType': 'FULL', // Binance: response type
  'iceberg': 0.0001,         // Iceberg order visible quantity
});

/**
 * Edit an existing order
 * @param id - Order ID to modify
 * @param symbol - Trading pair symbol
 * @param type - New order type (usually same as original)
 * @param side - New order side (usually same as original)  
 * @param amount - New order amount (optional)
 * @param price - New order price (optional)
 * @param params - Additional modification parameters
 * @returns Modified order object
 */
editOrder(id: string, symbol: string, type: OrderType, side: OrderSide, amount?: number, price?: number, params?: Dict): Promise<Order>;

// Modify order price
const modifiedOrder = await exchange.editOrder(
  'order-123',
  'BTC/USDT', 
  'limit', 
  'buy', 
  undefined,  // Keep same amount
  51000       // New price
);

// Modify order amount and price
const resizedOrder = await exchange.editOrder(
  'order-456',
  'BTC/USDT',
  'limit',
  'sell',
  0.002,      // New amount
  52000       // New price
);

// Note: Not all exchanges support order modification
// Check exchange.has.editOrder before using
if (exchange.has.editOrder) {
  const edited = await exchange.editOrder(orderId, symbol, type, side, newAmount, newPrice);
} else {
  // Cancel and recreate order
  await exchange.cancelOrder(orderId, symbol);
  const newOrder = await exchange.createOrder(symbol, type, side, newAmount, newPrice);
}

/**
 * Cancel a single order
 * @param id - Order ID to cancel
 * @param symbol - Trading pair symbol (required by some exchanges)
 * @param params - Additional cancellation parameters
 * @returns Canceled order object
 */
cancelOrder(id: string, symbol?: string, params?: Dict): Promise<Order>;

/**
 * Cancel multiple orders
 * @param ids - Array of order IDs to cancel
 * @param symbol - Trading pair symbol (optional)
 * @param params - Additional cancellation parameters
 * @returns Array of canceled order objects
 */
cancelOrders(ids: string[], symbol?: string, params?: Dict): Promise<Order[]>;

/**
 * Cancel all open orders
 * @param symbol - Trading pair symbol to cancel orders for (optional, cancels all if not provided)
 * @param params - Additional cancellation parameters
 * @returns Array of canceled order objects
 */
cancelAllOrders(symbol?: string, params?: Dict): Promise<Order[]>;

// Cancel single order
const canceledOrder = await exchange.cancelOrder('order-123', 'BTC/USDT');
console.log(`Canceled order ${canceledOrder.id}, status: ${canceledOrder.status}`);

// Cancel multiple orders
const orderIds = ['order-123', 'order-456', 'order-789'];
const canceledOrders = await exchange.cancelOrders(orderIds, 'BTC/USDT');
console.log(`Canceled ${canceledOrders.length} orders`);

// Cancel all orders for a symbol
const allCanceled = await exchange.cancelAllOrders('BTC/USDT');
console.log(`Canceled ${allCanceled.length} orders for BTC/USDT`);

// Cancel all orders across all symbols
const allOrdersCanceled = await exchange.cancelAllOrders();
console.log(`Canceled ${allOrdersCanceled.length} orders across all symbols`);

// Handle cancellation errors
try {
  await exchange.cancelOrder('non-existent-order');
} catch (error) {
  if (error instanceof ccxt.OrderNotFound) {
    console.log('Order was already canceled or filled');
  } else {
    console.error('Cancellation failed:', error.message);
  }
}

/**
 * Fetch a single order by ID
 * @param id - Order ID to fetch
 * @param symbol - Trading pair symbol (required by some exchanges)
 * @param params - Additional query parameters
 * @returns Order object
 */
fetchOrder(id: string, symbol?: string, params?: Dict): Promise<Order>;

/**
 * Fetch all orders (open and closed)
 * @param symbol - Trading pair symbol to filter by (optional)
 * @param since - Timestamp in milliseconds to fetch orders from (optional)
 * @param limit - Maximum number of orders to fetch (optional)
 * @param params - Additional query parameters
 * @returns Array of order objects
 */
fetchOrders(symbol?: string, since?: number, limit?: number, params?: Dict): Promise<Order[]>;

/**
 * Fetch only open orders
 * @param symbol - Trading pair symbol to filter by (optional)
 * @param since - Timestamp in milliseconds to fetch orders from (optional)  
 * @param limit - Maximum number of orders to fetch (optional)
 * @param params - Additional query parameters
 * @returns Array of open order objects
 */
fetchOpenOrders(symbol?: string, since?: number, limit?: number, params?: Dict): Promise<Order[]>;

/**
 * Fetch only closed orders (filled, canceled, expired)
 * @param symbol - Trading pair symbol to filter by (optional)
 * @param since - Timestamp in milliseconds to fetch orders from (optional)
 * @param limit - Maximum number of orders to fetch (optional)
 * @param params - Additional query parameters
 * @returns Array of closed order objects
 */
fetchClosedOrders(symbol?: string, since?: number, limit?: number, params?: Dict): Promise<Order[]>;

// Fetch specific order
const order = await exchange.fetchOrder('order-123', 'BTC/USDT');
console.log(`Order ${order.id}: ${order.status}, filled: ${order.filled}/${order.amount}`);

// Fetch all open orders
const openOrders = await exchange.fetchOpenOrders();
console.log(`${openOrders.length} open orders`);
openOrders.forEach(order => {
  console.log(`${order.symbol}: ${order.side} ${order.amount} @ ${order.price}`);
});

// Fetch open orders for specific symbol
const btcOrders = await exchange.fetchOpenOrders('BTC/USDT');
console.log(`${btcOrders.length} open BTC/USDT orders`);

// Fetch recent closed orders
const yesterday = Date.now() - 24 * 60 * 60 * 1000;
const recentClosedOrders = await exchange.fetchClosedOrders(undefined, yesterday, 50);
console.log(`${recentClosedOrders.length} orders closed in last 24h`);

// Fetch order history for specific symbol
const ethOrderHistory = await exchange.fetchOrders('ETH/USDT', undefined, 100);
const filledOrders = ethOrderHistory.filter(order => order.status === 'closed');
const canceledOrders = ethOrderHistory.filter(order => order.status === 'canceled');
console.log(`ETH/USDT: ${filledOrders.length} filled, ${canceledOrders.length} canceled`);

// Calculate order statistics
const totalVolume = filledOrders.reduce((sum, order) => sum + order.filled, 0);
const averagePrice = filledOrders.reduce((sum, order) => sum + order.average!, 0) / filledOrders.length;
console.log(`Total volume: ${totalVolume} ETH, Average price: $${averagePrice}`);

/**
 * Check if order is still open
 * @param order - Order object to check
 * @returns True if order is open
 */
isOrderOpen(order: Order): boolean;

/**
 * Check if order is closed (filled, canceled, or expired)
 * @param order - Order object to check
 * @returns True if order is closed
 */
isOrderClosed(order: Order): boolean;

/**
 * Calculate order fill percentage
 * @param order - Order object to analyze
 * @returns Fill percentage (0-100)
 */
getOrderFillPercentage(order: Order): number;

// Monitor order status
const orderId = 'order-123';
let order = await exchange.fetchOrder(orderId, 'BTC/USDT');

console.log(`Order ${order.id} status: ${order.status}`);
console.log(`Filled: ${order.filled}/${order.amount} (${(order.filled/order.amount*100).toFixed(1)}%)`);

// Wait for order to fill or expire
const checkOrderStatus = async (orderId: string, symbol: string, maxAttempts: number = 60) => {
  for (let i = 0; i < maxAttempts; i++) {
    const order = await exchange.fetchOrder(orderId, symbol);
    
    console.log(`Attempt ${i + 1}: Status ${order.status}, filled ${order.filled}/${order.amount}`);
    
    if (order.status === 'closed') {
      console.log(`Order filled at average price: $${order.average}`);
      return order;
    } else if (order.status === 'canceled' || order.status === 'expired') {
      console.log(`Order ${order.status}`);
      return order;
    }
    
    // Wait 5 seconds before next check
    await new Promise(resolve => setTimeout(resolve, 5000));
  }
  
  console.log('Order monitoring timeout');
  return null;
};

// Monitor multiple orders
const monitorOrders = async (orderIds: string[], symbol: string) => {
  const activeOrders = new Set(orderIds);
  
  while (activeOrders.size > 0) {
    for (const orderId of activeOrders) {
      try {
        const order = await exchange.fetchOrder(orderId, symbol);
        
        if (order.status !== 'open') {
          console.log(`Order ${orderId} ${order.status}`);
          activeOrders.delete(orderId);
        } else {
          console.log(`Order ${orderId}: ${order.filled}/${order.amount} filled`);
        }
      } catch (error) {
        console.error(`Error checking order ${orderId}:`, error.message);
        activeOrders.delete(orderId);
      }
    }
    
    if (activeOrders.size > 0) {
      await new Promise(resolve => setTimeout(resolve, 10000)); // Wait 10 seconds
    }
  }
  
  console.log('All orders completed');
};

// Advanced order management
class OrderManager {
  private exchange: any;
  private orders = new Map<string, Order>();
  
  constructor(exchange: any) {
    this.exchange = exchange;
  }
  
  async createAndTrack(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: number) {
    const order = await this.exchange.createOrder(symbol, type, side, amount, price);
    this.orders.set(order.id, order);
    console.log(`Created and tracking order ${order.id}`);
    return order;
  }
  
  async updateOrder(orderId: string) {
    const order = await this.exchange.fetchOrder(orderId);
    this.orders.set(orderId, order);
    return order;
  }
  
  async updateAllOrders() {
    for (const [orderId] of this.orders) {
      try {
        await this.updateOrder(orderId);
      } catch (error) {
        console.error(`Failed to update order ${orderId}:`, error.message);
      }
    }
  }
  
  getOpenOrders(): Order[] {
    return Array.from(this.orders.values()).filter(order => order.status === 'open');
  }
  
  getOrdersSummary() {
    const orders = Array.from(this.orders.values());
    const summary = {
      total: orders.length,
      open: orders.filter(o => o.status === 'open').length,
      filled: orders.filter(o => o.status === 'closed').length,
      canceled: orders.filter(o => o.status === 'canceled').length,
    };
    return summary;
  }
}