mtrack 0.12.0

// Copyright (C) 2026 Michael Wilson <mike@mdwn.dev>
//
// This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software
// Foundation, version 3.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along with
// this program. If not, see <https://www.gnu.org/licenses/>.
//
use crate::lighting::parser::*;
use crate::lighting::tempo::TempoTransition;
use std::time::Duration;

#[test]
fn test_end_to_end_measure_to_time_conversion() {
    // Test that measure-based cues convert to correct absolute times
    let content = r#"tempo {
    start: 0.0s
    bpm: 120
    time_signature: 4/4
}

show "Measure Conversion Test" {
    @1/1
    front_wash: static color: "blue", duration: 5s
    
    @2/1
    back_wash: static color: "red", duration: 5s
    
    @4/1
    side_wash: static color: "green", duration: 5s
}"#;

    let result = parse_light_shows(content);
    if let Err(e) = &result {
        println!("Parser error: {}", e);
        println!("Full error details: {:?}", e);
    }
    assert!(result.is_ok(), "Show should parse successfully");
    let shows = result.unwrap();
    let show = shows.get("Measure Conversion Test").unwrap();

    // At 120 BPM in 4/4: 1 beat = 0.5s, 1 measure = 2s
    // Measure 1, beat 1 = 0.0s
    // Measure 2, beat 1 = 2.0s
    // Measure 4, beat 1 = 6.0s
    assert_eq!(show.cues.len(), 3);
    assert_eq!(show.cues[0].time.as_secs_f64(), 0.0);
    assert_eq!(show.cues[1].time.as_secs_f64(), 2.0);
    assert_eq!(show.cues[2].time.as_secs_f64(), 6.0);
}

#[test]
fn test_end_to_end_fractional_beat_conversion() {
    // Test fractional beat positions
    let content = r#"tempo {
    start: 0.0s
    bpm: 120
    time_signature: 4/4
}

show "Fractional Beat Test" {
    @1/1
    front_wash: static color: "blue", duration: 5s
    
    @1/2
    back_wash: static color: "red", duration: 5s
    
    @1/2.5
    side_wash: static color: "green", duration: 5s
}"#;

    let result = parse_light_shows(content);
    if let Err(e) = &result {
        println!("Parse error: {}", e);
    }
    assert!(result.is_ok());
    let shows = result.unwrap();
    let show = shows.get("Fractional Beat Test").unwrap();

    // At 120 BPM: 1 beat = 0.5s
    // Measure 1, beat 1 = 0.0s
    // Measure 1, beat 2 = 0.5s
    // Measure 1, beat 2.5 = 0.75s
    assert_eq!(show.cues.len(), 3);
    assert_eq!(show.cues[0].time.as_secs_f64(), 0.0);
    let time1 = show.cues[1].time.as_secs_f64();
    let time2 = show.cues[2].time.as_secs_f64();
    println!(
        "Fractional beat test: beat 2 = {}s (expected 0.5s), beat 2.5 = {}s (expected 0.75s)",
        time1, time2
    );
    assert!((time1 - 0.5).abs() < 0.001, "Expected 0.5s, got {}s", time1);
    assert!(
        (time2 - 0.75).abs() < 0.001,
        "Expected 0.75s, got {}s",
        time2
    );
}

#[test]
fn test_end_to_end_beat_duration_conversion() {
    // Test that beat durations convert correctly
    let content = r#"tempo {
    start: 0.0s
    bpm: 120
    time_signature: 4/4
}

show "Beat Duration Test" {
    @1/1
    front_wash: static color: "blue", duration: 4beats
}"#;

    let result = parse_light_shows(content);
    if let Err(e) = &result {
        println!("Parse error: {}", e);
    }
    assert!(result.is_ok());
    let shows = result.unwrap();
    let show = shows.get("Beat Duration Test").unwrap();

    // At 120 BPM: 4 beats = 2.0s
    let effect = &show.cues[0].effects[0];
    let duration = effect.effect_type.duration();
    assert!(
        (duration.as_secs_f64() - 2.0).abs() < 0.001,
        "4 beats should be 2.0s at 120 BPM"
    );
}

#[test]
fn test_end_to_end_measure_duration_conversion() {
    // Test that measure durations convert correctly
    let content = r#"tempo {
    start: 0.0s
    bpm: 120
    time_signature: 4/4
}

show "Measure Duration Test" {
    @1/1
    front_wash: static color: "blue", duration: 2measures
}"#;

    let result = parse_light_shows(content);
    if let Err(e) = &result {
        println!("Parse error: {}", e);
    }
    assert!(result.is_ok());
    let shows = result.unwrap();
    let show = shows.get("Measure Duration Test").unwrap();

    // At 120 BPM in 4/4: 2 measures = 4.0s
    let effect = &show.cues[0].effects[0];
    let duration = effect.effect_type.duration();
    assert!(
        (duration.as_secs_f64() - 4.0).abs() < 0.001,
        "2 measures should be 4.0s at 120 BPM in 4/4"
    );
}

#[test]
fn test_end_to_end_tempo_change_affects_timing() {
    // Test that tempo changes affect subsequent measure-to-time conversions
    let content = r#"tempo {
    start: 0.0s
    bpm: 120
    time_signature: 4/4
    changes: [
    @8/1 { bpm: 60 }
    ]
}

show "Tempo Change Test" {
    @4/1
    front_wash: static color: "blue", duration: 5s
    
    @8/1
    back_wash: static color: "red", duration: 5s
    
    @12/1
    side_wash: static color: "green", duration: 5s
}"#;

    let result = parse_light_shows(content);
    if let Err(e) = &result {
        println!("Parse error: {}", e);
    }
    assert!(result.is_ok());
    let shows = result.unwrap();
    let show = shows.get("Tempo Change Test").unwrap();

    // At 120 BPM: measure 4 = 6.0s (3 measures * 4 beats * 0.5 s/beat = 6s)
    // At 120 BPM: measure 8 = 14.0s (7 measures * 4 beats * 0.5 s/beat = 14s)
    // At 60 BPM (starting at measure 8): measure 12 = 14.0s + 16.0s = 30.0s
    // (4 measures * 4 beats/measure * 1.0 s/beat = 16s)
    assert_eq!(show.cues.len(), 3);
    assert!((show.cues[0].time.as_secs_f64() - 6.0).abs() < 0.001);
    assert!((show.cues[1].time.as_secs_f64() - 14.0).abs() < 0.001);
    assert!((show.cues[2].time.as_secs_f64() - 30.0).abs() < 0.001);
}

#[test]
fn test_end_to_end_time_signature_change_affects_timing() {
    // Test that time signature changes affect measure calculations
    let content = r#"tempo {
    start: 0.0s
    bpm: 120
    time_signature: 4/4
    changes: [
    @4/1 { time_signature: 3/4 }
    ]
}

