(module (downstroke scene-loader) *
  (import scheme
          (chicken base)
          (only srfi-1 filter-map)
          (prefix sdl2 "sdl2:")
          (prefix sdl2-ttf "ttf:")
          defstruct
          (downstroke tilemap)
          (downstroke world)
          (downstroke assets)
          (downstroke engine)
          (downstroke prefabs))


  ;; Convert TMX object list to entities.
  ;; Object types are strings from XML; convert to symbols before instantiating.
  ;; Filters out #f results (objects without registered prefabs).
  (define (tilemap-objects->entities tilemap registry)
    (filter-map
     (lambda (obj)
       (instantiate-prefab registry
                           (string->symbol (object-type obj))
                           (object-x obj) (object-y obj)
                           (object-width obj) (object-height obj)))
     (tilemap-objects tilemap)))

  ;; Create an SDL2 texture from a tileset's embedded image surface.
  (define (create-texture-from-tileset renderer tileset)
    (sdl2:create-texture-from-surface renderer (tileset-image tileset)))

  ;; Create an SDL2 texture from the tileset image embedded in a tilemap.
  (define (create-tileset-texture renderer tilemap)
    (create-texture-from-tileset renderer (tilemap-tileset tilemap)))

  ;; Load a TMX tilemap file and store it in the game asset registry.
  ;; Returns the loaded tilemap struct.
  (define (game-load-tilemap! game key filename)
    (let ((tm (load-tilemap filename)))
      (game-asset-set! game key tm)
      tm))

  ;; Load a TSX tileset file and store it in the game asset registry.
  ;; Returns the loaded tileset struct.
  (define (game-load-tileset! game key filename)
    (let ((ts (load-tileset filename)))
      (game-asset-set! game key ts)
      ts))

  ;; Load a TTF font file and store it in the game asset registry.
  ;; size is the point size. Returns the loaded font.
  (define (game-load-font! game key filename size)
    (let ((font (ttf:open-font filename size)))
      (game-asset-set! game key font)
      font))

  ;; Load a scene from a TMX tilemap file.
  ;; 1. Loads the tilemap from the file (and stores in assets)
  ;; 2. Creates a texture from the tilemap's tileset image
  ;; 3. Creates a scene with empty entities list
  ;; 4. Sets the scene on the game
  ;; Returns the scene.
  (define (game-load-scene! game filename)
    (let* ((tm    (game-load-tilemap! game 'tilemap filename))
           (tex   (create-tileset-texture (game-renderer game) tm))
           (scene (make-scene
                   entities:        '()
                   tilemap:         tm
                   tileset:         #f
                   camera:          (make-camera x: 0 y: 0)
                   tileset-texture: tex
                   camera-target:   #f)))
      (game-scene-set! game scene)
      scene))

  ;; Build a tilemap-less scene driven only by a tileset (for sprite-only
  ;; demos/games that don't need a TMX map). Any keyword accepted by
  ;; make-scene can be passed via #!rest to override defaults.
  (define (make-sprite-scene #!key
                             (entities        '())
                             (tileset         #f)
                             (tileset-texture #f)
                             (camera          (make-camera x: 0 y: 0))
                             (camera-target   #f)
                             (background      #f)
                             (engine-update   #f))
    (make-scene
     entities:        entities
     tilemap:         #f
     tileset:         tileset
     camera:          camera
     tileset-texture: tileset-texture
     camera-target:   camera-target
     background:      background
     engine-update:   engine-update))

  ) ;; end module