;; experiment with all gauche regex facilities

(let ((match (#/mag-(\w+)-(\d+)/ "mag-ac-02")))
  (print (match))
  (print (match 1))
  (print (match 2)))

(rxmatch-let (#/mag-(\w+)-(\d+)/ "mag-ac-02") (all alpha numeric)
  (print all)
  (print alpha)
  (print numeric))

(print ((#/mag-(\w+)-(\d+)/ "mag-ac-02")))
(print ((#/mag-(\w+)-(\d+)/ "mag-ac-02") 0))
(print ((#/mag-(\w+)-(\d+)/ "mag-ac-02") 1))
(print ((#/mag-(\w+)-(\d+)/ "mag-ac-02") 2))

;; problem 1:
;; file naming scheme: mag-AA-NN.png, where A in [a-z], N in [0-9]
;; starting with a list of filenames, group by alphabetic part, then
;; output in alphanumeric order, both by alphabetic and numeric part.
;; e.g.
;; mag-aa-01
;; mag-aa-02
;; mag-ab-01
;; mag-ac-02
;; mag-ac-01
;; yields:
;; ((mag-aa-01 mag-aa-02) (mag-ab-01) (mag-ac-01 mag-ac-02))

(define filenames
  '("mag-ab-01.png" "mag-aa-02.png" "mag-ac-02.png"
    "mag-ac-01.png" "mag-aa-01.png"))

(define (decompose-filename name)
  (rxmatch-let (#/mag-(\w+)-(\d+)\.png/ name) (#f part1 part2)
    (list part1 part2)))

(define (sort-procedure a b)
  (if (string=? (car a) (car b))
      (string<? (cadr a) (cadr b))
      (string<? (car a) (car b))))

(use srfi-1)
(define (group sequence)
  "group sequence by common prefixes"
  (define (group/aux sequence result)
    (cond ((null? sequence) result)
          (else
           (receive (prefix-group rest)
               (span (pa$ string=? (car sequence)) sequence)
             (set! result (append result (list prefix-group)))
             (group/aux rest result)))))
  (group/aux sequence '()))

(print (group '("a" "a" "b" "b" "c" "d" "d" "e")))

(let ((parts (map decompose-filename filenames)))
  (print parts)
  (print (sort parts sort-procedure)))

;; -----------------------------------------------------------------
(define (schwartzian sequence computation-fn sort-fn)
  (map car
       (sort (map (lambda (x)
                    (list x (computation-fn x)))
                  sequence)
             (lambda (a b)
               (sort-fn (cadr a) (cadr b))))))

(print (schwartzian filenames decompose-filename sort-procedure))

(define (group sequence)
  "group sequence by common prefixes"
  (define (group/aux sequence result)
    (cond ((null? sequence) result)
          (else
           (let ((prefix (caadar sequence)))
             (print prefix)
             (receive (prefix-group rest)
                 (span (lambda (item)
                         (string=? prefix (caadr item)))
                       sequence)
               (set! result (append result (list prefix-group)))
               (group/aux rest result))))))
  (group/aux sequence '()))

(define (schwartzian-group sequence computation-fn sort-fn)
  (map (lambda (item)
         (map car item))
       (group
        (sort (map (lambda (x)
                     (list x (computation-fn x)))
                   sequence)
              (lambda (a b)
                (sort-fn (cadr a) (cadr b)))))))

(print (schwartzian-group filenames decompose-filename sort-procedure))