(import [os.path [expanduser]])
(import [sys [argv exit stderr]])
(import re)
(import [nntplib [NNTP-SSL]])
(import [subprocess [Popen PIPE]])

(require [hy.contrib.walk [let]])

(setv *auth-source* (expanduser "~/.authinfo.gpg"))
(setv *recognized-commands* ["describe-group"
                             "help"
                             "list-group"
                             "list-groups"])

(defn help [&rest args]
  "Display the documentation for a command to stdout."
  (unless (= (len args) 1)
    (err (.format "usage: help [command]"))
    (return))

  (let [command (first args)]
    (unless (in command *recognized-commands*)
      (err (.format "unrecognized command: {}" command))
      (exit 1))

    (let [handler (get (globals) (.replace command "-" "_"))]
      (print (. handler __doc__)))))

(defn get-user-info [host]
  (let [process (Popen ["gpg" "-q" "-d" *auth-source*] :stdout PIPE)
        output (first (.communicate process))]
    (for [line output]
      (when (.startswith line (.format "machine {}" host))
        (return line)))))

(defn err [&rest args]
  "Displays ARGS to stdout."
  (.write stderr (+ (first args) "\n") #* (rest args)))

(when (= __name__ "__main__")
  (unless (>= (len argv) 2)
    (err (.format "usage: {} [command] [args]" (first argv)))
    (err "recognized commands:")
    (for [command *recognized-commands*]
      (err (.format "  - {}" command)))
    (exit 1))

  (let [command (nth argv 1)]
    (unless (in command *recognized-commands*)
      (err (.format "unrecognized command: {}" command))
      (exit 1))

    ;; Special case for 'help', as it's the one command that doesn't require a
    ;; connection to the NNTP server.
    (if (= command "help")
        (help #* (drop 2 argv))
        (with [session (NNTP_SSL HOST :user USER :password PASSWORD)]
          ;; Otherwise, pull the function out of the global namespace.
          (let [handler (get (globals) (.replace command "-" "_"))]
            (handler #* (drop 2 argv)))))))

;; # To-be-converted Python
;;
;;
;; def list_groups(n, *args):
;;     pattern = args[0] if len(args) >= 1 else None
;; 
;;     _, groups = n.list()
;; 
;;     for group in groups:
;;         if pattern is None or re.match(pattern, group.group):
;;             print(group.group)
;; 
;; def describe_group(n, *args):
;;     if len(args) < 1:
;;         err("usage: describe-group [group]")
;;         return
;; 
;;     _, descs = n.descriptions(args[0])
;; 
;;     for desc in descs:
;;         print(desc)
;; 
;; def list_group(n, *args):
;;     if len(args) < 1:
;;         err("usage: list-group [group]")
;;         return
;; 
;;     _, _, first, last, _ = n.group(args[0])
;;     _, overviews = n.over((first, last))
;; 
;;     for article_num, overview in overviews:
;;         print("\"{}\" by {} on {}".format(
;;             overview.get("subject"),
;;             overview.get("from"),
;;             overview.get("date"),
;;         ))