(in-package :lol)


(defmethod get-def-values ((dimension keyword))
  (cadr (assoc dimension *dimension-set*)))

(defmethod get-def-values ((dimension symbol))
  (cadr (assoc (make-keyword dimension) *dimension-set*)))

(defmethod get-def-values ((dimension list))
  (mapcar #'get-default-values dimension))

(defmethod get-def-values ((dimension null))
  (let ((dim (mapcar #'car *dimension-set*)))
    (values (mapcar #'get-default-values dim)
            dim)))


(defun get-default-values (&optional dim)
  (get-def-values dim))

;(get-default-values :direction)
;(get-default-values 'direction)
;(get-default-values)




#|
(defmethod set-default-values ((parameter symbol))
   (cond ((eq 'support parameter)
          (setf *support-set* (mapcar #'read-from-string
                                      (seqstring-to-liststrings
                                       (get-string-from-user (format nil "Please, enter your support values. Previous values was:~%~S" *support-set*)
                                                             :size #@(500 100)
                                                             :position :centered
                                                             :window-title "Support values set")))))
         ((eq 'direction parameter)
          (setf *direction-set* (mapcar #'read-from-string
                                        (seqstring-to-liststrings
                                         (get-string-from-user (format nil "Please, enter your direction values. Previous values was:~%~S" *direction-set*) 
                                                               :size #@(500 100)
                                                               :position :centered
                                                               :window-title "Direction values set")))))
         
         ((eq 'level parameter)
          (setf *level-set* (mapcar #'read-from-string
                                    (seqstring-to-liststrings
                                     (get-string-from-user (format nil "Please, enter your level values. Previous values was:~%~S" *level-set*)
                                                           :size #@(500 100)
                                                           :position :centered
                                                           :window-title "Level values set")))))
         ((eq 'flexion parameter)
          (setf *flexion-set* (mapcar #'read-from-string
                                      (seqstring-to-liststrings
                                       (get-string-from-user (format nil "Please, enter your flexion values. Previous values was:~%~S" *flexion-set*)
                                                             :size #@(500 100)
                                                             :position :centered
                                                             :window-title "Flexion values set")))))
         ((eq 'distance parameter)
          (setf *distance-set* (mapcar #'read-from-string
                                       (seqstring-to-liststrings
                                        (get-string-from-user (format nil "Please, enter your distance values. Previous values was:~%~S" *distance-set*)
                                                              :size #@(500 100)
                                                              :position :centered
                                                              :window-title "Distance values set")))))
         ((eq 'curve parameter)
          (setf *curve-set* (mapcar #'read-from-string
                                    (seqstring-to-liststrings
                                     (get-string-from-user (format nil "Please, enter your curve values. Previous values was:~%~S" *curve-set*)
                                                           :size #@(500 100)
                                                           :position :centered
                                                           :window-title "Curve values set")))))
         ((eq 'rotation parameter)
          (setf *rotation-set* (mapcar #'read-from-string
                                       (seqstring-to-liststrings
                                        (get-string-from-user (format nil "Please, enter your rotation values. Previous values was:~%~S" *rotation-set*)
                                                              :size #@(500 100)
                                                              :position :centered
                                                              :window-title "Rotation values set")))))
         ((eq 'contact parameter)
          (setf *contact-set* (mapcar #'read-from-string
                                      (seqstring-to-liststrings
                                       (get-string-from-user (format nil "Please, enter your contact values. Previous values was:~%~S" *contact-set*)
                                                             :size #@(500 100)
                                                             :position :centered
                                                             :window-title "Contact contact set")))))
         ((eq 'address parameter)
          (setf *address-set* (mapcar #'read-from-string
                                      (seqstring-to-liststrings
                                       (get-string-from-user (format nil "Please, enter your address values. Previous values was:~%~S" *address-set*)
                                                             :size #@(500 100)
                                                             :position :centered
                                                             :window-title "Address values set")))))
         ((eq 'all parameter)
          (mapcar #'set-default-values '(support direction level distance flexion curve rotation contact address)))
         (t (lol-error-msg 
             (format nil "I don't understand this parameter name~%Please try :~%
'support~%'direction~%'level~%'distance~%'flexion~%'curve~%'rotation~%'contact~%'address~%'all")
             :size #@(350 250)))))
|#




(defmethod set-default-values ((parameter symbol))
   (setf parameter (make-keyword parameter))
   (let ((data (assoc parameter *dimension-set*)))
     (if data
       (setf (CADR (assoc parameter *dimension-set*))
             (string->list
              (get-string-from-user  (format nil "Please, enter your  ~S values :~%"
                                             (car data))
                                     :size #@(500 100)
                                     :position :centered
                                     :initial-string (list->string (cadr data))
                                     :window-title (format nil "~S values set" (car data)))))
       (format t "> LOL Warning : ~S doesn't exist.~%" parameter))
     ))



(defun list->string (list)
  (let ((r (loop for elt in list
                 collect (format nil "~S " elt))))
    (eval `(concatenate 'string .,r))))

(defun string->list (string &optional (pos 0) (r nil))
   (multiple-value-bind (sym pos)
                                     (read-from-string string nil nil :start pos)
       (when sym (push sym r))
       (if (< pos (length string))
          (string->list string pos r)
          (reverse r))))


#|
(assoc 'inclin *dimension-set*)
|#


#|
(set-default-values 'incli)
(set-default-values 'all)
|#