; octatonic scale for mapping use

(define octatonic (list 48 50 51 53 54 56 57 59 60 62 63 65 66 68 69 71 72 74 75 77 78 80 81 83 84))
(define rhythmic-scale (list 0.25 1.0 1.33 0.75))

(define (make-note pitch start length dynamic)
  (new midi 
    :time start
    :keynum pitch
    :duration length
    :amplitude dynamic))

; basic random walk

(define (random-walk start-value maximum-walk)
  (+ start-value (- (random (float (* maximum-walk 2)))
                    maximum-walk)))

; iteration of random walk into a list

(define (make-random-walk number-values start-value maximum-walk)
  (if (<= number-values 0)
    nil
    (let ((next-value (random-walk start-value maximum-walk)))
      (cons next-value
            (make-random-walk (- number-values 1) next-value maximum-walk)))))

; iteration with changing maximum amplitude

(define (make-walk-dynamic-maximum maxima-list start-value)
  (if (null? maxima-list)
    nil
    (let ((next-value (random-walk start-value (car maxima-list))))
      (cons next-value
            (make-walk-dynamic-maximum (cdr maxima-list) next-value)))))

; using iterated walk output to traverse a scale

(define (closest value lower-test higher-test)
  (cond ((> lower-test higher-test)
         (closest value higher-test lower-test))
        ((>= (- value lower-test)
             (- higher-test value))
         higher-test)
        (t lower-test)))

(define (map-element-to-scale value scale)
  (cond ((null? scale) nil)
        ((= (length scale) 1) (car scale))
        ((= (length scale) 2) (closest value (car scale) (cadr scale)))
        (t (map-helper value (car scale) (cdr scale)))))

(define (map-helper value best scale)
  (if (null? scale) 
    best
    (map-helper value (closest value best (car scale)) (cdr scale))))

(define (map-list-to-scale values scale)
  (if (null? values)
    nil
    (cons (map-element-to-scale (car values) scale)
          (map-list-to-scale (cdr values) scale))))

(map-list-to-scale (make-walk-dynamic-maximum (list 10 9 8 7 6 5 4 3 2 1) 60) octatonic)
  
; random walk applied to iteration of a gesture (as in GENDYN)

(define (random-walk-gesture gesture maximum-walk iterations)
  (if (<= iterations 0)
    nil
    (let ((next-gesture (make-gesture gesture maximum-walk)))
      (append next-gesture
              (random-walk-gesture next-gesture maximum-walk (- iterations 1))))))

(define (make-gesture gesture maximum-walk)
  (if (null? gesture)
    nil
    (cons (random-walk (car gesture) maximum-walk)
          (make-gesture (cdr gesture) maximum-walk))))