Error Handling

async function handleApiResponse(response) {
  if (!response.ok) {
    const errorData = await response.json();

    switch (response.status) {
      case 401:
        throw new AuthenticationError(errorData.error.message);
      case 404:
        throw new NotFoundError(errorData.error.message);
      case 409:
        throw new DuplicateLeadError(errorData.error.message);
      case 429:
        throw new RateLimitError(errorData.error.message, errorData.error.retryAfter);
      case 500:
        throw new ServerError(errorData.error.message);
      default:
        throw new ApiError(errorData.error.message, response.status);
    }
  }

  return response.json();
}

async function makeRequestWithRetry(url, options, maxRetries = 3) {
  const retryableStatuses = [429, 500, 502, 503, 504];

  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      const response = await fetch(url, options);

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

      if (!retryableStatuses.includes(response.status)) {
        throw new Error('Non-retryable error: ' + response.status);
      }

      if (attempt === maxRetries - 1) {
        throw new Error('Max retries exceeded');
      }

      const delay = Math.min(1000 * Math.pow(2, attempt), 10000);
      console.log(`Retrying in ${delay}ms (attempt ${attempt + 1})`);
      await new Promise(resolve => setTimeout(resolve, delay));

    } catch (error) {
      if (attempt === maxRetries - 1) throw error;
      await new Promise(resolve => setTimeout(resolve, 1000 * Math.pow(2, attempt)));
    }
  }
}

function logApiError(error, context) {
  const logData = {
    timestamp: new Date().toISOString(),
    context,
    error: {
      code: error.code,
      message: error.message,
      status: error.status
    }
  };

  switch (error.status) {
    case 401:
      // Authentication issues - warn level
      console.warn('API authentication error:', logData);
      break;
    case 429:
      // Rate limiting - info level (expected during high usage)
      console.info('API rate limit hit:', logData);
      break;
    case 500:
    case 502:
    case 503:
    case 504:
      // Server errors - error level
      console.error('API server error:', logData);
      break;
    default:
      // Client errors - debug level
      console.debug('API client error:', logData);
  }
}

function getUserFriendlyMessage(error) {
  const friendlyMessages = {
    INVALID_API_KEY: 'There was an authentication issue. Please check your API configuration.',
    CAMPAIGN_NOT_FOUND: 'The specified campaign could not be found. Please verify the campaign ID.',
    DUPLICATE_LEAD: 'This contact has already been added to the campaign.',
    RATE_LIMIT_EXCEEDED: 'You\'re sending requests too quickly. Please wait a moment before trying again.',
    CAMPAIGN_INACTIVE: 'The campaign is not currently accepting new leads.',
    INTERNAL_SERVER_ERROR: 'Something went wrong on our end. Please try again in a few moments.'
  };

  return friendlyMessages[error.code] || 'An unexpected error occurred. Please try again or contact support if the issue persists.';
}

async function importLeadsWithDuplicateHandling(leads, campaignId, apiKey) {
  const results = {
    added: [],
    duplicates: [],
    errors: []
  };

  for (const lead of leads) {
    try {
      const response = await fetch(
        `https://magnetite.ai/api/campaigns/${campaignId}/leads`,
        {
          method: 'POST',
          headers: {
            'Authorization': `Bearer ${apiKey}`,
            'Content-Type': 'application/json'
          },
          body: JSON.stringify(lead)
        }
      );

      const data = await response.json();

      if (response.ok) {
        results.added.push({ lead, prospectId: data.prospectId });
      } else if (data.error?.code === 'DUPLICATE_LEAD') {
        // Handle duplicate gracefully
        results.duplicates.push({
          lead,
          existingProspectId: data.error.existingProspectId
        });
      } else {
        results.errors.push({ lead, error: data.error });
      }
    } catch (error) {
      results.errors.push({ lead, error: error.message });
    }

    // Respect rate limits
    await new Promise(resolve => setTimeout(resolve, 1000));
  }

  return results;
}