(use traversal)
(use int-limits)
(use srfi-1)
(use qt-light)
(use utils)
(use gl)
;;;;;;;;;;;;;;;;;;;;;;;;;
;misc
(define (normalize val max)
  (/ val max)
  )

(define (scanl f init ls)
  (cons init
        (if (null? ls)
            '()
            (scanl f (f init (first ls)) (rest ls)))))

(define (vec-sum v1 v2)
  (list (+ (first v1) (first v2)) (+ (second v1) (second v2)))
  )
;;;;;;;;;;;;;;;;;;;;;;;;;
;rng stuff
(define rng_inited #f)
(define rng_seed 1)
(define (init-rng)
  (randomize rng_seed)
  (set! rng_inited #t))

(define (norm-rng) 
  (unless rng_inited (init-rng))
  (normalize (random most-positive-integer32) most-positive-integer32))

(define (genrn cnt)
  (list-tabulate cnt
    (lambda (i) (norm-rng))))

;;;;;;;;;;;;;;;;;;;;;;;;;
;random sampling processing

(define (p-action-idx rand interval-sizes interval-count)
  (define (p-action-index_ interval-sizes idx acc)
    (if (negative? (- acc (first interval-sizes))) 
        idx
        (p-action-index_ (rest interval-sizes) (+ 1 idx) (- acc (first interval-sizes))) ))
  
  (assert (= (length interval-sizes) interval-count) )
  (assert (= (sum interval-sizes) 1) )
  (p-action-index_ interval-sizes 0 rand))

;;;;;;;;;;;;;;;;;;;;;;;;;
;simulation procs

(define (simu-1d rands)
  (define (choose-step choice)
    (assert (<= 0 choice 1) )
    (case choice
      ((0) -1)
      ((1)  1) ))
  
  (let* ((init-pos 0)
         (p-interval-sizes '(0.5 0.5))
         (direction (lambda (rand) (choose-step (p-action-idx rand p-interval-sizes 2))))
         (steps (map direction rands)) )
    (scanl + init-pos steps)))

(define (simu-2d rands)
  (define (choose-step choice)
    (assert (<= 0 choice 3) )
    (case choice
      ((0) '(-1  0));left
      ((1) '( 0  1));up
      ((2) '( 1  0));right
      ((3) '( 0 -1)) ));down

  (let* ((init-pos '(0 0))
         (p-interval-sizes '(1/4 1/4 1/4 1/4))
         (direction (lambda (rand) (choose-step (p-action-idx rand p-interval-sizes 4))))
         (steps (map direction rands)) )
    (scanl vec-sum init-pos steps)))
;;;;;;;;;;;;;;;;;;;;;;;;;
;opengl

;;;;;;;;;;;;;;;;;;;;;;;;;
;gui
(define app (qt:init))
(define mainwindow (qt:widget (read-all "gui.ui")))

(define a 0)
(define b 0)
(define c 0)
(define av 0)
(define bv 0)
(define cv 0)

(let ((glparent (qt:find mainwindow "widget2"))
      (init (cut gl:ClearColor 0 1 0 1))
      (resize (lambda (w h)
                (when (zero? h) (set! h 1))
                (gl:Viewport 0 0 w h)
                (gl:MatrixMode gl:PROJECTION)
                (gl:LoadIdentity)
                (glu:Ortho2D -1 -1 1 1) ))
      (paint (lambda()
               (gl:Clear (bitwise-ior gl:COLOR_BUFFER_BIT gl:DEPTH_BUFFER_BIT))
               (gl:MatrixMode gl:MODELVIEW)
               (gl:LoadIdentity)
               (gl:Rotatef a b c 1)
               (gl:Begin gl:POLYGON)
               (gl:Vertex2f -0.5 -0.5)
               (gl:Vertex2f -0.5 0.5)
               (gl:Vertex2f 0.5 0.5)
               (gl:Vertex2f 0.5 -0.5)
               (gl:End) )))
  (define gl (qt:gl "glwidget" glparent init resize paint))
  (qt:layout-add-widget (qt:find mainwindow "vl5") gl)

  (define t (qt:timer 0.01))

  (qt:connect
   t "timeout()"
   (qt:receiver
    (lambda ()
      (set! a (+ a av))
      (set! b (+ b bv))
      (set! c (+ c cv))
      (qt:update gl) )))

  (qt:connect
   (qt:find mainwindow "horizontalSlider")
   "valueChanged(int)"
   (qt:receiver
    (lambda(value)
      (
       (print "a")
       (set! av value)
       ))))

  (qt:start t) )


(qt:show mainwindow)
(qt:run)

;;;;;;;;;;;;;;;;;;;;;;;;;
(define N 10)

(define (main)
  (define rands (genrn N))

  ;(simu-1d rands)
  (simu-2d rands)
  )
  
  
(print (main))