use super::harness::*;
use std::collections::HashMap;

fn parse_params(output: &str) -> HashMap<String, f64> {
    let mut params = HashMap::new();
    let parts: Vec<&str> = output.trim_start_matches('/').split('/').collect();
    let mut i = 0;
    while i + 1 < parts.len() {
        if let Ok(v) = parts[i + 1].parse::<f64>() {
            params.insert(parts[i].to_string(), v);
        }
        i += 2;
    }
    params
}

fn get_deltas(outputs: &[String]) -> Vec<f64> {
    outputs
        .iter()
        .map(|o| parse_params(o).get("delta").copied().unwrap_or(0.0))
        .collect()
}

fn get_durs(outputs: &[String]) -> Vec<f64> {
    outputs
        .iter()
        .map(|o| parse_params(o).get("dur").copied().unwrap_or(0.0))
        .collect()
}

fn get_sounds(outputs: &[String]) -> Vec<String> {
    outputs
        .iter()
        .map(|o| {
            let parts: Vec<&str> = o.trim_start_matches('/').split('/').collect();
            if parts.len() >= 2 && parts[0] == "sound" {
                parts[1].to_string()
            } else {
                String::new()
            }
        })
        .collect()
}

const EPSILON: f64 = 1e-9;

fn approx_eq(a: f64, b: f64) -> bool {
    (a - b).abs() < EPSILON
}

// At 120 BPM, speed 1.0: stepdur = 60/120/4/1 = 0.125s
// Root duration = 4 * stepdur = 0.5s

#[test]
fn stepdur_baseline() {
    let f = run("stepdur");
    assert!(approx_eq(stack_float(&f), 0.125));
}

