//! Provides physical in-memory file descriptors.
//!
//! This can be useful for temporary buffers where a file descriptor is required.
//! Huge-pages can also be used for this memory.
#![allow(deprecated)]

use super::*;
use libc::{
    c_uint,
    memfd_create,
    MFD_CLOEXEC,
    MFD_HUGETLB,

    ftruncate,

    lseek,
    SEEK_SET,
    SEEK_CUR,
    SEEK_END,
};
use std::{
    ffi::{CStr, CString},
    borrow::{
	Borrow,
	BorrowMut,
	Cow,
    },
    path::{
	Path, PathBuf,
    },
    ops,
};
use hugetlb::{
    MapHugeFlag,
    HugePage,
};

static UNNAMED: &'static CStr = unsafe {
    CStr::from_bytes_with_nul_unchecked(b"<unnamed memory file>\0")
};

const DEFAULT_FLAGS: c_uint = if cfg!(feature="default-cloexec") { MFD_CLOEXEC } else { 0 };

#[inline(always)]
//XXX: Is the static bound required here?
/// Create a raw, unmanaged, memory file with these flags and this name.
///
/// # Safety
/// The reference obtained by `name` must not move as long as the `Ok()` result is alive.
pub unsafe fn create_raw(name: impl AsRef<CStr>, flags: c_uint) -> io::Result<UnmanagedFD> 
{
    UnmanagedFD::new_raw(memfd_create(name.as_ref().as_ptr(), flags)).ok_or_else(|| io::Error::last_os_error())
}

/// A physical-memory backed file
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(transparent)]
pub struct MemoryFile(ManagedFD);

/// A named, physical-memory backed file
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[deprecated(note = "Use `MemoryFile::named[_with_size]()` instead.")]
pub struct NamedMemoryFile(Box<CStr>, MemoryFile);

impl NamedMemoryFile
{
    pub(crate) const PATH_PREFIX: &'static str = "/proc/self/fd/";
    
    /// Get the name of the memfd which will be `/proc/self/fd/memfd:{}` (where `{}` is `.name()`.)
    #[inline] 
    pub fn name(&self) -> &CStr
    {
	self.0.as_ref()
    }

    /// Get the absolute path (in `/proc/self/fd/`) of this memfd.
    #[inline] 
    pub fn get_path(&self) -> PathBuf
    {
	use std::ffi::OsStr;
	/// Name prefix within `PATH_PREFIX`.
	const PREFIX: &[u8; 6] = b"memfd:";

	// Alloc space for `PREFIX`+`self.0.len()` to create last element in path.
	stackalloc::alloca_zeroed(self.0.count_bytes() + PREFIX.len(), move |name| {
	    // Write `memfd:` to `name[..6]`
	    name[..PREFIX.len()].copy_from_slice(&PREFIX[..]);
	    // Write name to `name+6`
	    name[PREFIX.len()..].copy_from_slice(self.0.to_bytes());
	    
	    // for (&src, dest) in PREFIX.into_iter().chain(self.0.to_bytes().iter()).zip(&mut name[..])  {
	    // 	*dest = src;
	    // }
	    
	    debug_assert_ne!(name.last().unwrap(), &0, "Invalid stack based path-builder string");
	    
	    Path::new(Self::PATH_PREFIX).join(OsStr::from_bytes(&name[..]))
	})  
    }

    /// Consume into the internal `MemoryFile`.
    #[inline] 
    pub fn into_inner(self) -> MemoryFile
    {
	self.1
    }
}

impl AsRawFd for NamedMemoryFile
{
    #[inline] 
    fn as_raw_fd(&self) -> RawFd {
	self.1.as_raw_fd()
    }
}

impl IntoRawFd for NamedMemoryFile
{
    #[inline] 
    fn into_raw_fd(self) -> RawFd {
	self.1.into_raw_fd()
    }
}

