(ns edition2022.day11
  (:require [clojure.math :as math]
            [clojure.string :as str])
  (:import (clojure.lang PersistentQueue)))
(def example "Monkey 0:\n  Starting items: 79, 98\n  Operation: new = old * 19\n  Test: divisible by 23\n    If true: throw to monkey 2\n    If false: throw to monkey 3\n\nMonkey 1:\n  Starting items: 54, 65, 75, 74\n  Operation: new = old + 6\n  Test: divisible by 19\n    If true: throw to monkey 2\n    If false: throw to monkey 0\n\nMonkey 2:\n  Starting items: 79, 60, 97\n  Operation: new = old * old\n  Test: divisible by 13\n    If true: throw to monkey 1\n    If false: throw to monkey 3\n\nMonkey 3:\n  Starting items: 74\n  Operation: new = old + 3\n  Test: divisible by 17\n    If true: throw to monkey 0\n    If false: throw to monkey 1\n")
(defn parse-arg [arg]
  (if (= arg "old")
    "%"
    arg))
(defn eval-operation [operation-str]
  (let [exp-str (str/replace operation-str #"  Operation: new = " "")
        symbols (str/split exp-str #" ")
        s (str/join " " [(second symbols) (parse-arg (first symbols)) (parse-arg (nth symbols 2))])]
    (eval (read-string (str "#(" s ")")))))
(defn parse-items [items-str]
  (->> (str/replace items-str #"  Starting items: " "")
       (#(str/split % #", "))
       (map read-string)
       (map bigint)
       (reduce conj PersistentQueue/EMPTY)
       ))
(defn parse-last-number [line]
  (->> (str/split line #" ")
       (last)
       (#(str/replace % #":" ""))
       (read-string)))
(defn parse-monkey [lines]
  (let [idx (parse-last-number (first lines))
        items (parse-items (second lines))
        operation (eval-operation (nth lines 2))
        div (parse-last-number (nth lines 3))
        true-monkey (parse-last-number (nth lines 4))
        false-monkey (parse-last-number (nth lines 5))]
    {:id           idx
     :items        items
     :operation    operation
     :div          div
     :true-monkey  true-monkey
     :false-monkey false-monkey}))
(defn parse-monkeys [input]
  (let [lines (str/split-lines input)]
    (->> (partition-by #(= "" %) lines)
         (remove #(= 1 (count %)))
         (map parse-monkey)
         (into []))))
(defn peek-item [monkey]
  (peek (monkey :items)))
(defn remove-item [monkey]
  (let [items (monkey :items)]
    (assoc monkey :items (pop items))))
(defn add-item [monkey item]
  (let [items (monkey :items)]
    (assoc monkey :items (conj items item))))
(defn compute-worry-level [monkey item]
  ;(math/floor-div ((monkey :operation) item) 3)
  ((monkey :operation) item)
  )
(defn choose-where-to-pass [monkey item]
  (if (= 0 (mod item (monkey :div)))
    (monkey :true-monkey)
    (monkey :false-monkey)))
(defn register-inspection [monkey]
  (assoc monkey :inspections (inc (get monkey :inspections 0))))
(defn pass-item [current-monkey monkeys]
  (let [item (peek-item current-monkey)]
    (if item
      (let [new-iem (compute-worry-level current-monkey item)
            idx-to-pass (choose-where-to-pass current-monkey new-iem)
            monkey-to-pass (nth monkeys idx-to-pass)]
        (recur (register-inspection (remove-item current-monkey)) (assoc monkeys idx-to-pass (add-item monkey-to-pass new-iem))))
      (assoc monkeys (current-monkey :id) current-monkey))))
(defn play-round [monkeys]
  (loop [m monkeys
         idx 0]
    (if (< idx (count m))
      (recur (pass-item (nth m idx) m) (inc idx))
      m)))
(defn play-rounds [monkeys rounds]
  (loop [m monkeys
         r 0]
    (if (< r rounds)
      (recur (play-round m) (inc r))
      m)))
(def example-monkeys (parse-monkeys example))
(def first-pass (pass-item (first example-monkeys) example-monkeys))
(defn solution1 [input]
  (->> (play-rounds (parse-monkeys input) 10000)
       (map :inspections)
       (sort)
       (reverse)
       (#(* (first %) (second %)))))
(comment
  (math/floor-div 5 4)
  ((eval-operation "new = old * 3") 4)
  (seq (parse-items "  Starting items: 79, 98"))
  (seq (conj (parse-items "  Starting items: 79, 98") 67))
  (conj (parse-items "  Starting items: 79, 98") 3)
  (parse-last-number "  Test: divisible by 5")
  (parse-last-number "Monkey 3:")
  (parse-monkeys example)
  (map #(seq (:items %)) first-pass)
  (map #(seq (:items %)) (pass-item (second first-pass) first-pass))
  (map #(seq (:items %)) (play-round (parse-monkeys example)))
  (map #(seq (:items %)) (play-rounds example-monkeys 20))
  (play-rounds example-monkeys 20)
  (solution1 example)
  (solution1 (slurp "resources/day11.in"))
  )

(ns edition2022.day10
  (:require [clojure.string :as str]))
(def example "addx 15\naddx -11\naddx 6\naddx -3\naddx 5\naddx -1\naddx -8\naddx 13\naddx 4\nnoop\naddx -1\naddx 5\naddx -1\naddx 5\naddx -1\naddx 5\naddx -1\naddx 5\naddx -1\naddx -35\naddx 1\naddx 24\naddx -19\naddx 1\naddx 16\naddx -11\nnoop\nnoop\naddx 21\naddx -15\nnoop\nnoop\naddx -3\naddx 9\naddx 1\naddx -3\naddx 8\naddx 1\naddx 5\nnoop\nnoop\nnoop\nnoop\nnoop\naddx -36\nnoop\naddx 1\naddx 7\nnoop\nnoop\nnoop\naddx 2\naddx 6\nnoop\nnoop\nnoop\nnoop\nnoop\naddx 1\nnoop\nnoop\naddx 7\naddx 1\nnoop\naddx -13\naddx 13\naddx 7\nnoop\naddx 1\naddx -33\nnoop\nnoop\nnoop\naddx 2\nnoop\nnoop\nnoop\naddx 8\nnoop\naddx -1\naddx 2\naddx 1\nnoop\naddx 17\naddx -9\naddx 1\naddx 1\naddx -3\naddx 11\nnoop\nnoop\naddx 1\nnoop\naddx 1\nnoop\nnoop\naddx -13\naddx -19\naddx 1\naddx 3\naddx 26\naddx -30\naddx 12\naddx -1\naddx 3\naddx 1\nnoop\nnoop\nnoop\naddx -9\naddx 18\naddx 1\naddx 2\nnoop\nnoop\naddx 9\nnoop\nnoop\nnoop\naddx -1\naddx 2\naddx -37\naddx 1\naddx 3\nnoop\naddx 15\naddx -21\naddx 22\naddx -6\naddx 1\nnoop\naddx 2\naddx 1\nnoop\naddx -10\nnoop\nnoop\naddx 20\naddx 1\naddx 2\naddx 2\naddx -6\naddx -11\nnoop\nnoop\nnoop\n")
(defn translate-to-action [[action args]]
  (if (= action "noop")
    [0]
    [0 (Integer/parseInt args)]))
(defn translate-to-actions [lines]
  (->> (map #(str/split % #" ") lines)
       (map translate-to-action)
       (flatten)))
(defn calculate-signals [actions]
  (loop [cycle-signal {}
         signal 1
         cycle 1
         actions actions]
    (if (empty? actions)
      cycle-signal
      (recur (assoc cycle-signal cycle signal) (+ signal (first actions)) (inc cycle) (rest actions)))))
(defn signal-strength [cycle-signals]
  (let [cycles [20 60 100 140 180 220]
        signals (map cycle-signals cycles)]
    (->> (interleave cycles signals)
         (partition 2)
         (map #(reduce * %))
         (reduce +)
         )))
(defn solution1 [input]
  (->> (str/split-lines input)
       (translate-to-actions)
       (calculate-signals)
       (signal-strength)))
(defn lid-pixel [display cycle signal]
  (let [sprite #{(dec signal) signal (inc signal)}
        display-idx (dec cycle)
        ]
    (if (contains? sprite (mod display-idx 40))
      (assoc display display-idx \#)
      (assoc display display-idx \.))))
(defn render [input]
  (loop [display (vec (repeat 240 \space))
         cycle 1
         signals (->> (str/split-lines input)
                      (translate-to-actions)
                      (calculate-signals))]
    (if (= cycle (inc (count display)))
      display
      (recur (lid-pixel display cycle (signals cycle)) (inc cycle) signals))
    ))
(defn print-render [display]
  (->> (partition 40 display)
       (map #(println %))))
(comment
  (translate-to-action ["noop"])
  (translate-to-action ["addv" "5"])
  (solution1 example)
  (solution1 (slurp "resources/day10.in"))
  (print-render (render example))
  (print-render (render (slurp "resources/day10.in")))
  )

Monkey 0:
  Starting items: 75, 63
  Operation: new = old * 3
  Test: divisible by 11
    If true: throw to monkey 7
    If false: throw to monkey 2
Monkey 1:
  Starting items: 65, 79, 98, 77, 56, 54, 83, 94
  Operation: new = old + 3
  Test: divisible by 2
    If true: throw to monkey 2
    If false: throw to monkey 0
Monkey 2:
  Starting items: 66
  Operation: new = old + 5
  Test: divisible by 5
    If true: throw to monkey 7
    If false: throw to monkey 5
Monkey 3:
  Starting items: 51, 89, 90
  Operation: new = old * 19
  Test: divisible by 7
    If true: throw to monkey 6
    If false: throw to monkey 4
Monkey 4:
  Starting items: 75, 94, 66, 90, 77, 82, 61
  Operation: new = old + 1
  Test: divisible by 17
    If true: throw to monkey 6
    If false: throw to monkey 1
Monkey 5:
  Starting items: 53, 76, 59, 92, 95
  Operation: new = old + 2
  Test: divisible by 19
    If true: throw to monkey 4
    If false: throw to monkey 3
Monkey 6:
  Starting items: 81, 61, 75, 89, 70, 92
  Operation: new = old * old
  Test: divisible by 3
    If true: throw to monkey 0
    If false: throw to monkey 1
Monkey 7:
  Starting items: 81, 86, 62, 87
  Operation: new = old + 8
  Test: divisible by 13
    If true: throw to monkey 3
    If false: throw to monkey 5