/**
 * TASKMATE - Input Validierung
 * ============================
 * Schutz vor SQL-Injection und XSS
 */

const sanitizeHtml = require('sanitize-html');

/**
 * HTML-Tags entfernen (für reine Text-Felder)
 */
function stripHtml(input) {
  if (typeof input !== 'string') return input;
  return sanitizeHtml(input, {
    allowedTags: [],
    allowedAttributes: {}
  }).trim();
}

/**
 * Markdown-sichere Bereinigung (erlaubt bestimmte Tags)
 */
function sanitizeMarkdown(input) {
  if (typeof input !== 'string') return input;
  return sanitizeHtml(input, {
    allowedTags: [
      'p', 'br', 'strong', 'em', 'u', 's', 'code', 'pre',
      'ul', 'ol', 'li', 'blockquote', 'a', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6'
    ],
    allowedAttributes: {
      'a': ['href', 'title', 'target', 'rel']
    },
    allowedSchemes: ['http', 'https', 'mailto'],
    transformTags: {
      'a': (tagName, attribs) => {
        return {
          tagName: 'a',
          attribs: {
            ...attribs,
            target: '_blank',
            rel: 'noopener noreferrer'
          }
        };
      }
    }
  });
}

/**
 * Objekt rekursiv bereinigen
 */
function sanitizeObject(obj, options = {}) {
  if (obj === null || obj === undefined) return obj;

  if (typeof obj === 'string') {
    return options.allowHtml ? sanitizeMarkdown(obj) : stripHtml(obj);
  }

  if (Array.isArray(obj)) {
    return obj.map(item => sanitizeObject(item, options));
  }

  if (typeof obj === 'object') {
    const sanitized = {};
    for (const [key, value] of Object.entries(obj)) {
      // Bestimmte Felder dürfen Markdown enthalten
      const allowHtml = ['description', 'content'].includes(key);
      sanitized[key] = sanitizeObject(value, { allowHtml });
    }
    return sanitized;
  }

  return obj;
}

/**
 * Validierungsfunktionen
 */
const validators = {
  /**
   * Pflichtfeld prüfen
   */
  required: (value, fieldName) => {
    if (value === undefined || value === null || value === '') {
      return `${fieldName} ist erforderlich`;
    }
    return null;
  },

  /**
   * Minimale Länge prüfen
   */
  minLength: (value, min, fieldName) => {
    if (typeof value === 'string' && value.length < min) {
      return `${fieldName} muss mindestens ${min} Zeichen haben`;
    }
    return null;
  },

  /**
   * Maximale Länge prüfen
   */
  maxLength: (value, max, fieldName) => {
    if (typeof value === 'string' && value.length > max) {
      return `${fieldName} darf maximal ${max} Zeichen haben`;
    }
    return null;
  },

  /**
   * E-Mail-Format prüfen
   */
  email: (value, fieldName) => {
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    if (value && !emailRegex.test(value)) {
      return `${fieldName} muss eine gültige E-Mail-Adresse sein`;
    }
    return null;
  },

  /**
   * URL-Format prüfen
   */
  url: (value, fieldName) => {
    try {
      if (value) {
        new URL(value);
      }
      return null;
    } catch {
      return `${fieldName} muss eine gültige URL sein`;
    }
  },

  /**
   * Integer prüfen
   */
  integer: (value, fieldName) => {
    if (value !== undefined && value !== null && !Number.isInteger(Number(value))) {
      return `${fieldName} muss eine ganze Zahl sein`;
    }
    return null;
  },

  /**
   * Positiver Integer prüfen
   */
  positiveInteger: (value, fieldName) => {
    const num = Number(value);
    if (value !== undefined && value !== null && (!Number.isInteger(num) || num < 0)) {
      return `${fieldName} muss eine positive ganze Zahl sein`;
    }
    return null;
  },

  /**
   * Datum prüfen (YYYY-MM-DD)
   */
  date: (value, fieldName) => {
    if (value) {
      const dateRegex = /^\d{4}-\d{2}-\d{2}$/;
      if (!dateRegex.test(value)) {
        return `${fieldName} muss im Format YYYY-MM-DD sein`;
      }
      const date = new Date(value);
      if (isNaN(date.getTime())) {
        return `${fieldName} ist kein gültiges Datum`;
      }
    }
    return null;
  },

  /**
   * Enum-Wert prüfen
   */
  enum: (value, allowedValues, fieldName) => {
    if (value && !allowedValues.includes(value)) {
      return `${fieldName} muss einer der folgenden Werte sein: ${allowedValues.join(', ')}`;
    }
    return null;
  },

  /**
   * Hex-Farbe prüfen
   */
  hexColor: (value, fieldName) => {
    if (value) {
      const hexRegex = /^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/;
      if (!hexRegex.test(value)) {
        return `${fieldName} muss eine gültige Hex-Farbe sein (z.B. #FF0000)`;
      }
    }
    return null;
  }
};

/**
 * Passwort-Richtlinien prüfen
 */
function validatePassword(password) {
  const errors = [];
  const minLength = 8;

  if (!password || password.length < minLength) {
    errors.push(`Passwort muss mindestens ${minLength} Zeichen haben`);
  }

  if (password && !/[a-z]/.test(password)) {
    errors.push('Passwort muss mindestens einen Kleinbuchstaben enthalten');
  }

  if (password && !/[A-Z]/.test(password)) {
    errors.push('Passwort muss mindestens einen Großbuchstaben enthalten');
  }

  if (password && !/[0-9]/.test(password)) {
    errors.push('Passwort muss mindestens eine Zahl enthalten');
  }

  return errors;
}

/**
 * Express Middleware: Request-Body bereinigen
 */
function sanitizeMiddleware(req, res, next) {
  if (req.body && typeof req.body === 'object') {
    req.body = sanitizeObject(req.body);
  }

  if (req.query && typeof req.query === 'object') {
    req.query = sanitizeObject(req.query);
  }

  if (req.params && typeof req.params === 'object') {
    req.params = sanitizeObject(req.params);
  }

  next();
}

module.exports = {
  stripHtml,
  sanitizeMarkdown,
  sanitizeObject,
  validators,
  validatePassword,
  sanitizeMiddleware
};