impl Borrow<MemoryFile> for NamedMemoryFile
{
    #[inline] 
    fn borrow(&self) -> &MemoryFile {
	&self.1
    }
}
impl BorrowMut<MemoryFile> for NamedMemoryFile
{
    #[inline] 
    fn borrow_mut(&mut self) -> &mut MemoryFile {
	&mut self.1
    }
}
impl ops::DerefMut for NamedMemoryFile
{
    fn deref_mut(&mut self) -> &mut Self::Target {
	&mut self.1
    }
}
impl ops::Deref for NamedMemoryFile
{
    type Target = MemoryFile;
    #[inline] 
    fn deref(&self) -> &Self::Target {
	&self.1
    }
}

//impl `MemoryFile` (memfd_create() fd wrapper)
impl MemoryFile
{
    /// The total size of the `memfd` memory file.
    #[inline] 
    pub fn size(&self) -> io::Result<u64>
    {
	stat_file_size(&self.0)
    }
    
    /// Create a new, empty, memory file with the specified raw C-string pointer name and the default set of flags.
    /// # Safety
    ///
    /// `name` must be a:
    /// - Non-null, aligned, valid pointer to:
    /// - A nul-terminated, non-wide C string.
    /// - Which must **not** contain a `/`.
    #[inline(always)] 
    pub(super) unsafe fn new_raw_named(name: *const std::ffi::c_char, flags: c_uint) -> io::Result<Self>
    {
	let managed = unsafe {
	    match memfd_create(name, flags) {
		-1 => return Err(last_os_error()),
		fd => ManagedFD::take_unchecked(fd),
	    }
	};
	Ok(Self(managed))
    }
    
    /// Create a new, empty, memory file with no user-provided name and the default set of flags.
    pub fn new() -> io::Result<Self>
    {
	// SAFETY: `UNNAMED` is a constant that fits the constraints required for `name`.
	unsafe {
	    Self::new_raw_named(UNNAMED.as_ptr(), DEFAULT_FLAGS)
	}
    }
    #[inline] 
    pub fn resize(&mut self, value: usize) -> io::Result<()>
    {
	if 0 == unsafe { ftruncate(self.as_raw_fd(), value.try_into().map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?) } {
	    Ok(())
	} else {
	    Err(io::Error::last_os_error())
	}
    }
    
    pub fn with_hugetlb(hugetlb: MapHugeFlag) -> io::Result<Self>
    {
	unsafe { create_raw(UNNAMED, DEFAULT_FLAGS | MFD_HUGETLB | (hugetlb.get_mask() as c_uint)) }
	.map(ManagedFD::take)
	    .map(Self)
    }

    pub fn with_size(size: usize) -> io::Result<Self>
    {
	let mut this = Self(unsafe { create_raw(UNNAMED, DEFAULT_FLAGS) }.map(ManagedFD::take)?);
	this.resize(size)?;
	Ok(this)
    }

    #[inline] 
    pub fn with_size_hugetlb(size: usize, hugetlb: MapHugeFlag) -> io::Result<Self>
    {
	let mut this = Self::with_hugetlb(hugetlb)?;
	this.resize(size)?;
	Ok(this)
    }

    /// Create a new, empty, memory file with the specified raw C-string pointer name and the default set of flags.
    pub fn new_named(name: impl AsRef<str>) -> io::Result<Self>
    {
	Self::raw_with_str_name(name.as_ref(), DEFAULT_FLAGS)
    }

    #[inline(always)] 
    pub(crate) fn raw_with_str_name(name: &str, flags: c_uint) -> io::Result<Self>
    {
	stackalloc::alloca_zeroed(name.len()+1, move |cname| {
	    cname[..name.len()].copy_from_slice(name.as_bytes());
	    debug_assert_eq!(cname[name.len()], 0, "Copied name not nul-terminated for `memfd_create()` call.");
	    
	    // SAFETY: We have initialised `cname[..]`, and we know the final byte will be
	    unsafe {
		Self::new_raw_named(cname.as_ptr() as *const _, flags)
	    }
	})
    }
    