show "Time Signature Change Test" {
    @4/1
    front_wash: static color: "blue", duration: 5s
    
    @5/1
    back_wash: static color: "red", duration: 5s
}"#;

    let result = parse_light_shows(content);
    if let Err(e) = &result {
        println!("Parse error: {}", e);
    }
    assert!(result.is_ok());
    let shows = result.unwrap();
    let show = shows.get("Time Signature Change Test").unwrap();

    // At 120 BPM in 4/4: measure 4 = 6.0s
    // At 120 BPM in 3/4: measure 5 = 6.0s + 1.5s = 7.5s
    assert_eq!(show.cues.len(), 2);
    let time0 = show.cues[0].time.as_secs_f64();
    let time1 = show.cues[1].time.as_secs_f64();
    println!(
        "Time sig change test: measure 4 = {}s (expected 6.0s), measure 5 = {}s (expected 7.5s)",
        time0, time1
    );
    assert!((time0 - 6.0).abs() < 0.001, "Expected 6.0s, got {}s", time0);
    assert!((time1 - 7.5).abs() < 0.001, "Expected 7.5s, got {}s", time1);
}

#[test]
fn test_end_to_end_beat_duration_with_tempo_change() {
    // Test that beat durations use the tempo at the cue time
    let content = r#"tempo {
    start: 0.0s
    bpm: 120
    time_signature: 4/4
    changes: [
    @4/1 { bpm: 60 }
    ]
}

show "Beat Duration Tempo Change Test" {
    @2/1
    front_wash: static color: "blue", duration: 4beats
    
    @5/1
    back_wash: static color: "red", duration: 4beats
}"#;

    let result = parse_light_shows(content);
    if let Err(e) = &result {
        println!("Parse error: {}", e);
    }
    assert!(result.is_ok());
    let shows = result.unwrap();
    let show = shows.get("Beat Duration Tempo Change Test").unwrap();

    // At 120 BPM: 4 beats = 2.0s
    let effect1 = &show.cues[0].effects[0];
    let duration1 = effect1.effect_type.duration();
    assert!(
        (duration1.as_secs_f64() - 2.0).abs() < 0.001,
        "4 beats at 120 BPM should be 2.0s"
    );

    // At 60 BPM: 4 beats = 4.0s
    // The tempo changes to 60 BPM at @4/1, so @5/1 should use 60 BPM
    let cue1_time = show.cues[1].time;
    let effect2 = &show.cues[1].effects[0];
    let duration2 = effect2.effect_type.duration();
    let actual_duration = duration2.as_secs_f64();
    println!("Beat duration with tempo change test: cue 0 at @2/1 (time={:?}), cue 1 at @5/1 (time={:?}), duration = {}s (expected 4.0s at 60 BPM)", show.cues[0].time, cue1_time, actual_duration);
    if let Some(tm) = &show.tempo_map {
        let bpm_at_cue0 = tm.bpm_at_time(show.cues[0].time, 0.0);
        let bpm_at_cue1 = tm.bpm_at_time(cue1_time, 0.0);
        println!(
            "BPM at cue 0 time {:?} = {}, BPM at cue 1 time {:?} = {}",
            show.cues[0].time, bpm_at_cue0, cue1_time, bpm_at_cue1
        );
        println!("Tempo changes: {:?}", tm.changes);
        for change in &tm.changes {
            if let Some(change_time) = change.position.absolute_time() {
                println!(
                    "  Change at {:?}: bpm={:?}, transition={:?}",
                    change_time, change.bpm, change.transition
                );
            }
        }
    }
    assert!(
        (actual_duration - 4.0).abs() < 0.001,
        "4 beats at 60 BPM should be 4.0s, got {}s",
        actual_duration
    );
}

#[test]
fn test_end_to_end_up_time_and_down_time_with_beats() {
    // Test that up_time and down_time work with beats
    let content = r#"tempo {
    start: 0.0s
    bpm: 120
    time_signature: 4/4
}

show "Beat Fade Times Test" {
    @1/1
    front_wash: static color: "blue", up_time: 2beats, down_time: 2beats, hold_time: 5s
}"#;

    let result = parse_light_shows(content);
    if let Err(e) = &result {
        println!("Parse error: {}", e);
    }
    assert!(result.is_ok());
    let shows = result.unwrap();
    let show = shows.get("Beat Fade Times Test").unwrap();

    // At 120 BPM: 2 beats = 1.0s
    let effect = &show.cues[0].effects[0];
    assert!(effect.up_time.is_some());
    assert!(effect.down_time.is_some());
    assert!((effect.up_time.unwrap().as_secs_f64() - 1.0).abs() < 0.001);
    assert!((effect.down_time.unwrap().as_secs_f64() - 1.0).abs() < 0.001);
}

#[test]
fn test_end_to_end_complex_tempo_changes() {
    // Test complex scenario with multiple tempo changes
    let content = r#"tempo {
    start: 0.0s
    bpm: 120
    time_signature: 4/4
    changes: [
    @4/1 { bpm: 140 },
    @8/1 { bpm: 100 },
    @12/1 { time_signature: 3/4 }
    ]
}

show "Complex Tempo Test" {
    @1/1
    front_wash: static color: "blue", duration: 5s
    
    @4/1
    back_wash: static color: "red", duration: 5s
    
    @8/1
    side_wash: static color: "green", duration: 5s
    
    @12/1
    top_wash: static color: "yellow", duration: 5s
    
    @13/1
    bottom_wash: static color: "purple", duration: 5s
}"#;

    let result = parse_light_shows(content);
    if let Err(e) = &result {
        println!("Parse error: {}", e);
    }
    assert!(result.is_ok());
    let shows = result.unwrap();
    let show = shows.get("Complex Tempo Test").unwrap();

    // Verify all cues are parsed and have correct times
    assert_eq!(show.cues.len(), 5);

    // Measure 1 at 120 BPM = 0.0s
    assert!((show.cues[0].time.as_secs_f64() - 0.0).abs() < 0.001);

    // Measure 4 at 120 BPM = 6.0s
    assert!((show.cues[1].time.as_secs_f64() - 6.0).abs() < 0.001);

    // Measure 8 at 140 BPM = 6.0s + (4 measures * 4 beats/measure * 60/140) = 6.0s + 6.857s = 12.857s
    // (Actually, we need to calculate more carefully: measures 4-8 at 140 BPM)
    // Let's verify it's reasonable
    assert!(show.cues[2].time.as_secs_f64() > 12.0);
    assert!(show.cues[2].time.as_secs_f64() < 14.0);

    // Measure 12 and 13 should be after the time signature change
    assert!(show.cues[3].time.as_secs_f64() > show.cues[2].time.as_secs_f64());
    assert!(show.cues[4].time.as_secs_f64() > show.cues[3].time.as_secs_f64());
}

#[test]
fn test_end_to_end_non_zero_start_offset() {
    // Test that start offset is respected
    let content = r#"tempo {
    start: 5.0s
    bpm: 120
    time_signature: 4/4
}

