//! Durable file updates (spec §13.6): every write that must survive a

//! crash goes through here.

//!

//! A file is replaced by writing a uniquely named temporary file in the

//! same directory, syncing it, renaming it over the target, and syncing

//! the directory so the rename itself is on disk. A crash at any point

//! leaves either the old file or the new one, never a torn one; at worst

//! a stray temporary file, which nothing reads.

//!

//! In tests, `crash_after(n)` makes the n-th durable step on the current

//! thread fail as if the process had died there, so a test can stop an

//! operation at every step and check what is left behind.

use rand::RngCore;

use std::fs;

use std::io::{self, Write};

use std::path::Path;

/// Replace `path` with `data`, atomically and durably.

pub fn write_atomic(path: &Path, data: &[u8]) -> io::Result<()> {

    let dir = path.parent().unwrap_or(Path::new("."));

    let name = path

        .file_name()

        .map(|n| n.to_string_lossy().into_owned())

        .unwrap_or_default();

    let mut nonce = [0u8; 6];

    rand::rngs::OsRng.fill_bytes(&mut nonce);

    let tmp = dir.join(format!(".{name}.tmp-{}", hex::encode(nonce)));

    step("create temporary file")?;

    let written = (|| {

        let mut f = fs::File::create(&tmp)?;

        f.write_all(data)?;

        f.sync_all()?;

        step("rename into place")?;

        fs::rename(&tmp, path)

    })();

    if let Err(e) = written {

        if !is_injected(&e) {

            let _ = fs::remove_file(&tmp);

        }

        return Err(e);

    }

    sync_dir(dir)

}

/// Rename `from` to `to` and make the rename durable.

pub fn rename(from: &Path, to: &Path) -> io::Result<()> {

    step("rename")?;

    fs::rename(from, to)?;

    sync_dir(to.parent().unwrap_or(Path::new(".")))

}

/// Flush a directory's entries (new, renamed or removed files) to disk.

/// A no-op where directories cannot be opened for syncing.

pub fn sync_dir(dir: &Path) -> io::Result<()> {

    #[cfg(unix)]

    {

        fs::File::open(dir)?.sync_all()

    }

    #[cfg(not(unix))]

    {

        let _ = dir;

        Ok(())

    }

}

/// A point where a crash may happen. Outside tests it does nothing.

pub fn step(what: &str) -> io::Result<()> {

    #[cfg(test)]

    {

        failpoint::hit(what)

    }

    #[cfg(not(test))]

    {

        let _ = what;

        Ok(())

    }

}

const INJECTED: &str = "injected crash";

fn is_injected(e: &io::Error) -> bool {

    e.to_string().starts_with(INJECTED)

}

#[cfg(test)]

pub(crate) mod failpoint {

    use std::cell::Cell;

    use std::io;

    thread_local! {

        static COUNTDOWN: Cell<Option<usize>> = const { Cell::new(None) };

        static FIRED: Cell<bool> = const { Cell::new(false) };

    }

    /// Fail the `n`-th durable step from now (1-based) on this thread,

    /// and every step after it, as a dead process would.

    pub fn crash_after(n: usize) {

        COUNTDOWN.with(|c| c.set(Some(n)));

        FIRED.with(|f| f.set(false));

    }

    /// Stop injecting; returns whether a crash was injected.

    pub fn disarm() -> bool {

        COUNTDOWN.with(|c| c.set(None));

        FIRED.with(|f| f.replace(false))

    }

    pub(super) fn hit(what: &str) -> io::Result<()> {

        if FIRED.with(|f| f.get()) {

            return Err(io::Error::other(format!(

                "{} (after) at {what}",

                super::INJECTED

            )));

        }

        COUNTDOWN.with(|c| match c.get() {

            Some(1) => {

                c.set(None);

                FIRED.with(|f| f.set(true));

                Err(io::Error::other(format!("{} at {what}", super::INJECTED)))

            }

            Some(n) => {

                c.set(Some(n - 1));

                Ok(())

            }

            None => Ok(()),

        })

    }

}