#[path = "../../../os-turkfs-journal/src/replay.rs"]
mod replay;
use replay::{Block, Device, Error, Outcome, Recovery, HOMES};

struct Disk { homes: [Block;3], durable: [Block;3], calls: Vec<u64>, fail: Option<usize> }
impl Device for Disk {
    fn write(&mut self, lba: u64, bytes: &Block) -> Result<(), ()> {
        self.calls.push(lba);
        if self.fail == Some(self.calls.len()) { return Err(()); }
        self.homes[HOMES.iter().position(|v| *v==lba).unwrap()] = *bytes; Ok(())
    }
    fn flush(&mut self) -> Result<(), ()> {
        self.calls.push(0);
        if self.fail == Some(self.calls.len()) { return Err(()); }
        self.durable = self.homes; Ok(())
    }
}
fn setup() -> (Block, Block, Disk) {
    let mut log = [0;512]; log[..128].copy_from_slice(include_bytes!("fixtures/turkfs-journal-v1.bin"));
    let mut commit = [0;512]; commit[..8].copy_from_slice(b"TKCOMMIT");
    commit[8..16].copy_from_slice(&7u64.to_le_bytes()); commit[16..20].copy_from_slice(&log[28..32]);
    let homes = [[0x44;512],[0x66;512],[0x77;512]];
    (log,commit,Disk {homes,durable:homes,calls:Vec::new(),fail:None})
}

#[test]
fn os_turkfs_recovery_replay_positive() {
    // All eight old/new home combinations represent completed writes that can
    // survive before a final flush. Replay changes only the remaining homes.
    for mask in 0u8..8 {
        let (log,commit,mut disk) = setup();
        let mut recovery = Recovery::new(&log,&commit).unwrap();
        for i in 0..3 { if mask & (1<<i) != 0 { disk.homes[i] = recovery.expected()[i]; } }
        disk.durable = disk.homes;
        let observed = disk.homes;
        let remaining = 3-mask.count_ones() as u8;
        assert_eq!(recovery.replay(&mut disk,&observed),Ok(if remaining==0 { Outcome::AlreadyApplied } else {Outcome::Replayed {writes:remaining}}));
        assert_eq!(&disk.durable,recovery.expected());
        assert_eq!(disk.calls.len(),if remaining==0 {0} else {usize::from(remaining)+1});
        let calls = disk.calls.len();
        let mut second = Recovery::new(&log,&commit).unwrap();
        let observed = disk.homes;
        assert_eq!(second.replay(&mut disk,&observed),Ok(Outcome::AlreadyApplied));
        assert_eq!(disk.calls.len(),calls);
        assert_eq!(&disk.durable,second.expected());
    }
}

#[test]
fn os_turkfs_recovery_replay_negative() {
    let (log,commit,mut disk) = setup();
    let mut incomplete = Recovery::new(&log,&[0;512]).unwrap();
    let before = disk.homes;
    assert_eq!(incomplete.replay(&mut disk,&before),Ok(Outcome::NoCommit));
    assert!(disk.calls.is_empty()); assert_eq!(disk.homes,before);
    let mut broken = before; broken[2][0]^=1;
    let mut recovery = Recovery::new(&log,&commit).unwrap();
    assert_eq!(recovery.replay(&mut disk,&broken),Err(Error::UnexpectedHome));
    assert!(disk.calls.is_empty());
    let mut no_commit = Recovery::new(&log,&[0;512]).unwrap();
    let mut mixed = before; mixed[0] = no_commit.expected()[0];
    assert_eq!(no_commit.replay(&mut disk,&mixed),Err(Error::UncommittedHome));
    assert!(disk.calls.is_empty());
    let mut bad_commit=commit; bad_commit[16]^=1;
    assert_eq!(Recovery::new(&log,&bad_commit).unwrap_err(),Error::Commit);
    for failed_call in 1..=4 {
        let (log,commit,mut disk) = setup(); disk.fail=Some(failed_call);
        let mut recovery=Recovery::new(&log,&commit).unwrap(); let before=disk.homes;
        assert_eq!(recovery.replay(&mut disk,&before),Err(Error::Io));
        assert_eq!(disk.calls.len(),failed_call);
        assert_eq!(recovery.replay(&mut disk,&before),Err(Error::Terminal));
        for retained in [disk.homes,disk.durable] {
            let mut restarted=Recovery::new(&log,&commit).unwrap();
            let mut fresh=Disk {homes:retained,durable:retained,calls:Vec::new(),fail:None};
            assert!(restarted.replay(&mut fresh,&retained).is_ok());
            assert_eq!(&fresh.durable,restarted.expected());
        }
    }
}