HTTP/1.1 200 OK
X-RateLimit-Limit: 5000
X-RateLimit-Remaining: 4999
X-RateLimit-Reset: 1609459200
X-RateLimit-Window: 60

{
  "error": {
    "code": "rate_limit_exceeded",
    "message": "Too many requests. Please retry after some time.",
    "details": {
      "limit": 5000,
      "window": "1 minute",
      "retryAfter": 60
    }
  }
}

async function apiCallWithBackoff(apiCall, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await apiCall();
    } catch (error) {
      if (error.status === 429) {
        const retryAfter = parseInt(error.headers['retry-after']) || 60;
        const backoffDelay = Math.min(retryAfter * 1000, Math.pow(2, attempt) * 1000);
        
        console.log(`Rate limited. Retrying after ${backoffDelay}ms`);
        await new Promise(resolve => setTimeout(resolve, backoffDelay));
        
        if (attempt === maxRetries - 1) {
          throw error;
        }
      } else {
        throw error;
      }
    }
  }
}

function checkRateLimit(response) {
  const remaining = parseInt(response.headers['x-ratelimit-remaining']);
  const limit = parseInt(response.headers['x-ratelimit-limit']);
  const resetTime = parseInt(response.headers['x-ratelimit-reset']);
  
  // Warning when approaching limit
  if (remaining < limit * 0.1) {
    console.warn(`Approaching rate limit: ${remaining}/${limit} remaining`);
    
    // Consider pausing requests
    const timeToReset = (resetTime * 1000) - Date.now();
    if (timeToReset > 0 && remaining < 10) {
      console.log(`Pausing requests for ${timeToReset}ms`);
      return new Promise(resolve => setTimeout(resolve, timeToReset));
    }
  }
  
  return Promise.resolve();
}

// Usage
const response = await fetch('/api/transactions', options);
await checkRateLimit(response);
const data = await response.json();

class RequestQueue {
  constructor(rateLimit = 5000, window = 60000) {
    this.rateLimit = rateLimit;
    this.window = window;
    this.queue = [];
    this.processing = false;
    this.requestCount = 0;
    this.windowStart = Date.now();
  }

  async enqueue(apiCall) {
    return new Promise((resolve, reject) => {
      this.queue.push({ apiCall, resolve, reject });
      this.processQueue();
    });
  }

  async processQueue() {
    if (this.processing || this.queue.length === 0) return;
    
    this.processing = true;

    while (this.queue.length > 0) {
      // Check if we need to reset the window
      const now = Date.now();
      if (now - this.windowStart >= this.window) {
        this.requestCount = 0;
        this.windowStart = now;
      }

      // Check if we can make more requests
      if (this.requestCount >= this.rateLimit) {
        const waitTime = this.window - (now - this.windowStart);
        await new Promise(resolve => setTimeout(resolve, waitTime));
        continue;
      }

      const { apiCall, resolve, reject } = this.queue.shift();
      
      try {
        this.requestCount++;
        const result = await apiCall();
        resolve(result);
      } catch (error) {
        reject(error);
      }

      // Small delay to prevent overwhelming the server
      await new Promise(resolve => setTimeout(resolve, 10));
    }

    this.processing = false;
  }
}

// Usage
const queue = new RequestQueue(5000, 60000); // 5000 requests per minute

const transaction = await queue.enqueue(() => 
  orsunpay.transactions.create(transactionData)
);

async function batchTransactionLookups(transactionIds) {
  const batchSize = 50; // Process in smaller batches
  const results = [];

  for (let i = 0; i < transactionIds.length; i += batchSize) {
    const batch = transactionIds.slice(i, i + batchSize);
    
    // Process batch with some delay between batches
    const batchPromises = batch.map(id => 
      orsunpay.transactions.retrieve(id)
    );
    
    try {
      const batchResults = await Promise.all(batchPromises);
      results.push(...batchResults);
    } catch (error) {
      console.error(`Batch ${i}-${i + batchSize} failed:`, error);
      // Handle partial failures as needed
    }

    // Delay between batches to respect rate limits
    if (i + batchSize < transactionIds.length) {
      await new Promise(resolve => setTimeout(resolve, 1000));
    }
  }

  return results;
}

class RateLimitDebugger {
  constructor() {
    this.requests = [];
    this.startTime = Date.now();
  }

  logRequest(response) {
    const now = Date.now();
    this.requests.push({
      timestamp: now,
      status: response.status,
      remaining: response.headers['x-ratelimit-remaining'],
      limit: response.headers['x-ratelimit-limit'],
      reset: response.headers['x-ratelimit-reset']
    });

    // Keep only last 100 requests
    if (this.requests.length > 100) {
      this.requests.shift();
    }
  }

  getStats() {
    const now = Date.now();
    const lastMinute = this.requests.filter(
      r => now - r.timestamp < 60000
    );

    return {
      totalRequests: this.requests.length,
      requestsLastMinute: lastMinute.length,
      rateLimitErrors: this.requests.filter(r => r.status === 429).length,
      averageRemaining: this.requests
        .map(r => parseInt(r.remaining))
        .reduce((a, b, _, arr) => a + b / arr.length, 0)
    };
  }
}

// Usage
const debugger = new RateLimitDebugger();

// Log each API response
const response = await fetch('/api/transactions');
debugger.logRequest(response);

// Get usage statistics
console.log(debugger.getStats());