#lang racket
(require xml)
(require xml/path)
(require racket/cmdline)
(require racket/string)

(require (planet dherman/json:4:=0))
(require (planet lizorkin/sxml:2:1/sxml))

(define verbose-mode (make-parameter #f))
(define input-file-name (make-parameter "input.dam"))
(define image-files-base-path (make-parameter "./images/"))
(define output-directory (make-parameter "./output/"))

(define (trace text)
  (cond [(verbose-mode)
         (display text)
         (display "\n")]))

;TODO: Перетасовать спрайты так, что бы они соответствовали атласам
(define (export-levels)
  (let* ([output-directory-path (normalize-path (output-directory))]
         [dame-sxml (sxml:document (input-file-name))]
         ;[sprite-atlas-list ((sxpath "project/spriteEntries/group/@name/text()") dame-sxml)]
         [sprite-global-list ((sxpath "project/spriteEntries/group") dame-sxml)]
         [layer-group-list ((sxpath "project/layers/group") dame-sxml)])
    ;Clean output directory
    (define (clean-output-directory)
      (if (not (directory-exists? output-directory-path))
          (make-directory output-directory-path)
          (void)))
    ;Test group export flag
    (define (export-layer-group? group)
      (equal? "true" (car ((sxpath "@exports/text()") group))))
    ;Export group list as separate files
    (define (export-layer-group-list layer-group-list)
      (for-each
       (lambda (group)
         (let* ([group-name (car ((sxpath "@name/text()") group))]
                [level-path (build-path output-directory-path (string-append group-name ".json"))]
                [level-output-port (open-output-file level-path #:mode 'text #:exists 'replace)])
           (define (get-layer-hasheq layer)
             ;Sprite layer generator
             (define (get-spritelayer-hasheq sprite-layer)
               (let* ([sprite-list ((sxpath "sprite") layer)]
                      [sprite-index-list (map (lambda (sprite) (car ((sxpath "@idx/text()") sprite))) sprite-list)]
                      [sprite-indeces (make-hash)]
                      [global-to-local-indeces (make-hash)]
                      [local-index 0])
                 ;Compress sprite indeces
                 (for-each
                  (lambda (sprite-index)
                    (hash-set! sprite-indeces sprite-index #t))
                  sprite-index-list)

                 ;Generate spriteList
                 (hash-for-each sprite-indeces
                                (lambda (key value)
                                  (set! local-index (+ 1 local-index))
                                  (hash-set! global-to-local-indeces key local-index)))

                 ;Generate sprite name list
                 (define layer-sprite-name-list
                   (hash-map sprite-indeces
                             (lambda
                                 (key value)
                               (car ((sxpath (string-append "sprite[@idx=\"" key "\"]/@name/text()")) sprite-global-list)))))

                 ;Generate places
                 (define sprite-places (append*
                                        (map
                                         (lambda (sprite index)
                                           (let ([local-index (hash-ref global-to-local-indeces index)]
                                                 [x (string->number (car ((sxpath "@x/text()") sprite)))]
                                                 [y (string->number (car ((sxpath "@y/text()") sprite)))])
                                             (list local-index x y)))
                                         sprite-list sprite-index-list)))


                 (trace global-to-local-indeces)
                 `#hasheq(
                          (type . "sprites")
                          (places . ,sprite-places)
                          (sprites . ,layer-sprite-name-list))))

             (let* ([layer-type (car layer)])
               (match layer-type
                 ;Export sprite layer
                 ['spritelayer (get-spritelayer-hasheq layer)]
                 ;Export map layer
                 ['maplayer `#hasheq(
                                     (type . "tiles")
                                     (width . ,(car ((sxpath "@width/text()") layer)))
                                     (height . ,(car ((sxpath "@height/text()") layer)))
                                     (image . ,(car ((sxpath "@name/text()") layer)))
                                     (tileWidth . ,(string->number (car ((sxpath "@tileWidth/text()") layer))))
                                     (tileHeight . ,(string->number (car ((sxpath "@tileHeight/text()") layer))))
                                     (tiles . ,(map string->number (regexp-split #rx"," (string-join ((sxpath "row/text()") layer) ",")))))]
                 ;Export shape layer
                 ['shapelayer #hasheq((type . "shapes"))]
                 ;Export path layer
                 ['pathlayer #hasheq((type . "paths"))])))

           (write-json
            `#hasheq((name . ,group-name)
                     (layers . ,(map get-layer-hasheq ((sxpath "spritelayer|maplayer|shapelayer|pathlayer[@exports=\"true\"]") group))))
            level-output-port)
           (trace group-name)
           (close-output-port level-output-port)))
       layer-group-list))

    (clean-output-directory)
    (export-layer-group-list (filter export-layer-group? layer-group-list))
    (trace "DONE")))


(command-line
 #:program "export"
 #:once-each
 [("-p") image-base "Chose path to images"
         (image-files-base-path image-base)]
 [("-i") in-file "Chose input DAME file (default input.dam)"
         (input-file-name in-file)]
 [("-v" "--verbose") "Export with verbose messages"
                     (verbose-mode #t)]
 [("-o") out-dir ""
         (output-directory out-dir)]
 #:args () (void)
 (export-levels))