(defpackage :ssh-configurator
   (:use :clim :clim-lisp))
 (in-package :ssh-configurator)
 
 (defclass host ()
   ((%hosts :initarg :hosts :reader hosts)
    (%options :initarg :options :reader options)))
 (defclass ssh-config ()
   ((%hosts :initarg :hosts :reader hosts)
    (%options :initarg :options :reader options)))
 
 (defgeneric read-in (file object)
   (:method ((path string) object)
     (read-in (pathname path) object))
   (:method ((path pathname) object)
     (alexandria:with-input-from-file (f path)
       (read-in f object))))
 
 (defmethod read-in (file (host-blocks))
   )
 
 (defun prefix-count-if (pred seq)
   (length (serapeum:take-while pred seq)))
 
 (defun read-indented-block (stream)
   (values (loop for line = (read-line stream nil)
              for next-char = (peek-char nil stream nil)
              for whitespace-count = (prefix-count-if #'serapeum:whitespacep line)
              when (< whitespace-count (length line)) collect
                (cons whitespace-count
                      (subseq line whitespace-count))
              while (and next-char
                         (serapeum:whitespacep next-char)))
           stream))
 
 (defun tokenize-block (block)
   (mapcar (alexandria:compose 'serapeum:tokens
                               'cdr)
           block))
 
 (defun read-all-indented-blocks (stream)
   (loop for block = (read-indented-block stream)
      while block
      collect block))
 
 (define-application-frame ssh-configurator ()
   ((host-blocks :initarg :host-blocks :accessor host-blocks
                 :initform (error "need host blocks...")))
   (:panes
    (hosts (make-pane 'list-pane :items (host-blocks *application-frame*)))
    (props (make-pane 'list-pane :items '(2 3 41 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18))))
   (:layouts
    (default (vertically ()
               (scrolling ()
                 hosts)
               (scrolling ()
                 props))))
   )
 
 
 (defun ssh-configurator (host-blocks)
   (fw.lu:prog1-bind (f (make-application-frame 'ssh-configurator
                                                :host-blocks host-blocks))
     (bt:make-thread
      (serapeum:op (run-frame-top-level f))
      :name "ssh-configurator")))
 
 (defmacro print-and-return-when ((condition) form &rest others)
   `(let ((result ,form))
      (when ,condition
        (format *trace-output* "~&Result is: ~s~%~4t(~{~s~^ ~})~%" result (list ,@others)))
      result))
 
 (defun get-all-subclasses (object)
   (print-and-return-when ((typep (car result) 'standard-class))
    (etypecase object
      (list (mapcar 'get-all-subclasses object))
      (null (princ :what?))
      (symbol (get-all-subclasses (find-class object)))
      ((or standard-class sb-mop:funcallable-standard-class)
       (list (class-name object)
             (get-all-subclasses (sb-mop:class-direct-subclasses object)))))
    ))
 
 (defpackage :ssh-configurator/t
   (:use :cl :should-test))
 (in-package :ssh-configurator/t)
 (import 'ssh-configurator::read-indented-block)
 
 (deftest read-indented-block ()
     ()
   (should be equal
           '((0 . "a b c") (4 . "d"))
           (with-input-from-string (s (format nil "a b c~%~4td"))
             (read-indented-block s)))
   (should be equal
           '((0 . "e f g") (4 . "h"))
           (with-input-from-string (s (format nil "a b c~%~4td~%e f g~%~4th"))
             (read-indented-block
              (nth-value 1 (read-indented-block s)))))
   (should be equal
           '((0 . "e f g") (4 . "h"))
           (with-input-from-string (s (format nil "a b c~%~4td~%e f g~%~4th~%  "))
             (read-indented-block
              (nth-value 1 (read-indented-block s)))))
   (should be equal
           nil
           (with-input-from-string (s (format nil ""))
             (read-indented-block
              (nth-value 1 (read-indented-block s)))))
   (should be equal
           nil
           (with-input-from-string (s (format nil "   "))
             (read-indented-block
              (nth-value 1 (read-indented-block s))))))