Error Handling

async function handleAPIRequest(url, options) {
  try {
    const response = await fetch(url, options);
    
    if (!response.ok) {
      const error = await response.json();
      
      switch (response.status) {
        case 400:
          // Validation error - show to user
          showValidationError(error.detail);
          break;
          
        case 401:
          // Unauthorized - refresh token or redirect to login
          await refreshToken();
          break;
          
        case 403:
          // Forbidden - show permission error
          showPermissionError();
          break;
          
        case 404:
          // Not found - show not found message
          showNotFoundError();
          break;
          
        case 429:
          // Rate limited - retry after delay
          const retryAfter = response.headers.get('Retry-After') || 60;
          await sleep(retryAfter * 1000);
          return handleAPIRequest(url, options);
          
        case 500:
        case 502:
        case 503:
        case 504:
          // Server error - log error ID and show generic message
          console.error(`Server error ${error.errorId}`);
          showServerError(error.errorId);
          break;
          
        default:
          // Unknown error
          showGenericError();
      }
      
      throw new Error(error.detail);
    }
    
    return response.json();
  } catch (error) {
    // Network error or parsing error
    console.error('Request failed:', error);
    showNetworkError();
    throw error;
  }
}

function logError(error) {
  if (error.status >= 500 && error.errorId) {
    // Send to logging service
    analytics.track('API Error', {
      errorId: error.errorId,
      status: error.status,
      endpoint: error.instance,
      timestamp: error.timestamp,
      userId: getCurrentUserId()
    });
    
    // Show error ID to user for support
    console.error(`Error ID: ${error.errorId}`);
  }
}

class APIClient {
  async request(url, options) {
    const response = await fetch(url, {
      ...options,
      headers: {
        ...options.headers,
        'Authorization': `Bearer ${this.accessToken}`
      }
    });
    
    if (response.status === 401) {
      // Try refreshing the token
      const refreshed = await this.refreshToken();
      
      if (refreshed) {
        // Retry with new token
        return this.request(url, options);
      } else {
        // Refresh failed - redirect to login
        window.location.href = '/login';
        throw new Error('Session expired');
      }
    }
    
    return response;
  }
}

const errorMessages = {
  'ar': {
    'AUTH_INVALID_CREDENTIALS': 'البريد الإلكتروني أو كلمة المرور غير صحيحة',
    'OTP_EXPIRED': 'انتهت صلاحية رمز التحقق. يرجى طلب رمز جديد',
    'NF_DRIVER_NOT_FOUND': 'لم يتم العثور على السائق',
    'SERVER_ERROR': 'حدث خطأ في الخادم. يرجى المحاولة مرة أخرى'
  },
  'en': {
    'AUTH_INVALID_CREDENTIALS': 'Invalid email or password',
    'OTP_EXPIRED': 'OTP code has expired. Please request a new one',
    'NF_DRIVER_NOT_FOUND': 'Driver not found',
    'SERVER_ERROR': 'A server error occurred. Please try again'
  }
};

function showError(errorCode, language = 'ar') {
  const message = errorMessages[language][errorCode] 
    || errorMessages[language]['SERVER_ERROR'];
  
  // Show to user
  alert(message);
}

async function requestWithRetry(url, options, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      const response = await fetch(url, options);
      
      // Don't retry on client errors (except 429)
      if (response.status >= 400 && response.status < 500 && response.status !== 429) {
        return response;
      }
      
      // Retry on 5xx or 429
      if (response.status >= 500 || response.status === 429) {
        if (attempt < maxRetries - 1) {
          const delay = Math.pow(2, attempt) * 1000;
          console.log(`Retrying after ${delay}ms...`);
          await sleep(delay);
          continue;
        }
      }
      
      return response;
    } catch (error) {
      if (attempt === maxRetries - 1) throw error;
      
      const delay = Math.pow(2, attempt) * 1000;
      await sleep(delay);
    }
  }
}