# Set environment variables to avoid exposing tokens
export NUDJ_SUBDOMAIN="your-subdomain"
export NUDJ_TOKEN="your-token"

# Test API endpoints with curl
curl -X GET "https://${NUDJ_SUBDOMAIN}.nudj.cx/api/v2/integration/me" \
  -H "x-api-token: ${NUDJ_TOKEN}" \
  -H "Content-Type: application/json" \
  -v # Verbose output for debugging

# Test with different headers
curl -X GET "https://${NUDJ_SUBDOMAIN}.nudj.cx/api/v2/integration/challenges" \
  -H "x-api-token: ${NUDJ_TOKEN}" \
  -H "x-language: en" \
  -H "Content-Type: application/json"

# Test POST requests
curl -X POST "https://${NUDJ_SUBDOMAIN}.nudj.cx/api/v2/integration/action-participations" \
  -H "x-api-token: ${NUDJ_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "actionId": "action_123",
    "response": {"answer": "test"}
  }'

# Note: Never paste live tokens directly. Use environment variables and rotate tokens regularly.

// Enable detailed logging in browser
localStorage.setItem('nudj-debug', 'true');
localStorage.setItem('nudj-api-debug', 'true');

// Monitor network requests
function monitorApiCalls() {
  const originalFetch = window.fetch;
  
  window.fetch = async function(...args) {
    const [url, options] = args;
    const urlString = typeof url === 'string' ? url : url.toString();
    
    if (urlString.includes('nudj.cx')) {
      console.group('🌐 API Call');
      console.log('URL:', urlString);
      console.log('Options:', options);
      
      const start = performance.now();
      const response = await originalFetch.apply(this, args);
      const duration = performance.now() - start;
      
      console.log(`⏱️ Duration: ${duration.toFixed(2)}ms`);
      console.log('Status:', response.status);
      console.groupEnd();
      
      // Clone response to read body without consuming it
      const responseClone = response.clone();
      try {
        const data = await responseClone.json();
        console.log('Response Data:', data);
      } catch (e) {
        console.log('Response not JSON');
      }
      
      return response;
    }
    
    // For non-nudj URLs, just call original fetch
    return originalFetch.apply(this, args);
  };
}

monitorApiCalls();

class ApiRetryClient {
  constructor(baseUrl, token, maxRetries = 3) {
    this.baseUrl = baseUrl;
    this.token = token;
    this.maxRetries = maxRetries;
  }

  async request(endpoint, options = {}, retryCount = 0) {
    try {
      const response = await fetch(`${this.baseUrl}${endpoint}`, {
        ...options,
        headers: {
          'x-api-token': this.token,
          'Content-Type': 'application/json',
          ...options.headers
        }
      });

      // Don't retry client errors (4xx) except 401, 408, 429
      const retryableStatuses = [401, 408, 429, 500, 502, 503, 504];
      
      if (!response.ok && !retryableStatuses.includes(response.status)) {
        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
      }

      if (!response.ok && retryCount < this.maxRetries) {
        const delay = this.calculateBackoffDelay(retryCount, response.status);
        console.log(`Retrying request in ${delay}ms (attempt ${retryCount + 1}/${this.maxRetries})`);
        
        await new Promise(resolve => setTimeout(resolve, delay));
        return this.request(endpoint, options, retryCount + 1);
      }

      return response;
    } catch (error) {
      if (retryCount < this.maxRetries) {
        const delay = this.calculateBackoffDelay(retryCount);
        console.log(`Retrying failed request in ${delay}ms (attempt ${retryCount + 1}/${this.maxRetries})`);
        
        await new Promise(resolve => setTimeout(resolve, delay));
        return this.request(endpoint, options, retryCount + 1);
      }
      
      throw error;
    }
  }

  calculateBackoffDelay(retryCount, statusCode = null) {
    // Special handling for rate limits
    if (statusCode === 429) {
      return Math.min(60000, 1000 * Math.pow(2, retryCount)); // Max 1 minute
    }
    
    // Exponential backoff with jitter
    const baseDelay = 1000 * Math.pow(2, retryCount);
    const jitter = Math.random() * 1000;
    return Math.min(10000, baseDelay + jitter); // Max 10 seconds
  }
}

// Usage
const apiClient = new ApiRetryClient('https://yourorg.nudj.cx/api/v2', 'your-token');
const response = await apiClient.request('/integration/challenges');

class ErrorHandler {
  static getErrorMessage(error, context = 'general') {
    const errorCode = error.response?.data?.code || error.code;
    const statusCode = error.response?.status || error.status;
    
    // Context-specific error messages
    const errorMessages = {
      authentication: {
        401: 'Please sign in to continue',
        403: 'You don\'t have permission to perform this action',
        'UNAUTHORIZED': 'Your session has expired. Please sign in again.'
      },
      challenge: {
        404: 'This challenge is no longer available',
        'CHALLENGE_EXPIRED': 'This challenge has ended',
        'ALREADY_COMPLETED': 'You\'ve already completed this challenge',
        'NOT_ELIGIBLE': 'You\'re not eligible for this challenge'
      },
      reward: {
        'INSUFFICIENT_POINTS': 'You don\'t have enough points for this reward',
        'OUT_OF_STOCK': 'This reward is currently out of stock',
        'GEOGRAPHIC_RESTRICTION': 'This reward is not available in your region'
      },
      general: {
        400: 'Please check your input and try again',
        404: 'The requested item was not found',
        429: 'Too many requests. Please wait a moment and try again',
        500: 'Something went wrong on our end. Please try again later',
        'NETWORK_ERROR': 'Please check your internet connection',
        'TIMEOUT': 'The request took too long. Please try again'
      }
    };

    const contextMessages = errorMessages[context] || {};
    const fallbackMessages = errorMessages.general;
    
    return (
      contextMessages[errorCode] ||
      contextMessages[statusCode] ||
      fallbackMessages[errorCode] ||
      fallbackMessages[statusCode] ||
      error.message ||
      'An unexpected error occurred'
    );
  }

