;;; -*- lexical-binding: t -*-
;;
;; https://dataswamp.org/~incal/bad-el/src/bad-sdl3/bad-sdl3.el

(require 'cl-lib)
(cl-pushnew ".." load-path :test #'string=)
(require 'luki-lisp)

(-> 'bad-ecs)
(defvar ecs-circles)
(defvar ecs-triangles)
(defvar ecs-overview-mode)

(let ((dm (@f "bad-sdl3%s" module-file-suffix)))
  (load dm nil t)
  (declare-function clear_frame       dm)
  (declare-function draw_all_toggle   dm)
  (declare-function draw_frame        dm)
  (declare-function draw_grid_toggle  dm)
  (declare-function draw_init         dm)
  (declare-function draw_quit         dm)
  (declare-function sdl_draw_circle   dm)
  (declare-function sdl_draw_triangle dm))

(defun bad-grid-string ()
  (cl-loop
   for s across-ref ecs-grid
   concat (concat s "\n") into str
   finally return str))

(defun bad-grid-string-set-to-buffer ()
  (cl-loop
   with lines   = (--- ecs-grid)
   with buf-str = (take lines (split-string (buffer-substring-no-properties (point-min) (point-max)) "\n"))
   for b in buf-str
   for s across-ref ecs-grid
   do (setf s b)))

(defun hz ()       (let ((current-time-list nil)) (cdr (time-convert nil nil))))
(defun time-now () (let ((current-time-list nil)) (1st (time-convert nil nil))))

(defun sdl3-fps ()
  (cl-loop
   with frames  = 2048
   with fps     = 60
   with hz      = (hz)
   with ticks   = (/ hz fps)
   with beg     = nil
   with slp     = 0
   with tslp    = 0
   with lne_beg = 12
   with hline   = (make-string 112 45)
   initially
     (ecs-init)
     (draw_init)
     (draw_grid_toggle)
     (setf beg (time-now))
   for f from 0 to frames
   for next = (+ beg (* (1+ f) ticks)) do
     (ecs-grid-clear 32)
     (setf (aref ecs-grid (+ lne_beg 0)) (@f "GNU Emacs %d.%d\n" emacs-major-version emacs-minor-version))
     (setf (aref ecs-grid (+ lne_beg 1)) (@f "%s\n" "dynamic module with SDL3"))
     (setf (aref ecs-grid (+ lne_beg 2)) (@f "%s\n" hline))
     (setf (aref ecs-grid (+ lne_beg 3)) (@f "frame %d / %d (%d%%)\n" f frames (round (* 100 (// f frames)))))
     (setf (aref ecs-grid (+ lne_beg 4)) (@f "%s\n" hline))
     (setf (aref ecs-grid (+ lne_beg 5)) (@f "fps (set to) %d\n" fps))
     (setf (aref ecs-grid (+ lne_beg 6)) (@f "fps (actual) %.3f\n" (// (* hz f) (- (time-now) beg))))
     (setf (aref ecs-grid (+ lne_beg 7)) (@f "surplus time / frame: %.3f seconds\n" (// tslp (1+ f))))
     (draw_frame)
     (setf slp (// (- next (time-now)) hz))
     (++ tslp slp)
     (sleep-for slp)
   finally
     (sleep-for 4)
     (draw_quit)))

(defun minimize-screen ()
  (setq mode-line-format nil)
  (fringe-mode 0)
  ;; BEG UGLY HACK
  (discard-input)
  (read-event nil nil 0.1)
  (message "")
  (set-frame-position nil 0 0)
  (let ((side 1))
    (set-frame-width  nil side nil t)
    (set-frame-height nil side nil t)))

(defun ecs-draw-triangles ()
  (cl-loop
   with (r1 g1 b1) = '(0.81 0.72 0.63)
   with (r2 g2 b2) = '(0.51 0.52 0.53)
   with (r3 g3 b3) = '(0.11 0.21 0.31)
   for (x  y  z ) in ecs-triangles
   for (x1 y1 z1) = x
   for (x2 y2 z2) = y
   for (x3 y3 z3) = z do
     (cl-assert (n  x1)) (cl-assert (n  y1)) (cl-assert (n  z1))
     (cl-assert (n  x2)) (cl-assert (n  y2)) (cl-assert (n  z2))
     (cl-assert (n  x3)) (cl-assert (n  y3)) (cl-assert (n  z3))
     (cl-assert (nf r1)) (cl-assert (nf g1)) (cl-assert (nf b1))
     (cl-assert (nf r2)) (cl-assert (nf g2)) (cl-assert (nf b2))
     (cl-assert (nf r3)) (cl-assert (nf g3)) (cl-assert (nf b3))
     (sdl_draw_triangle x1 y1 z1 x2 y2 z2 x3 y3 z3 r1 g1 b1 r2 g2 b2 r3 g3 b3)
    finally (setf ecs-triangles nil)))

(defun ecs-draw-circles ()
  (cl-loop
   for (x y rad r g b) in ecs-circles
   do (sdl_draw_circle x y rad r g b)
   finally (setf ecs-circles nil)))

(defun sdl3-solar ()
  (cl-loop
   with run       = t
   with fps       = 60
   with hz        = (hz)
   with ticks     = (/ hz fps)
   with frames    = 4096
   with circles   = t
   with triangles = nil
   with slp       = 0
   with tslp      = 0
   with beg       = nil
   initially
     (ecs-solar-init)
     (draw_init)
     (minimize-screen)
     (& triangles (M-triangle [11 12 13] [0 1 2] [3 4 5]))
     (& (nor circles triangles) (draw_grid_toggle))
     (setf beg (time-now))
   for f from 0 to frames
   for next = (+ beg (* (1+ f) ticks))
   while run do (pcase (& (input-pending-p) (read-event))
                  ;; quit
                  ((or ?q 13) (setf run nil))
                  ;; modes
                  (?1 (draw_all_toggle))
                  (?2 (setf ecs-overview-mode (! ecs-overview-mode)))
                  (?3 (setf circles           (! circles)))
                  (?4 (setf triangles         (! triangles)))
                  (?5 (draw_grid_toggle))
                  ;; roll
                  (?u (ecs-camera-roll-left))
                  (?o (ecs-camera-roll-right))
                  ;; move
                  ((or ?d ?l) (ecs-camera-move-right))
                  ((or ?a ?j) (ecs-camera-move-left))
                  ((or ?r ?p) (ecs-camera-move-up))
                  ((or ?f 59) (ecs-camera-move-down))
                  ((or ?w ?i) (ecs-camera-move-forward))
                  ((or ?s ?k) (ecs-camera-move-backward)))
     (clear_frame)
     (ecs-solar-update-and-render)
     (& triangles (ecs-draw-triangles))
     (& circles   (ecs-draw-circles))
     (draw_frame)
     (setf slp (// (- next (time-now)) hz))
     (incf tslp slp)
     (sit-for slp t)
   finally
     (draw_quit)
     (write-to-stdout (@f "sleep: %.4f s/frame\n" (/ tslp frames)))))

(defun write-to-stdout (str &optional append)
  (& (su str)
     (let ((file (file-name-concat "dev" "stdout")))
       (& (file-exists-p file)
          (write-region str append file)))))

(<- 'bad-sdl3)