#[test]
fn single_emit() {
    let outputs = expect_outputs(r#""kick" s ."#, 1);
    let deltas = get_deltas(&outputs);
    assert!(approx_eq(deltas[0], 0.0), "single emit at start should have delta 0");
}

#[test]
fn implicit_subdivision_2() {
    let outputs = expect_outputs(r#""kick" s . ."#, 2);
    let deltas = get_deltas(&outputs);
    let step = 0.5 / 2.0;
    assert!(approx_eq(deltas[0], 0.0), "first slot at 0");
    assert!(approx_eq(deltas[1], step), "second slot at {}, got {}", step, deltas[1]);
}

#[test]
fn implicit_subdivision_4() {
    let outputs = expect_outputs(r#""kick" s . . . ."#, 4);
    let deltas = get_deltas(&outputs);
    let step = 0.5 / 4.0;
    for (i, delta) in deltas.iter().enumerate() {
        let expected = step * i as f64;
        assert!(
            approx_eq(*delta, expected),
            "slot {}: expected {}, got {}",
            i, expected, delta
        );
    }
}

#[test]
fn implicit_subdivision_3() {
    let outputs = expect_outputs(r#""kick" s . . ."#, 3);
    let deltas = get_deltas(&outputs);
    let step = 0.5 / 3.0;
    assert!(approx_eq(deltas[0], 0.0));
    assert!(approx_eq(deltas[1], step), "got {}", deltas[1]);
    assert!(approx_eq(deltas[2], 2.0 * step), "got {}", deltas[2]);
}

#[test]
fn silence_creates_gap() {
    let outputs = expect_outputs(r#""kick" s . _ ."#, 2);
    let deltas = get_deltas(&outputs);
    let step = 0.5 / 3.0;
    assert!(approx_eq(deltas[0], 0.0), "first at 0");
    assert!(
        approx_eq(deltas[1], 2.0 * step),
        "third slot (after silence) at {}, got {}",
        2.0 * step,
        deltas[1]
    );
}

#[test]
fn silence_at_start() {
    let outputs = expect_outputs(r#""kick" s _ ."#, 1);
    let deltas = get_deltas(&outputs);
    let step = 0.5 / 2.0;
    assert!(
        approx_eq(deltas[0], step),
        "emit after silence at {}, got {}",
        step,
        deltas[0]
    );
}

#[test]
fn silence_only() {
    let outputs = expect_outputs(r#""kick" s _"#, 0);
    assert!(outputs.is_empty(), "silence only should produce no output");
}

#[test]
fn sound_persists() {
    let outputs = expect_outputs(r#""kick" s . . "hat" s . ."#, 4);
    let sounds = get_sounds(&outputs);
    assert_eq!(sounds[0], "kick");
    assert_eq!(sounds[1], "kick");
    assert_eq!(sounds[2], "hat");
    assert_eq!(sounds[3], "hat");
}

#[test]
fn alternating_sounds() {
    let outputs = expect_outputs(r#""kick" s . "snare" s . "kick" s . "snare" s ."#, 4);
    let sounds = get_sounds(&outputs);
    assert_eq!(sounds, vec!["kick", "snare", "kick", "snare"]);
}

#[test]
fn dur_matches_slot_duration() {
    let outputs = expect_outputs(r#""kick" s . . . ."#, 4);
    let durs = get_durs(&outputs);
    let expected_dur = 0.5 / 4.0;
    for (i, dur) in durs.iter().enumerate() {
        assert!(
            approx_eq(*dur, expected_dur),
            "slot {} dur: expected {}, got {}",
            i, expected_dur, dur
        );
    }
}

#[test]
fn tempo_affects_subdivision() {
    let ctx = ctx_with(|c| c.tempo = 60.0);
    let f = forth();
    let outputs = f.evaluate(r#""kick" s . ."#, &ctx).unwrap();
    let deltas = get_deltas(&outputs);
    // At 60 BPM: stepdur = 0.25, root dur = 1.0
    let step = 1.0 / 2.0;
    assert!(approx_eq(deltas[0], 0.0));
    assert!(approx_eq(deltas[1], step), "got {}", deltas[1]);
}

#[test]
fn speed_affects_subdivision() {
    let ctx = ctx_with(|c| c.speed = 2.0);
    let f = forth();
    let outputs = f.evaluate(r#""kick" s . ."#, &ctx).unwrap();
    let deltas = get_deltas(&outputs);
    // At speed 2.0: stepdur = 0.0625, root dur = 0.25
    let step = 0.25 / 2.0;
    assert!(approx_eq(deltas[0], 0.0));
    assert!(approx_eq(deltas[1], step), "got {}", deltas[1]);
}

#[test]
fn cycle_picks_by_step() {
    for runs in 0..4 {
        let ctx = ctx_with(|c| c.runs = runs);
        let f = forth();
        let outputs = f.evaluate(r#""kick" s < . _ >"#, &ctx).unwrap();
        if runs % 2 == 0 {
            assert_eq!(outputs.len(), 1, "runs={}: . should be picked", runs);
        } else {
            assert_eq!(outputs.len(), 0, "runs={}: _ should be picked", runs);
        }
    }
}

#[test]
fn pcycle_picks_by_pattern() {
    for iter in 0..4 {
        let ctx = ctx_with(|c| c.iter = iter);
        let f = forth();
        let outputs = f.evaluate(r#""kick" s << . _ >>"#, &ctx).unwrap();
        if iter % 2 == 0 {
            assert_eq!(outputs.len(), 1, "iter={}: . should be picked", iter);
        } else {
            assert_eq!(outputs.len(), 0, "iter={}: _ should be picked", iter);
        }
    }
}

#[test]
fn cycle_with_sounds() {
    for runs in 0..3 {
        let ctx = ctx_with(|c| c.runs = runs);
        let f = forth();
        let outputs = f.evaluate(r#"< { "kick" s . } { "hat" s . } { "snare" s . } >"#, &ctx).unwrap();
        assert_eq!(outputs.len(), 1, "runs={}: expected 1 output", runs);
        let sounds = get_sounds(&outputs);
        let expected = ["kick", "hat", "snare"][runs % 3];
        assert_eq!(sounds[0], expected, "runs={}: expected {}", runs, expected);
    }
}

#[test]
fn dot_alias_for_emit() {
    let outputs = expect_outputs(r#""kick" s . . . ."#, 4);
    let sounds = get_sounds(&outputs);
    assert_eq!(sounds, vec!["kick", "kick", "kick", "kick"]);
}

#[test]
fn dot_with_silence() {
    let outputs = expect_outputs(r#""kick" s . _ . _"#, 2);
    let deltas = get_deltas(&outputs);
    let step = 0.5 / 4.0;
    assert!(approx_eq(deltas[0], 0.0));
    assert!(approx_eq(deltas[1], 2.0 * step));
}

#[test]
fn div_basic_subdivision() {
    let outputs = expect_outputs(r#"div "kick" s . "hat" s . ~"#, 2);
    let deltas = get_deltas(&outputs);
    let sounds = get_sounds(&outputs);
    assert_eq!(sounds, vec!["kick", "hat"]);
    assert!(approx_eq(deltas[0], 0.0));
    assert!(approx_eq(deltas[1], 0.25), "second should be at 0.25, got {}", deltas[1]);
}

#[test]
fn div_sequential() {
    // Two consecutive divs each claim a slot in root, so they're sequential
    let outputs = expect_outputs(r#"div "kick" s . ~ div "hat" s . ~"#, 2);
    let deltas = get_deltas(&outputs);
    let sounds = get_sounds(&outputs);
    assert_eq!(sounds, vec!["kick", "hat"]);
    assert!(approx_eq(deltas[0], 0.0));
    assert!(approx_eq(deltas[1], 0.25), "second div at slot 1, got {}", deltas[1]);
}

#[test]
fn div_with_root_emit() {
    // kick claims slot 0 at root, div claims slot 1 at root
    let outputs = expect_outputs(r#""kick" s . div "hat" s . ~"#, 2);
    let deltas = get_deltas(&outputs);
    let sounds = get_sounds(&outputs);
    assert_eq!(sounds, vec!["kick", "hat"]);
    assert!(approx_eq(deltas[0], 0.0), "kick at slot 0");
    assert!(approx_eq(deltas[1], 0.25), "hat at slot 1, got {}", deltas[1]);
}

#[test]
fn div_nested() {
    // kick claims slot 0 in outer div, inner div claims slot 1
    // Inner div's 2 hats subdivide its slot (0.25 duration) into 2 sub-slots
    let outputs = expect_outputs(r#"div "kick" s . div "hat" s . . ~ ~"#, 3);
    let sounds = get_sounds(&outputs);
    let deltas = get_deltas(&outputs);
    // Output order: kick (slot 0), then hats (slot 1 subdivided)
    assert_eq!(sounds[0], "kick");
    assert_eq!(sounds[1], "hat");
    assert_eq!(sounds[2], "hat");
    // Outer div has 2 slots of 0.25 each
    // kick at slot 0 -> delta 0
    // inner div at slot 1 -> starts at 0.25, subdivided into 2 -> hats at 0.25 and 0.375
    assert!(approx_eq(deltas[0], 0.0), "kick at 0, got {}", deltas[0]);
    assert!(approx_eq(deltas[1], 0.25), "first hat at 0.25, got {}", deltas[1]);
    assert!(approx_eq(deltas[2], 0.375), "second hat at 0.375, got {}", deltas[2]);
}

#[test]
fn div_with_silence() {
    let outputs = expect_outputs(r#"div "kick" s . _ ~"#, 1);
    let deltas = get_deltas(&outputs);
    assert!(approx_eq(deltas[0], 0.0));
}

#[test]
fn unmatched_scope_terminator_error() {
    let f = forth();
    let result = f.evaluate(r#""kick" s . ~"#, &default_ctx());
    assert!(result.is_err(), "unmatched ~ should error");
}

#[test]
fn stack_superposes_sounds() {
    let outputs = expect_outputs(r#"stack "kick" s . "hat" s . ~"#, 2);
    let deltas = get_deltas(&outputs);
    let sounds = get_sounds(&outputs);
    assert_eq!(sounds.len(), 2);
    // Both at delta 0 (stacked/superposed)
    assert!(approx_eq(deltas[0], 0.0));
    assert!(approx_eq(deltas[1], 0.0));
}

#[test]
fn stack_with_multiple_emits() {
    let outputs = expect_outputs(r#"stack "kick" s . . . . ~"#, 4);
    let deltas = get_deltas(&outputs);
    // All 4 kicks at delta 0
    for (i, delta) in deltas.iter().enumerate() {
        assert!(approx_eq(*delta, 0.0), "emit {} should be at 0, got {}", i, delta);
    }
}

#[test]
fn stack_inside_div() {
    // div subdivides, stack inside superposes
    // stack doesn't claim a slot in parent div, so snare is also at 0
    let outputs = expect_outputs(r#"div stack "kick" s . "hat" s . ~ "snare" s . ~"#, 3);
    let deltas = get_deltas(&outputs);
    let sounds = get_sounds(&outputs);
    // stack resolves first (kick, hat at 0), then div resolves (snare at 0)
    // since stack doesn't consume a slot in the parent div
    assert_eq!(sounds[0], "kick");
    assert_eq!(sounds[1], "hat");
    assert_eq!(sounds[2], "snare");
    assert!(approx_eq(deltas[0], 0.0));
    assert!(approx_eq(deltas[1], 0.0));
    assert!(approx_eq(deltas[2], 0.0), "snare at 0, got {}", deltas[2]);
}

#[test]
fn div_nested_with_sibling() {
    // Inner div claims slot 0, snare claims slot 1
    // Inner div's kick/hat subdivide slot 0
    let outputs = expect_outputs(r#"div div "kick" s . "hat" s . ~ "snare" s . ~"#, 3);
    let deltas = get_deltas(&outputs);
    let sounds = get_sounds(&outputs);
    // Outer div has 2 slots of 0.25 each
    // Inner div at slot 0: kick at 0, hat at 0.125
    // snare at slot 1: delta 0.25
    assert_eq!(sounds[0], "kick");
    assert_eq!(sounds[1], "hat");
    assert_eq!(sounds[2], "snare");
    assert!(approx_eq(deltas[0], 0.0), "kick at 0, got {}", deltas[0]);
    assert!(approx_eq(deltas[1], 0.125), "hat at 0.125, got {}", deltas[1]);
    assert!(approx_eq(deltas[2], 0.25), "snare at 0.25, got {}", deltas[2]);
}

#[test]
fn emit_n_basic() {
    let outputs = expect_outputs(r#""kick" s 4 .!"#, 4);
    let sounds = get_sounds(&outputs);
    assert_eq!(sounds, vec!["kick", "kick", "kick", "kick"]);
}

#[test]
fn emit_n_zero() {
    let outputs = expect_outputs(r#""kick" s 0 .!"#, 0);
    assert!(outputs.is_empty());
}

#[test]
fn emit_n_negative_error() {
    let f = forth();
    let result = f.evaluate(r#""kick" s -1 .!"#, &default_ctx());
    assert!(result.is_err());
}