;; deps
(local levels (. (require "levels.fnl") :levels))
(local bump (require "bump"))

;; global vars
(var player-art nil) ; 25x50 pixels each player is 25x25
(var dust-sprite nil) ; 35x35 pixels
(var walls-sprite nil)
(var walls-batch nil)
(var wall-quads nil)
(local collider-debug-boxes [])
(local bump-world (bump.newWorld 25))
(local game-state {
  :player-pos [0 0]
  :player-dir :n ; n = north, s = south, e = east, w = west
  :level 1
  :world []
})

; (lambda gen-wall-colliders [x y tile-id]
;   (let [colliders (
;     (icollect [_ v (ipairs (. levels :level01 :wall-colliders)]

;       )]
;       (if (< 2 v) (* v v)))


;     )])


; )

(fn love.load []
  (love.window.setMode 600 640)

  ;; load world images
  (set walls-sprite (love.graphics.newImage "assets/walls.png"))
  (set walls-batch (love.graphics.newSpriteBatch walls-sprite 2500))

  ;; load wall quads
  (set wall-quads [])
  (let [(h w) (: walls-sprite :getDimensions)]
    (for [i 0 19 1]
      (table.insert wall-quads (love.graphics.newQuad (* i 25) 0 25 25 h w))))
  ;; load tiles
  (each [_ row (pairs (. levels :level01 :tiles))]
    (each [_ tile (pairs row)]
      (let [
        x (. tile :x)
        y (. tile :y)
        id (. tile :tile-id)
        colliders (or (. levels.level01.wall-colliders (- id 1)) [])]
      (walls-batch:add (. wall-quads id) x y)
      ; (print (fennel.view colliders))
      (each [_ collider (pairs colliders)]
        (bump-world:add {: x : y} (+ x collider.x) (+ y collider.y) collider.width collider.height)
        (table.insert
          collider-debug-boxes
          {:x (+ x collider.x) :y (+ y collider.y) :width collider.width :height collider.height})
        ))))

  (set player-art {
    :player-sprite (love.graphics.newImage "assets/player.png")
    :player1-quad (love.graphics.newQuad 0 0 25 25 50 25)
    :player2-quad (love.graphics.newQuad 25 0 25 25 50 25)
  })

  (set dust-sprite (love.graphics.newImage "assets/dust_001.png"))
  ; (print (fennel.view game-state))
  ;; start a thread listening on stdin
  (: (love.thread.newThread "require('love.event')
while 1 do love.event.push('stdin', io.read('*line')) end") :start))

(fn love.handlers.stdin [line]
  ;; evaluate lines read from stdin as fennel code
  (let [(ok val) (pcall fennel.eval line)]
    (print (if ok (fennel.view val) val))))



;; drawing
(lambda color [full-r full-g full-b]
  (let [(r g b) (love.math.colorFromBytes full-r full-g full-b)]
  [r g b]
))

(local off-white (color 237 230 200))
(local black [0 0 0])
(local black-half-tone [0 0 0 0.25])

(fn draw-world []
  (love.graphics.setColor 1 1 1)  ; reset color to white (no tinting)
  (love.graphics.draw walls-batch)
)

; (print (fennel.view game-state))
; (fn draw-player []
;   (love.graphics.setColor 1 1 1)  ; reset color to white (no tinting)
;   (let [ [player-x player-y] (. game-state :player-pos) ]
;     (love.graphics.draw
;       (. player-art :player-sprite)
;       (. player-art :player1-quad)
;       (+ (* 25 player-x) x-offset 25)
;       (+ (* 25 player-y) y-offset 25))))


(fn love.draw []
  ;; clear the screen and set bg to off white
  (love.graphics.clear)
  (draw-world)


  (love.graphics.setColor (unpack black))  ; reset color to white (no tinting)
  (each [_ collider (pairs collider-debug-boxes)]
    (love.graphics.rectangle "line" collider.x collider.y collider.width collider.height))
)
  ; (love.graphics.print "Hello from Fennel!\nPress any key to quit" 10 10))

(fn love.keypressed [key]
  nil
  ; (let [
  ;   [player-x player-y] (. game-state :player-pos)
  ;   [next-player-x next-player-y] (case key
  ;                     :left [(- player-x 1) player-y]
  ;                     :up [player-x (- player-y 1)]
  ;                     :right [(+ player-x 1) player-y]
  ;                     :down [player-x (+ player-y 1)]
  ;                     _ [player-x player-y])
  ;   next-cell (. game-state :world next-player-y next-player-x)
  ;   valid-move (not= :wall (. next-cell :type))
  ;   ]
  ;   (when valid-move
  ;     (tset game-state :player-pos [next-player-x next-player-y]))
  ;   (tset game-state :world next-player-y next-player-x :revealed true)
  ;   (case key
  ;     :left (tset game-state :player-dir :w)
  ;     :up  (tset game-state :player-dir :n)
  ;     :right (tset game-state :player-dir :e)
  ;     :down (tset game-state :player-dir :s)))
  )