day18.clj

(ns day18
  (:require [clojure.pprint :refer [pprint]]
            [clojure.zip :as z]))

(defn exp-left [sn n]
  (loop [t (z/prev sn) l 1]
    (if (nil? t)
      sn
      (let [tn (z/node t)]
        (if (number? tn)
          (let [-t (z/replace t (+ tn n))]
            (reduce (fn [-t _] (z/next -t)) -t (range l)))
          (recur (z/prev t) (inc l)))))))

(defn exp-right [sn n]
  (loop [t (z/next sn) l 1]
    (if (z/end? t)
      sn
      (let [tn (z/node t)]
        (if (number? tn)
          (let [-t (z/replace t (+ tn n))]
            (reduce (fn [-t _] (z/prev -t)) -t (range l)))
          (recur (z/next t) (inc l)))))))

(defn sn-explode
  "Only explode the leftmost pair."
  [sn]
  (loop [n (z/next sn)]
    (if (z/end? n)
      nil ; no exploding
      (let [ns (z/node n)]
        (if (and (coll? ns) (number? (first ns)) (number? (last ns)) (> (count (z/path n)) 3))
          (-> (z/replace n 0) (exp-left (first ns)) (exp-right (last ns)) (z/root))
          (recur (z/next n)))))))

(defn sn-split
  "split the first number > 10"
  [sn]
  (loop [n (z/next sn)]
    (if (z/end? n)
      nil
      (let [ns (z/node n)]
        (if (and (number? ns) (> ns 9))
          (-> n (z/replace [(int (java.lang.Math/floor (/ ns 2))) (int (java.lang.Math/ceil (/ ns 2)))]) (z/root))
          (recur (z/next n)))))))

(defn sn-reduce [sn]
  (loop [-sn sn]
    (if-some [-sn (sn-explode -sn)]
      (recur (z/vector-zip -sn))
      (if-some [-sn (sn-split -sn)]
        (recur (z/vector-zip -sn))
        -sn))))

(defn sn-magtitude
  ([sn] (sn-magtitude sn 1))
  ([sn amp]
   (if (number? sn)
     (* sn amp)
     (let [[l r] sn]
       (+ (sn-magtitude l (* 3 amp)) (sn-magtitude r (* 2 amp)))))))

(defn sn-add [l r]
  (-> [l r] (z/vector-zip) (sn-reduce) (z/root)))

(->> (tree-seq coll? identity [7 [[[3 7] [4 3]] [[6 3] [8 8]]]]))

(defn sn-explode-2 [[l r]]
  (loop [-l l -r r d 0]
    (let [[x y] l]
      )
    )
  )

(->>
 [[[[0 [4 5]] [0 0]] [[[4 5] [2 6]] [9 5]]]
  [7 [[[3 7] [4 3]] [[6 3] [8 8]]]]
  [[2 [[0 8] [3 4]]] [[[6 7] 1] [7 [1 6]]]]
  [[[[2 4] 7] [6 [0 5]]] [[[6 8] [2 8]] [[2 1] [4 5]]]]
  [7 [5 [[3 8] [1 4]]]]
  [[2 [2 2]] [8 [8 1]]]
  [2 9]
  [1 [[[9 3] 9] [[9 0] [0 7]]]]
  [[[5 [7 4]] 7] 1]
  [[[[4 2] 2] 6] [8 7]]]
 (reduce sn-add)
 (sn-magtitude))

