(use-modules (guix)
             (gnu)
             (srfi srfi-1)
             (ice-9 match))


(define %table (make-hash-table))

(define (keyword-as-string arg)
  (map (compose symbol->string keyword->symbol)
       (filter keyword? arg)))

(define (count-items lst)
  (if (null? lst)
      '()
      (let ((sorted (sort lst string<=?)))
        (sort
         (fold (lambda (keyword result)
                 (match result
                   ((head tail ...)
                    (match head
                      ((k . v)
                       (if (string= k keyword)
                           (cons `(,k . ,(+ 1 v)) tail)
                           (cons `(,keyword . 1) result)))
                      (_ (format #t "Error:"))))
                   (_ (format #t "Error:"))))
               (list `(,(car sorted) . 1))
               (cdr sorted))
         (lambda (x1 x2)
           (match x1
             ((k1 . v1)
              (match x2
                ((k2 . v2)
                 (> v1 v2))))))))))


(fold-packages (lambda (package result)
                 (let ((bs  (build-system-name
                             (package-build-system package)))
                       (arg (package-arguments     package)))
                   (match (hash-ref result bs)
                     ((tot wo wi args)
                      (if (null? arg)
                          (hash-set! result bs (list
                                                (1+ tot)
                                                (1+ wo)
                                                wi args))
                          (hash-set! result bs (list
                                                (1+ tot)
                                                wo
                                                (1+ wi)
                                                (append (keyword-as-string arg)
                                                        args)))))
                     (#f (if (null? arg)
                             (hash-set! result bs (list 1 1 0 '()))
                             (hash-set! result bs (list 1 0 1 (keyword-as-string arg)))))
                     (_ (format #t "Error: ~s~%" (package-name package))))
                   result))
              %table)


(define fmt "~13s: ~4s = ~4s = ~4s + ~4s  ~{ ~s ~}~%")
(format #t fmt
        'key 'tot 'tot 'no-arguments 'arguments (list 'pattern?))
(hash-for-each-handle (lambda (kv)
                        (match kv
                          ((key . value)
                           (match value
                             ((tot wo wi args)
                              (format #t fmt
                                      key
                                      (+ wo wi)
                                      tot wo wi (count-items args)))))))
                      %table)