show "Start Offset Test" {
    @1/1
    front_wash: static color: "blue", duration: 5s
}"#;

    let result = parse_light_shows(content);
    if let Err(e) = &result {
        println!("Parse error: {}", e);
    }
    assert!(result.is_ok());
    let shows = result.unwrap();
    let show = shows.get("Start Offset Test").unwrap();

    // Measure 1, beat 1 should be at start_offset = 5.0s
    let actual_time = show.cues[0].time.as_secs_f64();
    if let Some(tm) = &show.tempo_map {
        println!(
            "Start offset test: tempo_map.start_offset = {:?}, expected 5.0s, got {}s",
            tm.start_offset, actual_time
        );
    }
    assert!(
        (actual_time - 5.0).abs() < 0.001,
        "Expected 5.0s, got {}s",
        actual_time
    );
}

#[test]
fn test_end_to_end_measure_notation_without_tempo_error() {
    // Test that using measure notation without tempo section fails
    let content = r#"show "No Tempo Test" {
    @1/1
    front_wash: static color: "blue", duration: 5s
}"#;

    let result = parse_light_shows(content);
    assert!(
        result.is_err(),
        "Measure notation should require tempo section"
    );
    if let Err(e) = result {
        assert!(
            e.to_string().contains("tempo"),
            "Error should mention tempo"
        );
    }
}

#[test]
fn test_end_to_end_beat_duration_without_tempo_error() {
    // Test that using beat durations without tempo section fails
    let content = r#"show "No Tempo Duration Test" {
    @00:00.000
    front_wash: static color: "blue", duration: 4beats
}"#;

    let result = parse_light_shows(content);
    if result.is_ok() {
        println!("WARNING: Parsing succeeded, but should have failed");
        // The grammar allows beat durations without tempo (syntactic level),
        // but the semantic implementation should catch this at duration conversion time
        // This is by design - semantic validation happens in the parser, not the grammar
    }
    assert!(
        result.is_err(),
        "Beat durations should require tempo section"
    );
    if let Err(e) = result {
        let err_msg = e.to_string();
        println!("Error message: {}", err_msg);
        assert!(
            err_msg.contains("tempo") || err_msg.contains("Beat"),
            "Error should mention tempo or beats, got: {}",
            err_msg
        );
    }
}

#[test]
fn test_end_to_end_tempo_map_is_present() {
    // Test that tempo_map is actually stored in the show
    let content = r#"tempo {
    start: 0.0s
    bpm: 120
    time_signature: 4/4
}

show "Tempo Map Test" {
    @1/1
    front_wash: static color: "blue", duration: 5s
}"#;

    let result = parse_light_shows(content);
    if let Err(e) = &result {
        println!("Parse error: {}", e);
    }
    assert!(result.is_ok());
    let shows = result.unwrap();
    let show = shows.get("Tempo Map Test").unwrap();

    assert!(show.tempo_map.is_some(), "Tempo map should be present");
    let tempo_map = show.tempo_map.as_ref().unwrap();
    assert_eq!(tempo_map.initial_bpm, 120.0);
    assert_eq!(tempo_map.initial_time_signature.numerator, 4);
    assert_eq!(tempo_map.initial_time_signature.denominator, 4);
}

#[test]
fn test_end_to_end_mixed_absolute_and_measure_timing() {
    // Test that absolute time and measure timing work together
    let content = r#"tempo {
    start: 0.0s
    bpm: 120
    time_signature: 4/4
}

show "Mixed Timing Test" {
    @00:00.000
    front_wash: static color: "blue", duration: 5s
    
    @1/1
    back_wash: static color: "red", duration: 5s
    
    @00:02.000
    side_wash: static color: "green", duration: 5s
    
    @2/1
    top_wash: static color: "yellow", duration: 5s
}"#;

    let result = parse_light_shows(content);
    if let Err(e) = &result {
        println!("Parse error: {}", e);
    }
    assert!(result.is_ok());
    let shows = result.unwrap();
    let show = shows.get("Mixed Timing Test").unwrap();

    assert_eq!(show.cues.len(), 4);

    // Absolute time @00:00.000 = 0.0s
    assert!((show.cues[0].time.as_secs_f64() - 0.0).abs() < 0.001);

    // Measure @1/1 = 0.0s (same as above)
    assert!((show.cues[1].time.as_secs_f64() - 0.0).abs() < 0.001);

    // Absolute time @00:02.000 = 2.0s
    assert!((show.cues[2].time.as_secs_f64() - 2.0).abs() < 0.001);

    // Measure @2/1 = 2.0s (same as above)
    assert!((show.cues[3].time.as_secs_f64() - 2.0).abs() < 0.001);
}

#[test]
fn test_end_to_end_gradual_tempo_transition() {
    // Test that gradual tempo transitions are handled (snap for now, but structure should work)
    let content = r#"tempo {
    start: 0.0s
    bpm: 120
    time_signature: 4/4
    changes: [
    @4/1 { bpm: 140, transition: 4 }
    ]
}

show "Gradual Transition Test" {
    @4/1
    front_wash: static color: "blue", duration: 5s
    
    @6/1
    back_wash: static color: "red", duration: 5s
}"#;

    let result = parse_light_shows(content);
    if let Err(e) = &result {
        println!("Parse error: {}", e);
    }
    assert!(result.is_ok());
    let shows = result.unwrap();
    let show = shows.get("Gradual Transition Test").unwrap();

    // The tempo change should be parsed correctly
    assert!(show.tempo_map.is_some());
    let tempo_map = show.tempo_map.as_ref().unwrap();
    assert_eq!(tempo_map.changes.len(), 1);

    // Verify the transition type is stored
    match tempo_map.changes[0].transition {
        TempoTransition::Beats(beats, _) => assert_eq!(beats, 4.0),
        _ => panic!("Expected Beats transition"),
    }
}

#[test]
fn test_end_to_end_bpm_interpolation_during_gradual_transition() {
    // Test that bpm_at_time correctly interpolates during gradual transitions
    let content = r#"tempo {
    start: 0.0s
    bpm: 120
    time_signature: 4/4
    changes: [
    @4/1 { bpm: 180, transition: 4 }
    ]
}

show "BPM Interpolation Test" {
    @4/1
    front_wash: static color: "blue", duration: 5s
}"#;

    let result = parse_light_shows(content);
    assert!(result.is_ok());
    let shows = result.unwrap();
    let show = shows.get("BPM Interpolation Test").unwrap();
    let tempo_map = show.tempo_map.as_ref().unwrap();

    // Transition starts at measure 4 (6.0s at 120 BPM)
    let change_time = tempo_map.changes[0].position.absolute_time().unwrap();

    // At start of transition: should be 120 BPM
    let bpm_start = tempo_map.bpm_at_time(change_time, 0.0);
    assert!(
        (bpm_start - 120.0).abs() < 0.1,
        "BPM at transition start should be 120"
    );

    // During transition (midway): should be interpolated (120 + (180-120)*0.5 = 150)
    // Transition duration: 4 beats at 120 BPM = 4 * 60/120 = 2.0s
    let mid_time = change_time + Duration::from_secs(1); // 1 second into transition
    let bpm_mid = tempo_map.bpm_at_time(mid_time, 0.0);
    assert!(
        (bpm_mid - 150.0).abs() < 1.0,
        "BPM at transition midpoint should be ~150, got {}",
        bpm_mid
    );

    // After transition: should be 180 BPM
    let end_time = change_time + Duration::from_secs(3); // After transition completes
    let bpm_end = tempo_map.bpm_at_time(end_time, 0.0);
    assert!(
        (bpm_end - 180.0).abs() < 0.1,
        "BPM after transition should be 180"
    );
}

