(local pxl8 (require :pxl8))
(local effects (require :pxl8.effects))
(local net (require :pxl8.net))
(local sky (require :mod.sky))

(local bob-amount 4.0)
(local bob-speed 8.0)
(local cam-smoothing 0.25)
(local cell-size 64)
(local cursor-sensitivity 0.008)
(local gravity -800)
(local grid-size 64)
(local ground-y 64)
(local jump-force 175)
(local land-recovery-speed 20)
(local land-squash-amount -4)
(local max-pitch 1.5)
(local move-speed 200)
(local turn-speed 2.0)

(local sim-tick-rate 60)
(local sim-dt (/ 1.0 sim-tick-rate))
(local history-size 128)
(local correction-threshold 1.0)

(var auto-run? false)
(var auto-run-cancel-key nil)
(var bob-time 0)
(var cam-pitch 0)
(var cam-x 1000)
(var cam-y 64)
(var cam-yaw 0)
(var cam-z 1000)
(var camera nil)
(var cursor-look? true)
(var grounded? true)
(var land-squash 0)
(var light-time 0)
(var network nil)
(var smooth-cam-x 1000)
(var smooth-cam-z 1000)
(var velocity-y 0)
(var world nil)
(var fps-avg 0)
(var fps-sample-count 0)

(local FIREBALL_COLOR 184)

(fn init-fireball-palette []
  (for [i 0 7]
    (let [t (/ i 7)
          r (math.floor (+ 0xFF (* t 0)))
          g (math.floor (+ 0x60 (* t (- 0xE0 0x60))))
          b (math.floor (+ 0x10 (* t (- 0x80 0x10))))]
      (pxl8.set_palette_rgb (+ FIREBALL_COLOR i) r g b))))

(var client-tick 0)
(var last-processed-tick 0)
(var time-accumulator 0)
(var position-history {})
(var pending-inputs {})

(fn history-idx [tick]
  (+ 1 (% tick history-size)))

(fn store-position [tick x z yaw]
  (tset position-history (history-idx tick) {:tick tick :x x :z z :yaw yaw}))

(fn get-position [tick]
  (let [entry (. position-history (history-idx tick))]
    (when (and entry (= entry.tick tick))
      entry)))

(fn store-pending-input [tick input]
  (tset pending-inputs (history-idx tick) {:tick tick :input input}))

(fn get-pending-input [tick]
  (let [entry (. pending-inputs (history-idx tick))]
    (when (and entry (= entry.tick tick))
      entry.input)))

(fn apply-movement [x z yaw input]
  (var new-x x)
  (var new-z z)

  (let [move-forward (or input.move_y 0)
        move-right (or input.move_x 0)]
    (when (or (not= move-forward 0) (not= move-right 0))
      (let [forward-x (- (math.sin yaw))
            forward-z (- (math.cos yaw))
            right-x (math.cos yaw)
            right-z (- (math.sin yaw))
            len (math.sqrt (+ (* move-forward move-forward) (* move-right move-right)))
            norm-forward (/ move-forward len)
            norm-right (/ move-right len)
            move-delta (* move-speed sim-dt)]
        (set new-x (+ new-x (* move-delta (+ (* forward-x norm-forward) (* right-x norm-right)))))
        (set new-z (+ new-z (* move-delta (+ (* forward-z norm-forward) (* right-z norm-right))))))))

  (values new-x new-z))
