{
  "error": {
    "code": "UNAUTHORIZED",
    "message": "Invalid or expired token",
    "details": "The provided access token is invalid or has expired"
  },
  "status": "error"
}

{
  "error": {
    "code": "INVALID_CREDENTIALS",
    "message": "Invalid client credentials",
    "details": "The provided client ID or secret key is invalid"
  },
  "status": "error"
}

{
  "error": {
    "code": "TOKEN_EXPIRED",
    "message": "Access token has expired",
    "details": "Please refresh your token or re-authenticate"
  },
  "status": "error"
}

{
  "error": {
    "code": "FORBIDDEN",
    "message": "Insufficient permissions",
    "details": "Your account does not have permission to access this resource"
  },
  "status": "error"
}

{
  "error": {
    "code": "ACCESS_DENIED",
    "message": "Access denied to resource",
    "details": "You do not have access to this resource"
  },
  "status": "error"
}

{
  "error": {
    "code": "VALIDATION_ERROR",
    "message": "Invalid request parameters",
    "details": {
      "name": "Team name is required and must be between 2-50 characters",
      "email": "Invalid email format"
    }
  },
  "status": "error"
}

{
  "error": {
    "code": "MISSING_REQUIRED_FIELD",
    "message": "Required field is missing",
    "details": "The 'name' field is required for team creation"
  },
  "status": "error"
}

{
  "error": {
    "code": "INVALID_FORMAT",
    "message": "Invalid data format",
    "details": "Email address must be a valid email format"
  },
  "status": "error"
}

{
  "error": {
    "code": "NOT_FOUND",
    "message": "Resource not found",
    "details": "The requested team does not exist or you do not have access to it"
  },
  "status": "error"
}

{
  "error": {
    "code": "RESOURCE_EXISTS",
    "message": "Resource already exists",
    "details": "A team with this name already exists in your organization"
  },
  "status": "error"
}

{
  "error": {
    "code": "RESOURCE_CONFLICT",
    "message": "Resource conflict",
    "details": "The resource has been modified by another user"
  },
  "status": "error"
}

{
  "error": {
    "code": "RATE_LIMIT_EXCEEDED",
    "message": "Too many requests",
    "details": "Rate limit of 100 requests per minute exceeded"
  },
  "status": "error"
}

{
  "error": {
    "code": "QUOTA_EXCEEDED",
    "message": "API quota exceeded",
    "details": "Monthly quota of 10000 requests exceeded"
  },
  "status": "error"
}

{
  "error": {
    "code": "INTERNAL_SERVER_ERROR",
    "message": "Internal server error",
    "details": "An unexpected error occurred. Please try again later."
  },
  "status": "error"
}

{
  "error": {
    "code": "SERVICE_UNAVAILABLE",
    "message": "Service temporarily unavailable",
    "details": "The service is currently undergoing maintenance"
  },
  "status": "error"
}

try {
  const response = await fetch(url, options);
  
  if (!response.ok) {
    const errorData = await response.json();
    
    switch (errorData.error.code) {
      case 'UNAUTHORIZED':
        // Refresh token or re-authenticate
        await refreshToken();
        break;
      case 'RATE_LIMIT_EXCEEDED':
        // Implement exponential backoff
        await delay(Math.pow(2, retryCount) * 1000);
        break;
      case 'VALIDATION_ERROR':
        // Show validation errors to user
        showValidationErrors(errorData.error.details);
        break;
      default:
        // Show generic error message
        showError(errorData.error.message);
    }
  }
} catch (error) {
  // Handle network errors
  console.error('Network error:', error);
}

async function makeRequestWithRetry(url, options, maxRetries = 3) {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      const response = await fetch(url, options);
      
      if (response.ok) {
        return await response.json();
      }
      
      const errorData = await response.json();
      
      // Don't retry client errors (4xx)
      if (response.status >= 400 && response.status < 500) {
        throw new Error(errorData.error.message);
      }
      
      // Retry server errors (5xx) and rate limits
      if (attempt === maxRetries) {
        throw new Error(errorData.error.message);
      }
      
      // Exponential backoff
      await delay(Math.pow(2, attempt) * 1000);
      
    } catch (error) {
      if (attempt === maxRetries) {
        throw error;
      }
      await delay(Math.pow(2, attempt) * 1000);
    }
  }
}

function logError(error, context) {
  const errorLog = {
    timestamp: new Date().toISOString(),
    error: {
      code: error.code,
      message: error.message,
      details: error.details
    },
    context: context,
    userAgent: navigator.userAgent,
    url: window.location.href
  };
  
  // Send to logging service
  fetch('/api/logs/error', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(errorLog)
  });
  
  // Also log to console in development
  if (process.env.NODE_ENV === 'development') {
    console.error('API Error:', errorLog);
  }
}