// JavaScript - Exponential backoff implementation
class RateLimitHandler {
  constructor(baseDelay = 1000, maxDelay = 32000, maxRetries = 5) {
    this.baseDelay = baseDelay;
    this.maxDelay = maxDelay;
    this.maxRetries = maxRetries;
  }
  
  async makeRequest(requestFn) {
    for (let attempt = 0; attempt < this.maxRetries; attempt++) {
      try {
        const response = await requestFn();
        
        // Check rate limit headers
        const remaining = response.headers.get('X-RateLimit-Remaining');
        if (remaining && parseInt(remaining) < 5) {
          console.warn('Approaching rate limit. Consider slowing down requests.');
        }
        
        return response;
        
      } catch (error) {
        if (error.status === 429 && attempt < this.maxRetries - 1) {
          // Get retry delay from header or calculate exponential backoff
          const retryAfter = error.headers?.get('Retry-After');
          const delay = retryAfter 
            ? parseInt(retryAfter) * 1000 
            : Math.min(this.baseDelay * Math.pow(2, attempt), this.maxDelay);
          
          console.log(`Rate limited. Waiting ${delay}ms before retry ${attempt + 1}`);
          await this.sleep(delay);
          continue;
        }
        throw error;
      }
    }
  }
  
  sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

// Usage
const rateLimiter = new RateLimitHandler();
const response = await rateLimiter.makeRequest(async () => {
  return fetch('https://api.moder8r.app/v1/moderate/text', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer m8r_sk_your_key_here',
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({ content: 'Text to moderate' })
  });
});

// Request queue for high-throughput applications
class RequestQueue {
  constructor(requestsPerMinute = 60) {
    this.requestsPerMinute = requestsPerMinute;
    this.requestTimes = [];
    this.queue = [];
    this.processing = false;
  }
  
  async addRequest(requestFn) {
    return new Promise((resolve, reject) => {
      this.queue.push({ requestFn, resolve, reject });
      this.processQueue();
    });
  }
  
  async processQueue() {
    if (this.processing || this.queue.length === 0) {
      return;
    }
    
    this.processing = true;
    
    while (this.queue.length > 0) {
      const now = Date.now();
      
      // Remove requests older than 1 minute
      this.requestTimes = this.requestTimes.filter(time => now - time < 60000);
      
      // Check if we can make another request
      if (this.requestTimes.length >= this.requestsPerMinute) {
        const oldestRequest = Math.min(...this.requestTimes);
        const waitTime = 60000 - (now - oldestRequest);
        
        console.log(`Rate limit reached. Waiting ${waitTime}ms`);
        await this.sleep(waitTime);
        continue;
      }
      
      // Process next request
      const { requestFn, resolve, reject } = this.queue.shift();
      
      try {
        this.requestTimes.push(now);
        const result = await requestFn();
        resolve(result);
      } catch (error) {
        reject(error);
      }
      
      // Small delay between requests to avoid overwhelming the server
      await this.sleep(100);
    }
    
    this.processing = false;
  }
  
  sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}