;; -*- lexical-binding: t; -*-

(defvar hmm-web-search-engines nil "hmm web search engines.")
(defvar hmm-web-browsers nil "hmm web browers.")
(defvar hmm-query-handlers nil "hmm query handlers.")
(defvar hmm-commands '(:query nil :url nil :file nil))

(defmacro hmm-define-web-search-engine (engine browser)
  (let* ((engine-name (plist-get engine :name))
         (browser-name (plist-get browser :name))
         (function-name (intern
                         (format "hmm-search-%s-%s" engine-name browser-name))))
    `(progn
       (defun ,function-name (query)
         ,(format "Search %s in %s." engine-name browser-name)
         (interactive ,(format "sSearch %s in %s for: " engine-name browser-name))
         (,(plist-get browser :command)
          (format ,(plist-get engine :format) query)))
       (hmm-add-command '(:command ,function-name) :query))))

(defun hmm-add-command (command handling)
  (let ((commands (plist-get hmm-commands handling)))
    (add-to-list 'commands command)
    (plist-put hmm-commands handling commands)))

(defun hmm-query-region (from to)
  (interactive "r")
  (unless (region-active-p) (error "Region not active."))
  (let* ((query (buffer-substring from to)))
    (hmm-search-internal query)))

(defun hmm-thing-at-point ()
  (interactive)
  "Prompt for what to do with thing at point.

If it is a file, display a list of file handlers.
If it is a url, display a list of url handlers."
  (cond ((thing-at-point-url-at-point)
         (hmm-url (thing-at-point-url-at-point)))
        ((thing-at-point-file-at-point)
         (hmm-file (thing-at-point-file-at-point)))
        (t (hmm-query (word-at-point)))))

(defun hmm-query (query)
  (interactive "sQuery: ")
  (hmm-open-internal query :query "Search %s using: "))

(defun hmm-url (url)
  (interactive (list (read-string "URL: " (thing-at-point-url-at-point))))
  (hmm-open-internal url :url "Handle url %s using: "))

(defun hmm-file (file)
  (interactive (list (read-string "File: " (thing-at-point-file-at-point))))
  (hmm-open-internal file :file "Handle file %s using: "))

(defun hmm-open-internal (thing type prompt)
  (let ((selected
         (completing-read
          (format prompt thing)
          (mapcar
           (lambda (command)
             (format "%s (%s)" command
                     (if (documentation command)
                         (car
                          (split-string
                           (documentation command)
                           "\n"))
                       "Undocumented")))
           (hmm-filter-commands thing type)))))
    (funcall (intern (car (split-string selected " ("))) thing)))

(defun hmm-filter-commands (thing type)
  (mapcar
   (lambda (handler)
     (plist-get handler :command))
   (seq-filter
    (lambda (handler)
      (string-match (or (plist-get handler :regex) ".*") thing))
    (plist-get hmm-commands type))))

(defun hmm-update-commands ()
  (interactive)
  (setq hmm-commands '(:query nil :url nil :file nil))
  (dolist (engine hmm-web-search-engines)
    (dolist (browser hmm-web-browsers)
      (eval `(hmm-define-web-search-engine ,engine ,browser))))
  (mapc (lambda (command) (hmm-add-command command :query))
        hmm-query-handlers)
  (mapc (lambda (browser)
          (add-to-list 'hmm-url-handlers
                       (list :command (plist-get browser :command)
                             :regex "^http\\(s\\)?://.*$")))
        hmm-web-browsers)
  (mapc (lambda (command) (hmm-add-command command :url))
        hmm-url-handlers))

(hmm-update-commands)

(provide 'hmm)