(defpackage :block-to-sexp
   (:use :cl))
 (in-package :block-to-sexp)
 
 (defun read-block (stream)
   (when (char= (read-char stream) #\{)
     (loop
        with block = (make-string-output-stream)
        with count = 0
        for char = (read-char stream)
        until (and (char= char #\}) (= count 0))
        when (char= char #\{) do (incf count)
        when (char= char #\}) do (decf count)
        do (write-char char block)
        finally
 	 (return (get-output-stream-string block)))))
 
 (defun read-to-block (stream)
   (with-output-to-string (s)
     (loop
        until (char= #\{ (peek-char nil stream))
        do (write-char (read-char stream) s))))
 
 (defun partition (char string &key from-end)
   (let ((pos (position char string :from-end from-end)))
     (if pos
 	(list (subseq string 0 pos)
 	      (subseq string (1+ pos)))
 	(list nil
 	      string))))
 
 (defun parse-rule (block)
   (mapcar #'serapeum:tokens
 	  (serapeum:split-sequence #\;
 				   (serapeum:collapse-whitespace block)
 				   :remove-empty-subseqs t)))
 
 (defun read-section (stream)
   (cons (serapeum:collapse-whitespace (read-to-block stream))
 	(parse-rule (read-block stream))))
 
 (defun parse-file (stream)
   (loop with result = (list)
      with done = nil
      until done
      do
        (handler-case (push (read-section stream)
 			   result)
 	 (end-of-file (c) c (setf done t)))
      finally
        (return (nreverse result))))
 
 (defun collapse-rule (rule)
   (let ((selector (car rule)))
     (mapcan (serapeum:op (mapcar (lambda (x) (list x _))
 				 selector))
 	    (cdr rule))))
 
 (defun reconstitute (rules)
   (loop for (selector (property value)) in rules
        collect (format nil "~a { ~a: ~a; }" selector property value)))
 
 (defun normalize-file (stream)
   (fw.lu:let-each (:be *)
     (parse-file stream)
     (mapcan #'collapse-rule *)
     (stable-sort * #'string< :key #'caadr)
     (reconstitute *)
     (serapeum:string-join * #\newline)))
 
 (defun test-read-block ()
   (let ((strings (list "asdf cda qwer dsfa"
 		       (format nil "asdf fdsaf ~% asdf qwerqw~%")
 		       (format nil "{asdf fdsaf ~% asdf qwerqw~%}")
 		       (format nil "asdf fdsaf {~% asdf qwerqw~%}"))))
     (loop
        for string in strings
        for n from 1
        do
 	 (with-input-from-string (s (format nil "{~a}" string))
 	   (format t "~&Test ~d: ~:[fail~;pass~]~%" n
 		   (string= string (read-block s)))))))