Rate Limits

const makeRequest = async (url) => {
  const response = await fetch(url, {
    headers: {
      'Authorization': `Bearer ${token}`
    }
  });

  // Check rate limit headers
  const limit = response.headers.get('X-RateLimit-Limit');
  const remaining = response.headers.get('X-RateLimit-Remaining');
  const reset = response.headers.get('X-RateLimit-Reset');

  console.log(`Rate limit: ${remaining}/${limit} requests remaining`);
  console.log(`Resets at: ${new Date(reset * 1000).toISOString()}`);

  if (response.status === 429) {
    const retryAfter = response.headers.get('Retry-After');
    throw new Error(`Rate limit exceeded. Retry after ${retryAfter} seconds`);
  }

  return response.json();
};

const makeRequestWithRetry = async (url, maxRetries = 3) => {
  let retries = 0;

  while (retries < maxRetries) {
    try {
      const response = await fetch(url, {
        headers: { 'Authorization': `Bearer ${token}` }
      });

      if (response.status === 429) {
        const retryAfter = parseInt(
          response.headers.get('Retry-After') || '60'
        );
        
        console.log(`Rate limited. Waiting ${retryAfter}s before retry...`);
        await new Promise(resolve => setTimeout(resolve, retryAfter * 1000));
        
        retries++;
        continue;
      }

      if (!response.ok) {
        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
      }

      return response.json();
    } catch (error) {
      if (retries >= maxRetries - 1) throw error;
      
      // Exponential backoff
      const waitTime = Math.pow(2, retries) * 1000;
      console.log(`Error occurred. Retrying in ${waitTime}ms...`);
      await new Promise(resolve => setTimeout(resolve, waitTime));
      
      retries++;
    }
  }

  throw new Error('Max retries exceeded');
};

class APIClient {
  constructor() {
    this.cache = new Map();
    this.cacheDuration = 5 * 60 * 1000; // 5 minutes
  }

  async getWithCache(endpoint) {
    const cached = this.cache.get(endpoint);
    
    if (cached && Date.now() - cached.timestamp < this.cacheDuration) {
      console.log('Returning cached data');
      return cached.data;
    }

    const data = await this.makeRequest(endpoint);
    
    this.cache.set(endpoint, {
      data,
      timestamp: Date.now()
    });

    return data;
  }

  async makeRequest(endpoint) {
    const response = await fetch(`https://api.saludya.com/v1${endpoint}`, {
      headers: { 'Authorization': `Bearer ${token}` }
    });
    
    return response.json();
  }
}

class RateLimitedQueue {
  constructor(maxRequestsPerWindow = 100, windowMs = 15 * 60 * 1000) {
    this.queue = [];
    this.processing = false;
    this.maxRequests = maxRequestsPerWindow;
    this.windowMs = windowMs;
    this.requestCount = 0;
    this.windowStart = Date.now();
  }

  async add(requestFn) {
    return new Promise((resolve, reject) => {
      this.queue.push({ requestFn, resolve, reject });
      this.process();
    });
  }

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

    while (this.queue.length > 0) {
      // Reset counter if window has passed
      if (Date.now() - this.windowStart >= this.windowMs) {
        this.requestCount = 0;
        this.windowStart = Date.now();
      }

      // Wait if limit reached
      if (this.requestCount >= this.maxRequests) {
        const waitTime = this.windowMs - (Date.now() - this.windowStart);
        console.log(`Rate limit reached. Waiting ${waitTime}ms...`);
        await new Promise(resolve => setTimeout(resolve, waitTime));
        this.requestCount = 0;
        this.windowStart = Date.now();
      }

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

      // Small delay between requests
      await new Promise(resolve => setTimeout(resolve, 100));
    }

    this.processing = false;
  }
}

// Usage
const queue = new RateLimitedQueue(100, 15 * 60 * 1000);

const fetchAppointment = (id) => {
  return queue.add(() => 
    fetch(`https://api.saludya.com/v1/appointments/${id}`, {
      headers: { 'Authorization': `Bearer ${token}` }
    }).then(r => r.json())
  );
};