// frontend/dashboard/src/api/interceptors.ts
/**
 * Request/Response interceptors for additional functionality
 */

import { AxiosRequestConfig, AxiosResponse } from 'axios';
import { apiCache } from './cache';

export function addLoggingInterceptor(client: any) {
  // Request logging
  client.interceptors.request.use(
    (config: AxiosRequestConfig) => {
      if (process.env.NODE_ENV === 'development') {
        console.log(`🚀 API Request: ${config.method?.toUpperCase()} ${config.url}`, {
          params: config.params,
          data: config.data,
        });
      }
      return config;
    },
    (error: any) => {
      if (process.env.NODE_ENV === 'development') {
        console.error('❌ API Request Error:', error);
      }
      return Promise.reject(error);
    }
  );

  // Response logging
  client.interceptors.response.use(
    (response: AxiosResponse) => {
      if (process.env.NODE_ENV === 'development') {
        console.log(`✅ API Response: ${response.config.method?.toUpperCase()} ${response.config.url}`, {
          status: response.status,
          data: response.data,
        });
      }
      return response;
    },
    (error: any) => {
      if (process.env.NODE_ENV === 'development') {
        console.error('❌ API Response Error:', {
          url: error.config?.url,
          status: error.response?.status,
          data: error.response?.data,
        });
      }
      return Promise.reject(error);
    }
  );
}

export function addCacheInterceptor(client: any) {
  // Response caching for GET requests
  client.interceptors.response.use(
    (response: AxiosResponse) => {
      const { method, url } = response.config;
      
      if (method === 'get' && url) {
        const cacheKey = `${method}:${url}`;
        apiCache.set(cacheKey, response.data, 300000); // 5 minutes
      }
      
      return response;
    },
    (error: any) => Promise.reject(error)
  );
}

export function addRetryInterceptor(client: any, maxRetries: number = 3) {
  client.interceptors.response.use(
    (response: AxiosResponse) => response,
    async (error: any) => {
      const { config } = error;
      
      if (!config || config.__retryCount >= maxRetries) {
        return Promise.reject(error);
      }
      
      config.__retryCount = config.__retryCount || 0;
      config.__retryCount += 1;
      
      // Only retry on network errors or 5xx errors
      if (
        !error.response ||
        (error.response.status >= 500 && error.response.status < 600)
      ) {
        const delay = Math.pow(2, config.__retryCount) * 1000; // Exponential backoff
        await new Promise(resolve => setTimeout(resolve, delay));
        return client(config);
      }
      
      return Promise.reject(error);
    }
  );
}