(fn init []
  (set camera (pxl8.create_camera_3d))
  (set world (pxl8.create_world))
  (sky.generate-stars 12345)
  (init-fireball-palette)

  (set network (net.Net.new {:port 7777}))
  (when network
    (network:connect)
    (network:spawn cam-x cam-y cam-z cam-yaw cam-pitch))

  (let [result (world:generate {
                 :type pxl8.PROCGEN_ROOMS
                 :width 64
                 :height 64
                 :seed 42
                 :min_room_size 5
                 :max_room_size 10
                 :num_rooms 20})]
    (if (< result 0)
        (pxl8.error (.. "Failed to generate rooms - result: " result))
        (let [floor-tex (pxl8.procgen_tex {:name "floor"
                                           :seed 11111
                                           :width 64
                                           :height 64
                                           :base_color 19})
            wall-tex (pxl8.procgen_tex {:name "wall"
                                        :seed 12345
                                        :width 64
                                        :height 64
                                        :base_color 4})
            sky-tex (pxl8.create_texture [0] 1 1)]

        (let [result (world:apply_textures [
                       {:name "floor"
                        :texture_id floor-tex
                        :rule (fn [normal] (> normal.y 0.7))}
                       {:name "ceiling"
                        :texture_id sky-tex
                        :rule (fn [normal] (< normal.y -0.7))}
                       {:name "wall"
                        :texture_id wall-tex
                        :rule (fn [normal] (and (<= normal.y 0.7) (>= normal.y -0.7)))}])]
          (when (< result 0)
            (pxl8.error (.. "Failed to apply textures - result: " result))))))))

(fn sample-input []
  (var move-forward 0)
  (var move-right 0)

  (when (pxl8.key_pressed "`")
    (set auto-run? (not auto-run?))
    (when (and auto-run? (pxl8.key_down "w"))
      (set auto-run-cancel-key "w")))
  (when (and auto-run? (not auto-run-cancel-key) (or (pxl8.key_down "w") (pxl8.key_down "s")))
    (set auto-run? false)
    (when (pxl8.key_down "s")
      (set auto-run-cancel-key "s")))
  (when (and auto-run-cancel-key (not (pxl8.key_down auto-run-cancel-key)))
    (set auto-run-cancel-key nil))

  (when (or (pxl8.key_down "w") auto-run?)
    (set move-forward (+ move-forward 1)))
  (when (and (pxl8.key_down "s") (not= auto-run-cancel-key "s"))
    (set move-forward (- move-forward 1)))
  (when (pxl8.key_down "a")
    (set move-right (- move-right 1)))
  (when (pxl8.key_down "d")
    (set move-right (+ move-right 1)))

  {:move_x move-right
   :move_y move-forward
   :look_dx (pxl8.mouse_dx)
   :look_dy (pxl8.mouse_dy)})

(fn reconcile [server-tick server-x server-z]
  (let [predicted (get-position server-tick)]
    (when predicted
      (let [dx (- predicted.x server-x)
            dz (- predicted.z server-z)
            error (math.sqrt (+ (* dx dx) (* dz dz)))]
        (when (> error correction-threshold)
          (set cam-x server-x)
          (set cam-z server-z)

          (for [t (+ server-tick 1) client-tick]
            (let [input (get-pending-input t)
                  hist (get-position t)]
              (when (and input hist)
                (let [(new-x new-z) (apply-movement cam-x cam-z hist.yaw input)]
                  (set cam-x new-x)
                  (set cam-z new-z)
                  (store-position t cam-x cam-z hist.yaw))))))))))

