veza/apps/web/src/services/api/client.ts

import axios, { AxiosError, InternalAxiosRequestConfig, AxiosResponse } from 'axios';
import { TokenStorage } from '../tokenStorage';
import { refreshToken } from '../tokenRefresh';
import { env } from '@/config/env';
import { parseApiError } from '@/utils/apiErrorHandler';
import { csrfService } from '../csrf';
import type { ApiResponse } from '@/types/api';

/**
 * Client API avec interceptors pour refresh automatique des tokens
 * et unwrapping du format backend { success, data, error }
 * Aligné avec FRONTEND_INTEGRATION.md
 */

// Client API réutilisable
export const apiClient = axios.create({
  baseURL: env.API_URL,
  timeout: 10000,
  headers: {
    'Content-Type': 'application/json',
  },
});

// Flag pour éviter les refresh en boucle
let isRefreshing = false;
let failedQueue: Array<{
  resolve: (value?: any) => void;
  reject: (error?: any) => void;
}> = [];

// T0177: Fonction pour traiter la queue de requêtes en attente
const processQueue = (error: Error | null, token: string | null = null) => {
  failedQueue.forEach((prom) => {
    if (error) {
      prom.reject(error);
    } else {
      prom.resolve(token);
    }
  });

  failedQueue = [];
};

// T0177: Interceptor de requête pour ajouter le token d'accès
// CRITIQUE: Récupérer TOUJOURS le token frais depuis localStorage car Zustand peut ne pas être hydraté
apiClient.interceptors.request.use(
  (config: InternalAxiosRequestConfig) => {
    const token = TokenStorage.getAccessToken();

    if (token && config.headers) {
      config.headers.Authorization = `Bearer ${token} `;
    }

    // Pour FormData, laisser Axios gérer automatiquement le Content-Type avec boundary
    // Ne pas forcer application/json si c'est un FormData
    if (config.data instanceof FormData && config.headers) {
      // Supprimer Content-Type pour que Axios calcule automatiquement multipart/form-data avec boundary
      delete config.headers['Content-Type'];
    }

    // Ajouter le token CSRF pour les méthodes qui modifient l'état
    const method = config.method?.toUpperCase();
    const isStateChanging = ['POST', 'PUT', 'DELETE', 'PATCH'].includes(method || '');
    const isCSRFRoute = config.url?.includes('/csrf-token');
    
    if (isStateChanging && !isCSRFRoute && config.headers) {
      const csrfToken = csrfService.getToken();
      if (csrfToken) {
        config.headers['X-CSRF-Token'] = csrfToken;
      }
    }

    return config;
  },
  (error) => {
    return Promise.reject(error);
  },
);

// Interceptor de réponse pour unwrap le format backend et gérer les erreurs
apiClient.interceptors.response.use(
  (response: AxiosResponse<ApiResponse<any>>) => {
    // Backend retourne { success: true, data: {...} }
    // On unwrap pour retourner directement data
    if (response.data && typeof response.data === 'object' && 'success' in response.data) {
      if (response.data.success === true) {
        // Retourner directement data, pas le wrapper
        return {
          ...response,
          data: response.data.data,
        } as AxiosResponse<any>;
      }
      // Si success === false, l'erreur sera gérée par le catch
      // Mais on devrait normalement ne jamais arriver ici car le backend
      // retourne un status HTTP d'erreur dans ce cas
    }
    // Si pas de format wrapper, retourner la réponse telle quelle
    return response;
  },
  async (error: AxiosError<ApiResponse<any>>) => {
    const originalRequest = error.config as InternalAxiosRequestConfig & {
      _retry?: boolean;
    };

    // Détecter 401 et refresh automatiquement
    // EXCLURE l'endpoint /auth/refresh pour éviter les boucles infinies
    const isRefreshEndpoint = originalRequest?.url?.includes('/auth/refresh');

    if (
      error.response?.status === 401 &&
      originalRequest &&
      !originalRequest._retry &&
      !isRefreshEndpoint
    ) {
      // Éviter les refresh multiples simultanés
      if (isRefreshing) {
        // Si un refresh est en cours, mettre la requête en queue
        return new Promise((resolve, reject) => {
          failedQueue.push({ resolve, reject });
        })
          .then((token) => {
            if (originalRequest.headers && token) {
              originalRequest.headers.Authorization = `Bearer ${token} `;
            }
            return apiClient(originalRequest);
          })
          .catch((err) => {
            return Promise.reject(err);
          });
      }

      originalRequest._retry = true;
      isRefreshing = true;

      try {
        // Refresh automatique du token
        await refreshToken();
        const newToken = TokenStorage.getAccessToken();

        if (!newToken) {
          throw new Error('Failed to get new access token after refresh');
        }

        if (originalRequest.headers) {
          originalRequest.headers.Authorization = `Bearer ${newToken} `;
        }

        // Traiter la queue et retry la requête originale
        processQueue(null, newToken);
        return apiClient(originalRequest);
      } catch (refreshError) {
        // Gérer cas refresh échoué
        processQueue(refreshError as Error, null);

        // Nettoyer les tokens
        TokenStorage.clearTokens();

        // Stocker un message d'erreur pour l'afficher après redirection
        if (typeof window !== 'undefined') {
          sessionStorage.setItem(
            'auth_error',
            'Your session has expired. Please log in again.',
          );
          // Rediriger vers login si refresh échoue (seulement dans le navigateur)
          window.location.href = '/login';
        }

        return Promise.reject(refreshError);
      } finally {
        isRefreshing = false;
      }
    }

    // Gestion spécifique des erreurs 429, 503, 502
    const status = error.response?.status;

    if (status === 429) {
      // Too Many Requests - Retry après delay
      const apiError = parseApiError(error);
      const retryAfter = apiError.retry_after || 5; // Default 5 secondes

      // Si la requête n'a pas encore été retentée, attendre et réessayer
      if (originalRequest && !originalRequest._retry && retryAfter > 0) {
        originalRequest._retry = true;

        // Attendre le délai spécifié avant de réessayer
        await new Promise((resolve) => setTimeout(resolve, retryAfter * 1000));

        // Réessayer la requête une seule fois
        return apiClient(originalRequest);
      }

      // Si déjà retentée ou retry_after invalide, rejeter avec l'erreur
      return Promise.reject(apiError);
    }

    if (status === 503) {
      // Service Unavailable - ClamAV ou autre service externe
      const apiError = parseApiError(error);
      // Message déjà formaté dans parseApiError avec message spécifique pour 503
      return Promise.reject(apiError);
    }

    if (status === 502) {
      // Bad Gateway - Problème de communication avec un service externe
      const apiError = parseApiError(error);
      // Message déjà formaté dans parseApiError avec message spécifique pour 502
      return Promise.reject(apiError);
    }

    // Parser l'erreur en ApiError standardisé pour les autres codes
    const apiError = parseApiError(error);
    return Promise.reject(apiError);
  },
);