/**
 * Utilitários Gerais de Segurança
 * 
 * Fornece funções para proteção contra XSS, validação de dados,
 * e outras medidas de segurança gerais.
 */

/**
 * Sanitiza HTML para prevenir XSS
 * Remove tags e atributos perigosos
 * @param {string} html - HTML a ser sanitizado
 * @returns {string} HTML sanitizado
 */
export const sanitizeHTML = (html) => {
  if (!html || typeof html !== 'string') {
    return '';
  }
  
  // Remove tags script, iframe, object, embed
  let sanitized = html
    .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '')
    .replace(/<iframe\b[^<]*(?:(?!<\/iframe>)<[^<]*)*<\/iframe>/gi, '')
    .replace(/<object\b[^<]*(?:(?!<\/object>)<[^<]*)*<\/object>/gi, '')
    .replace(/<embed\b[^<]*(?:(?!<\/embed>)<[^<]*)*<\/embed>/gi, '');
  
  // Remove event handlers (onclick, onerror, etc.)
  sanitized = sanitized.replace(/\s*on\w+\s*=\s*["'][^"']*["']/gi, '');
  
  // Remove javascript: em href e src
  sanitized = sanitized.replace(/href\s*=\s*["']javascript:[^"']*["']/gi, 'href="#"');
  sanitized = sanitized.replace(/src\s*=\s*["']javascript:[^"']*["']/gi, 'src=""');
  
  return sanitized;
};

/**
 * Escapa caracteres HTML especiais
 * @param {string} str - String a ser escapada
 * @returns {string} String escapada
 */
export const escapeHTML = (str) => {
  if (!str || typeof str !== 'string') {
    return '';
  }
  
  const map = {
    '&': '&amp;',
    '<': '&lt;',
    '>': '&gt;',
    '"': '&quot;',
    "'": '&#x27;',
    '/': '&#x2F;',
  };
  
  return str.replace(/[&<>"'/]/g, (char) => map[char]);
};

/**
 * Valida formato de email
 * @param {string} email - Email a ser validado
 * @returns {boolean} True se o email é válido
 */
export const validateEmail = (email) => {
  if (!email || typeof email !== 'string') {
    return false;
  }
  
  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  return emailRegex.test(email.trim());
};

/**
 * Valida força de senha
 * @param {string} password - Senha a ser validada
 * @returns {{valid: boolean, strength: string, issues: string[]}} Resultado da validação
 */
export const validatePasswordStrength = (password) => {
  if (!password || typeof password !== 'string') {
    return {
      valid: false,
      strength: 'weak',
      issues: ['Senha não fornecida']
    };
  }
  
  const issues = [];
  let strength = 'weak';
  
  if (password.length < 8) {
    issues.push('Senha deve ter pelo menos 8 caracteres');
  }
  
  if (!/[a-z]/.test(password)) {
    issues.push('Senha deve conter pelo menos uma letra minúscula');
  }
  
  if (!/[A-Z]/.test(password)) {
    issues.push('Senha deve conter pelo menos uma letra maiúscula');
  }
  
  if (!/[0-9]/.test(password)) {
    issues.push('Senha deve conter pelo menos um número');
  }
  
  if (!/[^a-zA-Z0-9]/.test(password)) {
    issues.push('Senha deve conter pelo menos um caractere especial');
  }
  
  // Determina força
  if (issues.length === 0) {
    strength = 'strong';
  } else if (issues.length <= 2) {
    strength = 'medium';
  }
  
  return {
    valid: issues.length === 0,
    strength,
    issues
  };
};

/**
 * Valida se uma string contém apenas caracteres seguros
 * @param {string} str - String a ser validada
 * @param {Object} options - Opções de validação
 * @returns {boolean} True se a string é segura
 */
export const validateSafeString = (str, options = {}) => {
  if (!str || typeof str !== 'string') {
    return false;
  }
  
  const {
    maxLength = 1000,
    allowSpecialChars = true,
    allowedChars = null
  } = options;
  
  if (str.length > maxLength) {
    return false;
  }
  
  // Verifica caracteres perigosos
  const dangerousPatterns = [
    /<script/gi,
    /javascript:/gi,
    /on\w+\s*=/gi,
    /data:text\/html/gi
  ];
  
  for (const pattern of dangerousPatterns) {
    if (pattern.test(str)) {
      return false;
    }
  }
  
  // Se especificado, valida apenas caracteres permitidos
  if (allowedChars && typeof allowedChars === 'string') {
    const regex = new RegExp(`^[${allowedChars}]+$`);
    return regex.test(str);
  }
  
  return true;
};

/**
 * Valida origem de requisição (proteção básica)
 * @param {string} origin - Origem da requisição
 * @returns {boolean} True se a origem é permitida
 */
export const validateOrigin = (origin) => {
  if (!origin) return false;
  
  // Lista de origens permitidas (deve vir de variável de ambiente)
  const allowedOrigins = [
    window.location.origin,
    import.meta.env.VITE_API_URL?.replace('/api', '') || '',
    'https://dev.workspace.itguys.com.br',
    'https://workspace.itguys.com.br'
  ].filter(Boolean);
  
  return allowedOrigins.some(allowed => origin.startsWith(allowed));
};

/**
 * Cria um nonce para Content Security Policy
 * @returns {string} Nonce aleatório
 */
export const generateNonce = () => {
  const array = new Uint8Array(16);
  if (typeof window !== 'undefined' && window.crypto && window.crypto.getRandomValues) {
    window.crypto.getRandomValues(array);
  } else {
    for (let i = 0; i < array.length; i++) {
      array[i] = Math.floor(Math.random() * 256);
    }
  }
  
  return Array.from(array, byte => byte.toString(16).padStart(2, '0')).join('');
};

/**
 * Valida se dados não contêm scripts ou código malicioso
 * @param {any} data - Dados a serem validados
 * @returns {boolean} True se os dados são seguros
 */
export const validateDataSafety = (data) => {
  if (!data) return true;
  
  if (typeof data === 'string') {
    return validateSafeString(data);
  }
  
  if (Array.isArray(data)) {
    return data.every(item => validateDataSafety(item));
  }
  
  if (typeof data === 'object') {
    return Object.values(data).every(value => validateDataSafety(value));
  }
  
  return true;
};
