(local state (require :lib.state))
(local cell (require :lib.cell))
(local cells (require :lib.cells))
(local fv (require :fennel.view))

(fn lerp* [a b c d x]
  (+ c (* (/ (- x a) (- b a)) (- d c))))

(fn vec-sub [a b]
  {:x (- a.x b.x)
   :y (- a.y b.y)})

(fn vec-lerp* [a b c d x]
  {:x (lerp* a.x b.x c.x d.x x.x)
    :y (lerp* a.y b.y c.y d.y x.y)})

(fn new-grid [w h f]
  (var t {})
  (for [x 0 (- w 1)]
    (tset t x {})
    (for [y 0 (- h 1)]
      (tset (. t x) y (f x y))))
  t)

(fn update [self]
  (set self.ship.x (+ self.ship.x 0.02))
  (set self.ship.y (+ self.ship.y 0.005))
  (set self.radius (lerp* 0 1 self.radius self.target-radius 0.3))
  (when (= self.tick 0)
    (for [x 0 (- self.width 1)]
      (for [y 0 (- self.height 1)]
        (fn get [v]
          (. self.grid
             (% (+ v.x x) self.width)
             (% (+ v.y y) self.height)))
        (if (. self.grid x y)
            ;; check if alive
            (tset self.grid-alt x y (cell.update (. self.grid x y)
                                                 get))
            ;; check for neighbors and then use one at random
            (do
              (var neighbors [])
              (for [x -1 1]
                (for [y -1 1]
                  (table.insert neighbors (get {: x : y}))))
              (if (. neighbors 1)
                  (tset self.grid-alt x y
                        (cell.birth (. neighbors (math.random (length neighbors))) get))
                  (tset self.grid-alt x y nil))))))
    (set (self.grid self.grid-alt) (values self.grid-alt self.grid)))
    ;; TODO
  (set self.tick (% (+ self.tick 1) self.rate)))

(fn id [x] x)

(fn draw [self]
  (local (width height) (love.graphics.getDimensions))
  ;; (love.graphics.scale width height)
  (let [camera-size (math.min width height)
        radius-x (* self.radius (/ width camera-size))
        radius-y (* self.radius (/ height camera-size))
        clipped-x (math.min radius-x self.max-radius)
        clipped-y (math.min radius-y self.max-radius)
        display-a {:x (* width (- 1 (/ clipped-x radius-x)) 0.5)
                   :y (* height (- 1 (/ clipped-y radius-y)) 0.5)}
        display-b {:x (- width display-a.x) :y (- height display-a.y)}
        display-size (vec-sub display-b display-a)
        camera-a {:x (- self.ship.x clipped-x)
                  :y (- self.ship.y clipped-y)}
        camera-b {:x (+ self.ship.x clipped-x)
                  :y (+ self.ship.y clipped-y)}
        cell-box (vec-lerp* {:x 0 :y 0}
                            {:x (* 2 clipped-x)
                             :y (* 2 clipped-y)}
                            ;; TODO: this is wrong
                            {:x 0 :y 0}
                            display-size
                            {:x 1 :y 1})]
    (love.graphics.setScissor (- display-a.x 1) (- display-a.y 1)
                              (- display-b.x display-a.x -2)
                              (- display-b.y display-a.y -2))
    (love.graphics.setColor 0.2 0.2 0.2)
    (love.graphics.setLineWidth 4)
    (love.graphics.rectangle :line
                             display-a.x display-a.y
                             (- display-b.x display-a.x)
                             (- display-b.y display-a.y))
    (love.graphics.setScissor display-a.x display-a.y
                              (- display-b.x display-a.x)
                              (- display-b.y display-a.y))
    (love.graphics.clear)
    (for [x (math.floor camera-a.x) (math.floor camera-b.x)]
      (for [y (math.floor camera-a.y) (math.floor camera-b.y)]
        (let [vec {:x (% x self.width) :y (% y self.height)}
              render-a (vec-lerp* camera-a camera-b display-a display-b
                                  {: x : y})
              render-b (vec-lerp* camera-a camera-b display-a display-b
                                  {:x (+ x 1) :y (+ y 1)})
              the (. self.grid vec.x vec.y)
              color (and the (cell.color the))]
          (when color
            (love.graphics.setColor (unpack color))
            (love.graphics.rectangle :fill
                                     (id render-a.x)
                                     (id render-a.y)
                                     (id cell-box.x)
                                     (id cell-box.y))))))
    ;; draw other stuff
    ))
    ;; (love.graphics.setLineWidth 0.1)
    ;; (love.graphics.line 0 0 0.3 0.3)
    ;; (love.graphics.polygon :line 0.3 0.3 0.6 0.3 0.4 0.6)
    ;; (love.graphics.line 0.4 0.8 0.4 0.8)
    ;; (love.graphics.print :Gaming))

(fn keypressed [self key scancode repeat]
  (when (= key "=")
    (set self.target-radius
         (math.max
           self.min-radius
           (math.min
             self.max-radius
             (- self.target-radius 4)))))
  (when (= key "-")
    (set self.target-radius
         (math.max
           self.min-radius
           (math.min
             self.max-radius
             (+ self.target-radius 4))))))

(fn init [self]
  (local width 64)
  (local height 64)
  (setmetatable
    {:width width
     :height height
     :ship {:x 31 :y 31}
     :radius 32
     :target-radius 32
     :max-radius (/ (math.min height width) 2)
     :min-radius 16
     :tick 0
     :rate 6
     :grid (new-grid width height #(if (= (math.random 6) 1)
                                (if (< $1 52)
                                    (cell.init cells.life)
                                    (cell.init cells.brain))
                                nil))
     :grid-alt (new-grid width height #nil)
     }
    self))

{state.draw draw state.init init state.update update state.keypressed keypressed}