(in-package :edn.generate)
 

 (defun generate-edn-in-range (min-nodes max-nodes)
   (loop for (edn nodes) = (multiple-value-list (generate-edn))
      until (<= min-nodes nodes max-nodes)
      finally (return (values edn nodes))))
 

 (defvar *last-edn*)

 (defun generate-edn ()

   (multiple-value-bind (edn nodes) (%generate-edn)
     (values (setf *last-edn* edn)
             nodes)))
 
 (defun last-generated ()
   (when (boundp '*last-edn*)
     *last-edn*))
 
 (defun %generate-edn ()

   (case (random 3)
     (0 (generate-map))
     (1 (generate-set))
     (2 (generate-vect))))
 
 (defun generate-nil ()

   (values "nil" 1))

 
 (defun prim-generate-char ()
   (code-char (+ 32 (random #.(- 128 32)))))
 
 (defun generate-string ()

   (values (loop with limit = (random 25)
              repeat limit
              collect (prim-generate-char) into chars
              finally (return (format nil "\"~a\""
                                      (serapeum:string-replace-all "\""
                                                                   (serapeum:string-replace-all
                                                                    "\\"
                                                                    (coerce chars 'string)
                                                                    "\\\\")
                                                                   "\\\""))))
           1))

 
 (defun generate-int ()

   (values (princ-to-string (- (random 20000)
                               10000))
           1))

 
 (defun flip-coin ()
   (= 1 (random 2)))
 
 (defun generate-float ()

   (values (format nil "~[~;-~;+~]~a.~:[~;~:*~a~]~:[~;e~:*~a~]~:[~;M~]"
                   (random 3)
                   (if (flip-coin)
                       (random 10000)
                       0)
                   (when (flip-coin)
                     (random 10000))
                   (when (flip-coin)
                     (- (random 100)
                        50))
                   (flip-coin))
           1))

 
 (defun generate-character ()

   (values (format nil "\\~c" (prim-generate-char))
           1))

 
 (defun generate-bool ()

   (values (if (flip-coin)
               "true"
               "false")
           1))

 
 (defmacro comment (&body b)
   (declare (ignore b))

   (format nil ";foobar~%"))

 
 (comment
   (or (alpha-char-p x)
       (member x '(#\! #\* #\? #\_ #\$ #\% #\& #\=))))
 
 (defun generate-capital ()
   (code-char
    (+ #.(char-code #\A)
       (random 26))))
 
 (defun generate-lower ()
   (code-char
    (+ #.(char-code #\a)
       (random 26))))
 
 (defun generate-initial-char ()
   (case (random 2)
     (0 (generate-capital))
     (1 (generate-lower))))
 
 (defun generate-middle-char ()
   (case (random 5)
     (0 (generate-capital))
     (1 (generate-lower))
     (2 (generate-capital))
     (3 (generate-lower))
     (4 (elt #(#\- #\_) (random 2)))))
 
 (defun generate-name (&optional (length 20))
   (loop repeat (+ 2 (random length))
      for char = (generate-initial-char) then (generate-middle-char)
      collect char into chars
      finally (return (coerce chars 'string))))
 
 (defun generate-symbol ()

   (values (let ((ns (generate-name 5))
                 (name (generate-name 20)))
             (if (flip-coin)
                 name
                 (format nil "~a/~a" ns name)))
           1))

 
 (defun generate-keyword ()

   (values (format nil ":~a" (generate-symbol))
           1))

 
 (defun generate-primitive ()
   (case (random 8)
     (0 (generate-string))
     (1 (generate-int))
     (2 (generate-bool))
     (3 (generate-float))
     (4 (generate-nil))
     (5 (generate-character))
     (6 (generate-keyword))
     (7 (generate-symbol))))
 
 (defun compound-or-primitive (&optional (primitive-func 'generate-primitive))
     (case (random 10)

       (0 (%generate-edn))

       (1 (funcall primitive-func))
       (2 (funcall primitive-func))
       (3 (funcall primitive-func))
       (4 (funcall primitive-func))
       (5 (funcall primitive-func))
       (6 (funcall primitive-func))
       (7 (funcall primitive-func))
       (8 (funcall primitive-func))
       (9 (funcall primitive-func))))
 
 (defun not-float ()
   (compound-or-primitive
    (lambda ()
      (case (random 5)
        (0 (generate-string))
        (1 (generate-int))
        (2 (generate-bool))
        (3 (generate-nil))
        (4 (generate-character))))))
 
 (defun generate-map (&optional (key-func 'not-float) (value-func 'compound-or-primitive))
   (loop

      with nodes = 0

      with keys = (fset:set)
      repeat (random 10)

      for key = (loop for (next key-nodes) = (multiple-value-list (funcall key-func))

                   until (not (fset:contains? keys next))

                   do (incf nodes key-nodes)

                   finally
                     (fset:includef keys next)
                     (return next))

      for (value value-nodes) = (multiple-value-list (funcall value-func))
      do (incf nodes value-nodes)

      collect (format nil "~a ~a" key value) into res

      finally (return (values (format nil "{~{~{~a~^~[ ~;, ~;,~; ,~]~}~}}"
                                      (mapcar (serapeum:op (list _1 (random 3)))
                                              (remove-duplicates res :test 'equal)))
                              nodes))))

 
 
 (defun generate-set (&optional (value-func 'not-float))
   (loop

      with nodes = 0

      repeat (random 19)

      for (value value-nodes) = (multiple-value-list (funcall value-func))

      collect value into res

      do (incf nodes value-nodes)
      finally (return (values (format nil "#{~{~{~a~^~[ ~;, ~;,~; ,~]~}~}}"
                                      (mapcar (serapeum:op (list _1 (random 3)))
                                              (remove-duplicates res :test 'equal)))
                              nodes))))

 
 (defun generate-vect (&optional (value-func 'compound-or-primitive))
   (loop

      with nodes = 0

      repeat (random 19)

      for (value value-nodes) = (multiple-value-list (funcall value-func))

      collect value into res

      do (incf nodes value-nodes)
      finally (return (values (format nil "[~{~{~a~^~[ ~;, ~;,~; ,~]~}~}]"
                                      (mapcar (serapeum:op (list _1 (random 3)))
                                              res))
                              nodes))))