(ns lein-test.core
  (:gen-class)
  (:require [clojurewerkz.machine-head.client :as mqtt]))

;; TIC TAC TOE

;; PRINT OUT BOARD

(defn label->string
  [label]
  (case label
    :empty " "
    :x "X"
    :o "O"
    (name label)))

(defn row->string
  [row]
  (str (reduce #(str %1 "|" (label->string %2)) "" row) "|") )

(defn print-board
  [board]
  (doseq [row (map row->string board)]
    (println row))
  board)

;; GET USER INPUT

(defn parse-user-input
  [input]
  (let [input (clojure.string/replace input #" " "")]
    (when (re-matches #"[0-9]+,[0-9]+" input)
      (map #(Integer. %) (clojure.string/split input #","))) )
  )
(defn get-move
  []
  (do
    (println "type the x,y coordinates of your move:")
    (parse-user-input (read-line))))


;; VALIDATE AND APPLY MOVES

(defn on-board?
  [board x y]
  (let [size (count board)]
    (and (< x size) (< y size)))
  )

(defn get-board-value
  [board x y]
  ((board y) x))


(defn valid-move?
  [board x y]
  (and (on-board? board x y) (= (get-board-value board x y) :empty)))

(defn make-move
  [board move x y]
  (if (valid-move? board x y)
    (assoc board y (assoc (board y) x move))))



;; GENERATE INITIAL BOARD

(defn make-board
  [n]
  (->>
    (repeat :empty)
    (take n)
    (into [])
    (repeat)
    (take n)
    (into [])))

;; GAME LOGIC

(declare play-round)

(defn get-opponent
  [me]
  (case me
    :x "O"
    :o "X"))

(defn handle-opponent
  [payload player server]
    (play-round (read-string payload) player server))

(defn send-to-server
  [board server player]
  (mqtt/publish server (str "mat/tictactoe" (label->string player)) (print-str board))  )

(defn play-turn
  [board player]
  (apply make-move board player (get-move)))

(defn play-round
  [board player server]
  (->
    (print-board board)
    (play-turn player)
    (print-board)
    (send-to-server server player))
  (println "Waiting for other player..."))

(defn new-game
  [nxn player]
  (let [server (mqtt/connect "tcp://test.mosquitto.org:1883")
        handler (fn [^String topic _ ^bytes payload]
                  (handle-opponent (String. payload) player server))]
    ((mqtt/subscribe server {(str "mat/tictactoe" (get-opponent player)) 0} handler)
    (when (= :o player)
      (play-round (make-board nxn) player server)
      )
    (while (mqtt/connected? server) ))))

(defn -main
  "Start a game. Specify board size and player x/o"
  [& args]
  (new-game (Integer. (first args)) (keyword (clojure.string/lower-case (second args)))))