    /// Create a new, empty, memory file with the specified raw C-string pointer name and the `MEMFD_HUGETLB` flag setup as provided as `hugetlb`.
    pub fn new_named_with_hugetlb(name: impl AsRef<str>, hugetlb: MapHugeFlag) -> io::Result<Self>
    {
	Self::raw_with_str_name(name.as_ref(), DEFAULT_FLAGS | MFD_HUGETLB | (hugetlb.get_mask() as c_uint))
    }

    /// Create a new memory file with the specified raw C-string pointer name and the default set of flags.
    /// Then resize it via `ftruncate()` to `size` bytes.
    pub fn new_named_with_size(name: impl AsRef<str>, size: usize) -> io::Result<Self>
    {
	let mut this = Self::raw_with_str_name(name.as_ref(), DEFAULT_FLAGS)?;
	this.resize(size)?;
	Ok(this)
    }
    
    /// Create a new memory file with the specified raw C-string pointer name and the `MEMFD_HUGETLB` flag setup as provided as `hugetlb`.
    /// Then resize it via `ftruncate()` to `size` bytes.
    pub fn new_named_with_size_hugetlb(name: impl AsRef<str>, size: usize, hugetlb: MapHugeFlag) -> io::Result<Self>
    {
	let mut this = Self::raw_with_str_name(name.as_ref(), DEFAULT_FLAGS | MFD_HUGETLB | (hugetlb.get_mask() as c_uint))?;
	this.resize(size)?;
	Ok(this)
    }
}

fn alloc_cstring(string: &str) -> std::ffi::CString
{
    #[cold]
    fn _contains_nul(mut bytes: Vec<u8>) -> std::ffi::CString
    {
	// SAFETY: We know this will only be called if byte `0` is in `bytes` (**before** the final element)
	let len = unsafe {
	    memchr::memchr(0, &bytes[..]).unwrap_unchecked()
	};
	bytes.truncate(len);
	// SAFETY: We have truncated the vector to end on the *first* instance of the `0` byte in `bytes`.
	unsafe {
	    std::ffi::CString::from_vec_with_nul_unchecked(bytes)
	}
    }
    let mut bytes = Vec::with_capacity(string.len()+1);
    bytes.extend_from_slice(string.as_bytes());
    bytes.push(0);
    match std::ffi::CString::from_vec_with_nul(bytes) {
	Ok(v) => v,
	Err(cn) => {
	    _contains_nul(cn.into_bytes())
	}
    }
}

impl NamedMemoryFile
{
    #[inline] 
    pub fn new(name: impl AsRef<str>) -> io::Result<Self>
    {
	let name: Box<CStr> = alloc_cstring(name.as_ref()).into();
	let managed = unsafe {
	    match memfd_create(name.as_ptr(), DEFAULT_FLAGS) {
		-1 => return Err(io::Error::last_os_error()),
		fd => ManagedFD::take_unchecked(fd),
	    }
	};
	Ok(Self(name, MemoryFile(managed)))
    }

    pub fn with_hugetlb(name: impl AsRef<str>, hugetlb: MapHugeFlag) -> io::Result<Self>
    {
	let name: Box<CStr> = alloc_cstring(name.as_ref()).into();
	let memfd = MemoryFile(unsafe { create_raw(&name, DEFAULT_FLAGS | MFD_HUGETLB | (hugetlb.get_mask() as c_uint)) }
			       .map(ManagedFD::take)?);
	Ok(Self(name, memfd))
    }

    pub fn with_size(name: impl AsRef<str>, size: usize) -> io::Result<Self>
    {
	let name: Box<CStr> = alloc_cstring(name.as_ref()).into();
	let mut this = MemoryFile(unsafe { create_raw(&name, DEFAULT_FLAGS) }.map(ManagedFD::take)?);
	this.resize(size)?;
	Ok(Self(name, this))
    }

    #[inline] 
    pub fn with_size_hugetlb(name: impl AsRef<str>, size: usize, hugetlb: MapHugeFlag) -> io::Result<Self>
    {
	let mut this = Self::with_hugetlb(name, hugetlb)?;
	this.resize(size)?;
	Ok(this)
    }
}