(fn update [dt]
  (let [fps (pxl8.get_fps)]
    (set fps-sample-count (+ fps-sample-count 1))
    (set fps-avg (+ (* fps-avg (/ (- fps-sample-count 1) fps-sample-count))
                    (/ fps fps-sample-count)))
    (when (>= fps-sample-count 120)
      (set fps-sample-count 0)
      (set fps-avg 0)))

  (when (world:is_loaded)
    (let [input (sample-input)
          grid-max (* grid-size cell-size)
          movement-yaw cam-yaw]

      (set time-accumulator (+ time-accumulator dt))

      (while (>= time-accumulator sim-dt)
        (set time-accumulator (- time-accumulator sim-dt))
        (set client-tick (+ client-tick 1))

        (store-pending-input client-tick input)

        (let [(new-x new-z) (apply-movement cam-x cam-z movement-yaw input)]
          (when (and (>= new-x 0) (<= new-x grid-max)
                     (>= new-z 0) (<= new-z grid-max))
            (let [(resolved-x _ resolved-z) (world:resolve_collision cam-x cam-y cam-z new-x cam-y new-z 5)]
              (set cam-x resolved-x)
              (set cam-z resolved-z)))

          (store-position client-tick cam-x cam-z movement-yaw)))

      (when cursor-look?
        (set cam-yaw (- cam-yaw (* input.look_dx cursor-sensitivity)))
        (set cam-pitch (math.max (- max-pitch)
                                 (math.min max-pitch
                                           (- cam-pitch (* input.look_dy cursor-sensitivity))))))

      (when (and (not cursor-look?) (pxl8.key_down "up"))
        (set cam-pitch (math.min max-pitch (+ cam-pitch (* turn-speed dt)))))
      (when (and (not cursor-look?) (pxl8.key_down "down"))
        (set cam-pitch (math.max (- max-pitch) (- cam-pitch (* turn-speed dt)))))
      (when (and (not cursor-look?) (pxl8.key_down "left"))
        (set cam-yaw (+ cam-yaw (* turn-speed dt))))
      (when (and (not cursor-look?) (pxl8.key_down "right"))
        (set cam-yaw (- cam-yaw (* turn-speed dt))))

      (when network
        (let [(ok err) (pcall (fn []
                                (network:send_input {:move_x input.move_x
                                                     :move_y input.move_y
                                                     :look_dx input.look_dx
                                                     :look_dy input.look_dy
                                                     :yaw movement-yaw
                                                     :tick client-tick})
                                (network:update dt)
                                (when (network:poll)
                                  (let [snapshot (network:snapshot)]
                                    (when (and snapshot (> snapshot.tick last-processed-tick))
                                      (set last-processed-tick snapshot.tick)
                                      (let [player-id (network:player_id)]
                                        (when (> player-id 0)
                                          (let [curr (network:entity_userdata player-id)]
                                            (when curr
                                              (let [srv-x (pxl8.unpack_f32_be curr 0)
                                                    srv-z (pxl8.unpack_f32_be curr 8)]
                                                (reconcile snapshot.tick srv-x srv-z)))))))))))]
          (when (not ok)
            (pxl8.error (.. "Network error: " err)))))

      (set smooth-cam-x (+ (* smooth-cam-x (- 1 cam-smoothing)) (* cam-x cam-smoothing)))
      (set smooth-cam-z (+ (* smooth-cam-z (- 1 cam-smoothing)) (* cam-z cam-smoothing)))

      (when (and (pxl8.key_pressed "space") grounded?)
        (set velocity-y jump-force)
        (set grounded? false))

      (set velocity-y (+ velocity-y (* gravity dt)))
      (set cam-y (+ cam-y (* velocity-y dt)))

      (when (<= cam-y ground-y)
        (when (not grounded?)
          (set land-squash land-squash-amount))
        (set cam-y ground-y)
        (set velocity-y 0)
        (set grounded? true))

      (when (< land-squash 0)
        (set land-squash (math.min 0 (+ land-squash (* land-recovery-speed dt)))))

      (let [moving (or (not= input.move_x 0) (not= input.move_y 0))]
        (if (and moving grounded?)
            (set bob-time (+ bob-time (* dt bob-speed)))
            (let [target-phase (* (math.floor (/ bob-time math.pi)) math.pi)]
              (set bob-time (+ (* bob-time 0.8) (* target-phase 0.2))))))

      (set light-time (+ light-time (* dt 0.15))))))

