import requests
import time

class NovaKitError(Exception):
    def __init__(self, message, status_code, data=None):
        self.message = message
        self.status_code = status_code
        self.data = data or {}

class AuthenticationError(NovaKitError):
    pass

class QuotaExceededError(NovaKitError):
    pass

class RateLimitError(NovaKitError):
    def __init__(self, message, status_code, retry_after, data=None):
        super().__init__(message, status_code, data)
        self.retry_after = retry_after

def make_api_request(endpoint, data, max_retries=3):
    for attempt in range(max_retries):
        response = requests.post(
            f"https://www.novakit.ai/api/v1/{endpoint}",
            headers={"Authorization": "Bearer sk_your_key"},
            json=data
        )

        if response.status_code == 200:
            return response.json()

        error_data = response.json()
        error_msg = error_data.get("error", "Unknown error")

        if response.status_code == 401:
            raise AuthenticationError(error_msg, 401, error_data)

        elif response.status_code == 402:
            raise QuotaExceededError(error_msg, 402, error_data)

        elif response.status_code == 429:
            retry_after = error_data.get("retry_after", 60)
            if attempt < max_retries - 1:
                time.sleep(retry_after)
                continue
            raise RateLimitError(error_msg, 429, retry_after, error_data)

        elif response.status_code >= 500:
            if attempt < max_retries - 1:
                time.sleep(2 ** attempt)  # Exponential backoff
                continue
            raise NovaKitError(error_msg, response.status_code, error_data)

        else:
            raise NovaKitError(error_msg, response.status_code, error_data)

    raise NovaKitError("Max retries exceeded", 500)

class NovaKitError extends Error {
  constructor(
    message: string,
    public statusCode: number,
    public data?: Record<string, unknown>
  ) {
    super(message);
    this.name = "NovaKitError";
  }
}

class AuthenticationError extends NovaKitError {
  constructor(message: string, data?: Record<string, unknown>) {
    super(message, 401, data);
    this.name = "AuthenticationError";
  }
}

class QuotaExceededError extends NovaKitError {
  constructor(message: string, data?: Record<string, unknown>) {
    super(message, 402, data);
    this.name = "QuotaExceededError";
  }
}

class RateLimitError extends NovaKitError {
  constructor(
    message: string,
    public retryAfter: number,
    data?: Record<string, unknown>
  ) {
    super(message, 429, data);
    this.name = "RateLimitError";
  }
}

async function makeApiRequest(
  endpoint: string,
  data: object,
  maxRetries = 3
): Promise<unknown> {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    const response = await fetch(
      `https://www.novakit.ai/api/v1/${endpoint}`,
      {
        method: "POST",
        headers: {
          "Authorization": "Bearer sk_your_key",
          "Content-Type": "application/json",
        },
        body: JSON.stringify(data),
      }
    );

    if (response.ok) {
      return response.json();
    }

    const errorData = await response.json();
    const errorMsg = errorData.error || "Unknown error";

    switch (response.status) {
      case 401:
        throw new AuthenticationError(errorMsg, errorData);
      case 402:
        throw new QuotaExceededError(errorMsg, errorData);
      case 429:
        const retryAfter = errorData.retry_after || 60;
        if (attempt < maxRetries - 1) {
          await sleep(retryAfter * 1000);
          continue;
        }
        throw new RateLimitError(errorMsg, retryAfter, errorData);
      default:
        if (response.status >= 500 && attempt < maxRetries - 1) {
          await sleep(Math.pow(2, attempt) * 1000);
          continue;
        }
        throw new NovaKitError(errorMsg, response.status, errorData);
    }
  }
  throw new NovaKitError("Max retries exceeded", 500);
}

const sleep = (ms: number) => new Promise(r => setTimeout(r, ms));

package novakit

import (
    "encoding/json"
    "fmt"
    "net/http"
    "time"
)

type APIError struct {
    Message    string
    StatusCode int
    Data       map[string]interface{}
}

func (e *APIError) Error() string {
    return fmt.Sprintf("%s (status %d)", e.Message, e.StatusCode)
}

func MakeAPIRequest(endpoint string, data interface{}) (map[string]interface{}, error) {
    maxRetries := 3

    for attempt := 0; attempt < maxRetries; attempt++ {
        resp, err := doRequest(endpoint, data)
        if err != nil {
            return nil, err
        }
        defer resp.Body.Close()

        var result map[string]interface{}
        json.NewDecoder(resp.Body).Decode(&result)

        if resp.StatusCode == 200 {
            return result, nil
        }

        errorMsg, _ := result["error"].(string)
        if errorMsg == "" {
            errorMsg = "Unknown error"
        }

        switch resp.StatusCode {
        case 401, 402, 403, 404:
            return nil, &APIError{errorMsg, resp.StatusCode, result}
        case 429:
            retryAfter := 60
            if ra, ok := result["retry_after"].(float64); ok {
                retryAfter = int(ra)
            }
            if attempt < maxRetries-1 {
                time.Sleep(time.Duration(retryAfter) * time.Second)
                continue
            }
            return nil, &APIError{errorMsg, 429, result}
        default:
            if resp.StatusCode >= 500 && attempt < maxRetries-1 {
                time.Sleep(time.Duration(1<<attempt) * time.Second)
                continue
            }
            return nil, &APIError{errorMsg, resp.StatusCode, result}
        }
    }
    return nil, &APIError{"Max retries exceeded", 500, nil}
}