(ns unheard.strudel.mini-notation-compiler-test
  (:refer-clojure :exclude [compile])
  (:require [clojure.test :refer [deftest is testing]]
            [unheard.strudel.mini-notation-compiler :refer [compile]]))

(deftest compile-tests
  (testing "single atom"
    (is (= :c
           (compile "c"))))

  (testing "rest literal"
    (is (= :r
           (compile "~"))))

  (testing "simple sequence - space separated"
    (is (= '(l :c :e :g)
           (compile "c e g"))))

  (testing "sequence with rest"
    (is (= '(l :c :r :g)
           (compile "c ~ g"))))

  (testing "subdivision with brackets"
    (is (= '(l :c (l :e :g) :b)
           (compile "c [e g] b"))))

  (testing "nested brackets"
    (is (= '(l :a (l :b (l :c :d)))
           (compile "a [b [c d]]"))))

  (testing "angle brackets - alternation"
    (is (= '(f :c :e :g :b)
           (compile "<c e g b>"))))

  (testing "parallel with commas"
    (is (= '(p :c :e :g)
           (compile "c,e,g"))))

  (testing "parallel in sequence"
    (is (= '(l (p :c :e :g) (p :d :f :a))
           (compile "[c,e,g] [d,f,a]"))))

  (testing "rate modifier - multiplication"
    (is (= '(rate 2 :c)
           (compile "c*2"))))

  (testing "rate modifier - division"
    (is (= '(rate (/ 1 2) :c)
           (compile "c/2"))))

  (testing "rate on group"
    (is (= '(rate 2 (l :e :g))
           (compile "[e g]*2"))))

  (testing "rate on alternation"
    (is (= '(rate 2 (f :c :e :g :b))
           (compile "<c e g b>*2"))))

  (testing "elongate modifier"
    (is (= '(elongate 3 :c)
           (compile "c@3"))))

  (testing "elongate in sequence"
    (is (= '(l (elongate 2 :a) :b :c)
           (compile "a@2 b c"))))

  (testing "replication modifier"
    (is (= '(rep 3 :c)
           (compile "c!3"))))

  (testing "replication in sequence"
    (is (= '(l (rep 2 :x) :y)
           (compile "x!2 y"))))

  (testing "multiple modifiers"
    (is (= '(rate 2 (elongate 3 :c))
           (compile "c@3*2"))))

  (testing "complex nested structure"
    (is (= '(l :c (f :e :g) :b :d)
           (compile "c <e g> b d"))))

  (testing "subdivision with parallel"
    (is (= '(l :x (p :y :z) :w)
           (compile "x [y,z] w"))))

  (testing "strudel example from docs"
    (is (= '(l :e5 (l :b4 :c5) :d5 (l :c5 :b4))
           (compile "e5 [b4 c5] d5 [c5 b4]"))))

  (testing "chord sequence"
    (is (= '(rate 2 (f (p :g3 :b3 :e4) (p :a3 :c3 :e4)))
           (compile "<[g3,b3,e4] [a3,c3,e4]>*2"))))

  (testing "elongated chord"
    (is (= '(rate 2 (f (elongate 2 (p :g3 :b3 :e4)) (p :a3 :c3 :e4)))
           (compile "<[g3,b3,e4]@2 [a3,c3,e4]>*2"))))

  (testing "replicated chord"
    (is (= '(rate 2 (f (rep 2 (p :g3 :b3 :e4)) (p :a3 :c3 :e4)))
           (compile "<[g3,b3,e4]!2 [a3,c3,e4]>*2"))))

  (testing "rest in subdivision"
    (is (= '(l :b4 (l :r :c5) :d5 :e5)
           (compile "b4 [~ c5] d5 e5"))))

  (testing "numbers as values"
    (is (= '(l 1 2 3)
           (compile "1 2 3"))))

  (testing "rational number rate"
    (is (= '(rate 3/2 :c)
           (compile "c*3/2"))))

  (testing "whitespace handling"
    (is (= '(l :a :b :c)
           (compile "  a   b   c  "))))

  (testing "complex real-world pattern"
    (is (= '(l (rate 2 (f :bd :sd)) (p :hat :hat :hat))
           (compile "<bd sd>*2 [hat,hat,hat]"))))

  (testing "newlines are converted to spaces"
    (is (= '(f :a :b :c :d)
           (compile "<a b\nc d>"))))

  (testing "multi-line pattern with parallel"
    (is (= '(f (l :a :b) (p :c :d))
           (compile "<\n[a b]\n[c,d]\n>"))))

  (testing "polymeter - comma in angle brackets zips elements"
    (is (= '(f (p :a :c) (p :b :d))
           (compile "<a b, c d>"))))

  (testing "polymeter - three groups"
    (is (= '(f (p :a :c :e) (p :b :d :f))
           (compile "<a b, c d, e f>"))))

  (testing "polymeter - unequal lengths pads with nils"
    (is (= '(f (p :a :c) (p :b :d) :e)
           (compile "<a b e, c d>"))))

  (testing "polymeter - single element groups"
    (is (= '(p :a :c)
           (compile "<a, c>"))))

  (testing "polymeter - with nested structures"
    (is (= '(f (p (l :a :b) (l :e :f))
               (p (l :c :d) (l :g :h)))
           (compile "<[a b] [c d], [e f] [g h]>"))))

  (testing "polymeter - with modifiers"
    (is (= '(rate 2 (f (p :a :c) (p :b :d)))
           (compile "<a b, c d>*2"))))

  (testing "polymeter - melody and bass pattern"
    (is (= '(f (p (l :e5 :b4) (rate 4 (l :e2 :e3)))
               (p (l :a4 :c5) (rate 4 (l :a2 :a3))))
           (compile "<[e5 b4] [a4 c5], [[e2 e3]*4] [[a2 a3]*4]>")))))