(defn printer [x] (do (println x) x))


(defn suit [card] (str (first (rest card))))

(defn rank [card] (cond
                    (Character/isDigit (first card)) (Integer/valueOf (str(first card)))
                    (= (first card) \T) 10
                    (= (first card) \J) 11
                    (= (first card) \Q) 12
                    (= (first card) \K) 13
                    (= (first card) \A) 14
                  )
)

;(defn pair? [hand] (= (count hand) (+ 1 (count  (set (map rank hand))))) )
(defn n-duplicates [hand] (frequencies (vals (frequencies (map rank hand)))) )
(defn pair? [hand]  (= (n-duplicates hand) {2 1, 1 3} ) )
(defn three-of-a-kind? [hand]  (= (n-duplicates hand) {3 1, 1 2} ) )
(defn four-of-a-kind? [hand]  (= (n-duplicates hand) {4 1, 1 1} ) )
(defn full-house? [hand]  (= (n-duplicates hand) {3 1, 2 1} ) )
(defn two-pairs? [hand]  (= (n-duplicates hand) {2 2, 1 1} ) )


;Pomoshni funkcii za flush i straight
(defn swap-ace [ranks] (map (fn [x] (if (= x 14) 1 x)) ranks))
(defn pom-flush [hand] (= 1 (count (set (map suit hand)))))
(defn straighten [ranks] (map (fn [x] (- x (first ranks))) ranks))
(defn pom-straight [hand] (or
                               (= (straighten (sort (map rank hand))) '(0 1 2 3 4) )
                               (= (straighten (sort (swap-ace (map rank hand)))) '(0 1 2 3 4) )
                          ) )


(defn flush? [hand] (and (pom-flush hand) (not (pom-straight hand)) ))
(defn straight? [hand] (and (not (pom-flush hand)) (pom-straight hand) ))
(defn straight-flush? [hand] (and  (pom-flush hand) (pom-straight hand) ))

(defn value [hand] (cond
                       (straight-flush? hand) 8
                       (four-of-a-kind? hand) 7
                       (full-house? hand) 6
                       (flush? hand) 5
                       (straight? hand) 4
                       (three-of-a-kind? hand) 3
                       (two-pairs? hand) 2
                       (pair? hand) 1
                       :else 0
 )
)

(defn low-ace [hand] ; converts Low Ace to 1
    (if
        (= (straighten (sort (swap-ace (map rank hand)) )) '(0 1 2 3 4) ) (swap-ace (map rank hand))
        (map rank hand)
    )
)

(defn kickers [hand]  (keys (into (sorted-map-by (fn [key1 key2]
                            (if
                                (=
                                     (get (frequencies (low-ace hand) ) key2)
                                     (get (frequencies (low-ace hand) ) key1)
                                )
                                (< key2 key1)
                                (<  (get (frequencies (low-ace hand) ) key2)
                                          (get (frequencies (low-ace hand) ) key1))
                            )
                        ))
                        (frequencies (low-ace hand) )))
)

(defn higher-kicker? [k1 k2]
    (cond
        (empty? k1) nil
        (empty? k2) true
        (> (first k1) (first k2)) true
        (< (first k1) (first k2)) nil
        :else (higher-kicker? (rest k1) (rest k2))
    )
)
(defn beats? [h1 h2]
    (cond (> (value h1) (value h2) ) true
          (= (value h1) (value h2)) (higher-kicker? (kickers h1) (kickers h2) )
          :else nil
    )
)
(defn modify [Lis]  (if (= 1 (count Lis)) (first Lis) Lis  ) )

(defn winning-hand [& hands]
    (if (empty? hands) nil
        (modify (reduce (fn [h1 h2]
                    (cond (beats? (first h1) (first h2)) h1
                          (beats? (first h2) (first h1)) h2
                          :else (concat h1 h2)
                    )) (map (fn [x] (list x)) hands) ) )
    )
)



(def high-seven ["2H" "3S" "4C" "5C" "7D"])
(def pair-hand ["2H" "2S" "4C" "5C" "7D"])
(def two-pairs-hand ["2H" "2S" "4C" "4D" "7D"])
(def three-of-a-kind-hand ["2H" "2S" "2C" "4D" "7D"])
(def four-of-a-kind-hand ["2H" "2S" "2C" "2D" "7D"])
(def straight-hand ["2H" "3S" "6C" "5D" "4D"])
(def low-ace-straight-hand ["2H" "3S" "4C" "5D" "AD"])
(def high-ace-straight-hand ["TH" "AS" "QC" "KD" "JD"])
(def flush-hand ["2H" "4H" "5H" "9H" "7H"])
(def full-house-hand ["2H" "5D" "2D" "2C" "5S"])
(def straight-flush-hand ["2H" "3H" "6H" "5H" "4H"])
(def low-ace-straight-flush-hand ["2D" "3D" "4D" "5D" "AD"])
(def high-ace-straight-flush-hand ["TS" "AS" "QS" "KS" "JS"])

(winning-hand pair-hand high-seven pair-hand)



(ns user(:use clojure.test))

(deftest t-suit
    (is (= "H" (suit "2H")))
    (is (= "D" (suit "TD")))
    (is (= "C" (suit "QC")))
    (is (= "S" (suit "JS")))
)
(deftest t-rank
    (is (= 2 (rank "2H")))
    (is (= 10 (rank "TD")))
    (is (= 12 (rank "QC")))
    (is (= 11 (rank "JS")))
)
(deftest t-pair?
    (is (not (pair? ["2H" "5D" "3C" "QS" "4D"])))
    (is (pair? ["2H" "2D" "JC" "QS" "4D"]))
    (is (not (pair? ["2H" "2D" "2C" "QS" "4D"])))
    (is (not (pair? ["2H" "2D" "2C" "2S" "4D"])))
    (is (not (pair? ["2H" "2D" "3C" "3S" "4D"])))
    (is (not (pair? ["2H" "2D" "3C" "3S" "3D"])))
)
(deftest t-three?
    (is (not (three-of-a-kind? ["2H" "5D" "3C" "QS" "4D"])))
    (is (not (three-of-a-kind? ["2H" "2D" "JC" "QS" "4D"])))
    (is  (three-of-a-kind? ["2H" "2D" "2C" "QS" "4D"]))
    (is (not (three-of-a-kind? ["2H" "2D" "2C" "2S" "4D"])))
    (is (not (three-of-a-kind? ["2H" "2D" "3C" "3S" "4D"])))
    (is (not (three-of-a-kind? ["2H" "2D" "3C" "3S" "3D"])))
)
(deftest t-four?
    (is (not (four-of-a-kind? ["2H" "5D" "3C" "QS" "4D"])))
    (is (not (four-of-a-kind? ["2H" "2D" "JC" "QS" "4D"])))
    (is (not (four-of-a-kind? ["2H" "2D" "2C" "QS" "4D"])))
    (is  (four-of-a-kind? ["2H" "2D" "2C" "2S" "4D"]))
    (is (not (four-of-a-kind? ["2H" "2D" "3C" "3S" "4D"])))
    (is (not (four-of-a-kind? ["2H" "2D" "3C" "3S" "3D"])))
)
(deftest t-house?
    (is (not (full-house? ["2H" "5D" "3C" "QS" "4D"])))
    (is (not (full-house? ["2H" "2D" "JC" "QS" "4D"])))
    (is (not (full-house? ["2H" "2D" "2C" "QS" "4D"])))
    (is (not (full-house? ["2H" "2D" "2C" "2S" "4D"])))
    (is (not (full-house? ["2H" "2D" "3C" "3S" "4D"])))
    (is  (full-house? ["2H" "2D" "3C" "3S" "3D"]))
)
(deftest t-two-pairs?
    (is (not (two-pairs? ["2H" "5D" "3C" "QS" "4D"])))
    (is (not (two-pairs? ["2H" "2D" "JC" "QS" "4D"])))
    (is (not (two-pairs? ["2H" "2D" "2C" "QS" "4D"])))
    (is (not (two-pairs? ["2H" "2D" "2C" "2S" "4D"])))
    (is  (two-pairs? ["2H" "2D" "3C" "3S" "4D"]))
    (is (not (two-pairs? ["2H" "2D" "3C" "3S" "3D"])))
)
(deftest t-flush?
    (is (flush? ["2H" "2H" "2H" "2H" "4H"]))
    (is (not (flush? ["2H" "3H" "4H" "5H" "6H"])))
    (is (not (flush? ["2H" "2D" "3C" "3S" "3D"])))
)
(deftest t-straight?
    (is (straight? ["2D" "3H" "4H" "5H" "AH"]))
    (is (not (straight? ["2H" "3H" "4H" "5H" "6H"])))
    (is (straight? ["AH" "TD" "JC" "QS" "KD"]))
    (is (straight? ["2D" "3H" "4H" "5H" "6H"]))
    (is (not (straight? ["2H" "3H" "4H" "7H" "TD"])))
)
(deftest t-straight-flush?
    (is  (straight-flush? ["2H" "3H" "4H" "5H" "6H"]))
    (is (not (straight-flush? ["AH" "3H" "4H" "5H" "6H"])))
    (is (not (straight-flush? ["2D" "3H" "4H" "5H" "AH"])))
    (is (not (straight-flush? ["2H" "5D" "3C" "QS" "4D"])))
)
(deftest t-kickers
    (is (= (kickers ["2H" "3S" "4C" "5D" "6D"]) '(6 5 4 3 2)))
    (is (= (kickers ["5H" "AS" "5C" "7D" "AD"]) '(14 5 7)))
)
(deftest t-higher-kicker
    (is (= nil (higher-kicker? (kickers ["2H" "3S" "4C" "5D" "6D"]) (kickers ["5H" "AS" "5C" "7D" "AD"]) )))
    (is (= true (higher-kicker? (kickers  ["5H" "AS" "5C" "7D" "AD"]) (kickers  ["2H" "3S" "4C" "5D" "6D"]))))
)

(run-tests)