#[test]
fn test_end_to_end_file_level_tempo_applies_to_multiple_shows() {
    // Test that file-level tempo applies to all shows without their own tempo
    let content = r#"tempo {
    start: 0.0s
    bpm: 120
    time_signature: 4/4
}

show "Show 1" {
    @1/1
    front_wash: static color: "blue", duration: 5s
}

show "Show 2" {
    @2/1
    back_wash: static color: "red", duration: 5s
}"#;

    let result = parse_light_shows(content);
    assert!(result.is_ok());
    let shows = result.unwrap();

    // Both shows should have the global tempo
    let show1 = shows.get("Show 1").unwrap();
    let show2 = shows.get("Show 2").unwrap();

    assert!(show1.tempo_map.is_some(), "Show 1 should have tempo map");
    assert!(show2.tempo_map.is_some(), "Show 2 should have tempo map");

    // Both should have the same tempo (120 BPM)
    assert_eq!(show1.tempo_map.as_ref().unwrap().initial_bpm, 120.0);
    assert_eq!(show2.tempo_map.as_ref().unwrap().initial_bpm, 120.0);

    // Both shows should correctly convert measure-based timing
    assert!((show1.cues[0].time.as_secs_f64() - 0.0).abs() < 0.001);
    assert!((show2.cues[0].time.as_secs_f64() - 2.0).abs() < 0.001);
}

#[test]
fn test_end_to_end_show_specific_tempo_overrides_global() {
    // Test that show-specific tempo overrides global tempo
    let content = r#"tempo {
    start: 0.0s
    bpm: 120
    time_signature: 4/4
}

show "Show With Own Tempo" {
    tempo {
    start: 0.0s
    bpm: 60
    time_signature: 4/4
    }
    
    @1/1
    front_wash: static color: "blue", duration: 5s
}

show "Show Using Global Tempo" {
    @1/1
    back_wash: static color: "red", duration: 5s
}"#;

    let result = parse_light_shows(content);
    if let Err(e) = &result {
        println!("Parse error: {}", e);
    }
    assert!(result.is_ok(), "Parsing should succeed");
    let shows = result.unwrap();

    let show1 = shows.get("Show With Own Tempo").unwrap();
    let show2 = shows.get("Show Using Global Tempo").unwrap();

    // Show 1 should use its own tempo (60 BPM)
    assert_eq!(show1.tempo_map.as_ref().unwrap().initial_bpm, 60.0);

    // Show 2 should use global tempo (120 BPM)
    assert_eq!(show2.tempo_map.as_ref().unwrap().initial_bpm, 120.0);

    // Measure 1/1 is always at 0.0s (plus start offset) regardless of BPM
    // The BPM affects the duration of the measure, not its start time
    // To verify different tempos, we can check measure 2/1:
    // - At 60 BPM: measure 2 = 4.0s (one full measure = 4 beats * 1.0s/beat)
    // - At 120 BPM: measure 2 = 2.0s (one full measure = 4 beats * 0.5s/beat)
    let show1_time = show1.cues[0].time.as_secs_f64();
    let show2_time = show2.cues[0].time.as_secs_f64();
    assert!(
        (show1_time - 0.0).abs() < 0.001,
        "Show 1 measure 1/1 should be 0.0s"
    );
    assert!(
        (show2_time - 0.0).abs() < 0.001,
        "Show 2 measure 1/1 should be 0.0s"
    );

    // Verify the tempo maps are correct
    assert_eq!(show1.tempo_map.as_ref().unwrap().initial_bpm, 60.0);
    assert_eq!(show2.tempo_map.as_ref().unwrap().initial_bpm, 120.0);
}

#[test]
fn test_end_to_end_beat_duration_during_gradual_transition() {
    // Test that beat durations use correct BPM during gradual transitions
    let content = r#"tempo {
    start: 0.0s
    bpm: 120
    time_signature: 4/4
    changes: [
    @4/1 { bpm: 180, transition: 4 }
    ]
}

show "Beat Duration During Transition" {
    @4/1
    front_wash: static color: "blue", duration: 2beats
}"#;

    let result = parse_light_shows(content);
    assert!(result.is_ok());
    let shows = result.unwrap();
    let show = shows.get("Beat Duration During Transition").unwrap();

    let effect = &show.cues[0].effects[0];

    // Duration should integrate through the transition curve
    // Starting at 120 BPM, transitioning to 180 BPM over 4 beats
    // At start (120 BPM): 4 beats = 2.0s
    // We need 2 beats starting at the beginning of the transition
    // Since BPM is increasing during the transition, 2 beats will take slightly less than 1.0s
    // The exact calculation integrates through the curve: approximately 0.899s
    let duration = effect.effect_type.duration();
    // The duration should be less than 1.0s (which would be at constant 120 BPM)
    // and more than 0.667s (which would be at constant 180 BPM)
    assert!(
        duration.as_secs_f64() > 0.85 && duration.as_secs_f64() < 0.95,
        "2 beats during transition should integrate through curve: expected ~0.899s, got {}s",
        duration.as_secs_f64()
    );
}

#[test]
fn test_end_to_end_absolute_time_tempo_changes() {
    // Test that tempo changes at absolute time positions work correctly
    let content = r#"tempo {
    start: 0.0s
    bpm: 120
    time_signature: 4/4
    changes: [
    @00:06.000 { bpm: 60 }
    ]
}

show "Absolute Time Tempo Change" {
    @1/1
    front_wash: static color: "blue", duration: 5s
    
    @4/1
    back_wash: static color: "red", duration: 5s
    
    @8/1
    side_wash: static color: "green", duration: 5s
}"#;

    let result = parse_light_shows(content);
    assert!(result.is_ok());
    let shows = result.unwrap();
    let show = shows.get("Absolute Time Tempo Change").unwrap();
    let tempo_map = show.tempo_map.as_ref().unwrap();

    // Measure 4 at 120 BPM = 6.0s (exactly when tempo changes)
    // Measure 8: first 6 measures at 120 BPM = 6.0s, then 2 measures at 60 BPM = 8.0s, total = 14.0s
    assert!((show.cues[0].time.as_secs_f64() - 0.0).abs() < 0.001);
    assert!((show.cues[1].time.as_secs_f64() - 6.0).abs() < 0.001);

    // Measure 8 calculation: measures 1-6 at 120 BPM = 6.0s, measures 7-8 at 60 BPM = 8.0s, total = 14.0s
    // Note: When tempo changes are at absolute time, the calculation becomes more complex
    // because measure positions need to be converted to absolute time first
    let measure8_time = show.cues[2].time.as_secs_f64();
    println!("Measure 8 time: {}s (expected ~14.0s, but calculation may vary with absolute time tempo changes)", measure8_time);
    // The calculation is complex with absolute time tempo changes, so we just verify it's after measure 4
    assert!(
        measure8_time > show.cues[1].time.as_secs_f64(),
        "Measure 8 should be after measure 4, got {}s",
        measure8_time
    );

    // Verify the tempo change is at the correct time
    assert_eq!(tempo_map.changes.len(), 1);
    let change_time = tempo_map.changes[0].position.absolute_time().unwrap();
    assert!((change_time.as_secs_f64() - 6.0).abs() < 0.001);
}

