use super::RenderData;

#[test]
fn dirty_signal_is_consumed_once() {
    let mut data = RenderData::new(64).unwrap();

    assert!(data.rows("signals").is_some());
    assert!(data.begin_render());
    assert!(!data.begin_render());

    data.mark_dirty();
    assert!(data.begin_render());
    assert!(!data.render_pending());
}

#[test]
fn skip_and_bundle_signals_hold_dirty_work() {
    let mut data = RenderData::new(64).unwrap();
    assert!(data.begin_render());

    data.write_signal(4, 1.0);
    data.mark_dirty();
    assert!(!data.begin_render());
    data.write_signal(4, 0.0);
    assert!(data.begin_render());

    data.write_signal(6, 1.0);
    data.mark_dirty();
    assert!(!data.begin_render());
    data.loadout_ready();
    assert!(data.begin_render());
}

fn rows_of(data: &RenderData, name: &str) -> u32 {
    data.rows(name).unwrap().rows
}

#[test]
fn spans_reuse_coalesced_gaps_before_growing() {
    let mut data = RenderData::new(4096).unwrap();
    data.create_rows("v".into(), 8, 16, "f32".into()).unwrap();

    assert_eq!(data.allocate_object("v", 2).unwrap(), (0, false));
    assert_eq!(data.allocate_object("v", 3).unwrap(), (2, false));
    assert_eq!(data.allocate_object("v", 3).unwrap(), (5, false));
    assert_eq!(rows_of(&data, "v"), 8);

    // Freeing the two middle spans leaves one coalesced hole of 6 rows.
    data.delete_object("v", 2).unwrap();
    data.delete_object("v", 5).unwrap();
    assert_eq!(data.delete_object("v", 5), Err("OBJECT_UNKNOWN"));
    assert_eq!(data.allocate_object("v", 6).unwrap(), (2, false));
    assert_eq!(rows_of(&data, "v"), 8);

    // A span that does not fit doubles capacity instead of growing to the exact need.
    assert_eq!(data.allocate_object("v", 1).unwrap(), (8, true));
    assert_eq!(rows_of(&data, "v"), 16);
    assert_eq!(data.allocate_object("v", 40).unwrap(), (9, true));
    assert_eq!(rows_of(&data, "v"), 56);
    assert_eq!(data.allocate_object("v", 0), Err("ROWS"));
}

#[test]
fn deleting_a_span_zeroes_every_row_and_keeps_neighbours() {
    let mut data = RenderData::new(4096).unwrap();
    data.create_rows("v".into(), 4, 16, "u32".into()).unwrap();
    let (first, _) = data.allocate_object("v", 2).unwrap();
    let (second, _) = data.allocate_object("v", 1).unwrap();
    let base = (data.rows("v").unwrap().offset - data.base) as usize + data.arena_start;
    data.arena[base..base + 48].fill(0xAB);

    data.delete_object("v", first).unwrap();
    assert!(data.bytes("v").unwrap()[..32].iter().all(|byte| *byte == 0));
    assert!(data.bytes("v").unwrap()[32..48]
        .iter()
        .all(|byte| *byte == 0xAB));
    assert_eq!(data.delete_rows("v"), Err("ROWS_ACTIVE"));
    data.delete_object("v", second).unwrap();
    data.delete_rows("v").unwrap();
}

#[test]
fn explicit_growth_feeds_the_span_allocator_and_relocation_keeps_content() {
    let mut data = RenderData::new(4096).unwrap();
    data.create_rows("a".into(), 1, 16, "u32".into()).unwrap();
    data.create_rows("b".into(), 1, 16, "u32".into()).unwrap();
    assert_eq!(data.allocate_object("a", 1).unwrap(), (0, false));
    let base = (data.rows("a").unwrap().offset - data.base) as usize + data.arena_start;
    data.arena[base..base + 16].fill(0xCD);

    let grown = data.create_rows("a".into(), 5, 16, "u32".into()).unwrap();
    assert_eq!(grown.rows, 5);
    assert!(data.bytes("a").unwrap()[..16]
        .iter()
        .all(|byte| *byte == 0xCD));
    assert!(data.bytes("a").unwrap()[16..].iter().all(|byte| *byte == 0));
    assert_eq!(data.allocate_object("a", 4).unwrap(), (1, false));
    assert_eq!(data.allocate_object("a", 1).unwrap(), (5, true));
}