use memmap::Mmap;

use std::path::{Path, PathBuf};

use super::revlog::RevlogError;

use crate::repo::Repo;

use crate::utils::strip_suffix;

const ONDISK_VERSION: u8 = 1;

pub(super) struct NodeMapDocket {

    pub data_length: usize,

    // TODO: keep here more of the data from `parse()` when we need it

}

impl NodeMapDocket {

    /// Return `Ok(None)` when the caller should proceed without a persistent

    /// nodemap:

    ///

    /// * This revlog does not have a `.n` docket file (it is not generated for

    ///   small revlogs), or

    /// * The docket has an unsupported version number (repositories created by

    ///   later hg, maybe that should be a requirement instead?), or

    /// * The docket file points to a missing (likely deleted) data file (this

    ///   can happen in a rare race condition).

    pub fn read_from_file(

        repo: &Repo,

        index_path: &Path,

    ) -> Result<Option<(Self, Mmap)>, RevlogError> {

        let docket_path = index_path.with_extension("n");

        let docket_bytes = match repo.store_vfs().read(&docket_path) {

            Err(e) if e.kind() == std::io::ErrorKind::NotFound => {

                return Ok(None)

            }

            Err(e) => return Err(RevlogError::IoError(e)),

            Ok(bytes) => bytes,

        };

            docket_bytes.split_first()

        {

            rest

        } else {

            return Ok(None);

        };

        // TODO: do we care about overflow for 4 GB+ nodemap files on 32-bit

        // systems?

        let uid =

            std::str::from_utf8(uid).map_err(|_| RevlogError::Corrupted)?;

        let docket = NodeMapDocket { data_length };

        let data_path = rawdata_path(&docket_path, uid);

        // TODO: use `std::fs::read` here when the `persistent-nodemap.mmap`

        // config is false?

        match repo.store_vfs().mmap_open(&data_path) {

            Ok(mmap) => {

                if mmap.len() >= data_length {

                    Ok(Some((docket, mmap)))

                } else {

                    Err(RevlogError::Corrupted)

                }

            }

            Err(error) => {

                if error.kind() == std::io::ErrorKind::NotFound {

                    Ok(None)

                } else {

                    Err(RevlogError::IoError(error))

                }

            }

        }

    }

}

fn rawdata_path(docket_path: &Path, uid: &str) -> PathBuf {

    let docket_name = docket_path

        .file_name()

        .expect("expected a base name")

        .to_str()

        .expect("expected an ASCII file name in the store");

    let prefix = strip_suffix(docket_name, ".n.a")

        .or_else(|| strip_suffix(docket_name, ".n"))

        .expect("expected docket path in .n or .n.a");

    let name = format!("{}-{}.nd", prefix, uid);

    docket_path

        .parent()

        .expect("expected a non-root path")

        .join(name)

}