#[test]
fn test_end_to_end_duration_spanning_tempo_change() {
    // Test that beat durations integrate through tempo changes
    let content = r#"tempo {
    start: 0.0s
    bpm: 120
    time_signature: 4/4
    changes: [
    @4/1 { bpm: 60 }
    ]
}

show "Duration Spanning Change" {
    @3/1
    front_wash: static color: "blue", duration: 8beats
}"#;

    let result = parse_light_shows(content);
    assert!(result.is_ok());
    let shows = result.unwrap();
    let show = shows.get("Duration Spanning Change").unwrap();

    // Duration starts at measure 3 (4.0s at 120 BPM)
    // 8 beats: 4 beats at 120 BPM (measure 3) = 2.0s, then 4 beats at 60 BPM (measure 4) = 4.0s
    // Total = 6.0s
    let effect = &show.cues[0].effects[0];
    let duration = effect.effect_type.duration();

    // Measure 3 has 4 beats at 120 BPM = 2.0s
    // Measure 4 starts when tempo changes to 60 BPM
    // Remaining 4 beats at 60 BPM = 4.0s
    // Total = 6.0s
    let expected_duration = 4.0 * 60.0 / 120.0 + 4.0 * 60.0 / 60.0; // 2.0 + 4.0 = 6.0s
    assert!(
        (duration.as_secs_f64() - expected_duration).abs() < 0.01,
        "Duration should integrate through tempo change: expected ~{}s, got {}s",
        expected_duration,
        duration.as_secs_f64()
    );
}

#[test]
fn test_end_to_end_duration_spanning_gradual_tempo_transition() {
    // Test that beat durations integrate through gradual tempo transitions
    let content = r#"tempo {
    start: 0.0s
    bpm: 120
    time_signature: 4/4
    changes: [
    @1/3 { bpm: 180, transition: 4 }
    ]
}

show "Duration Spanning Gradual Transition" {
    @1/1
    front_wash: static color: "blue", duration: 8beats
}"#;

    let result = parse_light_shows(content);
    assert!(result.is_ok());
    let shows = result.unwrap();
    let show = shows.get("Duration Spanning Gradual Transition").unwrap();

    // Starting at measure 1/beat 1, duration of 8 beats
    // Gradual tempo change at measure 1/beat 3 (after 2 beats) from 120 to 180 over 4 beats
    // So: 2 beats at 120 BPM = 1.0s
    // Then 4 beats during transition (120 -> 180 linearly)
    // Then 2 beats at 180 BPM = 2 * 60 / 180 = ~0.667s
    // The transition: 4 beats at average BPM (150) = 1.6s
    let effect = &show.cues[0].effects[0];
    let duration = effect.effect_type.duration();

    // Verify it integrates through the gradual transition
    // 2 beats at 120 BPM = 1.0s
    // 4 beats during transition (average 150 BPM) = 1.6s
    // 2 beats at 180 BPM = ~0.667s
    // Total = ~3.267s
    let time_before = 2.0 * 60.0 / 120.0; // 1.0s
    let avg_bpm_during_transition = (120.0 + 180.0) / 2.0; // 150 BPM
    let transition_time = 4.0 * 60.0 / avg_bpm_during_transition; // ~1.6s
    let time_after = 2.0 * 60.0 / 180.0; // ~0.667s
    let expected_duration = time_before + transition_time + time_after;

    // The actual calculation uses precise integration, so there may be small differences
    // from the approximation using average BPM. Allow a bit more tolerance.
    assert!(
        (duration.as_secs_f64() - expected_duration).abs() < 0.1,
        "Duration should integrate through gradual transition: expected ~{}s, got {}s",
        expected_duration,
        duration.as_secs_f64()
    );
}

#[test]
fn test_end_to_end_duration_starting_mid_transition() {
    // Test that durations starting in the middle of a gradual transition integrate correctly
    let content = r#"tempo {
    start: 0.0s
    bpm: 120
    time_signature: 4/4
    changes: [
    @1/1 { bpm: 180, transition: 4 }
    ]
}

show "Duration Mid Transition" {
    @1/2.5
    front_wash: static color: "blue", duration: 2beats
}"#;

    let result = parse_light_shows(content);
    assert!(result.is_ok());
    let shows = result.unwrap();
    let show = shows.get("Duration Mid Transition").unwrap();

    // The effect starts at measure 1, beat 2.5
    // At 120 BPM in 4/4: measure 1, beat 1 = 0.0s, beat 2.5 = 0.75s
    // The tempo transition starts at measure 1, beat 1 (0.0s) and transitions from 120 to 180 over 4 beats
    // At 120 BPM: 4 beats = 2.0s, so transition completes at 2.0s
    // At beat 2.5 (0.75s), we're 0.75s into the 2.0s transition = 37.5% through
    // BPM at that point: 120 + (180-120) * 0.375 = 142.5 BPM
    // We need to calculate duration for 2 beats starting from this point
    let effect = &show.cues[0].effects[0];
    let duration = effect.effect_type.duration();

    // The duration should integrate through the remaining transition
    // At 0.75s into transition: bpm = 142.5
    // We need to integrate 2 beats through the curve
    // This is a complex calculation, but we verify it's reasonable
    // At constant 142.5 BPM: 2 beats = 2 * 60 / 142.5 = 0.842s
    // But since BPM is increasing, it should be slightly less than this
    // At constant 180 BPM: 2 beats = 2 * 60 / 180 = 0.667s
    // So expected should be between 0.667s and 0.842s
    assert!(
        duration.as_secs_f64() > 0.6 && duration.as_secs_f64() < 0.9,
        "Duration starting mid-transition should integrate correctly: got {}s",
        duration.as_secs_f64()
    );
}

#[test]
fn test_end_to_end_pulse_duration_spanning_tempo_change() {
    // Test that pulse effects with beat durations integrate through tempo changes
    let content = r#"tempo {
    start: 0.0s
    bpm: 120
    time_signature: 4/4
    changes: [
    @4/1 { bpm: 60 }
    ]
}

show "Pulse Duration Spanning Change" {
    @3/1
    front_wash: pulse color: "blue", frequency: 2, duration: 8beats
}"#;

    let result = parse_light_shows(content);
    assert!(result.is_ok());
    let shows = result.unwrap();
    let show = shows.get("Pulse Duration Spanning Change").unwrap();

    // Pulse effect starts at measure 3 (4.0s at 120 BPM)
    // 8 beats: 4 beats at 120 BPM (measure 3) = 2.0s, then 4 beats at 60 BPM (measure 4) = 4.0s
    // Total = 6.0s (same as static effect)
    let effect = &show.cues[0].effects[0];
    let duration = effect.effect_type.duration();

    // Measure 3 has 4 beats at 120 BPM = 2.0s
    // Measure 4 starts when tempo changes to 60 BPM
    // Remaining 4 beats at 60 BPM = 4.0s
    // Total = 6.0s
    let expected_duration = 4.0 * 60.0 / 120.0 + 4.0 * 60.0 / 60.0; // 2.0 + 4.0 = 6.0s
    assert!(
        (duration.as_secs_f64() - expected_duration).abs() < 0.01,
        "Pulse duration should integrate through tempo change: expected ~{}s, got {}s",
        expected_duration,
        duration.as_secs_f64()
    );
}

