// config.js - Store this securely on your server
const API_CONFIG = {
  baseURL: 'https://api.oscarrondon.com/v1',
  apiKey: process.env.API_KEY, // Use environment variables
  timeout: 10000
};

// api-client.js - Create a reusable API client
class ApiClient {
  constructor(config) {
    this.baseURL = config.baseURL;
    this.apiKey = config.apiKey;
    this.timeout = config.timeout;
  }

  async request(endpoint, options = {}) {
    const url = `${this.baseURL}${endpoint}`;
    const config = {
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json',
        ...options.headers
      },
      timeout: this.timeout,
      ...options
    };

    try {
      const response = await fetch(url, config);
      if (!response.ok) {
        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
      }
      return await response.json();
    } catch (error) {
      console.error('API request failed:', error);
      throw error;
    }
  }
}

// iOS Swift Example
import Foundation

class APIService {
    private let baseURL = "https://api.oscarrondon.com/v1"
    private let apiKey: String
    
    init(apiKey: String) {
        self.apiKey = apiKey
    }
    
    func fetchContent(completion: @escaping (Result<[Content], APIError>) -> Void) {
        guard let url = URL(string: "\(baseURL)/content") else {
            completion(.failure(.invalidURL))
            return
        }
        
        var request = URLRequest(url: url)
        request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        
        URLSession.shared.dataTask(with: request) { data, response, error in
            if let error = error {
                completion(.failure(.networkError(error)))
                return
            }
            
            guard let data = data else {
                completion(.failure(.noData))
                return
            }
            
            do {
                let contentResponse = try JSONDecoder().decode(ContentResponse.self, from: data)
                completion(.success(contentResponse.data))
            } catch {
                completion(.failure(.decodingError(error)))
            }
        }.resume()
    }
}

# Python Example with caching
import requests
import time
from functools import lru_cache
from typing import Dict, List, Optional

class APIClient:
    def __init__(self, api_key: str, base_url: str = "https://api.oscarrondon.com/v1"):
        self.api_key = api_key
        self.base_url = base_url
        self.session = requests.Session()
        self.session.headers.update({
            'Authorization': f'Bearer {api_key}',
            'Content-Type': 'application/json'
        })
        self.last_request_time = 0
        self.rate_limit_delay = 0.1  # 100ms between requests
    
    def _rate_limit(self):
        """Implement simple rate limiting"""
        elapsed = time.time() - self.last_request_time
        if elapsed < self.rate_limit_delay:
            time.sleep(self.rate_limit_delay - elapsed)
        self.last_request_time = time.time()
    
    @lru_cache(maxsize=100)
    def get_content(self, content_type: Optional[str] = None) -> List[Dict]:
        """Cached content retrieval"""
        self._rate_limit()
        
        params = {}
        if content_type:
            params['type'] = content_type
            
        response = self.session.get(f"{self.base_url}/content", params=params)
        response.raise_for_status()
        return response.json()['data']

// Comprehensive error handling example
class APIError extends Error {
  constructor(message, status, code) {
    super(message);
    this.name = 'APIError';
    this.status = status;
    this.code = code;
  }
}

class APIClient {
  async request(endpoint, options = {}) {
    const maxRetries = 3;
    let attempt = 0;
    
    while (attempt < maxRetries) {
      try {
        const response = await fetch(`${this.baseURL}${endpoint}`, {
          headers: this.getHeaders(),
          ...options
        });
        
        if (!response.ok) {
          const errorData = await response.json().catch(() => ({}));
          
          switch (response.status) {
            case 401:
              throw new APIError('Authentication failed', 401, 'AUTH_FAILED');
            case 429:
              // Rate limited - implement exponential backoff
              const retryAfter = response.headers.get('Retry-After') || Math.pow(2, attempt);
              await this.sleep(retryAfter * 1000);
              attempt++;
              continue;
            case 500:
            case 502:
            case 503:
              // Server errors - retry with backoff
              if (attempt < maxRetries - 1) {
                await this.sleep(Math.pow(2, attempt) * 1000);
                attempt++;
                continue;
              }
              throw new APIError('Server error', response.status, 'SERVER_ERROR');
            default:
              throw new APIError(
                errorData.message || 'Unknown error',
                response.status,
                errorData.code || 'UNKNOWN_ERROR'
              );
          }
        }
        
        return await response.json();
      } catch (error) {
        if (error instanceof APIError) {
          throw error;
        }
        
        // Network or other errors
        if (attempt < maxRetries - 1) {
          await this.sleep(Math.pow(2, attempt) * 1000);
          attempt++;
          continue;
        }
        
        throw new APIError('Network error', 0, 'NETWORK_ERROR');
      }
    }
  }
  
  sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}