(import scheme
        (chicken base)
        (only srfi-1 iota map)
        (prefix sdl2 "sdl2:")
        (prefix sdl2-ttf "ttf:")
        (prefix sdl2-image "img:")
        downstroke-engine
        downstroke-world
        downstroke-tilemap
        downstroke-renderer
        downstroke-physics
        downstroke-entity
        downstroke-tween
        downstroke-scene-loader)

;; One row per easing symbol: #(entity tween left-x right-x ease-sym to-right?)
(define *ease-cells* #f)

(define *knock-ent* #f)
(define *knock-tw* #f)
(define *knock-cd* 0)

(define +knock-skip+
  '(jump acceleration gravity velocity-x velocity-y))

(define *ease-syms*
  '(linear quad-in quad-out quad-in-out cubic-in cubic-out cubic-in-out
    sine-in-out expo-in expo-out expo-in-out back-out))

(define *label-font* #f)
(define *title-font* #f)

(define +tile-ids+ '#(24 73 122 171 220))

(define (make-ease-cell ease-sym y tile-id)
  (let* ((left 20)
         (right (+ left 120))
         (ent (list #:type 'tween-demo #:x left #:y y #:width 14 #:height 14
                    #:vx 0 #:vy 0 #:gravity? #f #:solid? #f #:tile-id tile-id))
         (tw (make-tween ent props: `((#:x . ,right)) duration: 2600 ease: ease-sym)))
    (vector ent tw left right ease-sym #t)))

(define (advance-ease-cell! cell dt)
  (let ((ent (vector-ref cell 0))
        (tw (vector-ref cell 1))
        (left (vector-ref cell 2))
        (right (vector-ref cell 3))
        (ease (vector-ref cell 4))
        (to-right? (vector-ref cell 5)))
    (receive (tw2 ent2) (tween-step tw ent dt)
      (vector-set! cell 0 ent2)
      (cond ((tween-finished? tw2)
             (let* ((next-to-right? (not to-right?))
                    (target-x (if next-to-right? right left))
                    (tw3 (make-tween ent2 props: `((#:x . ,target-x))
                                     duration: 2600 ease: ease)))
               (vector-set! cell 1 tw3)
               (vector-set! cell 5 next-to-right?)))
            (else (vector-set! cell 1 tw2))))))

(define (update-knockback! dt tm)
  (set! *knock-cd* (+ *knock-cd* dt))
  (when (and *knock-ent* (not *knock-tw*) (>= *knock-cd* 3200))
    (set! *knock-cd* 0)
    (let ((x (entity-ref *knock-ent* #:x 0)))
      (set! *knock-ent* (entity-set *knock-ent* #:skip-pipelines +knock-skip+))
      (set! *knock-tw* (make-tween *knock-ent*
                      props: `((#:x . ,(+ x 88)))
                      duration: 650
                      ease: 'back-out
                      on-complete: (lambda (e)
                                     (set! *knock-ent* (entity-set e #:skip-pipelines '())))))))
  (when *knock-tw*
    (receive (t2 e2) (tween-step *knock-tw* *knock-ent* dt)
      (set! *knock-tw* (if (tween-finished? t2) #f t2))
      (set! *knock-ent* e2)))
  (when *knock-ent*
    (set! *knock-ent*
      (let* ((e *knock-ent*)
             (e (apply-jump e #f))
             (e (apply-acceleration e))
             (e (apply-gravity e))
             (e (apply-velocity-x e))
             (e (resolve-tile-collisions-x e tm))
             (e (apply-velocity-y e))
             (e (resolve-tile-collisions-y e tm))
             (e (detect-ground e tm)))
        e))))

(define (tweens-demo-render-labels! renderer)
  (let ((white (sdl2:make-color 255 255 255 255)))
    (draw-ui-text renderer *title-font*
      "Tween demo — easing rows + knockback / skip-pipelines" white 12 6)
    (draw-ui-text renderer *label-font*
      "Each box loops on X; bottom crate tweens right with physics integration skipped, tiles still collide."
      white 12 32)
    (do ((i 0 (+ i 1))) ((>= i (vector-length *ease-cells*)))
      (let* ((cell (vector-ref *ease-cells* i))
             (ent (vector-ref cell 0))
             (lab (symbol->string (vector-ref cell 4))))
        (draw-ui-text renderer *label-font* lab white 158 (- (entity-ref ent #:y 0) 2))))))

(define *game*
  (make-game
    title: "Demo: Tweens" width: 640 height: 480
    preload: (lambda (_game)
      (set! *title-font* (ttf:open-font "demo/assets/DejaVuSans.ttf" 22))
      (set! *label-font* (ttf:open-font "demo/assets/DejaVuSans.ttf" 13)))
    create: (lambda (game)
      (let ((scene (game-load-scene! game "demo/assets/level-0.tmx")))
        (set! *ease-cells*
          (list->vector
            (map (lambda (ease i)
                   (make-ease-cell ease (+ 52 (* i 20))
                     (vector-ref +tile-ids+ (modulo i (vector-length +tile-ids+)))))
                 *ease-syms*
                 (iota (length *ease-syms*)))))
        (set! *knock-ent*
          (list #:type 'knock-crate #:x 200 #:y 80 #:width 18 #:height 18
                #:vx 0 #:vy 0 #:gravity? #t #:on-ground? #f #:solid? #f #:tile-id 220))
        (set! *knock-tw* #f)
        (set! *knock-cd* 2500)
        (scene-entities-set! scene
          (append (map (lambda (i) (vector-ref (vector-ref *ease-cells* i) 0))
                       (iota (vector-length *ease-cells*)))
                  (list *knock-ent*)))))
    update: (lambda (game dt)
      (let* ((scene (game-scene game)) (tm (scene-tilemap scene)))
        (do ((i 0 (+ i 1))) ((>= i (vector-length *ease-cells*)))
          (advance-ease-cell! (vector-ref *ease-cells* i) dt))
        (update-knockback! dt tm)
        (scene-entities-set! scene
          (append (map (lambda (i) (vector-ref (vector-ref *ease-cells* i) 0))
                       (iota (vector-length *ease-cells*)))
                  (list *knock-ent*)))))
    render: (lambda (game)
      (tweens-demo-render-labels! (game-renderer game)))))

(game-run! *game*)