impl AsRawFd for MemoryFile
{
    #[inline] 
    fn as_raw_fd(&self) -> RawFd {
	self.0.as_raw_fd()
    }
}

impl FromRawFd for MemoryFile
{
    #[inline] 
    unsafe fn from_raw_fd(fd: RawFd) -> Self {
	Self(ManagedFD::from_raw_fd(fd))
    }
}

impl IntoRawFd for MemoryFile
{
    #[inline]
    fn into_raw_fd(self) -> RawFd {
	self.0.into_raw_fd()
    }
}

impl From<MemoryFile> for ManagedFD
{
    #[inline] 
    fn from(from: MemoryFile) -> Self
    {
	from.0
    }
}

impl From<MemoryFile> for std::fs::File
{
    #[inline] 
    fn from(from: MemoryFile) -> Self
    {
	from.0.into()
    }
}

raw::impl_io_for_fd!(MemoryFile => .0.as_raw_fd());

#[cfg(test)]
mod test {
    use std::io::{
	self,
	Write, Read, Seek,
    };
    
    #[test]
    fn default_flag_cloexec_visible()
    {
        println!("Default flags: {} (default-cloexec: {})", super::DEFAULT_FLAGS, cfg!(feature="default-cloexec"));

        assert_eq!(super::DEFAULT_FLAGS, cfg!(feature="default-cloexec").then(|| super::MFD_CLOEXEC).unwrap_or_default(), "Compile-time default creation flags are not in accordance with provided global crate configuration");
    }

    fn mem_seek()
    {
	// Test `SEEK_SET`.
	let mut file = super::MemoryFile::new_named("test-mem-seek").expect("Failed to create new file 'memfd:test-mem-seek'");
	file.write_all(b"hello world").expect("Failed to write to memfd");
	file.seek(io::SeekFrom::Start(6)).expect("Failed to seek to 6..");

	let mut buf = Vec::new();
	let sz = file.read_to_end(&mut buf).expect("Failed to read from memfd");

	assert_eq!(sz, 5, "Invalid number of bytes read");
	assert_eq!(&buf, b"world", "Invalid string data read");

	file.seek_relative(-(sz as i64)).expect("Failed to seek -5");
	
	buf.clear();
	assert_eq!(file.read_to_end(&mut buf).expect("Failed to read from memfd (2nd pass)"), sz, "Invalid number of bytes re-read from file");
	assert_eq!(&buf, b"world", "Invalid string data read in 2nd pass");
    }

    #[test]
    fn open_hugetlb()
    {
	const SIZE: usize = 1024 * 1024 * 4; // 1GB
	
	let ht = super::HugePage::Static(crate::MapHugeFlag::HUGE_2MB); // 2MB hugetlb
	
	let file = super::MemoryFile::new_named_with_size_hugetlb("test-mem-hugetlb", SIZE, dbg!(ht.compute_huge()).expect("Invalid `HugePage` spec."))
	    .expect("Failed to open hugetlb memfile");
	
	let mut file = crate::MappedFile::new(file, 4096, crate::Perm::Writeonly, crate::Flags::Shared.with_hugetlb(ht))
	    .expect("Failed to map hugetlb memfile for writing");

	write!(&mut &mut file[..], "Hello").expect("Failed to write to mapped file (1)");
	write!(&mut &mut file[2000..], "World").expect("Failed to write to mapped file (2)");

	file.flush(crate::Flush::Wait).expect("Failed to flush mapped data to memfd");

	let file = crate::MappedFile::new(super::ManagedFD::alias(file.inner()).expect("dup() failed"), 4096, crate::Perm::Readonly, crate::Flags::Shared)
	    .expect("Failed to map hugetlb memfile for reading");
	
	assert_eq!(&file[..5], b"Hello", "Invalid first write at 0");
	assert_eq!(&file[2000..2005], b"World", "Invalid second write at 2000");
    }
}