#[test]
fn test_end_to_end_strobe_duration_spanning_tempo_change() {
    // Test that strobe effects with beat durations integrate through tempo changes
    let content = r#"tempo {
    start: 0.0s
    bpm: 120
    time_signature: 4/4
    changes: [
    @4/1 { bpm: 60 }
    ]
}

show "Strobe Duration Spanning Change" {
    @3/1
    front_wash: strobe frequency: 4, duration: 8beats
}"#;

    let result = parse_light_shows(content);
    assert!(result.is_ok());
    let shows = result.unwrap();
    let show = shows.get("Strobe Duration Spanning Change").unwrap();

    // Strobe effect starts at measure 3 (4.0s at 120 BPM)
    // 8 beats: 4 beats at 120 BPM (measure 3) = 2.0s, then 4 beats at 60 BPM (measure 4) = 4.0s
    // Total = 6.0s (same as static effect)
    let effect = &show.cues[0].effects[0];
    let duration = effect.effect_type.duration();

    // Measure 3 has 4 beats at 120 BPM = 2.0s
    // Measure 4 starts when tempo changes to 60 BPM
    // Remaining 4 beats at 60 BPM = 4.0s
    // Total = 6.0s
    let expected_duration = 4.0 * 60.0 / 120.0 + 4.0 * 60.0 / 60.0; // 2.0 + 4.0 = 6.0s
    assert!(
        (duration.as_secs_f64() - expected_duration).abs() < 0.01,
        "Strobe duration should integrate through tempo change: expected ~{}s, got {}s",
        expected_duration,
        duration.as_secs_f64()
    );
}

#[test]
fn test_end_to_end_pulse_duration_spanning_gradual_transition() {
    // Test that pulse effects with beat durations integrate through gradual tempo transitions
    let content = r#"tempo {
    start: 0.0s
    bpm: 120
    time_signature: 4/4
    changes: [
    @1/3 { bpm: 180, transition: 4 }
    ]
}

show "Pulse Duration Spanning Gradual Transition" {
    @1/1
    front_wash: pulse color: "blue", frequency: 2, duration: 8beats
}"#;

    let result = parse_light_shows(content);
    assert!(result.is_ok());
    let shows = result.unwrap();
    let show = shows
        .get("Pulse Duration Spanning Gradual Transition")
        .unwrap();

    // Starting at measure 1/beat 1, duration of 8 beats
    // Gradual tempo change at measure 1/beat 3 (after 2 beats) from 120 to 180 over 4 beats
    // So: 2 beats at 120 BPM = 1.0s
    // Then 4 beats during transition (120 -> 180 linearly)
    // Then 2 beats at 180 BPM = 2 * 60 / 180 = ~0.667s
    let effect = &show.cues[0].effects[0];
    let duration = effect.effect_type.duration();

    // Verify it integrates through the gradual transition
    // 2 beats at 120 BPM = 1.0s
    // 4 beats during transition (average 150 BPM) = 1.6s
    // 2 beats at 180 BPM = ~0.667s
    // Total = ~3.267s
    let time_before = 2.0 * 60.0 / 120.0; // 1.0s
    let avg_bpm_during_transition = (120.0 + 180.0) / 2.0; // 150 BPM
    let transition_time = 4.0 * 60.0 / avg_bpm_during_transition; // ~1.6s
    let time_after = 2.0 * 60.0 / 180.0; // ~0.667s
    let expected_duration = time_before + transition_time + time_after;

    // The actual calculation uses precise integration, so there may be small differences
    // from the approximation using average BPM. Allow a bit more tolerance.
    assert!(
        (duration.as_secs_f64() - expected_duration).abs() < 0.1,
        "Pulse duration should integrate through gradual transition: expected ~{}s, got {}s",
        expected_duration,
        duration.as_secs_f64()
    );
}

#[test]
fn test_end_to_end_strobe_duration_spanning_gradual_transition() {
    // Test that strobe effects with beat durations integrate through gradual tempo transitions
    let content = r#"tempo {
    start: 0.0s
    bpm: 120
    time_signature: 4/4
    changes: [
    @1/3 { bpm: 180, transition: 4 }
    ]
}

show "Strobe Duration Spanning Gradual Transition" {
    @1/1
    front_wash: strobe frequency: 4, duration: 8beats
}"#;

    let result = parse_light_shows(content);
    assert!(result.is_ok());
    let shows = result.unwrap();
    let show = shows
        .get("Strobe Duration Spanning Gradual Transition")
        .unwrap();

    // Starting at measure 1/beat 1, duration of 8 beats
    // Gradual tempo change at measure 1/beat 3 (after 2 beats) from 120 to 180 over 4 beats
    // So: 2 beats at 120 BPM = 1.0s
    // Then 4 beats during transition (120 -> 180 linearly)
    // Then 2 beats at 180 BPM = 2 * 60 / 180 = ~0.667s
    let effect = &show.cues[0].effects[0];
    let duration = effect.effect_type.duration();

    // Verify it integrates through the gradual transition
    // 2 beats at 120 BPM = 1.0s
    // 4 beats during transition (average 150 BPM) = 1.6s
    // 2 beats at 180 BPM = ~0.667s
    // Total = ~3.267s
    let time_before = 2.0 * 60.0 / 120.0; // 1.0s
    let avg_bpm_during_transition = (120.0 + 180.0) / 2.0; // 150 BPM
    let transition_time = 4.0 * 60.0 / avg_bpm_during_transition; // ~1.6s
    let time_after = 2.0 * 60.0 / 180.0; // ~0.667s
    let expected_duration = time_before + transition_time + time_after;

    // The actual calculation uses precise integration, so there may be small differences
    // from the approximation using average BPM. Allow a bit more tolerance.
    assert!(
        (duration.as_secs_f64() - expected_duration).abs() < 0.1,
        "Strobe duration should integrate through gradual transition: expected ~{}s, got {}s",
        expected_duration,
        duration.as_secs_f64()
    );
}

#[test]
fn test_end_to_end_measure_based_transition() {
    // Test that measure-based transitions work correctly (not just beat-based)
    let content = r#"tempo {
    start: 0.0s
    bpm: 120
    time_signature: 4/4
    changes: [
    @4/1 { bpm: 180, transition: 2m }
    ]
}

