;;; today I'd like to do bass arpegios, with high chords
;; and maybe drums for both parts (from 09-09)
;; and join them?

;; IV V iii vi
;; (setq *my-chords* (list :major :major :minor :minor)
;;       *my-roots* (list 3 4 2 5))
;; (setq *my-chords* (list :major)
;;       *my-roots* (list 3))

;; Am – F – C – G (i – VI – III – VII)
;; (setq *my-chords* (list :minor :major :major :major)
;;       *my-roots* (list 0 3 2 6))

;; i - III - iv - VI
(setq *my-chords* (list :minor :major :minor :major)
      *my-roots* (list 0 2 3 5))

(in-package :cl-patterns)

(start-clock-loop :tempo 90/60 :force t)

(pb :lets-slow-bass-arpegio
  :dur 2
  :octave 3
  ;; :instrument :fmbass
  :embed (not-perfect-but-arpeggio *my-chords*)
  :embed (attr-per-phrase :root *my-roots*)
  )
;; (play :lets-slow-bass-arpegio)
;; (stop :lets-slow-bass-arpegio)

;; well, what if I rather take my simple-bass thing
;; and give it some kind of slow pattern
;; nope, that simple-bass plays whole chords
;;
;; at this point I'm just tempted to not use chords,
;; and have a PARP
(pdef :chord-defs
      (pbind :chord (pseq *my-chords* 1)
          :chord-base (pseq *my-roots* 1)))

(pb :lets-slow-bass-melody
  (parp
   (pdef :chord-defs)
   (pbind :step (pseq (list 0 1 0  1 2 0 1 2) 1)
          :dur (pseq (list 1/4 1/4 1 1 1 1 1 5/2) 1)
          ;; :note (pfunc (lambda ()
          ;;                (event-value *event* :step)))
          :note (pfunc (lambda ()
                         (+ (event-value *event* :chord-base)
                            (nth (event-value *event* :step)
                                 (chord-notes (event-value *event* :chord))))))
          )))
;; (next-upto-n (pdef :lets-slow-bass-melody) 10)
;; (play :lets-slow-bass-melody)
;; (end :lets-slow-bass-melody)
;; (stop :lets-slow-bass-melody)

(pb :embedding-bass-melogy-into-pattern
  (pseq (list (pbind
               :quant 4
               :dur (pseq (list (prest 7/2)) 1))
              (pbind
               :octave 2                ; let's add these later? when join both?
               :instrument :fmbass
               :embed :lets-slow-bass-melody))
        1))
(next-upto-n (pdef :embedding-bass-melogy-into-pattern) 20)
;; (play :embedding-bass-melogy-into-pattern)
;; (stop :embedding-bass-melogy-into-pattern)
;; (end :embedding-bass-melogy-into-pattern)

;; now. let's brainstorm the pattern on a single chord?

;; and well, my guess is that pattern should start from 1/2 before tha bar start?

;; so is there a "timer shift" for pattern?
;; if I can only align by quant
;; ( upbeat ? )
;; well 3 6 9 - and we have -1 +2 and +1 over the quant :4

;; ok, let's for not simulate that stuff by writing continuous bass melody
;; and adding 3 1/2 rest in the beginning

;; I'd like to add bottom note repeating at 1/2 ?

;;; let's just do same? quant 4, wait for the upbeat of next bar
;;; and start playing 1/2 8 times?
(pb :lets-slow-bass-melody-root-repeating
  (pseq (list (pbind :dur (pseq (list (prest 4)) 1)
                     :quant 4)
              (parp
               (pdef :chord-defs)
               (pbind
                :octave 1
                :instrument :fmbass
                :dur (pseq  (list (prest 5/2) (pfindur 1/2 7/2) (prest 2)) 1)
                :legato 0.5
                :note (pk :chord-base)))
              (pbind :dur (pseq (list (prest 1)) 1)))
        1))
(next-upto-n (pdef :lets-slow-bass-melody-root-repeating) 20)
;; (play :lets-slow-bass-melody-root-repeating)
;; (end :lets-slow-bass-melody-root-repeating)
;; (stop :lets-slow-bass-melody-root-repeating)

(pdef :full-bass-melody
    (ppar (list :embedding-bass-melogy-into-pattern :lets-slow-bass-melody-root-repeating)))
