import React from 'react';
import { useTranslation } from 'react-i18next';

interface PasswordCriteria {
  label: string;
  isValid: boolean;
  regex?: RegExp;
  checkFn?: (password: string) => boolean;
}

interface PasswordCriteriaProps {
  password: string;
  className?: string;
  showOnlyFailed?: boolean;
}

export const PasswordCriteria: React.FC<PasswordCriteriaProps> = ({
  password,
  className = '',
  showOnlyFailed = false
}) => {
  const { t } = useTranslation(['ui']);

  const criteria: PasswordCriteria[] = [
    {
      label: t('ui:password_criteria.min_length', 'Al menos 8 caracteres'),
      isValid: password.length >= 8,
      checkFn: (pwd) => pwd.length >= 8
    },
    {
      label: t('ui:password_criteria.max_length', 'Máximo 128 caracteres'),
      isValid: password.length <= 128,
      checkFn: (pwd) => pwd.length <= 128
    },
    {
      label: t('ui:password_criteria.uppercase', 'Al menos una letra mayúscula'),
      isValid: /[A-Z]/.test(password),
      regex: /[A-Z]/
    },
    {
      label: t('ui:password_criteria.lowercase', 'Al menos una letra minúscula'),
      isValid: /[a-z]/.test(password),
      regex: /[a-z]/
    },
    {
      label: t('ui:password_criteria.number', 'Al menos un número'),
      isValid: /\d/.test(password),
      regex: /\d/
    }
  ];

  const validatedCriteria = criteria.map(criterion => {
    // If password is empty, all criteria should be considered invalid initially
    if (!password) {
      return { ...criterion, isValid: false };
    }

    return {
      ...criterion,
      isValid: criterion.regex
        ? criterion.regex.test(password)
        : criterion.checkFn
          ? criterion.checkFn(password)
          : false
    };
  });

  const displayCriteria = showOnlyFailed 
    ? validatedCriteria.filter(c => !c.isValid)
    : validatedCriteria;

  if (displayCriteria.length === 0) return null;

  return (
    <div className={`text-sm space-y-1 ${className}`}>
      <p className="text-text-secondary font-medium mb-2">
        Requisitos de contraseña:
      </p>
      <ul className="space-y-1">
        {displayCriteria.map((criterion, index) => (
          <li key={index} className="flex items-center space-x-2">
            <span
              className={`w-4 h-4 rounded-full flex items-center justify-center text-xs font-bold ${
                criterion.isValid
                  ? 'bg-green-100 text-green-700 dark:bg-green-900 dark:text-green-300'
                  : 'bg-red-100 text-red-700 dark:bg-red-900 dark:text-red-300'
              }`}
            >
              {criterion.isValid ? '✓' : '✗'}
            </span>
            <span
              className={`${
                criterion.isValid
                  ? 'text-green-700 dark:text-green-300'
                  : 'text-red-700 dark:text-red-300'
              }`}
            >
              {criterion.label}
            </span>
          </li>
        ))}
      </ul>
    </div>
  );
};

export const validatePassword = (password: string): boolean => {
  return (
    password.length >= 8 &&
    password.length <= 128 &&
    /[A-Z]/.test(password) &&
    /[a-z]/.test(password) &&
    /\d/.test(password)
  );
};

export const getPasswordErrors = (password: string, t?: (key: string, fallback: string) => string): string[] => {
  const errors: string[] = [];

  if (password.length < 8) {
    errors.push(t?.('ui:password_criteria.errors.min_length', 'La contraseña debe tener al menos 8 caracteres') ?? 'La contraseña debe tener al menos 8 caracteres');
  }

  if (password.length > 128) {
    errors.push(t?.('ui:password_criteria.errors.max_length', 'La contraseña no puede exceder 128 caracteres') ?? 'La contraseña no puede exceder 128 caracteres');
  }

  if (!/[A-Z]/.test(password)) {
    errors.push(t?.('ui:password_criteria.errors.uppercase', 'La contraseña debe contener al menos una letra mayúscula') ?? 'La contraseña debe contener al menos una letra mayúscula');
  }

  if (!/[a-z]/.test(password)) {
    errors.push(t?.('ui:password_criteria.errors.lowercase', 'La contraseña debe contener al menos una letra minúscula') ?? 'La contraseña debe contener al menos una letra minúscula');
  }

  if (!/\d/.test(password)) {
    errors.push(t?.('ui:password_criteria.errors.number', 'La contraseña debe contener al menos un número') ?? 'La contraseña debe contener al menos un número');
  }

  return errors;
};