(fn frame []
  (pxl8.clear 1)

  (when (not camera)
    (pxl8.error "camera is nil!"))

  (when (not world)
    (pxl8.error "world is nil!"))

  (when (and world (not (world:is_loaded)))
    (pxl8.text "World not loaded yet..." 5 30 12))

  (when (and camera world (world:is_loaded))
    (let [bob-offset (* (math.sin bob-time) bob-amount)
          eye-y (+ cam-y bob-offset land-squash)
          forward-x (- (math.sin cam-yaw))
          forward-z (- (math.cos cam-yaw))
          target-x (+ smooth-cam-x forward-x)
          target-y (+ eye-y (math.sin cam-pitch))
          target-z (+ smooth-cam-z forward-z)
          aspect (/ (pxl8.get_width) (pxl8.get_height))]

      (camera:lookat [smooth-cam-x eye-y smooth-cam-z]
                     [target-x target-y target-z]
                     [0 1 0])
      (camera:set_perspective 1.047 aspect 1.0 4096.0)

      (let [light-pulse (+ 0.7 (* 0.3 (math.sin (* light-time 2))))
            forward-x (- (math.sin cam-yaw))
            forward-z (- (math.cos cam-yaw))
            light-x (+ smooth-cam-x (* 150 forward-x) (* 50 (math.cos light-time)))
            light-z (+ smooth-cam-z (* 150 forward-z) (* 50 (math.sin light-time)))
            light-y (+ eye-y 30)]
        (pxl8.begin_frame_3d camera {
          :ambient 80
          :celestial_dir [0.5 -0.8 0.3]
          :celestial_intensity 0.5
          :lights [{:x light-x :y light-y :z light-z
                    :r 255 :g 200 :b 150
                    :intensity (* 255 light-pulse)
                    :radius 400}]})
        (pxl8.clear_depth)

        (sky.update-gradient 1 2 6 6 10 18)
        (sky.render smooth-cam-x eye-y smooth-cam-z)
        (pxl8.clear_depth)

        (world:render [smooth-cam-x eye-y smooth-cam-z])

        (pxl8.end_frame_3d)

        (let [dx (- light-x smooth-cam-x)
              dy (- light-y eye-y)
              dz (- light-z smooth-cam-z)
              dist (math.sqrt (+ (* dx dx) (* dy dy) (* dz dz)))]
          (when (> dist 1)
            (let [inv-dist (/ 1 dist)
                  dir-x (* dx inv-dist)
                  dir-y (* dy inv-dist)
                  dir-z (* dz inv-dist)
                  cos-yaw (math.cos cam-yaw)
                  sin-yaw (math.sin cam-yaw)
                  cos-pitch (math.cos cam-pitch)
                  sin-pitch (math.sin cam-pitch)
                  rx (+ (* dir-x cos-yaw) (* dir-z sin-yaw))
                  rz (+ (* (- dir-x) sin-yaw) (* dir-z cos-yaw))
                  ry (- (* dir-y cos-pitch) (* rz sin-pitch))
                  fz (+ (* dir-y sin-pitch) (* rz cos-pitch))]
              (when (> fz 0.01)
                (let [width (pxl8.get_width)
                      height (pxl8.get_height)
                      fov 1.047
                      half-fov-tan (math.tan (* fov 0.5))
                      ndc-x (/ rx (* fz half-fov-tan aspect))
                      ndc-y (/ ry (* fz half-fov-tan))
                      sx (math.floor (* (+ 1 ndc-x) 0.5 width))
                      sy (math.floor (* (- 1 ndc-y) 0.5 height))
                      screen-size (/ 400 dist)
                      base-radius (math.max 2 (math.min 12 (math.floor screen-size)))
                      pulse-int (math.floor (* 180 light-pulse))]
                  (when (and (>= sx 0) (< sx width) (>= sy 0) (< sy height))
                    (effects.glows [
                      {:x sx :y sy :radius (+ base-radius 2) :intensity (/ pulse-int 5) :color (+ FIREBALL_COLOR 1) :shape effects.GLOW_CIRCLE}
                      {:x sx :y sy :radius base-radius :intensity pulse-int :color (+ FIREBALL_COLOR 5) :shape effects.GLOW_DIAMOND}]))))))))

      (sky.render-stars cam-yaw cam-pitch 1.0)

      (let [cx (/ (pxl8.get_width) 2)
            cy (/ (pxl8.get_height) 2)
            crosshair-size 4
            red-color 18]
        (pxl8.line (- cx crosshair-size) cy (+ cx crosshair-size) cy red-color)
        (pxl8.line cx (- cy crosshair-size) cx (+ cy crosshair-size) red-color))

      (pxl8.text (.. "fps: " (string.format "%.0f" fps-avg)) 5 5 12)
      (pxl8.text (.. "pos: " (string.format "%.0f" cam-x) ","
                     (string.format "%.0f" cam-y) ","
                     (string.format "%.0f" cam-z)) 5 15 12))))

{:init init
 :update update
 :frame frame}