const MAX_MESSAGE_LENGTH = 300;

function normalizeWhitespace(value) {
  return value.replace(/\s+/g, ' ').trim();
}

export function sanitizeText(value, fallback = '') {
  if (typeof value !== 'string') {
    return fallback;
  }

  const cleaned = normalizeWhitespace(
    value
      .replace(/[\u0000-\u001F\u007F]/g, ' ')
      .replace(/[<>]/g, '')
  );

  if (!cleaned) {
    return fallback;
  }

  if (cleaned.length > MAX_MESSAGE_LENGTH) {
    return `${cleaned.slice(0, MAX_MESSAGE_LENGTH)}…`;
  }

  return cleaned;
}

/**
 * Übersetzt einen Fehlercode mit optionalen Parametern
 * @param {string} code - Fehlercode (z.B. 'ERROR_USER_NOT_FOUND')
 * @param {object} params - Optionale Parameter für die Übersetzung
 * @param {Function} t - Übersetzungsfunktion (z.B. this.$t oder t aus useI18n)
 * @returns {string} Übersetzte Fehlermeldung
 */
export function translateErrorCode(code, params = null, t = null) {
  if (!code || !t) {
    return code || 'Unbekannter Fehler';
  }

  try {
    // Versuche, den Fehlercode zu übersetzen
    // Format: errors.ERROR_CODE_NAME
    const translationKey = `errors.${code}`;
    let translated = t(translationKey);
    
    // Wenn keine Übersetzung gefunden wurde, gib den Code zurück
    if (translated === translationKey) {
      return code;
    }
    
    // Wenn Parameter vorhanden sind, ersetze Platzhalter
    if (params && typeof params === 'object') {
      Object.keys(params).forEach(key => {
        const placeholder = `{${key}}`;
        const value = String(params[key]);
        translated = translated.replace(new RegExp(placeholder.replace(/[{}]/g, '\\$&'), 'g'), value);
      });
    }
    
    return translated;
  } catch (error) {
    console.error('[translateErrorCode] Error translating code:', code, error);
    return code;
  }
}

/**
 * Extrahiert Fehlercode und Parameter aus einer API-Fehlerantwort
 * @param {object} error - Axios-Fehler oder Fehler-Objekt
 * @returns {object|null} { code, params } oder null
 */
export function extractErrorCode(error) {
  if (!error) return null;
  
  // Prüfe response.data für Fehlercode
  const data = error?.response?.data;
  if (data && data.code) {
    return {
      code: data.code,
      params: data.params || null
    };
  }
  
  // Prüfe direktes error-Objekt
  if (error.code && error.code.startsWith('ERROR_')) {
    return {
      code: error.code,
      params: error.params || null
    };
  }
  
  return null;
}

/**
 * Gibt eine sichere, übersetzte Fehlermeldung zurück
 * @param {object} error - Axios-Fehler oder Fehler-Objekt
 * @param {string} fallback - Fallback-Nachricht (wird übersetzt, wenn t vorhanden)
 * @param {Function} t - Übersetzungsfunktion (optional)
 * @returns {string} Übersetzte Fehlermeldung
 */
export function getSafeErrorMessage(error, fallback = 'Unbekannter Fehler', t = null) {
  if (!error) {
    return t ? translateErrorCode('ERROR_UNKNOWN_ERROR', null, t) : fallback;
  }

  // Prüfe zuerst auf Fehlercode
  const errorCode = extractErrorCode(error);
  if (errorCode && t) {
    return translateErrorCode(errorCode.code, errorCode.params, t);
  }

  // Fallback: Suche nach String-Nachricht
  const candidates = [
    error?.response?.data?.error,
    error?.response?.data?.message,
    error?.message
  ];

  const firstValid = candidates.find((candidate) => typeof candidate === 'string' && candidate.trim().length > 0);
  if (!firstValid) {
    return t ? translateErrorCode('ERROR_UNKNOWN_ERROR', null, t) : fallback;
  }

  return sanitizeText(firstValid, t ? translateErrorCode('ERROR_UNKNOWN_ERROR', null, t) : fallback);
}

export function getSafeMessage(value, fallback = '') {
  if (value == null) {
    return fallback;
  }

  return sanitizeText(String(value), fallback);
}
