%% ChordPro Export Engraver
%% =========================
%% Single engraver in Score context that collects all data

#(use-modules (ice-9 format))
#(use-modules (srfi srfi-1))

%% Helper function to convert German minor chord notation to standard major form
%% Used for generating {define:} directives
#(define (german-minor-to-major-form chord-str)
  "Convert lowercase German minor chords (e.g., 'a7', 'fis') to standard form (e.g., 'Am7', 'Fism')"
  (if (or (not (string? chord-str)) (string-null? chord-str))
      chord-str
      (let* ((first-char (string-ref chord-str 0)))
        (if (char-lower-case? first-char)
            ;; It's a minor chord - capitalize first letter and add 'm' after accidentals
            (let* ((rest-str (if (> (string-length chord-str) 1)
                                (substring chord-str 1)
                                ""))
                   ;; Find where to insert 'm': after 'is' or 'es' if present, otherwise right after root
                   (insert-pos (cond
                                ((string-prefix? "is" rest-str) 2)
                                ((string-prefix? "es" rest-str) 2)
                                (else 0)))
                   (before-m (substring rest-str 0 insert-pos))
                   (after-m (substring rest-str insert-pos)))
              (string-append (string (char-upcase first-char)) before-m "m" after-m))
            ;; Already uppercase - return as is
            chord-str))))

%% Helper function to convert German accidentals to international format
#(define (german-accidentals-to-international chord-str)
  "Convert German 'is' to '#' and 'es' to 'b' (e.g., 'fis' -> 'F#', 'as' -> 'Ab')"
  (if (or (not (string? chord-str)) (string-null? chord-str))
      chord-str
      (let* ((first-char (string-ref chord-str 0))
             (rest-str (if (> (string-length chord-str) 1)
                          (substring chord-str 1)
                          ""))
             ;; Check for 'is' (sharp) or 'es' (flat)
             (has-is (string-prefix? "is" rest-str))
             (has-es (string-prefix? "es" rest-str))
             ;; Convert root note
             (root-upper (string (char-upcase first-char)))
             ;; Process accidentals and rest
             (processed-rest
               (cond
                (has-is  ; fis -> F#, cis -> C#
                 (string-append "#" (substring rest-str 2)))
                (has-es  ; as -> Ab, es -> Eb
                 (string-append "b" (substring rest-str 2)))
                (else rest-str))))
        ;; Special case: if it's a minor chord (lowercase), add 'm' after accidental
        (if (char-lower-case? first-char)
            ;; Minor: add 'm' after accidental
            (if (or has-is has-es)
                (string-append root-upper (substring processed-rest 0 1) "m" (substring processed-rest 1))
                (string-append root-upper "m" processed-rest))
            ;; Major: just return converted
            (string-append root-upper processed-rest)))))

