mod common;

use pimcore::{
    CoreInstructionsBuilder, Executable,
    instruction_set::{InstructionsBuilder, instruction_data::InstructionDataBuilder, isa::*},
};

#[test]
fn restarts_cores_and_loads_each_input() {
    let cpu = common::empty_cpu(1);
    let mut cores = CoreInstructionsBuilder::new(1);
    let mut instructions = InstructionsBuilder::new();
    let mut data = InstructionDataBuilder::new();
    data.set_core_indx(1).fix_core_indx();
    instructions.make_inst(sldi, data.set_rdimm(1, 0).build());
    instructions.make_inst(sldi, data.set_rdimm(2, 0).build());
    instructions.make_inst(ld, data.set_rdr1(2, 1).set_imm_len(4).build());
    instructions.make_inst(sldi, data.set_rdimm(3, 4).build());
    instructions.make_inst(st, data.set_rdr1(3, 2).set_imm_len(4).build());
    cores.set_core(1, instructions.build());

    let mut executable = Executable::new(cpu, cores.build());
    let first = 1.0f32.to_ne_bytes();
    let second = 2.0f32.to_ne_bytes();
    assert!(
        executable
            .execute_batch(&[&first[..3]], &[(0, 4)], &[])
            .is_err()
    );
    executable
        .execute_batch(&[&first, &second], &[(0, 4)], &[])
        .unwrap();

    assert_eq!(
        executable.cpu_mut().host().load::<f32>(4, 4).unwrap()[0],
        [2.0]
    );
}

#[test]
fn records_each_iteration_output() {
    let cpu = common::empty_cpu(1);
    let mut cores = CoreInstructionsBuilder::new(1);
    let mut instructions = InstructionsBuilder::new();
    let mut data = InstructionDataBuilder::new();
    data.set_core_indx(1).fix_core_indx();
    instructions.make_inst(sldi, data.set_rdimm(1, 0).build());
    instructions.make_inst(sldi, data.set_rdimm(2, 0).build());
    instructions.make_inst(ld, data.set_rdr1(2, 1).set_imm_len(4).build());
    instructions.make_inst(sldi, data.set_rdimm(3, 4).build());
    instructions.make_inst(st, data.set_rdr1(3, 2).set_imm_len(4).build());
    cores.set_core(1, instructions.build());

    let mut executable = Executable::new(cpu, cores.build());
    let first = 1.0f32.to_ne_bytes();
    let second = 2.0f32.to_ne_bytes();
    let outputs = executable
        .execute_batch(&[&first, &second], &[(0, 4)], &[(4, 2), (6, 2)])
        .unwrap();

    assert_eq!(outputs.len(), 2);
    assert_eq!(
        f32::from_ne_bytes(outputs[0].as_slice().try_into().unwrap()),
        1.0
    );
    assert_eq!(
        f32::from_ne_bytes(outputs[1].as_slice().try_into().unwrap()),
        2.0
    );
}