import time
import requests

class TicksupplyError(Exception):
    def __init__(self, code, message, request_id=None):
        self.code = code
        self.message = message
        self.request_id = request_id
        super().__init__(f"{code}: {message} (request_id: {request_id})")

def api_request(method, path, max_retries=3, **kwargs):
    """Make an API request with comprehensive error handling."""
    url = f"https://api.ticksupply.com{path}"
    headers = kwargs.pop("headers", {})
    headers["X-Api-Key"] = API_KEY
    
    for attempt in range(max_retries + 1):
        try:
            response = requests.request(
                method, url, headers=headers, timeout=30, **kwargs
            )
            
            # Success
            if response.status_code in (200, 201, 202, 204):
                if response.status_code == 204:
                    return None
                return response.json()
            
            # Parse error response
            try:
                error = response.json().get("error", {})
            except:
                error = {"code": "unknown", "message": response.text}

            code = error.get("code", "unknown")
            message = error.get("message", "Unknown error")
            request_id = response.headers.get("X-Request-Id", "")
            
            # Rate limit - always retry
            if response.status_code == 429:
                retry_after = int(response.headers.get("Retry-After", 30))
                print(f"Rate limited. Waiting {retry_after}s...")
                time.sleep(retry_after)
                continue
            
            # Server error - retry with backoff
            if response.status_code >= 500:
                if attempt < max_retries:
                    wait_time = 2 ** attempt
                    print(f"Server error. Waiting {wait_time}s...")
                    time.sleep(wait_time)
                    continue
            
            # Client errors - don't retry
            raise TicksupplyError(code, message, request_id)
            
        except requests.exceptions.Timeout:
            if attempt < max_retries:
                print(f"Timeout. Retrying ({attempt + 1}/{max_retries})...")
                continue
            raise
        except requests.exceptions.ConnectionError:
            if attempt < max_retries:
                time.sleep(2 ** attempt)
                continue
            raise
    
    raise Exception("Max retries exceeded")

# Usage
try:
    subscription = api_request("GET", f"/v1/subscriptions/{sub_id}")
    print(f"Found subscription: {subscription['id']}")
except TicksupplyError as e:
    if e.code == "not_found":
        print("Subscription not found")
    elif e.code == "unauthenticated":
        print("Invalid API key")
    else:
        print(f"API error: {e}")

class TicksupplyError extends Error {
  constructor(code, message, requestId) {
    super(`${code}: ${message} (request_id: ${requestId})`);
    this.code = code;
    this.requestId = requestId;
  }
}

async function apiRequest(method, path, options = {}, maxRetries = 3) {
  const url = `https://api.ticksupply.com${path}`;
  const headers = {
    "X-Api-Key": API_KEY,
    ...options.headers
  };
  
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      const response = await fetch(url, {
        method,
        headers,
        ...options
      });
      
      // Success
      if (response.ok) {
        if (response.status === 204) return null;
        return response.json();
      }
      
      // Parse error
      let error;
      try {
        const body = await response.json();
        error = body.error || {};
      } catch {
        error = { code: "unknown", message: await response.text() };
      }

      const { code = "unknown", message = "Unknown error" } = error;
      const requestId = response.headers.get("X-Request-Id") || "";
      
      // Rate limit
      if (response.status === 429) {
        const retryAfter = parseInt(response.headers.get("Retry-After") || "30");
        console.log(`Rate limited. Waiting ${retryAfter}s...`);
        await sleep(retryAfter * 1000);
        continue;
      }
      
      // Server error
      if (response.status >= 500 && attempt < maxRetries) {
        const waitTime = Math.pow(2, attempt) * 1000;
        console.log(`Server error. Waiting ${waitTime}ms...`);
        await sleep(waitTime);
        continue;
      }
      
      throw new TicksupplyError(code, message, requestId);
      
    } catch (err) {
      if (err instanceof TicksupplyError) throw err;
      if (attempt < maxRetries) {
        await sleep(Math.pow(2, attempt) * 1000);
        continue;
      }
      throw err;
    }
  }
}

function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

// Usage
try {
  const subscription = await apiRequest("GET", `/v1/subscriptions/${subId}`);
  console.log(`Found subscription: ${subscription.id}`);
} catch (err) {
  if (err instanceof TicksupplyError) {
    if (err.code === "not_found") {
      console.log("Subscription not found");
    } else {
      console.log(`API error: ${err.message}`);
    }
  } else {
    throw err;
  }
}