;; Función para generar contraseñas fuertes desde Emacs
(defun generate-strong-password (length complexity)
  "Genera una contraseña fuerte usando nuestro script personalizado.
LENGTH es la longitud de la contraseña.
COMPLEXITY es el nivel de complejidad (1-4)."
  (interactive 
   (list 
    (read-number "Longitud de la contraseña: " 16)
    (read-number "Nivel de complejidad (1-4): " 3)))

  (let ((script-path "~/bin/strong-password-generator.sh"))
    (if (file-exists-p script-path)
        (let ((password 
               (string-trim 
                (shell-command-to-string 
                 (format "%s %d %d" script-path length complexity)))))
          ;; Insertar en el buffer actual o mostrar en minibuffer
          (if (use-region-p)
              (progn
                (delete-region (region-beginning) (region-end))
                (insert password)
                (message "Contraseña insertada en el buffer"))
            (kill-new password)
            (message "Contraseña copiada al kill-ring: %s" password)))
      (message "Script no encontrado en %s. Verifique la ruta." script-path))))

;; Atajo de teclado para generar contraseñas rápidamente
(global-set-key (kbd "C-c p") 'generate-strong-password)

;; Integración con auth-source para gestión de contraseñas
(require 'auth-source)

(defun save-password-to-auth-source (host user password)
  "Guarda una contraseña en auth-source para el HOST y USER especificados."
  (interactive
   (list
    (read-string "Host/Servicio: ")
    (read-string "Usuario: ")
    (read-string "Contraseña: " nil nil nil t)))  ; No mostrar la contraseña

  ;; Crear entrada en auth-source
  (let ((auth-sources '("~/.authinfo.gpg")))
    (auth-source-forget-all-cached)
    (let ((entry (list :host host :user user :secret password)))
      (auth-source-save-behavior nil)
      (auth-source-save-new entry)
      (message "Contraseña guardada para %s@%s" user host))))

(defun generate-and-save-password (host user length complexity)
  "Genera una contraseña fuerte y la guarda en auth-source."
  (interactive
   (list
    (read-string "Host/Servicio: ")
    (read-string "Usuario: ")
    (read-number "Longitud de la contraseña: " 16)
    (read-number "Nivel de complejidad (1-4): " 3)))

  (let* ((script-path "~/bin/strong-password-generator.sh")
         (password
          (string-trim
           (shell-command-to-string
            (format "%s %d %d" script-path length complexity)))))

    ;; Guardar en auth-source
    (save-password-to-auth-source host user password)

    ;; También copiar al kill-ring para uso inmediato
    (kill-new password)
    (message "Contraseña generada y guardada para %s@%s (copiada al kill-ring)" user host)))

;; Función para recuperar contraseñas
(defun get-password-from-auth-source (host user)
  "Recupera una contraseña desde auth-source."
  (interactive
   (list
    (read-string "Host/Servicio: ")
    (read-string "Usuario: ")))

  (let* ((auth-info (car (auth-source-search :host host :user user)))
         (password (if auth-info
                      (let ((secret (plist-get auth-info :secret)))
                        (if (functionp secret)
                            (funcall secret)
                          secret))
                    nil)))

    (if password
        (progn
          (kill-new password)
          (message "Contraseña recuperada y copiada al kill-ring"))
      (message "No se encontró contraseña para %s@%s" user host))))

;; Atajo para generar y guardar
(global-set-key (kbd "C-c P") 'generate-and-save-password)

;; Integración con Password Store (pass)
(when (executable-find "pass")
  (require 'auth-source-pass)
  (auth-source-pass-enable)

  (defun generate-password-and-store-in-pass (path length complexity)
    "Genera una contraseña fuerte y la almacena usando pass."
    (interactive
     (list
      (read-string "Ruta en pass (ej. email/gmail.com): ")
      (read-number "Longitud de la contraseña: " 16)
      (read-number "Nivel de complejidad (1-4): " 3)))

    (let* ((script-path "~/bin/strong-password-generator.sh")
           (password
            (string-trim
             (shell-command-to-string
              (format "%s %d %d" script-path length complexity)))))

      ;; Almacenar en pass
      (shell-command-to-string (format "echo '%s' | pass insert -e '%s'" password path))

      ;; Copiar al kill-ring
      (kill-new password)
      (message "Contraseña generada y almacenada en pass: %s (copiada al kill-ring)" path)))

  ;; Atajo para la función de pass
  (global-set-key (kbd "C-c M-p") 'generate-password-and-store-in-pass))

;; Gestión de contraseñas con org-mode (cifrado)
(require 'org-crypt)
(require 'epa-file)
(epa-file-enable)
(org-crypt-use-before-save-magic)
(setq org-tags-exclude-from-inheritance (quote ("crypt")))
(setq org-crypt-key user-mail-address)  ;; Usar tu clave GPG

(defun create-password-entry-in-org ()
  "Crea una entrada para una contraseña en un archivo org cifrado."
  (interactive)
  (let* ((org-password-file "~/org/passwords.org.gpg")
         (host (read-string "Servicio/Sitio: "))
         (user (read-string "Usuario/Email: "))
         (notes (read-string "Notas adicionales: "))
         (length (read-number "Longitud de la contraseña: " 16))
         (complexity (read-number "Nivel de complejidad (1-4): " 3))
         (script-path "~/bin/strong-password-generator.sh")
         (password
          (string-trim
           (shell-command-to-string
            (format "%s %d %d" script-path length complexity)))))

    ;; Crear o abrir el archivo
    (unless (file-exists-p org-password-file)
      (with-temp-file org-password-file
        (insert "#+TITLE: Base de datos de contraseñas seguras\n")
        (insert "#+AUTHOR: " user-full-name "\n")
        (insert "#+STARTUP: content\n\n")))

    ;; Añadir nueva entrada
    (find-file org-password-file)
    (goto-char (point-max))
    (insert (format "\n* %s %s\n" host (format-time-string "(%Y-%m-%d)")))
    (insert (format "  :PROPERTIES:\n"))
    (insert (format "  :CREATED: %s\n" (format-time-string "[%Y-%m-%d %a %H:%M]")))
    (insert (format "  :USER: %s\n" user))
    (insert (format "  :END:\n"))
    (insert (format "** Credenciales :crypt:\n"))
    (insert (format "- Usuario: %s\n" user))
    (insert (format "- Contraseña: %s\n" password))
    (insert (format "- Generada: %s\n" (format-time-string "%Y-%m-%d")))
    (insert (format "- Longitud: %d caracteres\n" length))
    (insert (format "- Complejidad: nivel %d\n" complexity))
    (when (not (string= notes ""))
      (insert (format "** Notas\n%s\n" notes)))

    ;; Cifrar inmediatamente la sección
    (org-encrypt-entry)
    (save-buffer)

    ;; Copiar al kill-ring
    (kill-new password)
    (message "Entrada creada para %s y contraseña copiada al kill-ring" host)))

;; Atajo para crear entradas de contraseñas en org
(global-set-key (kbd "C-c M-P") 'create-password-entry-in-org)

;; Integración con Dired
(with-eval-after-load 'dired
  (define-key dired-mode-map (kbd ";p") 
    (lambda ()
      (interactive)
      (let ((default-directory dired-directory))
        (generate-strong-password 16 3)))))

#!/bin/bash
# memorable-password-generator.sh

# Definir conjuntos de palabras (esto sería mucho más extenso en una implementación real)
ADJECTIVES=("rápido" "alegre" "verde" "brillante" "suave" "áspero" "dulce" "amargo" "fuerte" "débil")
NOUNS=("tigre" "montaña" "océano" "jardín" "libro" "pluma" "casa" "estrella" "fuego" "nube")
VERBS=("corre" "salta" "nada" "vuela" "escribe" "lee" "canta" "baila" "ríe" "llora")

# Generar componentes aleatorios
get_random_element() {
    local array=("$@")
    echo "${array[RANDOM % ${#array[@]}]}"
}

# Generar una contraseña memorable
generate_memorable_password() {
    local adj=$(get_random_element "${ADJECTIVES[@]}")
    local noun=$(get_random_element "${NOUNS[@]}")
    local verb=$(get_random_element "${VERBS[@]}")
    local num=$((RANDOM % 1000))
    local special_chars=("!" "@" "#" "$" "%" "&" "*")
    local special=$(get_random_element "${special_chars[@]}")

    # Capitalizar primera letra de cada palabra para mayor seguridad
    adj=$(echo "$adj" | sed 's/\(.\)/\u\1/')
    noun=$(echo "$noun" | sed 's/\(.\)/\u\1/')
    verb=$(echo "$verb" | sed 's/\(.\)/\u\1/')

    echo "${adj}${special}${noun}${num}${verb}"
}

# Generar y mostrar
PASSWORD=$(generate_memorable_password)
echo "Contraseña memorable generada: $PASSWORD"
echo "Esta contraseña es más fácil de recordar pero sigue siendo segura."

(defun generate-memorable-password ()
  "Genera una contraseña memorable pero segura."
  (interactive)
  (let ((script-path "~/bin/memorable-password-generator.sh"))
    (if (file-exists-p script-path)
        (let ((password 
               (string-trim 
                (shell-command-to-string script-path))))
          (kill-new password)
          (message "Contraseña memorable generada y copiada: %s" password))
      (message "Script no encontrado en %s" script-path))))

(global-set-key (kbd "C-c m") 'generate-memorable-password)

#!/bin/bash
# passphrase-generator.sh

# Simulamos dados para seleccionar palabras del diccionario diceware
# En una implementación real, usaríamos un diccionario completo
DICEWARE_DICT=(
    "abaco" "badajo" "cabra" "dados" "efecto" "fábula" "gacela" "hacedor"
    "icono" "jabón" "kiosco" "labio" "maceta" "nadar" "oasis" "pacto"
    "queso" "rábano" "sábana" "tabla" "único" "vacío" "wafle" "xilófono"
    "yeso" "zarza" "águila" "búho" "cáliz" "dátil" "élite" "fénix"
    # Este diccionario sería mucho más extenso en la realidad
)

# Generar frase de contraseña
generate_passphrase() {
    local num_words=$1
    local passphrase=""
    local separator=$2

    for ((i=0; i<num_words; i++)); do
        # Seleccionar palabra aleatoria
        index=$((RANDOM % ${#DICEWARE_DICT[@]}))
        word=${DICEWARE_DICT[$index]}

        # Añadir capitalización aleatoria para mayor seguridad
        if ((RANDOM % 2)); then
            word=$(echo "$word" | sed 's/\(.\)/\u\1/')
        fi

        # Añadir a la frase
        if [[ -n "$passphrase" ]]; then
            passphrase="${passphrase}${separator}${word}"
        else
            passphrase=$word
        fi
    done

    # Añadir un número aleatorio al final
    passphrase="${passphrase}${separator}$(($RANDOM % 100))"

    echo "$passphrase"
}

# Generar y mostrar
NUM_WORDS=${1:-4}
SEPARATOR=${2:--}
PASSPHRASE=$(generate_passphrase $NUM_WORDS $SEPARATOR)

echo "Frase de contraseña generada: $PASSPHRASE"
echo "Esta frase tiene alta entropía pero es más fácil de recordar."

(defun generate-passphrase (words separator)
  "Genera una frase de contraseña usando el método diceware.
WORDS es el número de palabras a incluir.
SEPARATOR es el carácter separador entre palabras."
  (interactive
   (list
    (read-number "Número de palabras: " 4)
    (read-string "Separador: " "-")))

  (let ((script-path "~/bin/passphrase-generator.sh"))
    (if (file-exists-p script-path)
        (let ((passphrase 
               (string-trim 
                (shell-command-to-string 
                 (format "%s %d %s" script-path words separator)))))
          (kill-new passphrase)
          (message "Frase de contraseña generada y copiada: %s" passphrase))
      (message "Script no encontrado en %s" script-path))))

(global-set-key (kbd "C-c f") 'generate-passphrase)

(defun audit-password-strength (password)
  "Audita la fortaleza de una contraseña y sugiere mejoras."
  (interactive "sContraseña a auditar: ")

  (let ((length (length password))
        (has-uppercase (string-match-p "[A-Z]" password))
        (has-lowercase (string-match-p "[a-z]" password))
        (has-numbers (string-match-p "[0-9]" password))
        (has-symbols (string-match-p "[^a-zA-Z0-9]" password))
        (has-sequences (string-match-p "\\(abc\\|123\\|qwe\\)" password))
        (score 0)
        (feedback '()))

    ;; Evaluación de longitud
    (cond
     ((< length 8)
      (push "Longitud crítica: menos de 8 caracteres." feedback))
     ((< length 12)
      (push "Longitud insuficiente: menos de 12 caracteres." feedback)
      (cl-incf score))
     ((< length 16)
      (push "Longitud aceptable: entre 12-16 caracteres." feedback)
      (cl-incf score 2))
     (t
      (push "Longitud excelente: más de 16 caracteres." feedback)
      (cl-incf score 3)))

    ;; Evaluación de complejidad
    (when has-uppercase (cl-incf score) (push "Contiene mayúsculas [+]" feedback))
    (when has-lowercase (cl-incf score) (push "Contiene minúsculas [+]" feedback))
    (when has-numbers (cl-incf score) (push "Contiene números [+]" feedback))
    (when has-symbols (cl-incf score) (push "Contiene símbolos especiales [+]" feedback))

    ;; Penalizaciones
    (when has-sequences
      (cl-decf score)
      (push "Contiene secuencias predecibles (ej: abc, 123) [-]" feedback))

    (when (string-match-p (regexp-quote (user-login-name)) password)
      (cl-decf score 2)
      (push "Contiene tu nombre de usuario [-]" feedback))

    ;; Mostrar resultados
    (with-output-to-temp-buffer "*Password Audit*"
      (switch-to-buffer "*Password Audit*")
      (erase-buffer)
      (insert "=== AUDITORÍA DE SEGURIDAD DE CONTRASEÑA ===\n\n")
      (insert (format "Puntuación: %d/10\n\n" score))
      (insert "Análisis:\n")
      (dolist (item (reverse feedback))
        (insert (format "• %s\n" item)))

      (insert "\nRecomendaciones:\n")
      (cond
       ((< score 4)
        (insert "⚠️ Contraseña DÉBIL - Se recomienda cambio inmediato\n")
        (insert "• Utilice la función generate-strong-password para crear una nueva\n")
        (insert "• Aumente la longitud a mínimo 16 caracteres\n")
        (insert "• Incluya caracteres de todas las categorías\n"))
       ((< score 7)
        (insert "⚠️ Contraseña MODERADA - Se recomienda mejora\n")
        (insert "• Considere aumentar la longitud\n")
        (insert "• Añada el tipo de caracteres que faltan\n"))
       (t
        (insert "✅ Contraseña FUERTE - Cumple con los estándares recomendados\n")
        (insert "• Recuerde cambiarla periódicamente\n")
        (insert "• Asegúrese de no reutilizarla en otros servicios\n")))

      (insert "\n=== FIN DEL ANÁLISIS ===\n"))))

(global-set-key (kbd "C-c C-p a") 'audit-password-strength)