  static handleApiError(error, context = 'general') {
    const message = this.getErrorMessage(error, context);
    
    // Log detailed error for developers
    console.error('API Error:', {
      context,
      status: error.response?.status,
      code: error.response?.data?.code,
      message: error.response?.data?.message,
      originalError: error
    });

    // Show user-friendly message
    this.showToast(message, 'error');
    
    // Handle specific error types
    if (error.response?.status === 401) {
      this.redirectToLogin();
    }
    
    return { userMessage: message, error };
  }

  static showToast(message, type = 'info') {
    // Implement your toast notification system
    console.log(`Toast [${type}]: ${message}`);
  }

  static redirectToLogin() {
    // Implement redirect to login
    window.location.href = '/auth/signin';
  }
}

// Usage in components
try {
  await submitChallenge(challengeId, response);
} catch (error) {
  ErrorHandler.handleApiError(error, 'challenge');
}

class ApiPerformanceMonitor {
  constructor() {
    this.metrics = {
      requests: 0,
      totalTime: 0,
      errors: 0,
      slowRequests: 0,
      endpoints: new Map()
    };
    this.slowRequestThreshold = 3000; // 3 seconds
  }

  async trackRequest(endpoint, requestFunction) {
    const startTime = performance.now();
    const requestId = this.generateRequestId();
    
    try {
      console.log(`📊 [${requestId}] Starting request to ${endpoint}`);
      
      const result = await requestFunction();
      const duration = performance.now() - startTime;
      
      this.recordSuccess(endpoint, duration);
      
      if (duration > this.slowRequestThreshold) {
        console.warn(`🐌 [${requestId}] Slow request: ${endpoint} took ${duration.toFixed(2)}ms`);
      } else {
        console.log(`✅ [${requestId}] Request completed: ${endpoint} (${duration.toFixed(2)}ms)`);
      }
      
      return result;
    } catch (error) {
      const duration = performance.now() - startTime;
      this.recordError(endpoint, duration);
      
      console.error(`❌ [${requestId}] Request failed: ${endpoint} (${duration.toFixed(2)}ms)`, error);
      throw error;
    }
  }

  recordSuccess(endpoint, duration) {
    this.metrics.requests++;
    this.metrics.totalTime += duration;
    
    if (duration > this.slowRequestThreshold) {
      this.metrics.slowRequests++;
    }
    
    this.updateEndpointMetrics(endpoint, duration, true);
  }

  recordError(endpoint, duration) {
    this.metrics.requests++;
    this.metrics.errors++;
    this.metrics.totalTime += duration;
    
    this.updateEndpointMetrics(endpoint, duration, false);
  }

  updateEndpointMetrics(endpoint, duration, success) {
    if (!this.metrics.endpoints.has(endpoint)) {
      this.metrics.endpoints.set(endpoint, {
        requests: 0,
        totalTime: 0,
        errors: 0,
        avgTime: 0
      });
    }
    
    const endpointMetrics = this.metrics.endpoints.get(endpoint);
    endpointMetrics.requests++;
    endpointMetrics.totalTime += duration;
    
    if (!success) {
      endpointMetrics.errors++;
    }
    
    endpointMetrics.avgTime = endpointMetrics.totalTime / endpointMetrics.requests;
  }

  getReport() {
    const avgResponseTime = this.metrics.totalTime / this.metrics.requests;
    const errorRate = (this.metrics.errors / this.metrics.requests) * 100;
    const slowRequestRate = (this.metrics.slowRequests / this.metrics.requests) * 100;
    
    return {
      summary: {
        totalRequests: this.metrics.requests,
        avgResponseTime: avgResponseTime.toFixed(2) + 'ms',
        errorRate: errorRate.toFixed(2) + '%',
        slowRequestRate: slowRequestRate.toFixed(2) + '%'
      },
      endpoints: Array.from(this.metrics.endpoints.entries()).map(([endpoint, metrics]) => ({
        endpoint,
        requests: metrics.requests,
        avgTime: metrics.avgTime.toFixed(2) + 'ms',
        errorRate: ((metrics.errors / metrics.requests) * 100).toFixed(2) + '%'
      })).sort((a, b) => parseFloat(b.avgTime) - parseFloat(a.avgTime))
    };
  }

  generateRequestId() {
    return Math.random().toString(36).substr(2, 9);
  }

  // Method to be called periodically
  logReport() {
    const report = this.getReport();
    console.log('📈 API Performance Report:', report);
  }
}

// Usage
const monitor = new ApiPerformanceMonitor();

// Wrap API calls
const result = await monitor.trackRequest('/integration/challenges', async () => {
  return fetch('/api/v2/integration/challenges', {
    headers: { 'x-api-token': token }
  });
});

// Log periodic reports
setInterval(() => monitor.logReport(), 60000); // Every minute

// Enable debug logging
localStorage.setItem('nudj-debug', 'true');
localStorage.setItem('nudj-api-debug', 'true');
localStorage.setItem('nudj-verbose', 'true');

// View stored debug info
console.log('Debug Settings:', {
  debug: localStorage.getItem('nudj-debug'),
  apiDebug: localStorage.getItem('nudj-api-debug'),
  verbose: localStorage.getItem('nudj-verbose')
});