#lang racket/base

(require racket/file
         racket/list
         racket/match
         racket/string)

;; ------------------------------------------------
;; Constants
;; ------------------------------------------------
(define command-help-1 "help")
(define command-help-2 "--help")
(define command-help-3 "-h")
(define command-init "init")
(define command-ls "ls")
(define command-rm "rm")
(define command-add "add")
(define program-name "nicethings")
(define program-file (string-append "." program-name))
(define program-path (path->string (build-path (find-system-path 'home-dir) program-file)))
(define read-permissions 420)
(define newline "\n")
(define double-newline "\n\n")

;; ------------------------------------------------
;; Messages
;; ------------------------------------------------
(define messages
  (hash 'error-too-many-arguments
        (format (string-append "Error: Too many arguments." newline
                               "Try running '~a ~a' for more information.")
                program-name
                command-help-1)

        'error-incorrect-usage
        (format (string-append "Error: Incorrect usage." newline
                               "Try running '~a ~a' for more information.")
                program-name
                command-help-1)

        'couldnt-find-file
        (format (string-append "Error: Couldn't find ~a" newline
                               "Either the file doesn't exist, or the permissions are incorrect." newline
                               "If the file exists, try running chmod 600 ~a"
                               "If the file doesn't exist, try running ~a ~a")
                program-path
                program-path
                program-name
                command-init)

        'error-something-exists
        (format "Error: It looks like ~a already exists." program-path)

        'error-file-doesnt-exist
        (format (string-append "Error: '~a' doesn't exist." newline
                               "Try running '~a ~a'.")
                program-path
                program-name
                command-init)

        'error-item-not-found
        "Error: Item not found."

        'error-not-an-option
        "Error: not an option."

        'error-not-a-number
        "Error: not a number."

        'warning-permissions
        (format (string-append "Warning: The permissions on your '~a' file are incorrect." newline
                               "Other users on this host may be able to read your file." newline
                               "Try running 'chmod 600 ~a' to fix this." newline)
                program-path
                program-path)

        'init-cancelled
        (format "Cancelled the creation of '~a'." program-path)

        'init-prompt
        (format (string-append "The file '~a' will be created." newline
                               "Is this okay? [y/n]")
                program-path)

        'file-created
        (format "Successfully created ~a." program-path)

        'empty-list
        "There is nothing in your list."

        'added
        "Added '~a' to your list."

        'removed
        "Removed '~a' from your list."))

;; ------------------------------------------------
;; helpers
;; ------------------------------------------------
(define (messages-ref key)
  (hash-ref messages key))

(define (displayln-messages-ref key)
  (displayln (messages-ref key)))

(define (displayln-format-messages-ref key value)
  (displayln (format (messages-ref key) value)))

(define (create-file string)
  (close-output-port (open-output-file string)))

(define (has-read-permissions? string)
  (equal? read-permissions (file-or-directory-permissions string 'bits)))

;; ------------------------------------------------
;; init
;; ------------------------------------------------
(define (init/cancel)
  (displayln-messages-ref 'init-cancelled)
  (exit))

(define (init/create-file)
  (create-file program-path)
  (file-or-directory-permissions program-path read-permissions)
  (displayln-messages-ref 'file-created))

(define (init/prompt)
  (displayln-messages-ref 'init-prompt)
  (display "> ")
  (let ([input-symbol (string->symbol (read-line))])
    (case input-symbol
      ['y (init/create-file)]
      ['n (init/cancel)]
      [else (displayln-messages-ref 'error-not-an-option)])))

(define (init)
  (if (or (file-exists? program-path)
          (directory-exists? program-path))
    (displayln-messages-ref 'error-something-exists)
    (init/prompt)))

;; ------------------------------------------------
;; ls
;; ------------------------------------------------
(define (ls/display-list listof-items)
  (let* ([listof-number-strings (map number->string (range (length listof-items)))]
         [listof-numbered-items (map (lambda (a b) (string-append a ". " b))
                                     listof-number-strings
                                     listof-items)])
    (for ([item listof-numbered-items])
         (displayln item))))

(define (ls)
  (if (and (file-exists? program-path)
           (has-read-permissions? program-path))
    (let ([listof-items (file->lines program-path)])
      (if (null? listof-items)
        (displayln-messages-ref 'empty-list)
        (ls/display-list listof-items)))
    (displayln-messages-ref 'couldnt-file-file)))

;; ------------------------------------------------
;; rm
;; ------------------------------------------------
(define (rm/remove-nicething item-number)
  (let ([listof-items (file->lines program-path)])
    (if (and (not (null? listof-items))
             (exact? item-number)
             (>= item-number 0)
             (< item-number (length listof-items)))
      (let* ([item-to-remove (list-ref listof-items item-number)]
             [list-without-item (remove item-to-remove listof-items)])
        (display-lines-to-file list-without-item program-path #:exists 'truncate)
        (displayln-format-messages-ref 'removed item-to-remove))
      (displayln-messages-ref 'error-item-not-found))))

(define (rm arg)
  (if (and (file-exists? program-path)
           (has-read-permissions? program-path))
    (let ([item-number (string->number arg)])
      (if item-number
        (rm/remove-nicething item-number)
        (displayln-format-messages-ref 'error-not-a-number arg)))
    (displayln-messages-ref 'couldnt-find-file)))

;; ------------------------------------------------
;; add
;; ------------------------------------------------
(define (add nicething)
  (if (and (file-exists? program-path)
           (has-read-permissions? program-path))
    ;; The removing and adding of the '\n' is to
    ;; ensure only one '\n' exists at the end of the
    ;; item to be added.
    (let* ([nicething-no-newline (string-replace nicething "\n" "")]
           [nicething-newline (string-append nicething-no-newline "\n")])
      (display-to-file nicething-newline program-path #:exists 'append)
      (displayln-format-messages-ref 'added nicething-no-newline))
    (displayln-messages-ref 'couldnt-find-file)))

;; ------------------------------------------------
;; random message
;; ------------------------------------------------
(define (random-message)
  (let* ([root-home (build-path (find-system-path 'sys-dir) "home")] ;; /home
         ;; `#:build? #t` Builds full paths for all items listed in /home/
         [listof-home-directories (directory-list root-home #:build? #t)]
         [listof-nicethings-paths (map (lambda (x) (build-path x program-file))
                                       listof-home-directories)]
         [paths-with-nicethings (filter file-exists? listof-nicethings-paths)]
         [paths-readable (filter has-read-permissions? paths-with-nicethings)]
         [listof-nicethings (apply append (map file->lines paths-readable))]
         [list-length (length listof-nicethings)])
    (when (not (zero? list-length))
      (let* ([random-number (random list-length)]
             [random-nicething (list-ref listof-nicethings random-number)]
             [nicething-trimmed (string-replace random-nicething "\n" "")])
        (displayln nicething-trimmed)))))

;; ------------------------------------------------
;; help
;; ------------------------------------------------
(define (help)
  (displayln
    (string-append
      "Usage:" newline
      (format "  ~a [<command>] [<args>]" program-name)
      double-newline

      "Commands:" newline
      "  No command - Displays a random nicething from a random user." newline
      (format "  ~a - Creates a file in ~a, which allows you to contribute to the town-wide list of nicethings."
              command-init
              program-path) newline
      (format "  ~a - Adds a nicething to your list." command-add) newline
      (format "  ~a - Prints a numbered list of the nicethings you've added." command-ls) newline
      (format "  ~a - Removes a nicething from your list." command-rm)
      double-newline

      "Examples:" newline
      (format "  ~a" program-name) newline
      (format "  ~a ~a" program-name command-init) newline
      (format "  ~a ~a \"You are wonderful\"" program-name command-add) newline
      (format "  ~a ~a" program-name command-ls) newline
      (format "  ~a ~a 2" program-name command-rm))))

(define (process-args vectorof-args)
  (match vectorof-args
    [(or (vector (== command-help-1))
         (vector (== command-help-2))
         (vector (== command-help-3))) (help)]
    [(vector (== command-ls))          (ls)]
    [(vector (== command-init))        (init)]
    [(vector (== command-add) a)       (add a)]
    [(vector (== command-rm)  a)       (rm a)]
    [_                                 (random-message)]
    [(vector _ ...)                    (displayln-messages-ref 'error-incorrect-usage)]))

(define (main vectorof-args)
  (process-args vectorof-args))

(main (current-command-line-arguments))