(def logo
  `
▓█████▄  ▒█████   ██▀███   ▒█████
▒██▀ ██▌▒██▒  ██▒▓██ ▒ ██▒▒██▒  ██▒
░██   █▌▒██░  ██▒▓██ ░▄█ ▒▒██░  ██▒
░▓█▄   ▌▒██   ██░▒██▀▀█▄  ▒██   ██░
░▒████▓ ░ ████▓▒░░██▓ ▒██▒░ ████▓▒░
 ▒▒▓  ▒ ░ ▒░▒░▒░ ░ ▒▓ ░▒▓░░ ▒░▒░▒░
 ░ ▒  ▒   ░ ▒ ▒░   ░▒ ░ ▒░  ░ ▒ ▒░
 ░ ░  ░ ░ ░ ░ ▒    ░░   ░ ░ ░ ░ ▒
   ░        ░ ░     ░         ░ ░
 ░
`)

(def bye
  `
 ▄▄▄▄ ▓██   ██▓▓█████
▓█████▄▒██  ██▒▓█   ▀
▒██▒ ▄██▒██ ██░▒███
▒██░█▀  ░ ▐██▓░▒▓█  ▄
░▓█  ▀█▓░ ██▒▓░░▒████▒
░▒▓███▀▒ ██▒▒▒ ░░ ▒░ ░
▒░▒   ░▓██ ░▒░  ░ ░  ░
 ░    ░▒ ▒ ░░     ░
 ░     ░ ░        ░  ░
      ░░ ░
`)

(def dorodata "dorodata")

(defn help []
  (print "add, rm, mod, help, quit, [enter]"))

(defn readline []
  (let [line (file/read stdin :line)]
    (if (nil? line)
      nil
      (string/trimr line))))

(defn quit []
  (print bye)
  (os/exit 0))

(defn lines->entries [lines]
  (var entries @[])
  (loop [line :in lines
         :when (> (length line) 0)]
    (let [[key content] (string/split ":" line)
          kwkey (keyword key)]
      (when (or (= "id" key)
                (nil? (array/peek entries)))
        (array/push entries @{}))
      (set ((array/peek entries) kwkey)
           content)))
  entries)

(defn ensure-dorodata []
  (-> (file/open dorodata :w)
      (file/flush)
      (file/close)))

(defn load-entries []
  (let [f (file/open dorodata :r)
        content (file/read f :all)]
    (file/close f)
    (->> content
         (string/split "\n")
         lines->entries)))

(defn entries->string [entries]
  (reduce (fn [acc entry]
            (string acc
                    "id:" (entry :id) "\n"
                    "title:" (entry :title) "\n"))
          ""
          entries))

(defn save-entries [entries]
  (let [f (file/open dorodata :w)]
    (file/write f (entries->string entries))
    (file/flush f)
    (file/close f)))

(defn request-val [label]
  (print label)
  (readline))

(defn new-id []
  (inc (or (max ;(map (fn [e]
                        (scan-number
                         (get e :id "0")))
                      (load-entries)))
           0)))

(defn add []
  (-> (load-entries)
      (array/push {:id (new-id)
                   :title (request-val "Title")})
      save-entries))

(def structure
  {"add" add
   "rm" (fn [] (print "rm"))
   "mod" (fn [] (print "mod"))
   "help" help
   "" (fn [] (print "overview"))
   "quit" quit})

(defn main [& args]
  (ensure-dorodata)
  (print logo)
  (help)
  (while true
    ((get structure (readline) help))))