(use-modules (xapian wrap)
             (xapian xapian)
             (ice-9 match)
             (guix man-db)
             (srfi srfi-1)
             (srfi srfi-26))

;; eval: (put 'call-with-writable-database 'scheme-indent-function 1)

(define (index-mandb-entry db entry)
  (define (mandb-entry-id-term entry)
    (string-append "Q" "man:" (mandb-entry-name entry) "."
                   (number->string
                    (mandb-entry-section entry))))

  (when (mandb-entry-name entry)
    (let* ((idterm (mandb-entry-id-term entry))
           (doc (make-document
                 #:data (object->string
                         `((name . ,(mandb-entry-name entry))
                           (section . ,(number->string
                                        (mandb-entry-section entry)))
                           (file . ,(canonicalize-path
                                     (mandb-entry-file-name entry)))))
                 #:terms `((,idterm . 0))))
           (term-generator
            (make-term-generator #:stem (make-stem "en")
                                 #:document doc)))
      (index-text! term-generator (mandb-entry-name entry) #:prefix "A")
      (index-text! term-generator
                   (number->string (mandb-entry-section entry))
                   #:prefix "B")
      (index-text! term-generator (mandb-entry-synopsis entry))
      (replace-document! db idterm doc))))

(define (index-mandb-entries)
  (call-with-writable-database "/tmp/db"
    (lambda (db)
      (for-each (cut index-mandb-entry db <>)
                ;; (mandb-entries "/run/current-system/profile/share/man")
                (append-map mandb-entries
                            (string-split (getenv "MANPATH") #\:))
                ))))

(define* (parse-query* querystring #:key stemmer stemming-strategy
                       (prefixes '())
                       (boolean-prefixes '()))
  (let ((queryparser (new-QueryParser)))
    (QueryParser-set-stemmer queryparser stemmer)
    (when stemming-strategy
      (QueryParser-set-stemming-strategy queryparser stemming-strategy))
    (for-each (match-lambda
                ((field . prefix)
                 (QueryParser-add-prefix queryparser field prefix)))
              prefixes)
    (for-each (match-lambda
                ((field . prefix)
                 (QueryParser-add-boolean-prefix queryparser field prefix)))
              boolean-prefixes)
    (let ((query (QueryParser-parse-query queryparser querystring)))
      (delete-QueryParser queryparser)
      query)))

(define* (search querystring #:key (pagesize 100))
  (call-with-database "/tmp/db"
    (lambda (db)
      (let* ((query (parse-query querystring
                                  #:stemmer (make-stem "en")
                                  #:prefixes
                                  '(("name"    . "A")
                                    ("section" . "B"))))
             (enq (enquire db query)))
        ;; (Enquire-set-sort-by-value enq 0 #f)
        (reverse (mset-fold (lambda (item acc)
                              (cons (call-with-input-string
                                        (document-data (mset-item-document item))
                                      read)
                                    acc))
                            '()
                            (enquire-mset enq
                                          #:maximum-items pagesize)))))))