import axios, { AxiosInstance } from 'axios';
import { TokenStorage } from './tokenStorage';
import { logger } from '@/utils/logger';

// T0177: Créer un client axios séparé pour le refresh pour éviter les interceptors
// Lazy initialization pour faciliter les tests
let refreshClient: AxiosInstance | null = null;

// INT-016: Refresh proactif - rafraîchir 5 minutes avant expiration
const PROACTIVE_REFRESH_BUFFER_MS = 5 * 60 * 1000; // 5 minutes

// INT-016: Timer pour le refresh proactif
let proactiveRefreshTimer: ReturnType<typeof setTimeout> | null = null;

function getRefreshClient(): AxiosInstance {
  if (!refreshClient) {
    const baseURL = (() => {
      const url = import.meta.env.VITE_API_URL;
      if (!url) {
        if (import.meta.env.PROD) {
          throw new Error('VITE_API_URL must be defined in production');
        }
        // Fallback uniquement en développement
        return 'http://127.0.0.1:8080/api/v1';
      }
      return url;
    })();

    refreshClient = axios.create({
      baseURL,
      timeout: 10000,
      headers: {
        'Content-Type': 'application/json',
      },
      // SECURITY: Activer withCredentials pour envoyer les cookies httpOnly lors du refresh
      withCredentials: true,
    });
  }
  return refreshClient;
}

/**
 * TokenRefresh - Service de rafraîchissement des tokens d'authentification
 * T0176: Service pour rafraîchir les tokens via l'endpoint /auth/refresh
 * 
 * Format de réponse attendu du backend :
 * {
 *   "success": true,
 *   "data": {
 *     "access_token": "...",
 *     "refresh_token": "...",
 *     "expires_in": 3600
 *   }
 * }
 */

export interface RefreshTokenResponse {
  access_token: string;
  refresh_token: string;
  expires_in: number;
}

/**
 * INT-016: Décode un JWT pour extraire les claims (sans vérifier la signature)
 * Utilisé uniquement pour lire l'expiration, pas pour la validation de sécurité
 */
interface JWTPayload {
  exp?: number; // Expiration timestamp (seconds)
  iat?: number; // Issued at timestamp (seconds)
}

function decodeJWT(token: string): JWTPayload | null {
  try {
    const parts = token.split('.');
    if (parts.length !== 3) {
      return null;
    }
    // Décoder le payload (base64url)
    const payload = parts[1];
    const decoded = atob(payload.replace(/-/g, '+').replace(/_/g, '/'));
    return JSON.parse(decoded) as JWTPayload;
  } catch (error) {
    logger.warn('Failed to decode JWT', {
        error: error instanceof Error ? error.message : String(error),
        stack: error instanceof Error ? error.stack : undefined,
    });
    return null;
  }
}

/**
 * INT-016: Vérifie si un token est expiré ou proche de l'expiration
 * INT-AUTH-004: Exporté pour utilisation dans l'interceptor de requête
 * @param token - Token JWT à vérifier
 * @param bufferMs - Buffer en millisecondes avant expiration (défaut: 5 minutes)
 * @returns true si le token est expiré ou proche de l'expiration
 */
export function isTokenExpiringSoon(token: string | null, bufferMs: number = PROACTIVE_REFRESH_BUFFER_MS): boolean {
  if (!token) {
    return true;
  }

  const payload = decodeJWT(token);
  if (!payload || !payload.exp) {
    // Si on ne peut pas décoder, on considère qu'il faut rafraîchir
    return true;
  }

  const expirationTime = payload.exp * 1000; // Convertir en millisecondes
  const now = Date.now();
  const timeUntilExpiration = expirationTime - now;

  // Rafraîchir si expiré ou si expiration dans moins de bufferMs
  return timeUntilExpiration <= bufferMs;
}

/**
 * Rafraîchit le token d'accès en utilisant le refresh token
 * T0176: Appelle l'endpoint POST /api/v1/auth/refresh et met à jour les tokens
 * @returns Promise qui se résout quand le token est rafraîchi
 * @throws Error si le refresh token n'est pas disponible ou si le refresh échoue
 */
