(ns cipher-analytical-machine.cli
  (:require
   [cipher-analytical-machine.file :as file]
   [cipher-analytical-machine.caesar :as caesar]
   [cipher-analytical-machine.caesar-analyzers :as caesar-analyzers]
   [cipher-analytical-machine.symbol-factories :as sf]
   [cipher-analytical-machine.symbol-frequences :as symbol-frequences]
   [clojure.string :as cs]
   [clojure.tools.cli :refer [parse-opts]])
  (:gen-class))

(def cipher-options
  #{"Caesar"})

(def cli-options
  [["-m" "--message MESSAGE" "The message will be encrypted or decrypted."]
   ["-M" "--message-file MESSAGE-FILE" "The file contains the message that will be encrypted or decrypted."]
   ["-k" "--key KEY" "The key will be used to encrypt or decrypt."]
   ["-c" "--cipher CIPHER" "The cipher will be used to encrypt or decrypt a message."
    :default "Caesar"]
   ["-e" "--encrypt" "Encrypt the message."]
   ["-d" "--decrypt" "Decrypt the message."]
   ["-s" "--symbols" "The string will be used as a set of symbols for a cipher."
    :default (sf/default-symbol-factory "en")]
   ["-C" "--cracking" "Cracking the encrypted message."]
   ["-h" "--help"]])

(defn usage [options-summary]
  (->> ["This is cipher-analytical-machine. It can help you to learn how ciphers works."
        ""
        "Usage: cipher-analytical-machine [options]"
        ""
        "Options:"
        options-summary
        ""]
       (cs/join \newline)))

(defn error-msg [errors]
  (str "The following errors occurred while parsing your command:\n\n"
       (cs/join \newline errors)))

(defn map-has-keys?
  "Return true if all keys in the map."
  [map keys]
  (every? #(contains? map %) keys))

(defn validate-args
  "Validate command line arguments. Either return a map indicating the program
  should exit (with an error message, and optional ok status), or a map
  indicating the action the program should take and the options provided."
  [args]
  (let [{:keys [options arguments errors summary]} (parse-opts args cli-options)]
    (cond
      (:help options)
      {:exit-message (usage summary) :ok? true}

      errors
      {:exit-message (error-msg errors)}

      (map-has-keys? options [:encrypt, :decrypt])
      {:exit-message (error-msg ["You can't use enctypt and decrypt mode at the same time!!!"])}

      (map-has-keys? options [:message, :message-file])
      {:exit-message (error-msg ["You can't use message and message-file options at the same time!!!"])}

      (and (map-has-keys? options [:cipher, :key])
           (or (contains? options :message)
               (contains? options :message-file))
           (or (contains? options :encrypt)
               (contains? options :decrypt)))
      (cond
        (contains? options :encrypt)
        {:options options :arguments arguments :action-type :encrypt}

        (contains? options :decrypt)
        {:options options :arguments arguments :action-type :decrypt})

      (and (map-has-keys? options [:cipher, :cracking])
           (or (contains? options :message)
               (contains? options :message-file)))
      {:options options :arguments arguments :action-type :cracking}

      :else
      {:exit-message (usage summary)})))

(defn exit
  [exit-message status]
  (println exit-message)
  (System/exit (if status 0 1)))

(defn get-message
  "Return the message"
  [options arguments]
  (cond
    (contains? options :message)
    (:message options)

    (contains? options :message-file)
    (file/read-file (:message-file options))))

(defn actions
  [options arguments action-type]
  (let [message (get-message options arguments)
        key (Integer/parseInt (:key options))
        symbols (:symbols options)]
    (println
     (cond
       (= action-type :cracking)
       (caesar-analyzers/get-plaintext message symbols symbol-frequences/english-letter-frequences)

       (= action-type :encrypt)
       (caesar/encrypt-message message key symbols)

       (= action-type :decrypt)
       (caesar/decrypt-message message key symbols)))))