(import
 (owl toplevel)
 (owl random)
 (raylib))

(define width 800)
(define height 600)

(define circle-rad 11)

(define max-len 300)
(define speed 200)

(define points (map (lambda (x) (string->symbol (string-append "el-" (number->string x)))) (iota 0 1 128)))
(define connections
  (let loop ((n (length points)) (seed (seed->rands 2137)) (acc '()))
    (lets ((seed N (rand-range seed 1 8))
           (seed cpts (let L ((seed seed) (N N) (acc '()))
                        (lets ((seed pt (rand-range seed 0 (- (length points) 1))))
                              (if (= N 0)
                                  (values seed acc)
                                  (L seed (- N 1) (append acc (list pt))))))))
          (if (= n 0)
              acc
              (loop (- n 1) seed (append acc (list cpts)))))))
(define base-positions
  (let loop ((n (length points)) (seed (seed->rands 420)) (acc '()))
    (lets ((seed x (rand-range seed 0 width))
           (seed y (rand-range seed 0 height)))
      (if (= n 0)
          acc
          (loop (- n 1) seed (append acc (list (list x y))))))))

(define (vec2dist v1 v2)
  (isqrt (+ (* (- (car v1) (car v2)) (- (car v1) (car v2)))
            (* (- (cadr v1) (cadr v2)) (- (cadr v1) (cadr v2))))))

(define (vec2move-towards v target maxdist)
  (let* ((dx (- (car target) (car v)))
         (dy (- (cadr target) (cadr v)))
         (value (+ (* dx dx) (* dy dy))))
    (if (or (= value 0) (and (>= maxdist 0) (<= value (* maxdist maxdist))))
        target
        (let ((dist (isqrt (round value))))
          (list (ceiling (+ (car v) (/ dx (* dist maxdist))))
                (ceiling (+ (cadr v) (/ dy (* dist maxdist)))))))))

(define (draw-all-points positions)
  ;; connections behind points
  (for-each
   (lambda (n)
     (let ((pos (list-ref positions n)))
       (for-each
        (lambda (v)
          (let ((target (list-ref positions v)))
            (if (> (vec2dist pos target) max-len)
                (draw-line pos target orange)
                (draw-line pos target white))))
        (list-ref connections n))))
     (iota 0 1 (length positions)))

  (for-each
   (lambda (n)
     (let ((pos (list-ref positions n)))
       (draw-circle pos circle-rad red)))
   (iota 0 1 (length positions))))

(define (update-positions positions)
  (map
   (lambda (n)
     (let* ((pos (list-ref positions n))
            (lens (map (lambda (v) (vec2dist pos (list-ref positions v))) (list-ref connections n)))
            (max (let loop ((n 0) (max 0)) ;; max AT
                   (if (>= n (length lens))
                       max
                       (loop (+ n 1) (if (> (list-ref lens n) (list-ref lens max)) n max))))))
       (if (> (list-ref lens max) max-len)
           (vec2move-towards pos (list-ref positions (list-ref (list-ref connections n) max)) speed)
           pos)))
   (iota 0 1 (length positions))))

(lambda (_)
  (set-target-fps! 60)
  (with-window
   width height "hmmm"
   (let loop ((positions base-positions) (target-map '()))
     (let* ((positions (update-positions positions))
            (target-map (if (mouse-btn-down? mouse-button-left)
                            (if (null? target-map)
                                (map (lambda (p) (collision-point-circle? (mouse-pos) p circle-rad)) positions)
                                target-map)
                            null))
            (md (mouse-delta))
            (positions (if (mouse-btn-down? mouse-button-left)
                           (map (lambda (n) (let ((p (list-ref positions n)))
                                         (if (list-ref target-map n)
                                             (mouse-pos)
                                             p))) (iota 0 1 (length positions)))
                           positions)))
       (draw
        (clear-background black)
        (draw-all-points positions)
        (draw-fps '(0 0)))
       (if (window-should-close?)
           0
           (loop positions target-map))))))