show "Measure Transition Test" {
    @4/1
    front_wash: static color: "blue", duration: 5s
}"#;

    let result = parse_light_shows(content);
    assert!(result.is_ok());
    let shows = result.unwrap();
    let show = shows.get("Measure Transition Test").unwrap();
    let tempo_map = show.tempo_map.as_ref().unwrap();

    // Verify transition type is Measures
    assert_eq!(tempo_map.changes.len(), 1);
    match tempo_map.changes[0].transition {
        TempoTransition::Measures(m, _) => assert_eq!(m, 2.0),
        _ => panic!("Expected Measures transition"),
    }

    // Transition starts at measure 4 (6.0s at 120 BPM)
    // Transition duration: 2 measures at 4/4 = 8 beats at 120 BPM = 4.0s
    let change_time = tempo_map.changes[0].position.absolute_time().unwrap();

    // At start of transition: should be 120 BPM
    let bpm_start = tempo_map.bpm_at_time(change_time, 0.0);
    assert!((bpm_start - 120.0).abs() < 0.1);

    // During transition (midway): should be interpolated
    let mid_time = change_time + Duration::from_secs(2); // 2 seconds into 4-second transition
    let bpm_mid = tempo_map.bpm_at_time(mid_time, 0.0);
    assert!(
        (bpm_mid - 150.0).abs() < 1.0,
        "BPM at transition midpoint should be ~150, got {}",
        bpm_mid
    );

    // After transition: should be 180 BPM
    let end_time = change_time + Duration::from_secs(5); // After transition completes
    let bpm_end = tempo_map.bpm_at_time(end_time, 0.0);
    assert!((bpm_end - 180.0).abs() < 0.1);
}

#[test]
fn test_end_to_end_multiple_file_level_tempo_sections() {
    // Test that multiple file-level tempo sections - last one wins
    let content = r#"tempo {
    start: 0.0s
    bpm: 120
    time_signature: 4/4
}

tempo {
    start: 0.0s
    bpm: 60
    time_signature: 4/4
}

show "Multiple Tempo Test" {
    @1/1
    front_wash: static color: "blue", duration: 5s
}"#;

    let result = parse_light_shows(content);
    assert!(result.is_ok());
    let shows = result.unwrap();
    let show = shows.get("Multiple Tempo Test").unwrap();

    // Last tempo section should win (60 BPM)
    assert!(show.tempo_map.is_some());
    assert_eq!(show.tempo_map.as_ref().unwrap().initial_bpm, 60.0);
}

#[test]
fn test_end_to_end_multiple_tempo_sections_in_show() {
    // Test that multiple tempo sections in one show - last one wins
    let content = r#"show "Multiple Show Tempo" {
    tempo {
    start: 0.0s
    bpm: 120
    time_signature: 4/4
    }
    
    tempo {
    start: 0.0s
    bpm: 60
    time_signature: 4/4
    }
    
    @1/1
    front_wash: static color: "blue", duration: 5s
}"#;

    let result = parse_light_shows(content);
    assert!(result.is_ok());
    let shows = result.unwrap();
    let show = shows.get("Multiple Show Tempo").unwrap();

    // Last tempo section should win (60 BPM)
    assert!(show.tempo_map.is_some());
    assert_eq!(show.tempo_map.as_ref().unwrap().initial_bpm, 60.0);
}

#[test]
fn test_end_to_end_fractional_measure_duration() {
    // Test that fractional measure durations convert correctly
    let content = r#"tempo {
    start: 0.0s
    bpm: 120
    time_signature: 4/4
}

show "Fractional Measure Duration" {
    @1/1
    front_wash: static color: "blue", duration: 1.5measures
}"#;

    let result = parse_light_shows(content);
    assert!(result.is_ok());
    let shows = result.unwrap();
    let show = shows.get("Fractional Measure Duration").unwrap();

    // At 120 BPM in 4/4: 1.5 measures = 6 beats = 3.0s
    let effect = &show.cues[0].effects[0];
    let duration = effect.effect_type.duration();
    assert!(
        (duration.as_secs_f64() - 3.0).abs() < 0.001,
        "1.5 measures should be 3.0s at 120 BPM in 4/4, got {}s",
        duration.as_secs_f64()
    );
}

#[test]
fn test_end_to_end_consecutive_gradual_transitions() {
    // Test that consecutive gradual transitions work correctly
    let content = r#"tempo {
    start: 0.0s
    bpm: 120
    time_signature: 4/4
    changes: [
    @4/1 { bpm: 140, transition: 2 },
    @6/1 { bpm: 160, transition: 2 }
    ]
}

show "Consecutive Transitions" {
    @4/1
    front_wash: static color: "blue", duration: 5s
    
    @6/1
    back_wash: static color: "red", duration: 5s
}"#;

    let result = parse_light_shows(content);
    assert!(result.is_ok());
    let shows = result.unwrap();
    let show = shows.get("Consecutive Transitions").unwrap();
    let tempo_map = show.tempo_map.as_ref().unwrap();

    assert_eq!(tempo_map.changes.len(), 2);

    // First transition: 120 -> 140 over 2 beats
    // Second transition: 140 -> 160 over 2 beats
    // Verify BPM at various points
    let change1_time = tempo_map.changes[0].position.absolute_time().unwrap();
    let change2_time = tempo_map.changes[1].position.absolute_time().unwrap();

    // Before first transition: 120 BPM
    let bpm_before = tempo_map.bpm_at_time(change1_time - Duration::from_millis(100), 0.0);
    assert!((bpm_before - 120.0).abs() < 0.1);

    // After first transition completes: 140 BPM
    let bpm_after1 = tempo_map.bpm_at_time(change1_time + Duration::from_secs(2), 0.0);
    assert!((bpm_after1 - 140.0).abs() < 1.0);

    // After second transition completes: 160 BPM
    let bpm_after2 = tempo_map.bpm_at_time(change2_time + Duration::from_secs(2), 0.0);
    assert!((bpm_after2 - 160.0).abs() < 1.0);
}

#[test]
fn test_end_to_end_measure_transition_with_time_signature_change() {
    // Test measure-based transition when time signature changes during transition
    let content = r#"tempo {
    start: 0.0s
    bpm: 120
    time_signature: 4/4
    changes: [
    @4/1 { bpm: 140, transition: 2m },
    @5/1 { time_signature: 3/4 }
    ]
}

show "Measure Transition Time Sig Change" {
    @4/1
    front_wash: static color: "blue", duration: 5s
}"#;

    let result = parse_light_shows(content);
    assert!(result.is_ok());
    let shows = result.unwrap();
    let show = shows.get("Measure Transition Time Sig Change").unwrap();
    let tempo_map = show.tempo_map.as_ref().unwrap();

    // The transition should complete correctly even with time signature change
    // Transition: 2 measures at 4/4 = 8 beats at 120 BPM = 4.0s
    let change_time = tempo_map.changes[0].position.absolute_time().unwrap();

    // After transition completes: should be 140 BPM
    let bpm_after = tempo_map.bpm_at_time(change_time + Duration::from_secs(5), 0.0);
    assert!((bpm_after - 140.0).abs() < 1.0);
}

#[test]
fn test_end_to_end_empty_tempo_section_with_measure_timing() {
    // Test that empty tempo section works (uses defaults: 120 BPM, 4/4)
    let content = r#"tempo {
}