;; (play :full-bass-melody)
;; (stop :full-bass-melody)

;; yay, not sure whether I want :octave 1 or 2, but overall, cool,
;; even though - so much still to learn to not have to do manual calculaitons of prest and such

;; let's have some kind of light chord holding. not sure what I want, maybe default
;; maybe strings? or pluck

(pb :high-chords-hold
  :embed :chord-defs
  :instrument :tone-buzz
  :dur 8
  :quant 4
  :amp 0.05
  :note (p+ (pk :chord-base) (pnary #'chord-notes (pk :chord))))
(next-upto-n (pdef :high-chords-hold) 30)
;; (play :high-chords-hold)
;; (end :high-chords-hold)
;; (stop :high-chords-hold)

(pb :high-chords-with-pre-bar
  (pseq (list
         (pbind :dur (pseq (list (prest 4)) 1)) ; most awkward thing
         (pdef :high-chords-hold))
        1))

(pdef :total-base-section
      (ppar (list :full-bass-melody :high-chords-with-pre-bar)))
;; (play :total-base-section)
;; (stop :total-base-section)

;; well, it seems that with restarts defsynts of fmbass start playing worse?
;; responding less and less to short notes and legato?
;; is that due to not restarting sbcl?
;; let's try full restart

;;; I've done full restart, didn't totally help.
;; and I've set slower clock speed

;;; now, let's add intro, connection and ending?

(pb :intro
  :embed :chord-defs
  :dur (pseq (list 2 2 4) 1)
  :instrument :strings
  :amp 0.1
  :note (p+ (first *my-roots*) (pnary #'chord-notes (first *my-chords*))))
;; (play :intro)
;; (stop :intro)
;; (end :intro)
;; idea for not now - third chord make in two octaves?

;;; maybe add a scratch inbetween?
(pb :phrase-connection
  :instrument :fmbass
  :dur (pseq (list (prest 2) 12 (prest 4)) 1)
  :embed :chord-defs
  :octave 2
  :note (p+ (first *my-roots*) (pnary #'chord-notes (first *my-chords*)))
  )
;; (play :phrase-connection)
;; (stop :phrase-connection)

;;; for this to work, also evaluate ~/Documents/personal/common-lisp-study/music/dirty-journal/2022-09-09-maybe-cleanup-bass-from-chords.lisp
;; maybe later on cleanup I'd put everything into same file

(pdef :is-that-first-experiment
      (pseq (list (pdef :intro)
                  (pdef :total-base-section)
                  (pdef :phrase-connection)
                  (pdef :arpegios-and-bass))
            1))
;; (play :is-that-first-experiment)
;; (stop :is-that-first-experiment)
;; (end :is-that-first-experiment)

;; welp, when notes are too quick, they are not produced
;; and I also kind of wanted a percussion line, but oh well

;; ;;; ok, let's record that,

;; ;; we can write to buffer number out_buf_num by reading in from the 0 bus
;; (in-package cl-collider)
;; (defsynth disk_writer ((out_buf_num 99))
;;     (disk-out.ar out_buf_num (in.ar 0)))

;; (setf mybuffer (buffer-alloc (expt 2 17)))
;; mybuffer

;; ;; start a disk_writer synth
;; (setf writer_0 (synth 'disk_writer))

;; ;; make it output to buffer you allocated
;; (ctrl writer_0 :out_buf_num (bufnum mybuffer))

;; ;; continuously write the buffer contents to a file
;; ;; ;; IV V iii vi
;; ;; Am – F – C – G (i – VI – III – VII)
;; ;; i - III - iv - VI
;; (buffer-write mybuffer "/tmp/first-experiment-i-III-iv-VI.aiff" :leave-open-p t)

;; ;; now play whatever sounds you like

;; ;; e.g.
;; (in-package :cl-patterns)
;; (play :is-that-first-experiment)
;; (stop :is-that-first-experiment)
;; (end :is-that-first-experiment)

;; ;; then when you are done

;; (in-package cl-collider)
;; ;; stop the disk_writer synth
;; (free writer_0)

;; ;; close and free the buffer
;; (buffer-close mybuffer)
;; (buffer-free mybuffer)


;; ;; then you can play what you recorded with a utility like mpv:
;; ;;     mpv /tmp/foo.aiff