(use
  lazy-seq)

; from doodle

(define doodle-width 800)
(define doodle-height 480)


; from fps

(define (translate x y pict)
  pict)

(define (pcompose . rest)
  rest)

(define (pt x y) (cons x y))
(define (add-pts x y) (cons (+ (car x) (car y))
                            (+ (cdr x) (cdr y))))
(define pi (* 2 (asin 1)))
(define 2pi (* 2 pi))


; from frp.scm

(define (translate-pt p pict)
  (translate (car p) (cdr p) pict))

(define (time-stream) (constantly 0.01))
(define (event-stream) lazy-null)

; Remove this when included in lazy-seq {{{
(define (lazy-reductions kons knil . streams)
  (letrec ((s (lazy-seq
                (cons knil
                      (apply lazy-map kons s streams)))))
    s))
; }}}

(define (make-clock time)
  (lazy-reductions + 0 time))

(define (constantly x)
  (letrec ((s (lazy-seq (cons x s))))
    s))


; from test.scm

(define (stranslate pts picture)
  (lazy-map translate-pt pts picture))

(define (scompose . seqs)
  (apply lazy-map pcompose seqs))

(define (red-square)
  (constantly (list 'square)))

(define (delayed n seq)
  (lazy-append (lazy-take n (constantly (lazy-head seq)))
               seq))

(define (make-squares n pos)
  (let loop ((p 0))
    (if (= p n)
      '()
      (cons (stranslate (delayed p pos) (red-square))
            (loop (add1 p))))))

(define (oscillator f amp freq clock)
  (lazy-map
    (lambda (t)
      (* amp (f (* t freq 2pi))))
    clock))


(define (scene time events)
  (print "building scene")
  (let* ((clock (make-clock time))
         (x-pos (oscillator sin 345 (/ 1 6) clock))
         (y-pos (oscillator sin 185 (/ 1 3) clock))
         (pos (lazy-map add-pts center (lazy-map pt x-pos y-pos)))
         (the-scene (apply scompose (make-squares 100 pos))))
    (print "done building scene")
    the-scene))


; Rendering

(define center
  (constantly (pt (/ doodle-width 2) (/ doodle-height 2))))

(define (render pict)
  (void pict)
  )

(lazy-each render
           (scene (time-stream) (event-stream)))