export async function refreshToken(): Promise<void> {
  // SECURITY: Détecter si le backend utilise des cookies httpOnly
  // Si le refresh token n'est pas dans localStorage mais que l'utilisateur est authentifié,
  // c'est qu'on utilise des cookies httpOnly
  const refreshTokenFromStorage = TokenStorage.getRefreshToken();
  const hasAccessToken = !!TokenStorage.getAccessToken();
  
  // Si pas de refresh token dans localStorage mais access token présent,
  // on suppose que le backend utilise des cookies httpOnly
  const useHttpOnlyCookies = (!refreshTokenFromStorage || refreshTokenFromStorage === 'cookie-based') && hasAccessToken;
  
  // Vérifier qu'on a un moyen de rafraîchir (soit localStorage, soit cookies httpOnly)
  if (!useHttpOnlyCookies && (!refreshTokenFromStorage || refreshTokenFromStorage.trim() === '')) {
    throw new Error('No refresh token available');
  }

  try {
    // T0176: Appeler l'endpoint POST /auth/refresh
    // T0177: Utiliser refreshClient pour éviter les interceptors (qui causeraient une boucle)
    const client = getRefreshClient();
    
    // SECURITY: Si on utilise des cookies httpOnly, ne pas envoyer le refresh token dans le body
    // Le cookie sera envoyé automatiquement via withCredentials
    const requestBody = useHttpOnlyCookies 
      ? {} // Le refresh token est dans le cookie httpOnly, envoyé automatiquement
      : { refresh_token: refreshTokenFromStorage }; // Mode legacy: envoyer dans le body
    
    const response = await client.post<{
      success?: boolean;
      data?: RefreshTokenResponse;
      // Support pour format direct aussi (sans wrapper success/data)
      access_token?: string;
      refresh_token?: string;
      expires_in?: number;
    }>('/auth/refresh', requestBody);

    // Le backend peut retourner deux formats :
    // 1. { success: true, data: { access_token, refresh_token, expires_in } }
    // 2. { access_token, refresh_token, expires_in } (format direct)
    let access_token: string;
    let refresh_token: string;
    let expires_in: number;

    if (response.data?.success && response.data?.data) {
      // Format wrapper
      access_token = response.data.data.access_token;
      refresh_token = response.data.data.refresh_token;
      expires_in = response.data.data.expires_in;
    } else if (response.data?.access_token) {
      // Format direct
      access_token = response.data.access_token;
      refresh_token = response.data.refresh_token || 'cookie-based';
      expires_in = response.data.expires_in || 3600;
    } else {
      throw new Error(
        `Invalid refresh response format. Expected { success: true, data: { access_token, refresh_token, expires_in } } or { access_token, refresh_token, expires_in }, got: ${JSON.stringify(response.data)}`,
      );
    }

    if (!access_token) {
      throw new Error('Invalid refresh response: missing access_token');
    }

    // SECURITY: Si on utilise des cookies httpOnly, le refresh_token sera dans le cookie
    // Sinon, utiliser le refresh_token de la réponse (mode legacy)
    const finalRefreshToken = useHttpOnlyCookies 
      ? refresh_token || 'cookie-based' // Le backend sette le cookie, on utilise une valeur placeholder
      : refresh_token;

    if (!finalRefreshToken) {
      throw new Error('Invalid refresh response: missing refresh_token');
    }

    // T0176: Mettre à jour les tokens stockés
    // SECURITY: Access token en mémoire uniquement, refresh token dans cookie httpOnly (ou localStorage en mode legacy)
    TokenStorage.setTokens(access_token, finalRefreshToken);

    // INT-016: Programmer le refresh proactif pour le nouveau token
    scheduleProactiveRefresh(access_token, expires_in);
  } catch (error) {
    // T0176: Gérer les erreurs - supprimer les tokens en cas d'échec
    TokenStorage.clearTokens();
    // INT-016: Annuler le refresh proactif en cas d'erreur
    cancelProactiveRefresh();
    throw error;
  }
}

/**
 * INT-016: Programme un refresh proactif avant l'expiration du token
 * @param _accessToken - Token d'accès actuel (non utilisé directement, récupéré depuis storage)
 * @param expiresIn - Durée de validité en secondes
 */
function scheduleProactiveRefresh(_accessToken: string, expiresIn: number): void {
  // Annuler le timer précédent s'il existe
  cancelProactiveRefresh();

  // Calculer le temps jusqu'au refresh proactif
  const expiresInMs = expiresIn * 1000;
  const refreshTime = Math.max(0, expiresInMs - PROACTIVE_REFRESH_BUFFER_MS);

  if (refreshTime <= 0) {
    // Le token expire bientôt, rafraîchir immédiatement
    refreshToken().catch((error) => {
      logger.warn('Proactive token refresh failed', {
          error: error instanceof Error ? error.message : String(error),
          stack: error instanceof Error ? error.stack : undefined,
      });
    });
    return;
  }

  // Programmer le refresh proactif
  proactiveRefreshTimer = setTimeout(() => {
    const currentToken = TokenStorage.getAccessToken();
    if (currentToken && isTokenExpiringSoon(currentToken, PROACTIVE_REFRESH_BUFFER_MS)) {
      refreshToken().catch((error) => {
        logger.warn('Proactive token refresh failed', {
            error: error instanceof Error ? error.message : String(error),
            stack: error instanceof Error ? error.stack : undefined,
        });
      });
    }
    proactiveRefreshTimer = null;
  }, refreshTime);
}

/**
 * INT-016: Annule le refresh proactif programmé
 */
function cancelProactiveRefresh(): void {
  if (proactiveRefreshTimer) {
    clearTimeout(proactiveRefreshTimer);
    proactiveRefreshTimer = null;
  }
}

/**
 * INT-016: Vérifie si le token actuel doit être rafraîchi et le rafraîchit si nécessaire
 * @returns Promise qui se résout si le token est valide ou a été rafraîchi
 */
export async function ensureValidToken(): Promise<void> {
  const accessToken = TokenStorage.getAccessToken();
  const refreshTokenValue = TokenStorage.getRefreshToken();

  if (!accessToken || !refreshTokenValue) {
    throw new Error('No tokens available');
  }

  // Si le token est expiré ou proche de l'expiration, le rafraîchir
  if (isTokenExpiringSoon(accessToken, PROACTIVE_REFRESH_BUFFER_MS)) {
    await refreshToken();
  } else {
    // Programmer le refresh proactif si pas déjà programmé
    const payload = decodeJWT(accessToken);
    if (payload?.exp) {
      const expiresIn = Math.max(0, payload.exp - Math.floor(Date.now() / 1000));
      scheduleProactiveRefresh(accessToken, expiresIn);
    }
  }
}

/**
 * INT-016: Initialise le système de refresh proactif
 * À appeler après un login ou un refresh réussi
 */
export function initializeProactiveRefresh(): void {
  const accessToken = TokenStorage.getAccessToken();
  if (!accessToken) {
    return;
  }

  const payload = decodeJWT(accessToken);
  if (payload?.exp) {
    const expiresIn = Math.max(0, payload.exp - Math.floor(Date.now() / 1000));
    scheduleProactiveRefresh(accessToken, expiresIn);
  }
}

/**
 * INT-016: Nettoie le système de refresh proactif
 * À appeler lors du logout
 */
export function cleanupProactiveRefresh(): void {
  cancelProactiveRefresh();
}