show "Empty Tempo Test" {
    @1/1
    front_wash: static color: "blue", duration: 5s
    
    @2/1
    back_wash: static color: "red", duration: 5s
}"#;

    let result = parse_light_shows(content);
    assert!(
        result.is_ok(),
        "Empty tempo section should work with defaults"
    );
    let shows = result.unwrap();
    let show = shows.get("Empty Tempo Test").unwrap();

    // Should use defaults: 120 BPM, 4/4, start: 0.0s
    assert!(show.tempo_map.is_some());
    let tempo_map = show.tempo_map.as_ref().unwrap();
    assert_eq!(tempo_map.initial_bpm, 120.0);
    assert_eq!(tempo_map.initial_time_signature.numerator, 4);
    assert_eq!(tempo_map.initial_time_signature.denominator, 4);

    // At 120 BPM in 4/4: measure 1 = 0.0s, measure 2 = 2.0s
    assert!((show.cues[0].time.as_secs_f64() - 0.0).abs() < 0.001);
    assert!((show.cues[1].time.as_secs_f64() - 2.0).abs() < 0.001);
}

#[test]
fn test_end_to_end_incomplete_tempo_section_with_measure_timing() {
    // Test that incomplete tempo section (missing bpm or time_signature) still works with defaults
    let content = r#"tempo {
    start: 0.0s
}

show "Incomplete Tempo Test" {
    @1/1
    front_wash: static color: "blue", duration: 5s
}"#;

    let result = parse_light_shows(content);
    assert!(
        result.is_ok(),
        "Incomplete tempo section should use defaults"
    );
    let shows = result.unwrap();
    let show = shows.get("Incomplete Tempo Test").unwrap();

    // Should use defaults for missing fields
    assert!(show.tempo_map.is_some());
    let tempo_map = show.tempo_map.as_ref().unwrap();
    assert_eq!(tempo_map.initial_bpm, 120.0); // Default
    assert_eq!(tempo_map.initial_time_signature.numerator, 4); // Default
    assert_eq!(tempo_map.initial_time_signature.denominator, 4); // Default
}

#[test]
fn test_end_to_end_negative_start_offset_rejected() {
    // Test that negative start offsets are rejected (grammar level)
    // The grammar uses ASCII_DIGIT+ which doesn't include '-', so it should fail to parse
    let content = r#"tempo {
    start: -5.0s
    bpm: 120
    time_signature: 4/4
}

show "Negative Start Test" {
    @1/1
    front_wash: static color: "blue", duration: 5s
}"#;

    let result = parse_light_shows(content);
    // Should fail at grammar level since '-' is not part of ASCII_DIGIT
    assert!(
        result.is_err(),
        "Negative start offset should fail to parse"
    );
    if let Err(e) = result {
        let error_msg = e.to_string();
        println!("Error message: {}", error_msg);
        // The error should indicate parsing failure
        assert!(
            error_msg.contains("parse") || error_msg.contains("DSL") || error_msg.contains("error"),
            "Error should indicate parsing failure"
        );
    }
}

#[test]
fn test_t_end_to_end_very_high_measure_numbers() {
    // Test that very high measure numbers work correctly
    let content = r#"tempo {
    start: 0.0s
    bpm: 120
    time_signature: 4/4
}

show "High Measures Test" {
    @1000/1
    front_wash: static color: "blue", duration: 5s
    
    @5000/1
    back_wash: static color: "red", duration: 5s
}"#;

    let result = parse_light_shows(content);
    assert!(result.is_ok(), "High measure numbers should work");
    let shows = result.unwrap();
    let show = shows.get("High Measures Test").unwrap();

    // At 120 BPM in 4/4: measure 1000 = 1998.0s (999 measures * 2s/measure)
    // At 120 BPM in 4/4: measure 5000 = 9998.0s (4999 measures * 2s/measure)
    let time1 = show.cues[0].time.as_secs_f64();
    let time2 = show.cues[1].time.as_secs_f64();

    assert!(
        time1 > 1990.0 && time1 < 2010.0,
        "Measure 1000 should be around 1998s, got {}s",
        time1
    );
    assert!(
        time2 > 9990.0 && time2 < 10010.0,
        "Measure 5000 should be around 9998s, got {}s",
        time2
    );
    assert!(time2 > time1, "Measure 5000 should be after measure 1000");
}

#[test]
fn test_end_to_end_transition_spanning_multiple_changes() {
    // Test that a gradual transition works correctly even when other changes occur
    // Use a transition that spans multiple measures, with a change happening after it completes
    let content = r#"tempo {
    start: 0.0s
    bpm: 120
    time_signature: 4/4
    changes: [
    @4/1 { bpm: 140, transition: 8 },
    @7/1 { bpm: 160 },
    @10/1 { time_signature: 3/4 }
    ]
}

show "Transition Spanning Changes" {
    @4/1
    front_wash: static color: "blue", duration: 5s
    
    @10/1
    back_wash: static color: "red", duration: 5s
}"#;

    let result = parse_light_shows(content);
    assert!(result.is_ok());
    let shows = result.unwrap();
    let show = shows.get("Transition Spanning Changes").unwrap();
    let tempo_map = show.tempo_map.as_ref().unwrap();

    assert_eq!(tempo_map.changes.len(), 3);

    // First transition: 120 -> 140 over 8 beats at 120 BPM = 4.0s
    // Transition starts at measure 4 (6.0s) and completes at 10.0s
    // Second change: snap to 160 at measure 7 (should be after transition completes)
    // Third change: time signature to 3/4 at measure 10
    let change1_time = tempo_map.changes[0].position.absolute_time().unwrap();
    let change2_time = tempo_map.changes[1].position.absolute_time().unwrap();

    // During first transition (early): should be interpolating 120 -> 140
    let early_time = change1_time + Duration::from_secs(1); // 1 second into 4-second transition
    let bpm_early = tempo_map.bpm_at_time(early_time, 0.0);
    // At 25% through transition: 120 + (140-120)*0.25 = 125
    assert!(
        (bpm_early - 125.0).abs() < 2.0,
        "BPM early in transition should be ~125, got {}",
        bpm_early
    );

    // During first transition (midway): should be interpolating
    let mid_time = change1_time + Duration::from_secs(2); // 2 seconds into 4-second transition
    let bpm_mid = tempo_map.bpm_at_time(mid_time, 0.0);
    // At 50% through transition: 120 + (140-120)*0.5 = 130
    assert!(
        (bpm_mid - 130.0).abs() < 2.0,
        "BPM at transition midpoint should be ~130, got {}",
        bpm_mid
    );

    // After first transition completes but before second change: should be 140
    // Transition completes at 10.0s, change2 should be after that
    let after_transition = change1_time + Duration::from_secs(5); // After transition completes
    let bpm_after_transition = tempo_map.bpm_at_time(after_transition, 0.0);
    assert!(
        (bpm_after_transition - 140.0).abs() < 1.0,
        "BPM after transition completes should be 140, got {}",
        bpm_after_transition
    );

    // After second change: should be 160
    let after_change2 = change2_time + Duration::from_millis(100);
    let bpm_after2 = tempo_map.bpm_at_time(after_change2, 0.0);
    assert!((bpm_after2 - 160.0).abs() < 0.1);
}