Skip to main content

acorde_layout/
engine.rs

1use crate::{
2    AccidentalMark, BeamGroup, ConcertKeyOverride, CourtesyAccidental, LayoutConfig, LayoutResult,
3    RowLayout, SourceVoiceAddress, SpanMark, TupletGroup,
4};
5use acorde_core::{
6    AccidentalDisplay, BeamState, HairpinKind, NotationSpanner, NotationSpannerKind, NoteAddr,
7    OttavaKind, Score, Step, TupletBoundary, compute_beams,
8};
9use std::collections::{HashMap, HashSet};
10
11/// Shift `fifths` (circle-of-fifths key index) by `semitones` semitones.
12///
13/// Uses the modular relationship: 7 semitones = +1 fifth (sharp).
14/// Maps result to [-7, 7].
15fn transpose_key_fifths(fifths: i8, semitones: i8) -> i8 {
16    let raw = (semitones as i16 * 7).rem_euclid(12) as i8;
17    let delta = if raw > 6 { raw - 12 } else { raw };
18    (fifths + delta).clamp(-7, 7)
19}
20
21/// Compute a `LayoutResult` for the given score and configuration.
22///
23/// The result is independent of pixel dimensions so any renderer can consume it.
24pub fn compute_layout(score: &Score, config: &LayoutConfig) -> LayoutResult {
25    let per_row = config.measures_per_row.max(1);
26    let first_row = config.first_row_measures.map(|n| n.max(1));
27    let vis_slots = build_vis_slots(score);
28    let rows = build_rows(score, &vis_slots, per_row, first_row);
29    // Typed slurs retain their exact pairs; a boolean note flag cannot represent
30    // overlapping or numbered slurs at the same endpoint.
31    let spans = resolve_spans(&score.with_legacy_spanner_flags(), &score.spanners);
32
33    let mut concert_key_overrides = Vec::new();
34    if config.concert_pitch {
35        let base_fifths = score.settings.key_signature.fifths;
36        for (pi, part) in score.parts.iter().enumerate() {
37            for (si, staff) in part.staves.iter().enumerate() {
38                if staff.transpose_semitones != 0 {
39                    concert_key_overrides.push(ConcertKeyOverride {
40                        part_index: pi,
41                        staff_index: si,
42                        fifths: transpose_key_fifths(base_fifths, staff.transpose_semitones),
43                    });
44                }
45            }
46        }
47    }
48
49    let beam_groups = collect_beam_groups(score, false);
50    let tuplet_groups = collect_tuplet_groups(score);
51    let courtesy_accidentals = collect_courtesy_accidentals(score);
52    let accidentals = collect_accidental_marks(score);
53    let source_voice_addresses = collect_source_voice_addresses(score);
54
55    LayoutResult {
56        vis_slots,
57        rows,
58        spans,
59        typed_spanners: score.spanners.clone(),
60        concert_key_overrides,
61        beam_groups,
62        tuplet_groups,
63        courtesy_accidentals,
64        accidentals,
65        source_voice_addresses,
66    }
67}
68
69/// Compute ordinary layout plus opt-in display beams without modifying the score.
70pub fn compute_layout_with_display_beams(score: &Score, config: &LayoutConfig) -> LayoutResult {
71    let mut layout = compute_layout(score, config);
72    add_display_beams(score, &mut layout);
73    layout
74}
75
76/// Replace only the beam groups in an existing layout with display beam suggestions.
77/// The score, authored beam states, and all other layout decisions are unchanged.
78pub fn add_display_beams(score: &Score, layout: &mut LayoutResult) {
79    layout.beam_groups = collect_beam_groups(score, true);
80}
81
82fn collect_source_voice_addresses(score: &Score) -> Vec<SourceVoiceAddress> {
83    let mut addresses = Vec::new();
84    for (part, part_value) in score.parts.iter().enumerate() {
85        for (staff, staff_value) in part_value.staves.iter().enumerate() {
86            for (measure, measure_value) in staff_value.measures.iter().enumerate() {
87                for (voice, source_voice_number) in
88                    measure_value.source_voice_numbers.iter().enumerate()
89                {
90                    if let Some(source_voice_number) = source_voice_number {
91                        addresses.push(SourceVoiceAddress {
92                            part,
93                            staff,
94                            measure,
95                            voice,
96                            source_voice_number: *source_voice_number,
97                        });
98                    }
99                }
100            }
101        }
102    }
103    addresses
104}
105
106// ── vis_slots ─────────────────────────────────────────────────────────────────
107
108fn build_vis_slots(score: &Score) -> Vec<usize> {
109    let measure_count = score
110        .parts
111        .first()
112        .and_then(|p| p.staves.first())
113        .map(|s| s.measures.len())
114        .unwrap_or(0);
115
116    let mut slots = Vec::new();
117    for phys in 0..measure_count {
118        let count = multi_rest_count(score, phys).max(1);
119        for _ in 0..count {
120            slots.push(phys);
121        }
122    }
123    slots
124}
125
126fn multi_rest_count(score: &Score, measure_index: usize) -> usize {
127    score
128        .parts
129        .iter()
130        .flat_map(|p| p.staves.iter())
131        .filter_map(|s| s.measures.get(measure_index))
132        .filter_map(|m| m.multi_rest_count)
133        .map(|c| c as usize)
134        .max()
135        .unwrap_or(1)
136}
137
138// ── rows ──────────────────────────────────────────────────────────────────────
139
140fn force_break_after(score: &Score, phys: usize) -> bool {
141    score
142        .parts
143        .iter()
144        .flat_map(|p| p.staves.iter())
145        .filter_map(|s| s.measures.get(phys))
146        .any(|m| m.system_break || m.page_break)
147}
148
149pub(crate) fn build_rows(
150    score: &Score,
151    vis_slots: &[usize],
152    per_row: usize,
153    first_row_limit: Option<usize>,
154) -> Vec<RowLayout> {
155    if vis_slots.is_empty() {
156        return vec![RowLayout {
157            measure_indices: Vec::new(),
158        }];
159    }
160
161    let mut rows: Vec<RowLayout> = Vec::new();
162    let mut current: Vec<usize> = Vec::new();
163    let mut current_width = 0usize;
164    let mut last_phys = usize::MAX;
165
166    for &phys in vis_slots {
167        if phys != last_phys {
168            let limit = if rows.is_empty() {
169                first_row_limit.unwrap_or(per_row)
170            } else {
171                per_row
172            };
173            let span_width = multi_rest_count(score, phys).max(1);
174            if !current.is_empty() && current_width.saturating_add(span_width) > limit {
175                rows.push(RowLayout {
176                    measure_indices: std::mem::take(&mut current),
177                });
178                current_width = 0;
179            }
180            current.push(phys);
181            current_width = current_width.saturating_add(span_width);
182            if force_break_after(score, phys) {
183                rows.push(RowLayout {
184                    measure_indices: std::mem::take(&mut current),
185                });
186                current_width = 0;
187            }
188        }
189        last_phys = phys;
190    }
191
192    if !current.is_empty() {
193        rows.push(RowLayout {
194            measure_indices: current,
195        });
196    }
197    rows
198}
199
200/// Approximate the horizontal demand of one measure in notation units.
201///
202/// This is a deterministic lower bound shared by SVG and print row selection. The
203/// renderer still resolves actual glyph placement and collisions after breaks are chosen.
204pub fn notation_density_units(score: &Score, measure: usize) -> usize {
205    let mut widest_staff = 3usize;
206    for staff in score.parts.iter().flat_map(|part| &part.staves) {
207        let Some(measure) = staff.measures.get(measure) else {
208            continue;
209        };
210        let voice_width = measure
211            .voices
212            .iter()
213            .map(|voice| {
214                voice
215                    .iter()
216                    .filter(|note| !note.hidden)
217                    .map(|note| {
218                        let notehead_width = if note.is_rest { 1 } else { 2 };
219                        let chord_width = note.pitches.len().saturating_sub(1);
220                        let accidental_width =
221                            note.pitches.iter().filter(|pitch| pitch.alter != 0).count();
222                        let lyric_width = note
223                            .lyric
224                            .as_ref()
225                            .map_or(0, |lyric| lyric.text.chars().count().div_ceil(3));
226                        notehead_width
227                            + chord_width
228                            + accidental_width
229                            + usize::from(note.dot_count)
230                            + lyric_width
231                            + usize::from(note.chord_symbol.is_some()) * 2
232                            + note.articulations.len().div_ceil(2)
233                    })
234                    .sum::<usize>()
235            })
236            .max()
237            .unwrap_or(0);
238        let text_width = measure
239            .texts
240            .iter()
241            .map(|text| text.text.chars().count().div_ceil(4))
242            .sum::<usize>();
243        widest_staff = widest_staff.max(voice_width + text_width + 3);
244    }
245    widest_staff
246}
247
248// ── span resolution ───────────────────────────────────────────────────────────
249
250/// Pair hairpin starts and ends on one staff in time order, across voices: a wedge may begin
251/// on a note of one voice and end where another voice moves (MusicXML places wedges by time).
252fn resolve_staff_hairpins(
253    spans: &mut Vec<SpanMark>,
254    part: usize,
255    staff_index: usize,
256    staff: &acorde_core::Staff,
257) {
258    let mut events = Vec::new();
259    for (mi, measure) in staff.measures.iter().enumerate() {
260        for (voice, notes) in measure.voices.iter().enumerate().take(4) {
261            let mut onset = 0.0f64;
262            for (ni, note) in notes.iter().enumerate() {
263                if note.hairpin_start.is_some() || note.hairpin_end {
264                    events.push((mi, onset, voice, ni, note.hairpin_start, note.hairpin_end));
265                }
266                onset += note.beats();
267            }
268        }
269    }
270    events.sort_by(|a, b| {
271        a.0.cmp(&b.0)
272            .then(a.1.total_cmp(&b.1))
273            .then(a.2.cmp(&b.2))
274            .then(a.3.cmp(&b.3))
275    });
276    let mut open_hairpin: Option<(NoteAddr, HairpinKind)> = None;
277    for (measure, _, voice, note, start_kind, end) in events {
278        let addr = NoteAddr {
279            part,
280            staff: staff_index,
281            measure,
282            voice,
283            note,
284        };
285        // A note can end one hairpin and start the next (cresc. into dim.): close the
286        // earlier one first.
287        let ends_earlier = end && open_hairpin.is_some();
288        if ends_earlier && let Some((start, kind)) = open_hairpin.take() {
289            spans.push(SpanMark::Hairpin {
290                kind,
291                start,
292                end: addr.clone(),
293            });
294        }
295        if let Some(kind) = start_kind {
296            open_hairpin = Some((addr.clone(), kind));
297        }
298        if end
299            && !ends_earlier
300            && let Some((start, kind)) = open_hairpin.take()
301        {
302            spans.push(SpanMark::Hairpin {
303                kind,
304                start,
305                end: addr,
306            });
307        }
308    }
309}
310
311fn resolve_spans(score: &Score, typed_spanners: &[NotationSpanner]) -> Vec<SpanMark> {
312    let mut spans = Vec::new();
313    let typed_slur_endpoints = typed_spanners
314        .iter()
315        .filter(|span| span.kind == NotationSpannerKind::Slur)
316        .flat_map(|span| [&span.start, &span.end])
317        .map(|addr| (addr.part, addr.staff, addr.measure, addr.voice, addr.note))
318        .collect::<HashSet<_>>();
319
320    for (pi, part) in score.parts.iter().enumerate() {
321        for (si, staff) in part.staves.iter().enumerate() {
322            resolve_staff_hairpins(&mut spans, pi, si, staff);
323            for voice in 0..4usize {
324                let mut open_ottava: Option<(NoteAddr, OttavaKind)> = None;
325                let mut open_pedal: Option<NoteAddr> = None;
326                let mut open_slurs: Vec<NoteAddr> = Vec::new();
327                let mut open_trill_line: Option<NoteAddr> = None;
328                let mut open_glissando: Option<NoteAddr> = None;
329
330                for (mi, measure) in staff.measures.iter().enumerate() {
331                    for (ni, note) in measure.voices[voice].iter().enumerate() {
332                        let addr = NoteAddr {
333                            part: pi,
334                            staff: si,
335                            measure: mi,
336                            voice,
337                            note: ni,
338                        };
339
340                        if let Some(kind) = note.ottava_start {
341                            open_ottava = Some((addr.clone(), kind));
342                        }
343                        if note.ottava_end
344                            && let Some((start, kind)) = open_ottava.take()
345                        {
346                            spans.push(SpanMark::Ottava {
347                                kind,
348                                start,
349                                end: addr.clone(),
350                            });
351                        }
352
353                        let onset: f64 = measure.voices[voice]
354                            .iter()
355                            .take(ni)
356                            .map(|note| note.beats())
357                            .sum();
358                        let timed_here = |down| {
359                            measure.timed_pedals.iter().any(|pedal| {
360                                pedal.down == down && (pedal.position_beats - onset).abs() < 1e-9
361                            })
362                        };
363                        if note.pedal_start && !timed_here(true) {
364                            open_pedal = Some(addr.clone());
365                        }
366                        if note.pedal_end
367                            && !timed_here(false)
368                            && let Some(start) = open_pedal.take()
369                        {
370                            spans.push(SpanMark::Pedal {
371                                start,
372                                end: addr.clone(),
373                            });
374                        }
375
376                        // Close before opening: one note may end a phrase and
377                        // start the next. A stack preserves nested legacy slurs.
378                        // Typed endpoints are handled below with exact identities.
379                        if !typed_slur_endpoints.contains(&(pi, si, mi, voice, ni)) {
380                            if note.slur_end
381                                && let Some(start) = open_slurs.pop()
382                            {
383                                spans.push(SpanMark::Slur {
384                                    start,
385                                    end: addr.clone(),
386                                });
387                            }
388                            if note.slur_start {
389                                open_slurs.push(addr.clone());
390                            }
391                        }
392
393                        if note.trill_line_start {
394                            open_trill_line = Some(addr.clone());
395                        }
396                        if note.trill_line_end
397                            && let Some(start) = open_trill_line.take()
398                        {
399                            spans.push(SpanMark::TrillLine {
400                                start,
401                                end: addr.clone(),
402                            });
403                        }
404
405                        if note.glissando_start {
406                            open_glissando = Some(addr.clone());
407                        }
408                        if note.glissando_end
409                            && let Some(start) = open_glissando.take()
410                        {
411                            spans.push(SpanMark::Glissando {
412                                start,
413                                end: addr.clone(),
414                            });
415                        }
416
417                        if let Some(chord) = &note.chord_symbol
418                            && let Some(end) = &chord.range_end
419                        {
420                            spans.push(SpanMark::Harmony {
421                                label: chord.display_text(),
422                                start: addr.clone(),
423                                end: end.clone(),
424                            });
425                        }
426                    }
427                }
428            }
429        }
430    }
431
432    spans.extend(
433        typed_spanners
434            .iter()
435            .filter(|span| span.kind == NotationSpannerKind::Slur)
436            .map(|span| SpanMark::Slur {
437                start: span.start.clone(),
438                end: span.end.clone(),
439            }),
440    );
441    spans
442}
443
444// ── beam groups ───────────────────────────────────────────────────────────────
445
446fn collect_beam_groups(score: &Score, infer_unmarked: bool) -> Vec<BeamGroup> {
447    let mut groups = Vec::new();
448    for (pi, part) in score.parts.iter().enumerate() {
449        for (si, staff) in part.staves.iter().enumerate() {
450            let mut meter = score.settings.time_signature.clone();
451            for (mi, measure) in staff.measures.iter().enumerate() {
452                if let Some(change) = &measure.time_sig {
453                    meter = change.clone();
454                }
455                for (vi, voice) in measure.voices.iter().enumerate() {
456                    let mut current: Option<Vec<usize>> = None;
457
458                    for (ni, note) in voice.iter().enumerate() {
459                        match note.beam {
460                            BeamState::Begin => {
461                                current = Some(vec![ni]);
462                            }
463                            BeamState::BeginEnd => {
464                                groups.push(BeamGroup {
465                                    part: pi,
466                                    staff: si,
467                                    measure: mi,
468                                    voice: vi,
469                                    note_indices: vec![ni],
470                                });
471                            }
472                            BeamState::Continue
473                            | BeamState::ForwardHook
474                            | BeamState::BackwardHook => {
475                                if let Some(ref mut g) = current {
476                                    g.push(ni);
477                                }
478                            }
479                            BeamState::End => {
480                                if let Some(mut g) = current.take() {
481                                    g.push(ni);
482                                    groups.push(BeamGroup {
483                                        part: pi,
484                                        staff: si,
485                                        measure: mi,
486                                        voice: vi,
487                                        note_indices: g,
488                                    });
489                                }
490                            }
491                            BeamState::None => {
492                                current = None;
493                            }
494                        }
495                    }
496                    if infer_unmarked {
497                        let recommended = compute_beams(voice, &meter);
498                        let mut candidate = Vec::new();
499                        let mut flush = |candidate: &mut Vec<usize>| {
500                            if candidate.len() >= 2 {
501                                groups.push(BeamGroup {
502                                    part: pi,
503                                    staff: si,
504                                    measure: mi,
505                                    voice: vi,
506                                    note_indices: std::mem::take(candidate),
507                                });
508                            } else {
509                                candidate.clear();
510                            }
511                        };
512                        for (ni, (note, suggested)) in voice.iter().zip(&recommended).enumerate() {
513                            if matches!(suggested, BeamState::Begin | BeamState::None)
514                                || matches!(
515                                    note.tuplet_boundary,
516                                    Some(TupletBoundary::Start | TupletBoundary::StartStop)
517                                )
518                            {
519                                flush(&mut candidate);
520                            }
521                            if *suggested != BeamState::None
522                                && note.beam == BeamState::None
523                                && !note.explicit_unbeamed
524                                && !note.is_grace
525                                && !note.is_cue
526                                && !note.hidden
527                            {
528                                candidate.push(ni);
529                            } else {
530                                flush(&mut candidate);
531                            }
532                            if *suggested == BeamState::End
533                                || matches!(
534                                    note.tuplet_boundary,
535                                    Some(TupletBoundary::Stop | TupletBoundary::StartStop)
536                                )
537                            {
538                                flush(&mut candidate);
539                            }
540                        }
541                        flush(&mut candidate);
542                    }
543                }
544            }
545        }
546    }
547    groups
548}
549
550// ── tuplet groups ─────────────────────────────────────────────────────────────
551
552fn collect_tuplet_groups(score: &Score) -> Vec<TupletGroup> {
553    let mut groups = Vec::new();
554    for (pi, part) in score.parts.iter().enumerate() {
555        for (si, staff) in part.staves.iter().enumerate() {
556            for (mi, measure) in staff.measures.iter().enumerate() {
557                for (vi, voice) in measure.voices.iter().enumerate() {
558                    for (first, last) in acorde_core::tuplet_group_ranges(voice) {
559                        let note_indices: Vec<_> = (first..=last)
560                            .filter(|&index| {
561                                !voice[index].is_grace && voice[index].tuplet.is_some()
562                            })
563                            .collect();
564                        if note_indices.len() >= 2
565                            && let Some(ti) = voice[first].tuplet.as_ref()
566                        {
567                            groups.push(TupletGroup {
568                                part: pi,
569                                staff: si,
570                                measure: mi,
571                                voice: vi,
572                                note_indices,
573                                actual_notes: ti.actual_notes,
574                                normal_notes: ti.normal_notes,
575                            });
576                        }
577                    }
578                }
579            }
580        }
581    }
582    groups
583}
584
585fn step_idx(step: &Step) -> u8 {
586    match step {
587        Step::C => 0,
588        Step::D => 1,
589        Step::E => 2,
590        Step::F => 3,
591        Step::G => 4,
592        Step::A => 5,
593        Step::B => 6,
594    }
595}
596
597/// Accidental implied by a key signature for a given step: 0, 1, or -1.
598fn key_alter(fifths: i8, step: &Step) -> i8 {
599    const SHARPS: [Step; 7] = [
600        Step::F,
601        Step::C,
602        Step::G,
603        Step::D,
604        Step::A,
605        Step::E,
606        Step::B,
607    ];
608    const FLATS: [Step; 7] = [
609        Step::B,
610        Step::E,
611        Step::A,
612        Step::D,
613        Step::G,
614        Step::C,
615        Step::F,
616    ];
617    if fifths > 0 && SHARPS[..fifths as usize].contains(step) {
618        1
619    } else if fifths < 0 && FLATS[..(-fifths) as usize].contains(step) {
620        -1
621    } else {
622        0
623    }
624}
625
626fn collect_courtesy_accidentals(score: &Score) -> Vec<CourtesyAccidental> {
627    let mut result = Vec::new();
628    let base_fifths = score.settings.key_signature.fifths;
629
630    for (pi, part) in score.parts.iter().enumerate() {
631        for (si, staff) in part.staves.iter().enumerate() {
632            // Maps (step_index, octave) -> alter from the previous measure.
633            let mut prev_alters: HashMap<(u8, i8), i8> = HashMap::new();
634            let mut current_fifths = base_fifths;
635
636            for (mi, measure) in staff.measures.iter().enumerate() {
637                if let Some(key_sig) = measure.key_sig.as_ref() {
638                    current_fifths = key_sig.fifths;
639                    prev_alters.clear();
640                }
641
642                // Phase 1: check this measure's notes against prev_alters.
643                for (vi, voice) in measure.voices.iter().enumerate() {
644                    for (ni, note) in voice.iter().enumerate() {
645                        for (pitch_idx, pitch) in note.pitches.iter().enumerate() {
646                            let key = (step_idx(&pitch.step), pitch.octave);
647                            // A parenthesized accidental the source asked for is always drawn.
648                            let requested = note.accidental_display(pitch_idx)
649                                == AccidentalDisplay::Parenthesized;
650                            // Consume the previous-bar state on the first occurrence. A
651                            // mandatory accidental already covers a chromatic pitch; do not
652                            // repeat it, or add a reminder for a key-signature sharp/flat.
653                            let previous = prev_alters.remove(&key);
654                            let natural_reminder = !note.tie_end
655                                && note.accidental_display(pitch_idx) == AccidentalDisplay::Auto
656                                && pitch.alter == 0
657                                && key_alter(current_fifths, &pitch.step) == 0
658                                && previous.is_some_and(|alter| alter != 0);
659                            if requested || natural_reminder {
660                                result.push(CourtesyAccidental {
661                                    part: pi,
662                                    staff: si,
663                                    measure: mi,
664                                    voice: vi,
665                                    note_index: ni,
666                                    pitch_index: pitch_idx,
667                                    alter: pitch.alter,
668                                });
669                            }
670                        }
671                    }
672                }
673
674                // Phase 2: rebuild prev_alters from this measure's chromatically altered pitches.
675                prev_alters.clear();
676                for voice in &measure.voices {
677                    for note in voice {
678                        for pitch in note.pitches.iter() {
679                            if pitch.alter != key_alter(current_fifths, &pitch.step) {
680                                prev_alters
681                                    .insert((step_idx(&pitch.step), pitch.octave), pitch.alter);
682                            }
683                        }
684                    }
685                }
686            }
687        }
688    }
689    result
690}
691
692// ── mandatory accidentals ────────────────────────────────────────────────────
693
694/// Collect mandatory (non-courtesy) accidental marks.
695///
696/// State is scoped per `(part, staff)` and reset every measure to the key signature's
697/// implied alteration — accidentals never carry across a barline. Within a measure, all
698/// voices on the staff share one accidental context (mirrors [`collect_courtesy_accidentals`]'s
699/// voice-major scan order). Tied continuations (`tie_end`) never need a fresh accidental.
700fn collect_accidental_marks(score: &Score) -> Vec<AccidentalMark> {
701    let mut result = Vec::new();
702    let base_fifths = score.settings.key_signature.fifths;
703
704    for (pi, part) in score.parts.iter().enumerate() {
705        for (si, staff) in part.staves.iter().enumerate() {
706            let mut current_fifths = base_fifths;
707
708            for (mi, measure) in staff.measures.iter().enumerate() {
709                if let Some(key_sig) = measure.key_sig.as_ref() {
710                    current_fifths = key_sig.fifths;
711                }
712
713                // Active alteration per (step, octave), established within this measure only.
714                let mut active: HashMap<(u8, i8), i8> = HashMap::new();
715
716                for (vi, voice) in measure.voices.iter().enumerate() {
717                    for (ni, note) in voice.iter().enumerate() {
718                        for (pitch_idx, pitch) in note.pitches.iter().enumerate() {
719                            let key = (step_idx(&pitch.step), pitch.octave);
720                            let baseline = active
721                                .get(&key)
722                                .copied()
723                                .unwrap_or_else(|| key_alter(current_fifths, &pitch.step));
724                            let display = note.accidental_display(pitch_idx);
725                            let parenthesized = display == AccidentalDisplay::Parenthesized;
726                            if pitch.alter != baseline {
727                                // A parenthesized one is drawn with the courtesy marks.
728                                if (!note.tie_end || display == AccidentalDisplay::Explicit)
729                                    && !parenthesized
730                                {
731                                    result.push(AccidentalMark {
732                                        part: pi,
733                                        staff: si,
734                                        measure: mi,
735                                        voice: vi,
736                                        note_index: ni,
737                                        pitch_index: pitch_idx,
738                                        alter: pitch.alter,
739                                    });
740                                }
741                                active.insert(key, pitch.alter);
742                            } else if matches!(
743                                display,
744                                AccidentalDisplay::Explicit
745                                    | AccidentalDisplay::Cautionary
746                                    | AccidentalDisplay::Editorial
747                            ) {
748                                // Cautionary and editorial accidentals are drawn even when the
749                                // key and the bar already imply them.
750                                result.push(AccidentalMark {
751                                    part: pi,
752                                    staff: si,
753                                    measure: mi,
754                                    voice: vi,
755                                    note_index: ni,
756                                    pitch_index: pitch_idx,
757                                    alter: pitch.alter,
758                                });
759                            }
760                        }
761                    }
762                }
763            }
764        }
765    }
766    result
767}
768
769#[cfg(test)]
770mod tests {
771    use super::*;
772    use acorde_core::{Clef, Measure, Part, Score, Staff};
773
774    fn score_with_measures(n: usize) -> Score {
775        let mut score = Score::default();
776        score.parts.clear();
777        let mut staff = Staff::new(Clef::Treble);
778        for i in 0..n {
779            let mut m = Measure::empty(4, 4);
780            m.number = i as u32 + 1;
781            staff.measures.push(m);
782        }
783        let mut part = Part::new("P1", "P1");
784        part.staves.push(staff);
785        score.parts.push(part);
786        score
787    }
788
789    #[test]
790    fn default_score_has_one_row_of_four() {
791        // Score::default() ships with 4 measures; default measures_per_row=4
792        let score = Score::default();
793        let result = compute_layout(&score, &LayoutConfig::default());
794        assert_eq!(result.rows.len(), 1);
795        assert_eq!(result.rows[0].measure_indices, vec![0, 1, 2, 3]);
796        assert_eq!(result.vis_slots.len(), 4);
797        assert!(result.spans.is_empty());
798    }
799
800    #[test]
801    fn vis_slots_expand_multi_rest() {
802        let mut score = score_with_measures(1);
803        score.parts[0].staves[0].measures[0].multi_rest_count = Some(4);
804
805        let result = compute_layout(
806            &score,
807            &LayoutConfig {
808                measures_per_row: 8,
809                concert_pitch: false,
810                first_row_measures: None,
811            },
812        );
813        assert_eq!(result.vis_slots.len(), 4);
814        assert!(result.vis_slots.iter().all(|&v| v == 0));
815    }
816
817    #[test]
818    fn measures_split_into_rows() {
819        let score = score_with_measures(6);
820        let result = compute_layout(
821            &score,
822            &LayoutConfig {
823                measures_per_row: 4,
824                concert_pitch: false,
825                first_row_measures: None,
826            },
827        );
828        assert_eq!(result.rows.len(), 2);
829        assert_eq!(result.rows[0].measure_indices, vec![0, 1, 2, 3]);
830        assert_eq!(result.rows[1].measure_indices, vec![4, 5]);
831    }
832
833    #[test]
834    fn single_measure_single_row() {
835        let score = score_with_measures(1);
836        let result = compute_layout(
837            &score,
838            &LayoutConfig {
839                measures_per_row: 4,
840                concert_pitch: false,
841                first_row_measures: None,
842            },
843        );
844        assert_eq!(result.rows.len(), 1);
845        assert_eq!(result.rows[0].measure_indices, vec![0]);
846    }
847
848    #[test]
849    fn exactly_full_rows() {
850        let score = score_with_measures(8);
851        let result = compute_layout(
852            &score,
853            &LayoutConfig {
854                measures_per_row: 4,
855                concert_pitch: false,
856                first_row_measures: None,
857            },
858        );
859        assert_eq!(result.rows.len(), 2);
860        assert_eq!(result.rows[0].measure_indices.len(), 4);
861        assert_eq!(result.rows[1].measure_indices.len(), 4);
862    }
863
864    #[test]
865    fn concert_pitch_bb_clarinet_transposes_key() {
866        // Bb clarinet: transpose_semitones=-2, written key C major (fifths=0)
867        // Concert key = Bb major (fifths=-2)
868        let mut score = score_with_measures(1);
869        score.parts[0].staves[0].transpose_semitones = -2;
870        let result = compute_layout(
871            &score,
872            &LayoutConfig {
873                measures_per_row: 4,
874                concert_pitch: true,
875                first_row_measures: None,
876            },
877        );
878        assert_eq!(result.concert_key_overrides.len(), 1);
879        assert_eq!(result.concert_key_overrides[0].part_index, 0);
880        assert_eq!(result.concert_key_overrides[0].staff_index, 0);
881        assert_eq!(result.concert_key_overrides[0].fifths, -2);
882    }
883
884    #[test]
885    fn concert_pitch_false_no_override() {
886        let mut score = score_with_measures(1);
887        score.parts[0].staves[0].transpose_semitones = -2;
888        let result = compute_layout(
889            &score,
890            &LayoutConfig {
891                measures_per_row: 4,
892                concert_pitch: false,
893                first_row_measures: None,
894            },
895        );
896        assert!(result.concert_key_overrides.is_empty());
897    }
898
899    #[test]
900    fn concert_pitch_zero_transpose_no_override() {
901        // transpose_semitones=0 means concert pitch equals written pitch; no override needed.
902        let score = score_with_measures(1);
903        let result = compute_layout(
904            &score,
905            &LayoutConfig {
906                measures_per_row: 4,
907                concert_pitch: true,
908                first_row_measures: None,
909            },
910        );
911        assert!(result.concert_key_overrides.is_empty());
912    }
913
914    #[test]
915    fn transpose_key_formula_eb_alto_sax() {
916        // Eb alto sax: transpose_semitones=-9, written key C major (fifths=0)
917        // Concert key = Eb major (fifths=-3): delta = (-9*7) rem_euclid 12 = 9 → 9-12=-3
918        assert_eq!(transpose_key_fifths(0, -9), -3);
919    }
920
921    #[test]
922    fn transpose_key_formula_perfect_fifth_up() {
923        // +7 semitones = P5 up → +1 sharp (G major = fifths=1)
924        assert_eq!(transpose_key_fifths(0, 7), 1);
925    }
926
927    #[test]
928    fn system_break_splits_row() {
929        // 3 measures; measure[1] has system_break → rows: [0,1] and [2]
930        let mut score = score_with_measures(3);
931        score.parts[0].staves[0].measures[1].system_break = true;
932        let result = compute_layout(
933            &score,
934            &LayoutConfig {
935                measures_per_row: 4,
936                concert_pitch: false,
937                first_row_measures: None,
938            },
939        );
940        assert_eq!(result.rows.len(), 2);
941        assert_eq!(result.rows[0].measure_indices, vec![0, 1]);
942        assert_eq!(result.rows[1].measure_indices, vec![2]);
943    }
944
945    #[test]
946    fn page_break_splits_row() {
947        let mut score = score_with_measures(3);
948        score.parts[0].staves[0].measures[0].page_break = true;
949        let result = compute_layout(
950            &score,
951            &LayoutConfig {
952                measures_per_row: 4,
953                concert_pitch: false,
954                first_row_measures: None,
955            },
956        );
957        assert_eq!(result.rows.len(), 2);
958        assert_eq!(result.rows[0].measure_indices, vec![0]);
959        assert_eq!(result.rows[1].measure_indices, vec![1, 2]);
960    }
961
962    #[test]
963    fn system_break_overrides_per_row() {
964        // per_row=4 but system_break after measure[1] → row ends early
965        let mut score = score_with_measures(5);
966        score.parts[0].staves[0].measures[1].system_break = true;
967        let result = compute_layout(
968            &score,
969            &LayoutConfig {
970                measures_per_row: 4,
971                concert_pitch: false,
972                first_row_measures: None,
973            },
974        );
975        assert_eq!(result.rows.len(), 2);
976        assert_eq!(result.rows[0].measure_indices, vec![0, 1]);
977        assert_eq!(result.rows[1].measure_indices, vec![2, 3, 4]);
978    }
979
980    #[test]
981    fn no_break_unchanged() {
982        let score = score_with_measures(3);
983        let result = compute_layout(
984            &score,
985            &LayoutConfig {
986                measures_per_row: 4,
987                concert_pitch: false,
988                first_row_measures: None,
989            },
990        );
991        assert_eq!(result.rows.len(), 1);
992        assert_eq!(result.rows[0].measure_indices, vec![0, 1, 2]);
993    }
994
995    // ── first_row_measures ────────────────────────────────────────────────────
996
997    #[test]
998    fn first_row_measures_limits_first_row() {
999        // 5 measures, per_row=4, first_row_measures=2 → row[0]=2, row[1]=3
1000        let score = score_with_measures(5);
1001        let result = compute_layout(
1002            &score,
1003            &LayoutConfig {
1004                measures_per_row: 4,
1005                concert_pitch: false,
1006                first_row_measures: Some(2),
1007            },
1008        );
1009        assert_eq!(result.rows.len(), 2);
1010        assert_eq!(result.rows[0].measure_indices, vec![0, 1]);
1011        assert_eq!(result.rows[1].measure_indices, vec![2, 3, 4]);
1012    }
1013
1014    #[test]
1015    fn first_row_measures_none_unchanged() {
1016        // first_row_measures=None → same as using per_row for all rows
1017        let score = score_with_measures(5);
1018        let without = compute_layout(
1019            &score,
1020            &LayoutConfig {
1021                measures_per_row: 4,
1022                concert_pitch: false,
1023                first_row_measures: None,
1024            },
1025        );
1026        let with_none = compute_layout(&score, &LayoutConfig::default());
1027        assert_eq!(without.rows.len(), with_none.rows.len());
1028        for (a, b) in without.rows.iter().zip(with_none.rows.iter()) {
1029            assert_eq!(a.measure_indices, b.measure_indices);
1030        }
1031    }
1032
1033    #[test]
1034    fn beam_groups_empty_for_default_score() {
1035        let score = Score::default();
1036        let result = compute_layout(&score, &LayoutConfig::default());
1037        assert!(result.beam_groups.is_empty());
1038    }
1039
1040    #[test]
1041    fn display_beams_follow_simple_and_compound_meter_without_changing_score() {
1042        use acorde_core::{Duration, Note, Pitch, Step, TimeSignature};
1043        let note = || Note::new(Pitch::new(Step::C, 4), Duration::Eighth);
1044        let mut score = score_with_measures(2);
1045        score.parts[0].staves[0].measures[0].voices[0] = vec![note(); 4];
1046        score.parts[0].staves[0].measures[1].time_sig = Some(TimeSignature {
1047            numerator: 6,
1048            denominator: 8,
1049        });
1050        score.parts[0].staves[0].measures[1].voices[0] = vec![note(); 6];
1051        let original = score.clone();
1052
1053        assert!(
1054            compute_layout(&score, &LayoutConfig::default())
1055                .beam_groups
1056                .is_empty()
1057        );
1058        let layout = compute_layout_with_display_beams(&score, &LayoutConfig::default());
1059        let groups: Vec<_> = layout
1060            .beam_groups
1061            .iter()
1062            .map(|g| (g.measure, g.note_indices.clone()))
1063            .collect();
1064        assert_eq!(
1065            groups,
1066            vec![
1067                (0, vec![0, 1]),
1068                (0, vec![2, 3]),
1069                (1, vec![0, 1, 2]),
1070                (1, vec![3, 4, 5])
1071            ]
1072        );
1073        assert_eq!(
1074            serde_json::to_value(&score).unwrap(),
1075            serde_json::to_value(&original).unwrap()
1076        );
1077    }
1078
1079    #[test]
1080    fn display_beams_respect_authored_unbeamed_rest_grace_and_barlines() {
1081        use acorde_core::{BeamState, Duration, Note, Pitch, Step};
1082        let note = || Note::new(Pitch::new(Step::C, 4), Duration::Eighth);
1083        let mut score = score_with_measures(2);
1084        let mut authored = note();
1085        authored.beam = BeamState::Begin;
1086        let mut authored_end = note();
1087        authored_end.beam = BeamState::End;
1088        let mut no = note();
1089        no.explicit_unbeamed = true;
1090        let mut grace = note();
1091        grace.is_grace = true;
1092        score.parts[0].staves[0].measures[0].voices[0] = vec![
1093            authored,
1094            authored_end,
1095            no,
1096            note(),
1097            Note::rest(Duration::Eighth),
1098            note(),
1099            grace,
1100            note(),
1101        ];
1102        score.parts[0].staves[0].measures[1].voices[0] = vec![note(), note()];
1103
1104        let layout = compute_layout_with_display_beams(&score, &LayoutConfig::default());
1105        let groups: Vec<_> = layout
1106            .beam_groups
1107            .iter()
1108            .map(|g| (g.measure, g.note_indices.clone()))
1109            .collect();
1110        assert_eq!(groups, vec![(0, vec![0, 1]), (1, vec![0, 1])]);
1111    }
1112
1113    #[test]
1114    fn display_beams_keep_pickup_and_tuplet_boundaries_separate() {
1115        use acorde_core::{Duration, Note, Pitch, Step, TupletBoundary, TupletInfo};
1116        let mut score = score_with_measures(2);
1117        let mut notes: Vec<_> = (0..6)
1118            .map(|_| Note::new(Pitch::new(Step::C, 4), Duration::Eighth))
1119            .collect();
1120        for note in &mut notes[..3] {
1121            note.tuplet = Some(TupletInfo {
1122                actual_notes: 3,
1123                normal_notes: 2,
1124            });
1125        }
1126        notes[0].tuplet_boundary = Some(TupletBoundary::Start);
1127        notes[2].tuplet_boundary = Some(TupletBoundary::Stop);
1128        // A short first measure is a pickup; its beam groups remain measure-local.
1129        score.parts[0].staves[0].measures[0].voices[0] = notes;
1130        score.parts[0].staves[0].measures[1].voices[0] = (0..2)
1131            .map(|_| Note::new(Pitch::new(Step::D, 4), Duration::Eighth))
1132            .collect();
1133
1134        let layout = compute_layout_with_display_beams(&score, &LayoutConfig::default());
1135        assert_eq!(layout.beam_groups[0].note_indices, vec![0, 1, 2]);
1136        assert!(
1137            layout
1138                .beam_groups
1139                .iter()
1140                .any(|group| group.measure == 1 && group.note_indices == vec![0, 1])
1141        );
1142        assert!(
1143            layout
1144                .beam_groups
1145                .iter()
1146                .all(|g| !g.note_indices.contains(&2) || !g.note_indices.contains(&3))
1147        );
1148    }
1149
1150    #[test]
1151    fn layout_exposes_source_voice_number_for_canonical_slot() {
1152        let mut score = score_with_measures(1);
1153        score.parts[0].staves[0].measures[0].source_voice_numbers[1] = Some(5);
1154
1155        let result = compute_layout(&score, &LayoutConfig::default());
1156        assert_eq!(
1157            result.source_voice_addresses,
1158            vec![SourceVoiceAddress {
1159                part: 0,
1160                staff: 0,
1161                measure: 0,
1162                voice: 1,
1163                source_voice_number: 5,
1164            }]
1165        );
1166    }
1167
1168    #[test]
1169    fn beam_groups_begin_end_collected() {
1170        use acorde_core::{BeamState, Duration, Note, Pitch, Step};
1171        let mut score = score_with_measures(1);
1172        let mut n1 = Note::new(Pitch::new(Step::C, 4), Duration::Eighth);
1173        n1.beam = BeamState::Begin;
1174        let mut n2 = Note::new(Pitch::new(Step::D, 4), Duration::Eighth);
1175        n2.beam = BeamState::Continue;
1176        let mut n3 = Note::new(Pitch::new(Step::E, 4), Duration::Eighth);
1177        n3.beam = BeamState::End;
1178        score.parts[0].staves[0].measures[0].voices[0] = vec![n1, n2, n3];
1179
1180        let result = compute_layout(&score, &LayoutConfig::default());
1181        assert_eq!(result.beam_groups.len(), 1);
1182        assert_eq!(result.beam_groups[0].note_indices, vec![0, 1, 2]);
1183        assert_eq!(result.beam_groups[0].part, 0);
1184        assert_eq!(result.beam_groups[0].measure, 0);
1185        assert_eq!(result.beam_groups[0].voice, 0);
1186    }
1187
1188    #[test]
1189    fn beam_groups_beginend_is_standalone_group() {
1190        use acorde_core::{BeamState, Duration, Note, Pitch, Step};
1191        let mut score = score_with_measures(1);
1192        let mut n = Note::new(Pitch::new(Step::C, 4), Duration::Eighth);
1193        n.beam = BeamState::BeginEnd;
1194        score.parts[0].staves[0].measures[0].voices[0] = vec![n];
1195
1196        let result = compute_layout(&score, &LayoutConfig::default());
1197        assert_eq!(result.beam_groups.len(), 1);
1198        assert_eq!(result.beam_groups[0].note_indices, vec![0]);
1199    }
1200
1201    #[test]
1202    fn tuplet_groups_empty_for_default_score() {
1203        let score = Score::default();
1204        let result = compute_layout(&score, &LayoutConfig::default());
1205        assert!(result.tuplet_groups.is_empty());
1206    }
1207
1208    #[test]
1209    fn tuplet_groups_triplet_collected() {
1210        use acorde_core::{Duration, Note, Pitch, Step, TupletInfo};
1211        let ti = TupletInfo {
1212            actual_notes: 3,
1213            normal_notes: 2,
1214        };
1215        let mut score = score_with_measures(1);
1216        let notes: Vec<Note> = (0..3)
1217            .map(|i| {
1218                let step = [Step::C, Step::D, Step::E][i].clone();
1219                let mut n = Note::new(Pitch::new(step, 4), Duration::Quarter);
1220                n.tuplet = Some(ti.clone());
1221                n
1222            })
1223            .collect();
1224        score.parts[0].staves[0].measures[0].voices[0] = notes;
1225
1226        let result = compute_layout(&score, &LayoutConfig::default());
1227        assert_eq!(result.tuplet_groups.len(), 1);
1228        assert_eq!(result.tuplet_groups[0].note_indices, vec![0, 1, 2]);
1229        assert_eq!(result.tuplet_groups[0].actual_notes, 3);
1230        assert_eq!(result.tuplet_groups[0].normal_notes, 2);
1231        assert_eq!(result.tuplet_groups[0].part, 0);
1232        assert_eq!(result.tuplet_groups[0].measure, 0);
1233    }
1234
1235    #[test]
1236    fn tuplet_groups_no_group_for_single_tuplet_note() {
1237        use acorde_core::{Duration, Note, Pitch, Step, TupletInfo};
1238        let mut score = score_with_measures(1);
1239        let mut n = Note::new(Pitch::new(Step::C, 4), Duration::Quarter);
1240        n.tuplet = Some(TupletInfo {
1241            actual_notes: 3,
1242            normal_notes: 2,
1243        });
1244        score.parts[0].staves[0].measures[0].voices[0] = vec![n];
1245
1246        let result = compute_layout(&score, &LayoutConfig::default());
1247        // Single-note tuplet: not enough to form a group (need >= 2)
1248        assert!(result.tuplet_groups.is_empty());
1249    }
1250
1251    #[test]
1252    fn hairpin_span_resolved() {
1253        use acorde_core::{Duration, HairpinKind, Note, Pitch, Step};
1254        let mut score = score_with_measures(1);
1255        let mut n1 = Note::new(Pitch::new(Step::C, 4), Duration::Quarter);
1256        n1.hairpin_start = Some(HairpinKind::Crescendo);
1257        let mut n2 = Note::new(Pitch::new(Step::D, 4), Duration::Quarter);
1258        n2.hairpin_end = true;
1259        score.parts[0].staves[0].measures[0].voices[0] = vec![n1, n2];
1260
1261        let result = compute_layout(&score, &LayoutConfig::default());
1262        assert_eq!(result.spans.len(), 1);
1263        if let SpanMark::Hairpin { kind, start, end } = &result.spans[0] {
1264            assert_eq!(*kind, HairpinKind::Crescendo);
1265            assert_eq!(start.note, 0);
1266            assert_eq!(end.note, 1);
1267        } else {
1268            panic!("expected Hairpin span");
1269        }
1270    }
1271
1272    #[test]
1273    fn slur_span_resolved() {
1274        use acorde_core::{Duration, Note, Pitch, Step};
1275        let mut score = score_with_measures(1);
1276        let mut n1 = Note::new(Pitch::new(Step::C, 4), Duration::Quarter);
1277        n1.slur_start = true;
1278        let mut n2 = Note::new(Pitch::new(Step::D, 4), Duration::Quarter);
1279        n2.slur_end = true;
1280        score.parts[0].staves[0].measures[0].voices[0] = vec![n1, n2];
1281
1282        let result = compute_layout(&score, &LayoutConfig::default());
1283        let slur = result
1284            .spans
1285            .iter()
1286            .find(|s| matches!(s, SpanMark::Slur { .. }));
1287        assert!(slur.is_some(), "expected a Slur span");
1288        if let Some(SpanMark::Slur { start, end }) = slur {
1289            assert_eq!(start.note, 0);
1290            assert_eq!(end.note, 1);
1291        }
1292    }
1293
1294    #[test]
1295    fn adjacent_legacy_slurs_share_an_endpoint_without_zero_length() {
1296        use acorde_core::{Duration, Note, Pitch, Step};
1297        let mut score = score_with_measures(1);
1298        let mut notes = [Step::C, Step::D, Step::E, Step::F]
1299            .map(|step| Note::new(Pitch::new(step, 4), Duration::Quarter));
1300        notes[0].slur_start = true;
1301        notes[1].slur_end = true;
1302        notes[1].slur_start = true;
1303        notes[2].slur_end = true;
1304        score.parts[0].staves[0].measures[0].voices[0] = notes.to_vec();
1305        let slurs = compute_layout(&score, &LayoutConfig::default())
1306            .spans
1307            .into_iter()
1308            .filter_map(|span| match span {
1309                SpanMark::Slur { start, end } => Some((start.note, end.note)),
1310                _ => None,
1311            })
1312            .collect::<Vec<_>>();
1313        assert_eq!(slurs, vec![(0, 1), (1, 2)]);
1314    }
1315
1316    #[test]
1317    fn nested_legacy_slurs_close_in_last_in_first_out_order() {
1318        use acorde_core::{Duration, Note, Pitch, Step};
1319        let mut score = score_with_measures(1);
1320        let mut notes = [Step::C, Step::D, Step::E, Step::F]
1321            .map(|step| Note::new(Pitch::new(step, 4), Duration::Quarter));
1322        notes[0].slur_start = true;
1323        notes[1].slur_start = true;
1324        notes[2].slur_end = true;
1325        notes[3].slur_end = true;
1326        score.parts[0].staves[0].measures[0].voices[0] = notes.to_vec();
1327        let slurs = compute_layout(&score, &LayoutConfig::default())
1328            .spans
1329            .into_iter()
1330            .filter_map(|span| match span {
1331                SpanMark::Slur { start, end } => Some((start.note, end.note)),
1332                _ => None,
1333            })
1334            .collect::<Vec<_>>();
1335        assert_eq!(slurs, vec![(1, 2), (0, 3)]);
1336    }
1337
1338    #[test]
1339    fn typed_slurs_keep_overlapping_pairs_without_legacy_duplicates() {
1340        use acorde_core::{Duration, Note, Pitch, Step};
1341        let mut score = score_with_measures(1);
1342        let mut notes = [Step::C, Step::D, Step::E, Step::F]
1343            .map(|step| Note::new(Pitch::new(step, 4), Duration::Quarter));
1344        notes[0].slur_start = true;
1345        notes[1].slur_start = true;
1346        notes[2].slur_end = true;
1347        notes[3].slur_end = true;
1348        score.parts[0].staves[0].measures[0].voices[0] = notes.to_vec();
1349        for (id, start, end) in [("outer", 0, 2), ("overlap", 1, 3)] {
1350            score.spanners.push(NotationSpanner {
1351                id: id.into(),
1352                kind: NotationSpannerKind::Slur,
1353                start: NoteAddr {
1354                    part: 0,
1355                    staff: 0,
1356                    measure: 0,
1357                    voice: 0,
1358                    note: start,
1359                },
1360                end: NoteAddr {
1361                    part: 0,
1362                    staff: 0,
1363                    measure: 0,
1364                    voice: 0,
1365                    note: end,
1366                },
1367                number: None,
1368                line_type: None,
1369                text: None,
1370                placement: None,
1371                ottava_size: None,
1372                ottava_type: None,
1373            });
1374        }
1375        let slurs = compute_layout(&score, &LayoutConfig::default())
1376            .spans
1377            .into_iter()
1378            .filter_map(|span| match span {
1379                SpanMark::Slur { start, end } => Some((start.note, end.note)),
1380                _ => None,
1381            })
1382            .collect::<Vec<_>>();
1383        assert_eq!(slurs, vec![(0, 2), (1, 3)]);
1384    }
1385
1386    #[test]
1387    fn typed_spanners_keep_stable_identity_in_layout_result() {
1388        use acorde_core::{Duration, NotationSpanner, NotationSpannerKind, Note, Pitch, Step};
1389        let mut score = score_with_measures(1);
1390        score.parts[0].staves[0].measures[0].voices[0] = vec![
1391            Note::new(Pitch::new(Step::C, 4), Duration::Quarter),
1392            Note::new(Pitch::new(Step::D, 4), Duration::Quarter),
1393        ];
1394        score.spanners.push(NotationSpanner {
1395            id: "typed-slur-7".to_string(),
1396            kind: NotationSpannerKind::Slur,
1397            start: NoteAddr {
1398                part: 0,
1399                staff: 0,
1400                measure: 0,
1401                voice: 0,
1402                note: 0,
1403            },
1404            end: NoteAddr {
1405                part: 0,
1406                staff: 0,
1407                measure: 0,
1408                voice: 0,
1409                note: 1,
1410            },
1411            number: Some(7),
1412            line_type: Some("dashed".to_string()),
1413            text: None,
1414            placement: Some("above".to_string()),
1415            ottava_size: None,
1416            ottava_type: None,
1417        });
1418
1419        let result = compute_layout(&score, &LayoutConfig::default());
1420        assert_eq!(result.typed_spanners.len(), 1);
1421        assert_eq!(result.typed_spanners[0].id, "typed-slur-7");
1422        assert_eq!(result.typed_spanners[0].number, Some(7));
1423    }
1424
1425    #[test]
1426    fn harmony_range_span_resolved_from_typed_end_address() {
1427        use acorde_core::{ChordSymbol, Duration, Note, NoteAddr, Pitch, Step};
1428        let mut score = score_with_measures(2);
1429        score.parts[0].staves[0].measures[0].voices[0] =
1430            vec![Note::new(Pitch::new(Step::C, 4), Duration::Whole)];
1431        score.parts[0].staves[0].measures[1].voices[0] =
1432            vec![Note::new(Pitch::new(Step::G, 4), Duration::Whole)];
1433        score.parts[0].staves[0].measures[0].voices[0][0].chord_symbol = Some(ChordSymbol {
1434            root: "C".to_owned(),
1435            kind: "major".to_owned(),
1436            bass: None,
1437            placement: None,
1438            extender: true,
1439            harmonic_degree: None,
1440            harmony_function: None,
1441            harmony_type: None,
1442            chord_ref: None,
1443            range_end: Some(NoteAddr {
1444                part: 0,
1445                staff: 0,
1446                measure: 1,
1447                voice: 0,
1448                note: 0,
1449            }),
1450            degrees: Vec::new(),
1451        });
1452
1453        let result = compute_layout(&score, &LayoutConfig::default());
1454        assert!(matches!(
1455            result.spans.as_slice(),
1456            [SpanMark::Harmony { label, start, end }]
1457                if label == "C" && start.measure == 0 && end.measure == 1
1458        ));
1459    }
1460
1461    // ── CourtesyAccidental ────────────────────────────────────────────────────
1462
1463    #[test]
1464    fn courtesy_none_for_clean_score() {
1465        // Default score has no chromatic alterations — no courtesy accidentals.
1466        let score = Score::default();
1467        let result = compute_layout(&score, &LayoutConfig::default());
1468        assert!(result.courtesy_accidentals.is_empty());
1469    }
1470
1471    #[test]
1472    fn courtesy_after_chromatic_alteration() {
1473        // Measure 0: F# (alter=1). Measure 1: F natural (alter=0).
1474        // The F in measure 1 should get a courtesy accidental.
1475        use acorde_core::{Duration, Note, Pitch, Step};
1476        let mut score = score_with_measures(2);
1477
1478        let mut fsharp = Note::new(Pitch::new(Step::F, 4), Duration::Quarter);
1479        fsharp.pitches[0].alter = 1;
1480        score.parts[0].staves[0].measures[0].voices[0] = vec![fsharp];
1481
1482        let fnat = Note::new(Pitch::new(Step::F, 4), Duration::Quarter);
1483        // alter=0 is default; key signature is C major (fifths=0) so F natural has key_alter=0
1484        score.parts[0].staves[0].measures[1].voices[0] = vec![fnat];
1485
1486        let result = compute_layout(&score, &LayoutConfig::default());
1487        assert_eq!(result.courtesy_accidentals.len(), 1);
1488        let ca = &result.courtesy_accidentals[0];
1489        assert_eq!(ca.measure, 1);
1490        assert_eq!(ca.alter, 0); // natural sign
1491    }
1492
1493    #[test]
1494    fn courtesy_same_alteration_no_courtesy() {
1495        // Measure 0: F#. Measure 1: F# again.
1496        // The first F# needs a mandatory accidental, not an extra courtesy.
1497        use acorde_core::{Duration, Note, Pitch, Step};
1498        let mut score = score_with_measures(2);
1499
1500        let mut fsharp1 = Note::new(Pitch::new(Step::F, 4), Duration::Quarter);
1501        fsharp1.pitches[0].alter = 1;
1502        score.parts[0].staves[0].measures[0].voices[0] = vec![fsharp1];
1503
1504        let mut fsharp2 = Note::new(Pitch::new(Step::F, 4), Duration::Quarter);
1505        fsharp2.pitches[0].alter = 1;
1506        score.parts[0].staves[0].measures[1].voices[0] = vec![fsharp2];
1507
1508        let result = compute_layout(&score, &LayoutConfig::default());
1509        assert!(result.courtesy_accidentals.is_empty());
1510    }
1511
1512    #[test]
1513    fn courtesy_tied_note_excluded() {
1514        // A note with tie_end=true should never get a courtesy accidental.
1515        use acorde_core::{Duration, Note, Pitch, Step};
1516        let mut score = score_with_measures(2);
1517
1518        let mut fsharp = Note::new(Pitch::new(Step::F, 4), Duration::Quarter);
1519        fsharp.pitches[0].alter = 1;
1520        score.parts[0].staves[0].measures[0].voices[0] = vec![fsharp];
1521
1522        let mut tied = Note::new(Pitch::new(Step::F, 4), Duration::Quarter);
1523        tied.pitches[0].alter = 1;
1524        tied.tie_end = true;
1525        score.parts[0].staves[0].measures[1].voices[0] = vec![tied];
1526
1527        let result = compute_layout(&score, &LayoutConfig::default());
1528        assert!(result.courtesy_accidentals.is_empty());
1529    }
1530
1531    #[test]
1532    fn courtesy_key_change_resets() {
1533        // Measure 0: F# (alter=1). Measure 1: key changes to G major (fifths=1, F# implied).
1534        // The key change clears prev_alters, so F in measure 1 won't get a courtesy.
1535        use acorde_core::{Duration, KeySignature, Note, Pitch, Step};
1536        let mut score = score_with_measures(2);
1537
1538        let mut fsharp = Note::new(Pitch::new(Step::F, 4), Duration::Quarter);
1539        fsharp.pitches[0].alter = 1;
1540        score.parts[0].staves[0].measures[0].voices[0] = vec![fsharp];
1541
1542        // Set key signature on measure 1 to G major (1 sharp = F#)
1543        score.parts[0].staves[0].measures[1].key_sig = Some(KeySignature {
1544            fifths: 1,
1545            mode: "major".to_string(),
1546        });
1547        // F# is now implied by the key — alter=1 == key_alter(1, F) → not in prev_alters
1548        let mut fsharp2 = Note::new(Pitch::new(Step::F, 4), Duration::Quarter);
1549        fsharp2.pitches[0].alter = 1;
1550        score.parts[0].staves[0].measures[1].voices[0] = vec![fsharp2];
1551
1552        let result = compute_layout(&score, &LayoutConfig::default());
1553        // key change clears prev_alters before phase 1 → no courtesy for measure 1
1554        assert!(result.courtesy_accidentals.is_empty());
1555    }
1556
1557    // ── AccidentalMark ────────────────────────────────────────────────────────
1558
1559    #[test]
1560    fn requested_accidentals_are_drawn_where_the_rules_imply_them() {
1561        use acorde_core::{Duration, Note, Pitch, Step};
1562        let mut score = score_with_measures(1);
1563        let mut cautionary = Note::new(Pitch::new(Step::C, 4), Duration::Quarter);
1564        cautionary.set_accidental_display(0, AccidentalDisplay::Cautionary);
1565        let mut sharp = Note::new(Pitch::with_alter(Step::F, 4, 1), Duration::Quarter);
1566        sharp.set_accidental_display(0, AccidentalDisplay::Parenthesized);
1567        let mut bracketed = Note::new(Pitch::new(Step::G, 4), Duration::Quarter);
1568        bracketed.set_accidental_display(0, AccidentalDisplay::Parenthesized);
1569        let plain = Note::new(Pitch::new(Step::A, 4), Duration::Quarter);
1570        score.parts[0].staves[0].measures[0].voices[0] = vec![cautionary, sharp, bracketed, plain];
1571
1572        let result = compute_layout(&score, &LayoutConfig::default());
1573        let mandatory: Vec<usize> = result.accidentals.iter().map(|a| a.note_index).collect();
1574        let courtesy: Vec<usize> = result
1575            .courtesy_accidentals
1576            .iter()
1577            .map(|a| a.note_index)
1578            .collect();
1579        // The cautionary natural is drawn plain; the sharp and the natural asked for in
1580        // parentheses are drawn as courtesy marks, and the sharp is not drawn twice.
1581        assert_eq!(mandatory, vec![0]);
1582        assert_eq!(courtesy, vec![1, 2]);
1583    }
1584
1585    #[test]
1586    fn accidental_none_for_clean_score() {
1587        let score = Score::default();
1588        let result = compute_layout(&score, &LayoutConfig::default());
1589        assert!(result.accidentals.is_empty());
1590    }
1591
1592    #[test]
1593    fn accidental_first_chromatic_note_in_measure() {
1594        // C major, single F# in measure 0 → one mandatory accidental (sharp).
1595        use acorde_core::{Duration, Note, Pitch, Step};
1596        let mut score = score_with_measures(1);
1597        let mut fsharp = Note::new(Pitch::new(Step::F, 4), Duration::Quarter);
1598        fsharp.pitches[0].alter = 1;
1599        score.parts[0].staves[0].measures[0].voices[0] = vec![fsharp];
1600
1601        let result = compute_layout(&score, &LayoutConfig::default());
1602        assert_eq!(result.accidentals.len(), 1);
1603        assert_eq!(result.accidentals[0].alter, 1);
1604        assert_eq!(result.accidentals[0].measure, 0);
1605    }
1606
1607    #[test]
1608    fn accidental_repeat_same_alter_in_measure_not_marked_again() {
1609        // Two F#s in the same measure: only the first needs an accidental.
1610        use acorde_core::{Duration, Note, Pitch, Step};
1611        let mut score = score_with_measures(1);
1612        let mut f1 = Note::new(Pitch::new(Step::F, 4), Duration::Quarter);
1613        f1.pitches[0].alter = 1;
1614        let mut f2 = Note::new(Pitch::new(Step::F, 4), Duration::Quarter);
1615        f2.pitches[0].alter = 1;
1616        score.parts[0].staves[0].measures[0].voices[0] = vec![f1, f2];
1617
1618        let result = compute_layout(&score, &LayoutConfig::default());
1619        assert_eq!(result.accidentals.len(), 1);
1620    }
1621
1622    #[test]
1623    fn accidental_reverts_to_natural_within_same_measure() {
1624        // F# then F natural, same measure: the natural needs its own mark too.
1625        use acorde_core::{Duration, Note, Pitch, Step};
1626        let mut score = score_with_measures(1);
1627        let mut f1 = Note::new(Pitch::new(Step::F, 4), Duration::Quarter);
1628        f1.pitches[0].alter = 1;
1629        let f2 = Note::new(Pitch::new(Step::F, 4), Duration::Quarter); // alter=0
1630        score.parts[0].staves[0].measures[0].voices[0] = vec![f1, f2];
1631
1632        let result = compute_layout(&score, &LayoutConfig::default());
1633        assert_eq!(result.accidentals.len(), 2);
1634        assert_eq!(result.accidentals[0].alter, 1);
1635        assert_eq!(result.accidentals[1].alter, 0);
1636    }
1637
1638    #[test]
1639    fn accidental_does_not_carry_across_barline() {
1640        // F# in measure 0; measure 1's F# needs its own mark (accidentals reset per measure).
1641        // This is the case that would otherwise double up with a CourtesyAccidental —
1642        // callers must prefer `accidentals` over `courtesy_accidentals` when both exist.
1643        use acorde_core::{Duration, Note, Pitch, Step};
1644        let mut score = score_with_measures(2);
1645        let mut f1 = Note::new(Pitch::new(Step::F, 4), Duration::Quarter);
1646        f1.pitches[0].alter = 1;
1647        score.parts[0].staves[0].measures[0].voices[0] = vec![f1];
1648        let mut f2 = Note::new(Pitch::new(Step::F, 4), Duration::Quarter);
1649        f2.pitches[0].alter = 1;
1650        score.parts[0].staves[0].measures[1].voices[0] = vec![f2];
1651
1652        let result = compute_layout(&score, &LayoutConfig::default());
1653        assert_eq!(result.accidentals.len(), 2);
1654        assert!(result.accidentals.iter().any(|a| a.measure == 1));
1655        assert!(result.courtesy_accidentals.is_empty());
1656    }
1657
1658    #[test]
1659    fn accidental_tied_note_excluded() {
1660        use acorde_core::{Duration, Note, Pitch, Step};
1661        let mut score = score_with_measures(1);
1662        let mut tied = Note::new(Pitch::new(Step::F, 4), Duration::Quarter);
1663        tied.pitches[0].alter = 1;
1664        tied.tie_end = true;
1665        score.parts[0].staves[0].measures[0].voices[0] = vec![tied];
1666
1667        let result = compute_layout(&score, &LayoutConfig::default());
1668        assert!(result.accidentals.is_empty());
1669    }
1670
1671    #[test]
1672    fn accidental_shared_across_voices_on_same_staff() {
1673        // Voice 0 introduces F#; voice 1's F# later in the same measure shares the context.
1674        use acorde_core::{Duration, Note, Pitch, Step};
1675        let mut score = score_with_measures(1);
1676        let mut f_v0 = Note::new(Pitch::new(Step::F, 4), Duration::Quarter);
1677        f_v0.pitches[0].alter = 1;
1678        score.parts[0].staves[0].measures[0].voices[0] = vec![f_v0];
1679        let mut f_v1 = Note::new(Pitch::new(Step::F, 4), Duration::Quarter);
1680        f_v1.pitches[0].alter = 1;
1681        score.parts[0].staves[0].measures[0].voices[1] = vec![f_v1];
1682
1683        let result = compute_layout(&score, &LayoutConfig::default());
1684        assert_eq!(result.accidentals.len(), 1);
1685    }
1686
1687    #[test]
1688    fn accidental_double_sharp_marked() {
1689        use acorde_core::{Duration, Note, Pitch, Step};
1690        let mut score = score_with_measures(1);
1691        let mut n = Note::new(Pitch::new(Step::F, 4), Duration::Quarter);
1692        n.pitches[0].alter = 2;
1693        score.parts[0].staves[0].measures[0].voices[0] = vec![n];
1694
1695        let result = compute_layout(&score, &LayoutConfig::default());
1696        assert_eq!(result.accidentals.len(), 1);
1697        assert_eq!(result.accidentals[0].alter, 2);
1698    }
1699}