%% Helper function to convert B/b chords to Bb/Bbm form for {define:} directives
#(define (german-b-to-bb-form chord-str)
  "Convert B/b chords to Bb/Bbm format (e.g., 'B7' -> 'Bb7', 'b' -> 'Bbm', 'b7' -> 'Bbm7')"
  (if (or (not (string? chord-str)) (string-null? chord-str))
      chord-str
      (let ((first-char (string-ref chord-str 0)))
        (cond
         ;; Uppercase B -> Bb + rest
         ((char=? first-char #\B)
          (string-append "Bb" (substring chord-str 1)))
         ;; Lowercase b -> Bbm + rest (it's b-minor)
         ((char=? first-char #\b)
          (let ((rest-str (if (> (string-length chord-str) 1)
                             (substring chord-str 1)
                             "")))
            (string-append "Bbm" rest-str)))
         (else chord-str)))))

%% Helper function to convert H/h chords to B/Bm form for {define:} directives
#(define (german-h-to-b-form chord-str)
  "Convert H/h chords to B/Bm format (e.g., 'H7' -> 'B7', 'h' -> 'Bm', 'h7' -> 'Bm7')"
  (if (or (not (string? chord-str)) (string-null? chord-str))
      chord-str
      (let ((first-char (string-ref chord-str 0)))
        (cond
         ;; Uppercase H -> B + rest
         ((char=? first-char #\H)
          (string-append "B" (substring chord-str 1)))
         ;; Lowercase h -> Bm + rest (it's h-minor)
         ((char=? first-char #\h)
          (let ((rest-str (if (> (string-length chord-str) 1)
                             (substring chord-str 1)
                             "")))
            (string-append "Bm" rest-str)))
         (else chord-str)))))

%% Helper function to track minor/B/H/accidental chords and return original
#(define (track-and-return-chord chord-str)
  "Track chords that need {define:} directives and return original."
  (if (or (not (string? chord-str)) (string-null? chord-str))
      chord-str
      (let* ((first-char (string-ref chord-str 0))
             (rest-str (if (> (string-length chord-str) 1)
                          (substring chord-str 1)
                          ""))
             (has-is (string-prefix? "is" rest-str))
             (has-es (string-prefix? "es" rest-str))
             (has-accidental (or has-is has-es)))
        (cond
         ;; H/h chords (German H = English B)
         ((char=? first-char #\H)
          (unless (member chord-str chordpro-h-chords-used)
            (set! chordpro-h-chords-used (cons chord-str chordpro-h-chords-used))))
         ((char=? first-char #\h)
          (unless (member chord-str chordpro-h-chords-used)
            (set! chordpro-h-chords-used (cons chord-str chordpro-h-chords-used))))
         
         ;; B/b chords (German B = English Bb)
         ((char=? first-char #\B)
          (unless (member chord-str chordpro-b-chords-used)
            (set! chordpro-b-chords-used (cons chord-str chordpro-b-chords-used))))
         ((char=? first-char #\b)
          (unless (member chord-str chordpro-b-chords-used)
            (set! chordpro-b-chords-used (cons chord-str chordpro-b-chords-used))))
         
         ;; Chords with accidentals (is/es)
         (has-accidental
          (unless (member chord-str chordpro-accidental-chords-used)
            (set! chordpro-accidental-chords-used (cons chord-str chordpro-accidental-chords-used))))
         
         ;; Other lowercase chords (minor without B/H/accidentals)
         ((char-lower-case? first-char)
          (unless (member chord-str chordpro-minor-chords-used)
            (set! chordpro-minor-chords-used (cons chord-str chordpro-minor-chords-used)))))
        
        ;; Always return original
        chord-str)))

%% Helper function to convert chord music object to chord name string
#(define (music-to-chord-name chord-music)
  "Extract pitches from a chord music object and convert to German chord name"
  (if (not chord-music)
      ""
      (let* ((pitches (music-pitches chord-music)))
        (if (or (not pitches) (null? pitches))
            ""  ; No pitches found
            (let* (;; Use ignatzek chord naming with German root names
                   (chord-markup ((chord-name:name-markup 'deutsch) pitches #f #f #f))
                   ;; Convert markup to string
                   (chord-str (if (markup? chord-markup)
                                 (markup->string chord-markup)
                                 ""))
                   ;; Remove spaces
                   (cleaned (string-delete #\space chord-str)))
              cleaned)))))

%% Helper function to normalize multiple spaces to single space
#(define (normalize-spaces str)
  "Replace multiple consecutive spaces with a single space"
  (let loop ((chars (string->list str))
             (result '())
             (prev-was-space #f))
    (if (null? chars)
        (list->string (reverse result))
        (let ((char (car chars)))
          (if (char=? char #\space)
              (if prev-was-space
                  ;; Skip this space
                  (loop (cdr chars) result #t)
                  ;; Keep this space
                  (loop (cdr chars) (cons char result) #t))
              ;; Not a space
              (loop (cdr chars) (cons char result) #f))))))

%% Helper function to extract chord names from markup, handling \altChord format
#(define (extract-chord-names-from-markup markup)
  "Extract chord names from markup, handling complex structures like \altChord which produces 'B(Gm)' format"
  (let* ((raw-str (cond
                    ((string? markup) markup)
                    ((markup? markup) (markup->string markup))
                    ((pair? markup) (extract-chord-names-from-markup (car markup)))
                    (else (format #f "~a" markup))))
         ;; Remove all spaces
         (clean-str (string-delete #\space raw-str)))
    ;; Check if this is an altChord format: "B(Gm)" or similar
    (if (string-index clean-str #\()
        ;; Multiple chords: split by parentheses
        (let* ((open-paren (string-index clean-str #\())
               (close-paren (string-index clean-str #\)))
               (first-chord (substring clean-str 0 open-paren))
               (second-chord (if (and open-paren close-paren)
                                (substring clean-str (+ open-paren 1) close-paren)
                                "")))
          ;; Format as:[B][(Gm)] - first chord normal, second in parens
          (string-append first-chord "][(" second-chord ")"))
        ;; Single chord: return as is
        clean-str)))

%% Global state - shared across all engraver instances!
#(define chordpro-syllables-collected '())
#(define chordpro-chords-collected '())
#(define chordpro-breaks-collected '())
#(define chordpro-stanza-numbers '())
%% Format: (moment verse-idx text direction) for inline text markers like repStart/repStop
#(define chordpro-inline-texts-collected '())
%%Track break moments to detect verse changes
#(define chordpro-seen-break-moments '())
%% Increments with each verse (each chordlyrics call)
#(define chordpro-current-verse-index 0)
%% Collected minor chords (lowercase German chords) for {define:} directives
#(define chordpro-minor-chords-used '())
%% Collected B chords (German B = English Bb) for {define:} directives
#(define chordpro-b-chords-used '())
%% Collected H chords (German H = English B) for {define:} directives
#(define chordpro-h-chords-used '())
%% Collected chords with accidentals (is/es) for {define:} directives
#(define chordpro-accidental-chords-used '())

%% Configuration and metadata (set by layout_bottom.ily or song file)
#(define chordpro-export-enabled #t)
#(define chordpro-current-filename "output")
#(define chordpro-header-title "Untitled")
#(define chordpro-header-authors #f)

%% Write flag (ensures we only write once, not for each finalize call)
#(define chordpro-file-written #f)

%% Helper function to format stanza label for ChordPro
#(define (format-chordpro-stanza-label stanza-type stanza-numbers)
  "Generate ChordPro label based on stanza type and optional numbers"
  (let* ((has-numbers (and stanza-numbers (not (null? stanza-numbers))))
         (numbers-string (if has-numbers
                            (string-join (map (lambda (n) (format #f "~a" n)) stanza-numbers) ", ")
                            "")))
    (cond
     ((eq? stanza-type 'ref)
      (if has-numbers
          (format #f (if (defined? 'refStringWithNumbers) refStringWithNumbers "Ref. ~a:") numbers-string)
          (if (defined? 'refString) refString "Ref.:")))
     ((eq? stanza-type 'bridge)
      (if has-numbers
          (format #f (if (defined? 'bridgeStringWithNumbers) bridgeStringWithNumbers "Bridge ~a:") numbers-string)
          (if (defined? 'bridgeString) bridgeString "Bridge:")))
     (else #f))))

%% Single engraver in Score context
#(define ChordPro_score_collector
   (lambda (context)
     (let ((pending-syllable #f)
           (this-verse-index #f))
       (make-engraver
        ;; Initialize - called when engraver is created (once per \chordlyrics)
        ((initialize engraver)
         ;; Each \chordlyrics call creates a new Score, so this marks a new verse
         (when (> chordpro-current-verse-index 0)
           ;; Reset break tracking for new verse
           (set! chordpro-seen-break-moments '()))
         ;; Store the verse index for this instance
         (set! this-verse-index chordpro-current-verse-index)
         ;; Increment global index for next verse
         (set! chordpro-current-verse-index (+ chordpro-current-verse-index 1)))

        ;; Event listeners
        (listeners
         ;; LyricEvent from Lyrics context
         ((lyric-event engraver event)
          (let ((text (ly:event-property event 'text))
                (moment (ly:context-current-moment context)))
            (when (string? text)
              ;; On first lyric event for this engraver instance, capture the verse index
              (when (not this-verse-index)
                (set! this-verse-index chordpro-current-verse-index)
                (set! chordpro-current-verse-index (+ chordpro-current-verse-index 1)))

              ;; Save previous syllable if any (it had no hyphen)
              (when pending-syllable
                (set! chordpro-syllables-collected
                      (cons (list (car pending-syllable) (cadr pending-syllable) #f (caddr pending-syllable))
                            chordpro-syllables-collected)))
              ;; Store new syllable as pending (with THIS instance's verse index)
              (set! pending-syllable (list moment text this-verse-index)))))

         ;; HyphenEvent from Lyrics context
         ((hyphen-event engraver event)
          (when pending-syllable
            (set! chordpro-syllables-collected
                  (cons (list (car pending-syllable) (cadr pending-syllable) #t (caddr pending-syllable))
                        chordpro-syllables-collected))
            (set! pending-syllable #f)))

         ;; BreakEvent - store break moment
         ((break-event engraver event)
          (let ((moment (ly:context-current-moment context)))

            ;; Store break with this instance's verse index
            (set! chordpro-breaks-collected
                  (cons (cons moment this-verse-index) chordpro-breaks-collected)))))

        ;; Acknowledge grobs from child contexts
        (acknowledgers
         ;; StanzaNumber grobs to extract stanza type and text
         ((stanza-number-interface engraver grob source-engraver)
          (let* ((details (ly:grob-property grob 'details '()))
                 (custom-realstanza (ly:assoc-get 'custom-realstanza details #f))
                 (stanza-type (ly:assoc-get 'custom-stanza-type details 'verse))
                 (stanza-numbers (ly:assoc-get 'custom-stanza-numbers details '()))
                 ;; Check for custom inline text (e.g., repStart/repStop with direction)
                 (custom-inline-text (ly:assoc-get 'custom-inline-text details #f))
                 (custom-inline-direction (ly:assoc-get 'custom-inline-direction details CENTER))
                 ;; Try to read stanza text from multiple sources:
                 ;; 1. From the grob's text property
                 (stanza-text-from-grob (ly:grob-property grob 'text #f))
                 ;; 2. From the Lyrics context's stanza property
                 (lyrics-context (ly:translator-context source-engraver))
                 (stanza-text-from-context (if lyrics-context
                                              (ly:context-property lyrics-context 'stanza #f)
                                              #f))
                 ;; Use context property if available, otherwise grob property
                 (stanza-markup (or stanza-text-from-context stanza-text-from-grob))
                 ;; For ref/bridge, always use format-chordpro-stanza-label
                 ;; For verse, extract from markup (includes roman numerals if \romanStanza was used)
                 (stanza-text (if (or (eq? stanza-type 'ref) (eq? stanza-type 'bridge))
                                 (format-chordpro-stanza-label stanza-type stanza-numbers)
                                 (if (markup? stanza-markup)
                                     (markup->string stanza-markup)
                                     (if stanza-markup
                                         (format #f "~a" stanza-markup)
                                         #f))))
                 (existing (assoc this-verse-index chordpro-stanza-numbers))
                 (moment (ly:context-current-moment (ly:translator-context source-engraver)))
                 (direction (ly:grob-property grob 'direction CENTER)))

            ;; If custom-inline-text is set, always collect it as inline text (regardless of realstanza)
            ;; This allows repStart/repStop to be collected even when combined with real stanza numbers
            (when custom-inline-text
              (set! chordpro-inline-texts-collected
                    (cons (list moment this-verse-index custom-inline-text custom-inline-direction)
                          chordpro-inline-texts-collected)))

            ;; If this is NOT a real stanza marker (custom-realstanza not set or ##f),
            ;; collect it as inline text with direction info
            (when (and (not custom-realstanza) (not custom-inline-text))
              (when stanza-text  ; Only if there's text to display
                (set! chordpro-inline-texts-collected
                      (cons (list moment this-verse-index stanza-text direction)
                            chordpro-inline-texts-collected))))

            ;; Store or update stanza info for this verse (only if it's a real stanza marker)
            ;; Entry format: (verse-idx stanza-text stanza-type realstanza-flag)
            (when custom-realstanza
              (if existing
                ;; Update existing entry with type and text if available
                ;; IMPORTANT: Don't overwrite realstanza=##t markers and their text
                (let* ((existing-text (cadr existing))
                       (existing-type (caddr existing))
                       (existing-realstanza (if (> (length existing) 3) (cadddr existing) #f)))
                  (set! chordpro-stanza-numbers
                        (map (lambda (entry)
                               (if (= (car entry) this-verse-index)
                                   (list (car entry)
                                        ;; If existing entry is a real stanza, don't overwrite text
                                        ;; Otherwise, use new text if available
                                        (if existing-realstanza
                                            existing-text
                                            (or stanza-text existing-text))
                                        ;; Update type only if custom-realstanza is set
                                        (if custom-realstanza stanza-type existing-type)
                                        ;; Preserve ##t realstanza flag
                                        (or existing-realstanza custom-realstanza))
                                   entry))
                             chordpro-stanza-numbers)))
                ;; Create new entry with type, text, and realstanza flag
                (set! chordpro-stanza-numbers
                      (cons (list this-verse-index stanza-text stanza-type custom-realstanza)
                            chordpro-stanza-numbers)))))) ; closes set!, if, when, stanza-number-interface

         ;; ChordName grobs from ChordNames context
         ;; Store grob reference - visibility will be recorded by ChordPro_chord_visibility_recorder
         ((chord-name-interface engraver grob source-engraver)
          (let* ((moment (ly:context-current-moment context))
                 ;; Get details property to check for altChord
                 (details (ly:grob-property grob 'details '()))
                 (alt-main-name (assoc-get 'alt-chord-main-name details #f))
                 (alt-alt-name (assoc-get 'alt-chord-alt-name details #f))
                 ;; Extract chord name
                 (chord-name-final
                   (if (and alt-main-name alt-alt-name)
                       ;; This is an altChord - use the pre-extracted names
                       (let ((main (track-and-return-chord alt-main-name))
                             (alt (track-and-return-chord alt-alt-name)))
                         ;; Check if main is empty - if so, only output alt in parens
                         (if (string-null? main)
                             (string-append "[(" alt ")]")  ; Only alt chord: [(D7)]
                             ;; Format as: [B][(Gm)] (complete with all brackets)
                             (string-append "[" main "][(" alt ")]")))
                       ;; Normal chord - extract from markup text
                       (let* ((chord-text (ly:grob-property grob 'text))
                              (chord-names-str (extract-chord-names-from-markup chord-text))
                              ;; Check if it contains "][(": multiple chords (shouldn't happen anymore)
                              (has-bracket (string-index chord-names-str #\])))
                         (if has-bracket
                             ;; Multiple chords from old logic: manually split and process
                             (let* ((bracket-pos (string-index chord-names-str #\]))
                                    (first-part (substring chord-names-str 0 bracket-pos))
                                    (rest (substring chord-names-str bracket-pos))
                                    (open-pos (string-index rest #\())
                                    (close-pos (string-index rest #\)))
                                    (second-part (if (and open-pos close-pos)
                                                    (substring rest (+ open-pos 1) close-pos)
                                                    ""))
                                    (first-converted (track-and-return-chord first-part))
                                    (second-converted (track-and-return-chord second-part)))
                               (string-append first-converted "][(" second-converted ")"))
                             ;; Single chord: just track and return original
                             (track-and-return-chord chord-names-str))))))
            ;; Store grob reference along with chord data (unless empty)
            ;; Format: (moment chord-name verse-index grob)
            ;; Filter out completely empty chords, but convert ][(X) to [(X)]
            (let ((processed-chord-name
                    (cond
                      ;; Empty chord
                      ((or (string-null? chord-name-final)
                          (string=? chord-name-final "")
                          (string=? chord-name-final "]["))
                       #f)  ; Filter out
                      ;; Pattern ][(X) - empty main, only alt in parens: convert to [(X)]
                      ((string-prefix? "][(" chord-name-final)
                       ;; ][(D7) → [(D7)]
                       (let* ((inner (substring chord-name-final 3 (- (string-length chord-name-final) 1))))
                         (string-append "[(" inner ")]")))
                      ;; Normal chord
                      (else chord-name-final))))
              (when processed-chord-name
                (set! chordpro-chords-collected
                      (cons (list moment processed-chord-name this-verse-index grob) chordpro-chords-collected))))))

         ;; LyricText grobs to get stanza number
         ((lyric-syllable-interface engraver grob source-engraver)
          (let* ((stanza-grob (ly:grob-property grob 'stanza #f))
                 ;; Get the Lyrics context from the source engraver
                 (lyrics-context (ly:translator-context source-engraver))
                 (stanza-context (if lyrics-context
                                     (ly:context-property lyrics-context 'stanza #f)
                                     #f))
                 (stanza-value (or stanza-grob stanza-context)))

            (when stanza-value
              ;; Only update existing stanza entries (don't create new ones)
              ;; New entries should only be created by stanza-number-interface
              (let* ((existing (assoc this-verse-index chordpro-stanza-numbers))
                     (existing-text (if existing (cadr existing) #f))
                     (stanza-text (if (markup? stanza-value)
                                     (markup->string stanza-value)
                                     (format #f "~a" stanza-value))))
                ;; Only update if entry exists and existing text is empty/false and new text is non-empty
                (when (and existing
                          (not (and (string? existing-text) (not (string-null? existing-text))))
                          (string? stanza-text)
                          (not (string-null? stanza-text)))
                  ;; Update existing entry with text (keep type and realstanza flag)
                  (set! chordpro-stanza-numbers
                        (map (lambda (entry)
                               (if (= (car entry) this-verse-index)
                                   (list (car entry)
                                        (or existing-text stanza-text)  ; Keep existing text if present
                                        (caddr entry)   ; Keep stanza-type
                                        (if (> (length entry) 3) (cadddr entry) #f)) ; Keep realstanza-flag if exists
                                   entry))
                             chordpro-stanza-numbers))))))) ; schließt lyric-syllable-interface
        ) ; schließt acknowledgers
        ;; End of timestep
        ((stop-translation-timestep engraver)
         (when pending-syllable
           (set! chordpro-syllables-collected
                 (cons (list (car pending-syllable) (cadr pending-syllable) #f (caddr pending-syllable))
                       chordpro-syllables-collected))
           (set! pending-syllable #f)))

        ;; Finalize - just write debug, don't filter chords yet
        ;; (Filtering happens in chordpro-write-from-engraver-data where grob properties are final)
        ((finalize engraver)
         ;; Save any remaining pending syllable
         (when pending-syllable
           (set! chordpro-syllables-collected
                 (cons (list (car pending-syllable) (cadr pending-syllable) #f (caddr pending-syllable))
                       chordpro-syllables-collected))
           (set! pending-syllable #f))

         ;; Write debug output (overwrite each time, final version will be complete)
         (with-output-to-file "/tmp/chordpro_debug.txt"
           (lambda ()
             (display (format #f "ChordPro: Collected ~a syllables, ~a chords (unfiltered), ~a breaks, ~a verses\n"
                            (length chordpro-syllables-collected)
                            (length chordpro-chords-collected)
                            (length chordpro-breaks-collected)
                            chordpro-current-verse-index))
             (display "All syllables:\n")
             (for-each
               (lambda (syl)
                 (display (format #f "  V~a: '~a' hyphen=~a at ~a\n"
                                (cadddr syl) (cadr syl) (if (caddr syl) "YES" "NO") (car syl))))
               (reverse chordpro-syllables-collected))
             (newline)
             (display "Breaks:\n")
             (for-each
               (lambda (brk)
                 (display (format #f "  V~a at ~a\n" (cdr brk) (car brk))))
               (reverse chordpro-breaks-collected))
             (newline)
             (display "All chords (after visibility filtering):\n")
             (for-each
               (lambda (chord)
                 (display (format #f "  V~a: ~a at ~a\n"
                                (caddr chord) (cadr chord) (car chord))))
               (reverse chordpro-chords-collected))
             (newline)
             (display "Stanza numbers:\n")
             (for-each
               (lambda (stanza-entry)
                 (display (format #f "  V~a: '~a' (type: ~a, real: ~a)\n"
                                (car stanza-entry) (cadr stanza-entry) (caddr stanza-entry) (cadddr stanza-entry))))
               (reverse chordpro-stanza-numbers))
             (newline)
             (display "Inline texts (repStart/repStop etc.):\n")
             (for-each
               (lambda (inline-entry)
                 (display (format #f "  V~a: '~a' at ~a (dir: ~a)\n"
                                (cadr inline-entry) (caddr inline-entry) (car inline-entry) (cadddr inline-entry))))
               (reverse chordpro-inline-texts-collected)))))

       ))))

%% Helper functions to format and write ChordPro
#(define (chordpro-write-from-engraver-data num-verses)
  "Write ChordPro file from collected engraver data"
  (let* ((filename (if (defined? 'chordpro-current-filename)
                       chordpro-current-filename
                       "output"))
         (output-file (string-append filename ".cho"))
         ;; Reverse all lists (they were collected in reverse order)
         (syllables (reverse chordpro-syllables-collected))
         (chords (reverse chordpro-chords-collected))
         (breaks (reverse chordpro-breaks-collected)))

    (with-output-to-file output-file
      (lambda ()
        ;; Write metadata
        (display (format #f "{title: ~a}\n"
                        (if (defined? 'chordpro-header-title)
                            chordpro-header-title
                            "Untitled")))
        (when (and (defined? 'chordpro-header-authors) chordpro-header-authors)
          (display (format #f "{artist: ~a}\n"
                          (format-chordpro-authors chordpro-header-authors))))
        
        ;; Write {define:} directives for all used minor chords
        (unless (null? chordpro-minor-chords-used)
          (newline)
          (for-each
            (lambda (minor-chord)
              ;; Convert minor chord to major form for the definition
              (let ((major-form (german-minor-to-major-form minor-chord)))
                (display (format #f "{define: ~a copy ~a}\n" minor-chord major-form))))
            (reverse chordpro-minor-chords-used)))
        
        ;; Write {define:} directives for all used B chords (German B = English Bb)
        (unless (null? chordpro-b-chords-used)
          (for-each
            (lambda (b-chord)
              ;; Convert B/b to Bb/Bbm form for the definition
              (let ((bb-form (german-b-to-bb-form b-chord)))
                (display (format #f "{define: ~a copy ~a}\n" b-chord bb-form))))
            (reverse chordpro-b-chords-used)))
        
        ;; Write {define:} directives for all used H chords (German H = English B)
        (unless (null? chordpro-h-chords-used)
          (for-each
            (lambda (h-chord)
              ;; Convert H/h to B/Bm form for the definition
              (let ((b-form (german-h-to-b-form h-chord)))
                (display (format #f "{define: ~a copy ~a}\n" h-chord b-form))))
            (reverse chordpro-h-chords-used)))
        
        ;; Write {define:} directives for chords with accidentals (is/es -> #/b)
        (unless (null? chordpro-accidental-chords-used)
          (for-each
            (lambda (accidental-chord)
              ;; Convert German accidentals to international format
              (let ((intl-form (german-accidentals-to-international accidental-chord)))
                (display (format #f "{define: ~a copy ~a}\n" accidental-chord intl-form))))
            (reverse chordpro-accidental-chords-used)))
        
        (newline)

        ;; Write each verse in reverse order (they were collected backwards)
        (let loop ((verse-idx (- num-verses 1)))
          (when (>= verse-idx 0)
            ;; Get syllables, chords and breaks for this verse
            (let* ((verse-syllables (filter (lambda (s) (= (cadddr s) verse-idx)) syllables))
                   (verse-chords-raw (filter (lambda (c)
                                               (and (list? c)
                                                    (>= (length c) 3)
                                                    (= (caddr c) verse-idx)))
                                             chords))
                   ;; Simple filtering: remove repeated consecutive chords
                   (verse-chords (let filter-repeats ((chords-left verse-chords-raw)
                                                       (last-chord #f)
                                                       (result '()))
                                   (if (null? chords-left)
                                       (reverse result)
                                       (let* ((chord (car chords-left))
                                              (chord-name (cadr chord)))
                                         (if (equal? chord-name last-chord)
                                             ;; Skip repeated chord
                                             (filter-repeats (cdr chords-left) last-chord result)
                                             ;; Include new chord
                                             (filter-repeats (cdr chords-left) chord-name
                                                           (cons (list (car chord) chord-name (caddr chord)) result)))))))
                   (verse-breaks (filter (lambda (b) (= (cdr b) verse-idx)) breaks))
                   (verse-inline-texts (filter (lambda (r) (= (cadr r) verse-idx))
                                               (reverse chordpro-inline-texts-collected)))
                   ;; Get stanza info (number, type, and realstanza flag) for this verse
                   (stanza-entry (find (lambda (s) (= (car s) verse-idx)) chordpro-stanza-numbers))
                   (stanza-num (if stanza-entry (cadr stanza-entry) #f))
                   (stanza-type (if stanza-entry (caddr stanza-entry) 'verse))
                   (realstanza (if stanza-entry (cadddr stanza-entry) #f))
                   ;; Determine ChordPro directive based on type
                   (start-directive (cond
                                     ((eq? stanza-type 'ref) "start_of_chorus")
                                     ((eq? stanza-type 'bridge) "start_of_bridge")
                                     (else "start_of_verse")))
                   (end-directive (cond
                                   ((eq? stanza-type 'ref) "end_of_chorus")
                                   ((eq? stanza-type 'bridge) "end_of_bridge")
                                   (else "end_of_verse"))))

              (when (not (null? verse-syllables))
                ;; If realstanza is ##t, output with ChordPro directives
                ;; Otherwise, just output the text (e.g., for repStartWithTag/repStopWithTag)
                (if realstanza
                    (begin
                      (if (and stanza-num (not (string-null? stanza-num)))
                          (display (format #f "{~a: label=\"~a\"}\n" start-directive stanza-num))
                          (display (format #f "{~a}\n" start-directive)))
                      (display (format-verse-as-chordpro verse-syllables verse-chords verse-breaks verse-inline-texts))
                      (display (format #f "\n{~a}\n\n" end-directive)))
                    (begin
                      ;; For non-real stanzas, just output stanza marker as comment if present
                      (when (and stanza-num (not (string-null? stanza-num)))
                        (display (format #f "# ~a\n" stanza-num)))
                      (display (format-verse-as-chordpro verse-syllables verse-chords verse-breaks verse-inline-texts))
                      (display "\n\n"))))

            (loop (- verse-idx 1)))))))

    ))

#(define (format-verse-as-chordpro syllables chords breaks inline-texts)
  "Format one verse as ChordPro text with line breaks.
   Chords are placed at syllable boundaries, not word boundaries.
   Inline texts (𝄆 𝄇 etc.) are inserted based on their direction property."
  (let* (;; Get break moments
         (break-moments (sort (map (lambda (b) (ly:moment-main (car b))) breaks) <))
         ;; Map each chord to the nearest following syllable
         (chord-to-syllable-map (map-chords-to-syllables chords syllables))
         ;; Sort inline texts by moment
         (sorted-inline-texts (sort inline-texts (lambda (a b) (ly:moment<? (car a) (car b)))))
         ;; Build formatted output
         (lines '())
         (current-line '())
         (current-word-parts '())
         (pending-word-suffix-chords '())  ; Collect suffix chords during word building
         (word-start-moment #f))

    ;; Process each syllable
    (let process-syllables ((syls-left syllables) (syl-idx 0) (breaks-left break-moments) (inlines-left sorted-inline-texts) (pending-line-chords '()))
      (if (null? syls-left)
          ;; Finish last word and line
          (begin
            (unless (null? current-word-parts)
              ;; Append pending suffix chords to the last word part
              (when (not (null? pending-word-suffix-chords))
                (let ((last-part (car current-word-parts))
                      (suffix-str (string-concatenate (reverse pending-word-suffix-chords))))
                  (set! current-word-parts (cons (string-append last-part suffix-str) (cdr current-word-parts)))
                  (set! pending-word-suffix-chords '())))
              (set! current-line (cons (string-concatenate (reverse current-word-parts)) current-line)))
            (unless (null? current-line)
              (set! lines (cons (reverse current-line) lines))))

          ;; Process next syllable
          (let* ((syl-entry (car syls-left))
                 (syl-moment (ly:moment-main (car syl-entry)))
                 (syl-text-raw (cadr syl-entry))
                 ;; Normalize: treat whitespace-only strings as empty (lyric extenders come as spaces)
                 (syl-text (if (and (string? syl-text-raw)
                                    (not (string-null? syl-text-raw))
                                    (string-every char-set:whitespace syl-text-raw))
                               ""
                               syl-text-raw))
                 (has-hyphen (caddr syl-entry))
                 (rest-syls (cdr syls-left))
                 ;; Find chords for this syllable position (including extenders!)
                 (syl-chords (filter (lambda (cm) (= (caddr cm) syl-idx)) chord-to-syllable-map))
                 ;; Separate chords into prefix (before/on syllable) and suffix (after syllable)
                 ;; Separate chords into prefix (before/on syllable) and suffix (after syllable)
                 (prefix-chords (filter (lambda (c) (<= (ly:moment-main (car c)) syl-moment)) syl-chords))
                 (suffix-chords-all (filter (lambda (c) (> (ly:moment-main (car c)) syl-moment)) syl-chords))
                 ;; Filter suffix chords: only keep those where NO line break exists between syllable and chord
                 ;; If a break is between the syllable and chord, the chord belongs to the next line
                 (suffix-chords (filter (lambda (c)
                                          (let ((chord-moment (ly:moment-main (car c))))
                                            ;; Keep chord if no break exists, or if break is not between syl and chord
                                            (or (null? breaks-left)
                                                (let ((next-break (car breaks-left)))
                                                  ;; Only keep if break is AFTER the chord (or before/at syllable)
                                                  ;; Reject if: syl-moment < next-break <= chord-moment
                                                  (not (and (> next-break syl-moment)
                                                           (<= next-break chord-moment)))))))
                                        suffix-chords-all))
                 ;; Collect chords that were filtered out - they belong to the next line
                 (next-line-chords (filter (lambda (c)
                                             (let ((chord-moment (ly:moment-main (car c))))
                                               (and (not (null? breaks-left))
                                                    (let ((next-break (car breaks-left)))
                                                      (and (> next-break syl-moment)
                                                           (<= next-break chord-moment))))))
                                           suffix-chords-all))
                 ;; Create chord prefix: add space after chord if it plays on a rest (before syllable)
                 (chord-prefix (if (null? prefix-chords)
                                   ""
                                   (string-join
                                     (map (lambda (c)
                                            (let* ((chord-moment (ly:moment-main (car c)))
                                                   (chord-name (cadr c))
                                                   ;; Check if chord plays before syllable (on a rest)
                                                   (on-rest? (< chord-moment syl-moment))
                                                   ;; Check if chord already has brackets
                                                   (has-brackets (string-prefix? "[" chord-name)))
                                              (if has-brackets
                                                  ;; Already has brackets - just add space if needed
                                                  (if on-rest?
                                                      (string-append chord-name " ")
                                                      chord-name)
                                                  ;; Add brackets
                                                  (if on-rest?
                                                      (string-append "[" chord-name "] ")
                                                      (string-append "[" chord-name "]")))))
                                          prefix-chords)
                                     "")))
                 ;; Create chord suffix for chords that play after the syllable (on rests)
                 (chord-suffix (if (null? suffix-chords)
                                   ""
                                   (string-join
                                     (map (lambda (c)
                                            (let ((chord-name (cadr c)))
                                              ;; Check if chord already has brackets (e.g., "[(D7)]")
                                              (if (string-prefix? "[" chord-name)
                                                  chord-name  ; Already has brackets
                                                  (string-append "[" chord-name "]"))))
                                          suffix-chords)
                                     "")))
                 ;; Check for line break
                 (next-syl-moment (if (null? rest-syls) 999999 (ly:moment-main (car (car rest-syls)))))
                 (break-here (and (not (null? breaks-left))
                                 (let ((next-break (car breaks-left)))
                                   (and (> next-break syl-moment)
                                        (<= next-break next-syl-moment))))))

            ;; Check for inline texts at this syllable position
            (let* ((inline-result
                     (let collect-inlines ((inls inlines-left) (collected '()))
                       (if (or (null? inls)
                               (let ((inl-entry (car inls)))
                                 (> (ly:moment-main (car inl-entry)) syl-moment)))
                           (list (reverse collected) inls)
                           (collect-inlines (cdr inls) (cons (car inls) collected)))))
                   (inlines-to-insert (car inline-result))
                   (new-inlines-left (cadr inline-result))
                   ;; Separate by direction: LEFT texts go before, RIGHT texts go after
                   (before-texts (filter (lambda (i) (eqv? (cadddr i) LEFT)) inlines-to-insert))
                   (after-texts (filter (lambda (i) (eqv? (cadddr i) RIGHT)) inlines-to-insert)))

              ;; If this is the start of a new line and we have pending chords from the previous line
              (when (and (null? current-line) (not (null? pending-line-chords)))
                ;; If we're continuing a word (current-word-parts not empty), add chords as infix
                ;; Otherwise add them as a separate word-like element
                (if (not (null? current-word-parts))
                    ;; Add pending chords as infix to the last word part
                    (let* ((last-part (car current-word-parts))
                           (rest-parts (cdr current-word-parts))
                           (pending-chord-str (string-join
                                                (map (lambda (c)
                                                       (let ((chord-name (cadr c)))
                                                         (if (string-prefix? "[" chord-name)
                                                             chord-name  ; Already has brackets
                                                             (string-append "[" chord-name "]"))))
                                                     pending-line-chords)
                                                "")))
                      (set! current-word-parts (cons (string-append last-part pending-chord-str) rest-parts)))
                    ;; No word continuation - add as separate element
                    (let ((pending-chord-str (string-join
                                               (map (lambda (c)
                                                      (let ((chord-name (cadr c)))
                                                        (if (string-prefix? "[" chord-name)
                                                            chord-name  ; Already has brackets
                                                            (string-append "[" chord-name "]"))))
                                                    pending-line-chords)
                                               "")))
                      (set! current-line (cons pending-chord-str current-line)))))

              ;; Insert texts that should appear BEFORE the syllable (direction = LEFT)
              (for-each
                (lambda (inline-text)
                  (set! current-line (cons (caddr inline-text) current-line)))
                before-texts)

              ;; Track word start
              (when (null? current-word-parts)
                (set! word-start-moment syl-moment))

              ;; Add text to current word only if syllable is not empty (not a lyric extender _)
              ;; Handle chords: if we're continuing a word (current-word-parts not empty),
              ;; prefix chords should be inserted between syllables as infixes (without trailing space)
              (unless (string-null? syl-text)
                (if (null? current-word-parts)
                    ;; First syllable of word: use prefix as normal
                    (set! current-word-parts (cons (string-append chord-prefix syl-text) current-word-parts))
                    ;; Continuation of word: insert prefix chord between previous syllable and this one
                    (begin
                      ;; Append prefix chord to the LAST syllable (strip trailing space from chord-prefix for infix use)
                      (unless (string-null? chord-prefix)
                        (let* ((last-part (car current-word-parts))
                               (rest-parts (cdr current-word-parts))
                               ;; Remove trailing space from chord-prefix if present
                               (chord-infix (if (string-suffix? " " chord-prefix)
                                               (substring chord-prefix 0 (- (string-length chord-prefix) 1))
                                               chord-prefix)))
                          (set! current-word-parts (cons (string-append last-part chord-infix) rest-parts))))
                      ;; Add current syllable
                      (set! current-word-parts (cons syl-text current-word-parts)))))

              ;; Always collect suffix chords (even from extenders), they'll be output at word end
              (unless (string-null? chord-suffix)
                (set! pending-word-suffix-chords (cons chord-suffix pending-word-suffix-chords)))

              ;; Complete word only if: no hyphen AND syllable has text (not an extender)
              (when (and (not has-hyphen) (not (string-null? syl-text)))
                (if (null? current-word-parts)
                    ;; No word parts (shouldn't happen) - just output suffix chords if any
                    (unless (null? pending-word-suffix-chords)
                      (set! current-line (cons (string-concatenate (reverse pending-word-suffix-chords)) current-line))
                      (set! pending-word-suffix-chords '()))
                    ;; Normal word completion with all collected suffix chords
                    (let ((word-with-suffix
                            (if (null? pending-word-suffix-chords)
                                (string-concatenate (reverse current-word-parts))
                                (string-append
                                  (string-concatenate (reverse current-word-parts))
                                  (string-concatenate (reverse pending-word-suffix-chords))))))
                      (set! current-line (cons word-with-suffix current-line))
                      (set! current-word-parts '())
                      (set! pending-word-suffix-chords '()))))
              (for-each
                (lambda (inline-text)
                  (set! current-line (cons (caddr inline-text) current-line)))
                after-texts)

              ;; If break here, complete line (word parts continue on next line)
              (if break-here
                  (begin
                    (set! lines (cons (reverse current-line) lines))
                    (set! current-line '())
                    (process-syllables rest-syls (+ syl-idx 1) (cdr breaks-left) new-inlines-left next-line-chords))
                  (process-syllables rest-syls (+ syl-idx 1) breaks-left new-inlines-left '())))))

    ;; Format all lines and normalize multiple spaces
    (string-join
      (map (lambda (line-words)
             (let ((line (string-join line-words " ")))
               (normalize-spaces line)))
           (reverse lines))
      "\n"))))

#(define (map-chords-to-syllables chords syllables)
  "For each chord, find the nearest following syllable.
   If no following syllable within tolerance, use the last preceding syllable.
   Returns list of (chord-moment chord-name syllable-index)"
  (let ((tolerance (ly:make-moment 1/4)))
    (filter-map
      (lambda (chord-entry)
        (let* ((chord-moment (car chord-entry))
               (chord-name (cadr chord-entry))
               ;; Find syllables that start AT or AFTER this chord (within tolerance)
               (candidate-syllables-forward
                 (filter-map
                   (lambda (syl-entry syl-idx)
                     (let* ((syl-moment (car syl-entry))
                            (diff (ly:moment-sub syl-moment chord-moment)))
                       ;; Syllable must start at or after chord, within tolerance
                       (if (and (not (ly:moment<? diff (ly:make-moment 0)))  ; diff >= 0
                                (ly:moment<=? diff tolerance))
                           (list diff syl-idx)
                           #f)))
                   syllables
                   (iota (length syllables)))))  ; syllable indices

          ;; If no forward match, try to find the last syllable BEFORE the chord
          (if (not (null? candidate-syllables-forward))
              ;; Pick the closest following syllable (smallest diff)
              (let* ((sorted (sort candidate-syllables-forward (lambda (a b) (ly:moment<? (car a) (car b)))))
                     (best (car sorted))
                     (best-syl-idx (cadr best)))
                (list chord-moment chord-name best-syl-idx))
              ;; No following syllable - find last preceding syllable
              (let ((preceding-syllables
                      (filter-map
                        (lambda (syl-entry syl-idx)
                          (let* ((syl-moment (car syl-entry))
                                 (diff (ly:moment-sub chord-moment syl-moment)))
                            ;; Chord must come after syllable (diff > 0)
                            (if (ly:moment<? (ly:make-moment 0) diff)
                                (list diff syl-idx syl-moment)
                                #f)))
                        syllables
                        (iota (length syllables)))))
                (if (null? preceding-syllables)
                    #f  ; No syllables at all - skip this chord
                    ;; Pick the latest preceding syllable (smallest diff = closest before chord)
                    (let* ((sorted (sort preceding-syllables (lambda (a b) (ly:moment<? (car a) (car b)))))
                           (best (car sorted))
                           (best-syl-idx (cadr best)))
                      (list chord-moment chord-name best-syl-idx)))))))
      chords)))

#(define (join-syllables-into-words syllables)
  "Join syllables into words based on hyphen flags"
  ;; syllables structure: (moment text has-hyphen verse-idx)
  (let ((result '())
        (current-word-parts '())
        (word-start-moment #f))
    (for-each
      (lambda (syl-entry)
        (let* ((moment (car syl-entry))
               (text (cadr syl-entry))
               (has-hyphen (caddr syl-entry)))
          ;; Track the moment of the first syllable of each word
          (when (null? current-word-parts)
            (set! word-start-moment moment))

          ;; Add syllable part to current word
          (set! current-word-parts (cons text current-word-parts))

          ;; If no hyphen after this syllable, the word is complete
          (unless has-hyphen
            (let ((complete-word (string-concatenate (reverse current-word-parts))))
              (set! result (cons (cons word-start-moment complete-word) result)))
            (set! current-word-parts '()))))
      syllables)

    ;; Return words in correct order
    (reverse result)))

#(define (find-chord-at-moment chords moment)
  "Find chord at or close to the given syllable moment"
  ;; chords structure: (moment name verse-idx)
  ;; Strategy: Find the CLOSEST chord that comes AT or AFTER the word start
  ;; This way each chord is only matched to the nearest preceding word
  (let ((tolerance (ly:make-moment 1/4)))  ; Allow chord up to 1/4 after word start
    (let loop ((remaining chords) (best-match #f) (best-diff #f))
      (cond
        ((null? remaining) best-match)
        (else
         (let* ((chord-entry (car remaining))
                (chord-moment (car chord-entry))
                (chord-name (cadr chord-entry))
                (diff (ly:moment-sub chord-moment moment)))  ; positive if chord is after word
           ;; Only consider chords that are AT or AFTER the word start (diff >= 0)
           ;; and within tolerance
           (let ((valid (and (not (ly:moment<? diff (ly:make-moment 0)))  ; diff >= 0
                             (ly:moment<=? diff tolerance))))
             (if (and valid
                      (or (not best-diff)
                          (ly:moment<? diff best-diff)))  ; prefer closest (smallest diff)
                 (loop (cdr remaining) chord-name diff)
                 (loop (cdr remaining) best-match best-diff)))))))))

#(define (ly:moment=? a b)
  "Check if two moments are equal"
  (and (not (ly:moment<? a b))
       (not (ly:moment<? b a))))

#(define (ly:moment-abs m)
  "Get absolute value of moment"
  (if (ly:moment<? m (ly:make-moment 0))
      (ly:moment-sub (ly:make-moment 0) m)
      m))

#(define (ly:moment<=? m1 m2)
  "Check if m1 <= m2"
  (or (ly:moment<? m1 m2)
      (ly:moment=? m1 m2)))

#(define (ly:moment-add m1 m2)
  "Add two moments"
  (ly:moment-sub m1 (ly:moment-sub (ly:make-moment 0) m2)))

#(define (format-chordpro-authors authors)
  "Format authors list for ChordPro"
  (cond
    ((list? authors)
     (string-join
       (filter (lambda (s) (not (string-null? s)))
               (map (lambda (author-info)
                      (cond
                        ((pair? author-info) (car author-info))
                        ((string? author-info) author-info)
                        (else "")))
                    authors))
       ", "))
    (else "")))

%% Define markup command for delayed ChordPro write BEFORE modifying TEXT_PAGES
%% Uses delay-stencil-evaluation to write after all engraver data is collected
#(define-markup-command (chordpro-delayed-write layout props)
  ()
  #:category other
  "Invisible markup that writes ChordPro file during stencil evaluation (after all engraver data is collected)"
  ;; We use a delayed stencil to ensure all engraver data is available
  (ly:make-stencil
    `(delay-stencil-evaluation
      ,(delay (begin
        (when (and (defined? 'chordpro-export-enabled)
                   chordpro-export-enabled
                   (not chordpro-file-written)
                   (> chordpro-current-verse-index 0))
          (chordpro-write-from-engraver-data chordpro-current-verse-index)
          (set! chordpro-file-written #t))
        empty-stencil)))))