;; from Rosetta code, with modifications https://rosettacode.org/wiki/Password_generator#Common_Lisp
(defpackage :fwoar.password-gen
  (:use :cl )
  (:export ))
(in-package :fwoar.password-gen)

(defparameter *lowercase* "abcdefghijklmnopqrstuvwxyz")

(defparameter *uppercase* "ABCDEFGHIJKLMNOPQRSTUVWXYZ")

(defparameter *numbers* "1234567890")

(defparameter *special-characters*
  '(#\! #\\ #\# #\% #\& #\* #\+ #\, #\- #\. #\: #\< #\= #\>
    #\? #\^ #\_ #\| #\~))

(defparameter *similar-characters*
  '(#\I #\l #\1 #\| #\O #\0 #\5 #\S #\2 #\Z))

(defparameter *excluded-characters*
  '(#\@ #\! #\[ #\] #\{ #\} #\/ #\\ #\' #\" #\& #\< #\> #\`))

(defun make-readable (flag s)
  (if flag
      (remove-if (lambda (x)
                   (member x *similar-characters*))
                 s)
      s))

(defun shuffle-seq (input-seq)
  (loop with l = (length input-seq)
        for i below l
        do (rotatef (elt input-seq i)
                    (elt input-seq
                         (random l))))
  input-seq)

(defun sample (seq)
  (elt seq
       (random (length seq))))

(defun generate-password (len human-readable exclude-excluded additional-special asp)
  (let* ((upper (make-readable human-readable *uppercase*))
         (lower (make-readable human-readable *lowercase*))
         (number (make-readable human-readable *numbers*))
         (special-initial (make-readable human-readable *special-characters*))
         (special (cond (asp (coerce additional-special 'list))
                        (exclude-excluded
                         (set-difference special-initial *excluded-characters*))
                        (t special-initial)))
         (character-groups (list upper lower number special))
         (initial-password (reduce (lambda (acc x)
                                     (cons (sample x) acc))
                                   character-groups
                                   :initial-value NIL)))

    (coerce (shuffle-seq
             (reduce (lambda (acc x)
                       (declare (ignore x))
                       (let ((group (nth (random (length character-groups))
                                         character-groups)))
                         (cons (sample group)
                               acc)))
                     (make-list (- len 4))
                     :initial-value initial-password))
            'string)))

(defun main (len count &optional human-readable exclude-excluded (additional-special nil asp))
  (setf *random-state* (make-random-state t))
  (if (< len 4)
      (print "Length must be at least 4~%")
      (loop for x from 1 to count do
        (princ (generate-password len human-readable exclude-excluded additional-special asp))
        (terpri))))

(defun parse-bool (str)
  (case (elt (string-downcase str) 0)
    ((#\t #\y) t)
    ((#\f #\n) nil)))