(def input
  [[[[3 [8 6]] [6 1]] [[[1 1] 2] [[1 0] 0]]]
   [[[1 [7 3]] 1] 9]
   [[[2 6] [[3 1] [0 9]]] [[7 [4 8]] [[2 7] 3]]]
   [[[3 [0 4]] [[8 4] [1 9]]] [7 [2 [5 7]]]]
   [[[4 5] [[0 7] 1]] [9 [0 4]]]
   [[5 [[1 5] [3 6]]] 8]
   [[3 [[9 3] 9]] 9]
   [2 [[[2 1] [0 5]] [9 9]]]
   [[2 [6 9]] [[[4 1] 0] [3 4]]]
   [[[[6 8] 0] [[8 8] 9]] [[[4 2] 3] [3 [7 3]]]]
   [[3 7] 9]
   [[[[2 5] 8] [2 5]] [[0 [5 7]] [[2 5] 4]]]
   [[[8 [6 6]] 0] [4 [[5 6] [8 4]]]]
   [[[1 [8 2]] [[0 4] [2 6]]] [[3 4] 0]]
   [[1 [[9 2] [6 0]]] [[[0 9] 5] [[8 0] [1 5]]]]
   [[2 [[2 3] [1 8]]] [3 [[7 2] [0 7]]]]
   [[5 4] 5]
   [[[[4 2] [4 8]] [7 3]] [0 [[8 9] 6]]]
   [[[6 7] 0] 5]
   [[2 [[9 0] [8 4]]] [[[7 4] [3 4]] 0]]
   [[[9 [8 9]] 1] [[5 [6 7]] 3]]
   [[2 [0 0]] [3 [[2 5] [1 4]]]]
   [[0 1] [0 [[8 8] [8 3]]]]
   [[[0 2] [2 8]] [1 [[7 0] 0]]]
   [[[[5 4] 3] [[7 5] [2 6]]] [[5 8] [0 1]]]
   [0 [0 0]]
   [[5 [[5 6] 0]] [[[2 7] 9] [7 9]]]
   [[[[0 8] 2] [[2 5] [7 6]]] [[9 7] [[8 7] [9 2]]]]
   [[[0 [4 6]] [[6 3] [4 4]]] [8 [[4 8] [4 8]]]]
   [[[[8 9] [3 8]] 8] [[[7 9] 6] [9 [2 7]]]]
   [[[[8 9] [1 6]] 0] [[[8 7] 4] [9 [1 4]]]]
   [5 7]
   [[[[1 5] [3 6]] [[5 5] 4]] [[3 3] [4 [4 0]]]]
   [[[0 6] [5 [5 3]]] [[4 [0 0]] 8]]
   [7 [6 8]]
   [[[[8 5] 9] [[3 2] 7]] [[[6 6] 5] 2]]
   [[[[4 4] [0 4]] 9] 0]
   [[0 [3 [9 3]]] [9 [[8 0] [0 9]]]]
   [[[[4 0] 0] [1 [1 7]]] [[3 [3 0]] [[1 3] 6]]]
   [[9 4] [3 [[7 1] 6]]]
   [[[[3 7] 7] 1] [[4 3] [[6 9] [6 9]]]]
   [[[8 [2 5]] [[8 4] 4]] [[[3 4] [6 7]] [5 [8 5]]]]
   [2 [4 [[3 2] 7]]]
   [[[[3 1] [5 6]] [[2 7] 7]] [4 [8 [7 4]]]]
   [[7 8] [[[3 9] 7] 2]]
   [[[[8 8] [5 8]] [[1 0] [6 0]]] [[[1 2] 6] [[4 2] [5 5]]]]
   [[1 [0 9]] [[[2 1] 1] 1]]
   [[6 [8 1]] [4 [[7 8] 5]]]
   [[[1 [1 6]] [1 [5 7]]] [[[2 8] 6] 0]]
   [9 1]
   [[[0 [6 5]] [[8 5] 2]] [[[2 4] [7 3]] [[1 5] [9 2]]]]
   [[[2 7] [0 [3 6]]] [[[1 0] [9 6]] [1 [0 4]]]]
   [6 [[[5 9] 8] [0 2]]]
   [7 [[[9 4] [8 6]] [[1 1] 1]]]
   [[[2 1] 0] 8]
   [1 [[6 [1 4]] [[0 0] [1 9]]]]
   [[[1 [7 9]] 2] 8]
   [[[[0 9] 2] [[8 4] 9]] [0 [[7 7] [4 8]]]]
   [[1 [2 [1 8]]] [[[3 6] [2 1]] [3 [5 0]]]]
   [[3 3] [3 5]]
   [[[[9 3] [4 3]] [5 [8 1]]] [[6 [5 0]] 9]]
   [0 [[9 [3 5]] 3]]
   [[[9 1] 0] [[[5 9] [8 0]] [7 [4 8]]]]
   [[[[7 7] 8] 3] [[[6 6] [6 5]] [6 4]]]
   [[[[3 7] 1] [9 [4 2]]] [[9 [2 5]] [[9 0] 5]]]
   [5 [[0 2] 6]]
   [[[[2 7] [5 3]] [1 8]] 2]
   [[[8 [7 7]] [9 [0 0]]] 4]
   [[[4 [1 4]] 0] [[[8 7] 8] [[4 1] 7]]]
   [[[[0 6] 0] [[3 2] [9 8]]] [[9 [4 5]] [[7 7] [0 8]]]]
   [[[[6 3] 3] [[1 5] 7]] [[0 1] [7 7]]]
   [[[[2 0] 2] [3 [3 5]]] [[[0 8] [8 2]] [[0 6] 5]]]
   [[[6 [5 3]] [[5 5] 9]] [[5 9] [[8 7] [3 7]]]]
   [[[[1 7] [3 4]] [9 2]] 1]
   [[[[8 2] 6] 1] [[5 [2 7]] [3 9]]]
   [5 [5 7]]
   [[[[9 8] [3 4]] [[2 5] [5 6]]] [[[2 7] 7] [9 [8 7]]]]
   [[[1 4] [[6 1] [1 3]]] [1 [7 [1 7]]]]
   [[[[1 4] 8] [[5 1] 8]] [[[1 3] [6 9]] [6 [3 3]]]]
   [[[[4 0] [0 7]] [4 5]] [4 2]]
   [3 8]
   [7 [[[7 6] 5] [[6 6] 5]]]
   [[[5 [0 5]] [4 4]] [3 [[4 2] [7 0]]]]
   [[[[7 9] 8] [9 6]] [5 0]]
   [[[[3 0] [5 2]] 1] [[[6 9] [5 3]] [[2 5] [6 3]]]]
   [7 [[[7 7] [4 5]] [9 2]]]
   [[7 [[4 2] [9 3]]] [7 [6 1]]]
   [7 9]
   [[[8 [8 1]] [[7 3] 1]] [[9 8] [2 [8 3]]]]
   [[[9 3] 3] 3]
   [[[8 [5 7]] [[2 1] [1 3]]] [[[3 5] 2] 0]]
   [[[8 8] 0] [[1 4] [[8 6] 9]]]
   [[9 [3 [3 0]]] [1 7]]
   [1 [[[8 8] 1] [2 [0 5]]]]
   [[0 [1 5]] [9 [0 [9 0]]]]
   [1 [[[1 1] [8 3]] [1 8]]]
   [[5 [[7 7] [3 3]]] [[[6 6] [7 8]] [1 [0 0]]]]
   [[[[6 7] 1] [0 2]] [[[4 2] [7 6]] [[8 4] [4 9]]]]
   [[6 [[3 3] [9 0]]] [1 [[4 5] 4]]]
   [[[[3 4] 7] [9 0]] [[[4 5] 1] [[5 1] [9 3]]]]])

(->> input (reduce sn-add) (sn-magtitude))

(->>
 (for [i input
       j input
       :when (not (= i j))]
   (-> (sn-add i j) (sn-magtitude)))
 (apply max))

;; (let [t (z/vector-zip [[[[[4 3] 4] 4] [7 [[8 4] 9]]] [1 1]])]
;;   ;; (-> t (explode) (z/vector-zip) (explode) (z/vector-zip) (explode)))
;;   (let [n (-> t (z/next) (z/next) (z/next) (z/next))]
;;     (-> n (z/replace 0) (exp-left 9) (exp-right 8) (z/root)))