use crate::kernel::{fuse_attr, fuse_file_lock, fuse_forget_one, fuse_kstatfs};
use std::{convert::TryFrom, error, fmt};

/// Attributes about a file.
///
/// This type is ABI-compatible with `fuse_attr`.
#[derive(Debug, Default, Clone, Copy)]
#[repr(transparent)]
pub struct FileAttr(fuse_attr);

impl FileAttr {
    /// Return the inode number.
    pub fn ino(&self) -> u64 {
        self.0.ino
    }

    /// Set the inode number.
    pub fn set_ino(&mut self, ino: u64) {
        self.0.ino = ino;
    }

    /// Return the size of content.
    pub fn size(&self) -> u64 {
        self.0.size
    }

    /// Set the size of content.
    pub fn set_size(&mut self, size: u64) {
        self.0.size = size;
    }

    /// Return the permission of the inode.
    pub fn mode(&self) -> u32 {
        self.0.mode
    }

    /// Set the permission of the inode.
    pub fn set_mode(&mut self, mode: u32) {
        self.0.mode = mode;
    }

    /// Return the number of hard links.
    pub fn nlink(&self) -> u32 {
        self.0.nlink
    }

    /// Set the number of hard links.
    pub fn set_nlink(&mut self, nlink: u32) {
        self.0.nlink = nlink
    }

    /// Return the user ID.
    pub fn uid(&self) -> u32 {
        self.0.uid
    }

    /// Set the user ID.
    pub fn set_uid(&mut self, uid: u32) {
        self.0.uid = uid;
    }

    /// Return the group ID.
    pub fn gid(&self) -> u32 {
        self.0.gid
    }

    /// Set the group ID.
    pub fn set_gid(&mut self, gid: u32) {
        self.0.gid = gid;
    }

    /// Return the device ID.
    pub fn rdev(&self) -> u32 {
        self.0.rdev
    }

    /// Set the device ID.
    pub fn set_rdev(&mut self, rdev: u32) {
        self.0.rdev = rdev;
    }

    /// Return the block size.
    pub fn blksize(&self) -> u32 {
        self.0.blksize
    }

    /// Set the block size.
    pub fn set_blksize(&mut self, blksize: u32) {
        self.0.blksize = blksize;
    }

    /// Return the number of allocated blocks.
    pub fn blocks(&self) -> u64 {
        self.0.blocks
    }

    /// Set the number of allocated blocks.
    pub fn set_blocks(&mut self, blocks: u64) {
        self.0.blocks = blocks;
    }

    /// Return the last accessed time.
    pub fn atime(&self) -> (u64, u32) {
        (self.0.atime, self.0.atimensec)
    }

    /// Set the last accessed time.
    pub fn set_atime(&mut self, sec: u64, nsec: u32) {
        self.0.atime = sec;
        self.0.atimensec = nsec;
    }

    /// Return the last modification time.
    pub fn mtime(&self) -> (u64, u32) {
        (self.0.mtime, self.0.mtimensec)
    }

    /// Set the last modification time.
    pub fn set_mtime(&mut self, sec: u64, nsec: u32) {
        self.0.mtime = sec;
        self.0.mtimensec = nsec;
    }

    /// Return the last created time.
    pub fn ctime(&self) -> (u64, u32) {
        (self.0.ctime, self.0.ctimensec)
    }

    /// Set the last created time.
    pub fn set_ctime(&mut self, sec: u64, nsec: u32) {
        self.0.ctime = sec;
        self.0.ctimensec = nsec;
    }
}

impl TryFrom<libc::stat> for FileAttr {
    type Error = std::num::TryFromIntError;

    fn try_from(attr: libc::stat) -> Result<Self, Self::Error> {
        Ok(Self(fuse_attr {
            ino: u64::try_from(attr.st_ino).map_err(Self::Error::from)?,
            size: u64::try_from(attr.st_size).map_err(Self::Error::from)?,
            blocks: u64::try_from(attr.st_blocks).map_err(Self::Error::from)?,
            atime: u64::try_from(attr.st_atime).map_err(Self::Error::from)?,
            mtime: u64::try_from(attr.st_mtime).map_err(Self::Error::from)?,
            ctime: u64::try_from(attr.st_ctime).map_err(Self::Error::from)?,
            atimensec: u32::try_from(attr.st_atime_nsec).map_err(Self::Error::from)?,
            mtimensec: u32::try_from(attr.st_mtime_nsec).map_err(Self::Error::from)?,
            ctimensec: u32::try_from(attr.st_ctime_nsec).map_err(Self::Error::from)?,
            mode: u32::try_from(attr.st_mode).map_err(Self::Error::from)?,
            nlink: u32::try_from(attr.st_nlink).map_err(Self::Error::from)?,
            uid: u32::try_from(attr.st_uid).map_err(Self::Error::from)?,
            gid: u32::try_from(attr.st_gid).map_err(Self::Error::from)?,
            rdev: u32::try_from(attr.st_gid).map_err(Self::Error::from)?,
            blksize: u32::try_from(attr.st_blksize).map_err(Self::Error::from)?,
            padding: 0,
        }))
    }
}

impl FileAttr {
    pub(crate) fn into_inner(self) -> fuse_attr {
        self.0
    }
}

/// File lock information.
///
/// This type is ABI-compatible with `fuse_file_lock`.
#[derive(Debug, Copy, Clone, Default)]
#[repr(transparent)]
pub struct FileLock(fuse_file_lock);

impl FileLock {
    pub(crate) fn new(attr: &fuse_file_lock) -> &Self {
        unsafe { &*(attr as *const fuse_file_lock as *const Self) }
    }

    /// Return the type of lock.
    pub fn typ(&self) -> u32 {
        self.0.typ
    }

    /// Set the type of lock.
    pub fn set_typ(&mut self, typ: u32) {
        self.0.typ = typ;
    }

    /// Return the starting offset for lock.
    pub fn start(&self) -> u64 {
        self.0.start
    }

    /// Set the starting offset for lock.
    pub fn set_start(&mut self, start: u64) {
        self.0.start = start;
    }

    /// Return the ending offset for lock.
    pub fn end(&self) -> u64 {
        self.0.end
    }

    /// Set the ending offset for lock.
    pub fn set_end(&mut self, end: u64) {
        self.0.end = end;
    }

    /// Return the process ID blocking the lock.
    pub fn pid(&self) -> u32 {
        self.0.pid
    }

    /// Set the process ID blocking the lock.
    pub fn set_pid(&mut self, pid: u32) {
        self.0.pid = pid;
    }

    pub(crate) fn into_inner(self) -> fuse_file_lock {
        self.0
    }
}

impl TryFrom<libc::flock> for FileLock {
    type Error = InvalidFileLock;

    #[allow(clippy::cast_sign_loss)]
    fn try_from(lk: libc::flock) -> Result<Self, Self::Error> {
        const F_RDLCK: u32 = libc::F_RDLCK as u32;
        const F_WRLCK: u32 = libc::F_WRLCK as u32;
        const F_UNLCK: u32 = libc::F_UNLCK as u32;

        let lock_type = lk.l_type as u32;
        let (start, end) = match lock_type {
            F_UNLCK => (0, 0),
            F_RDLCK | F_WRLCK => {
                let start = lk.l_start as u64;
                let end = if lk.l_len == 0 {
                    std::u64::MAX
                } else {
                    start + (lk.l_len as u64) - 1
                };
                (start, end)
            }
            _ => return Err(InvalidFileLock(())),
        };

        Ok(Self(fuse_file_lock {
            start,
            end,
            typ: lock_type,
            pid: lk.l_pid as u32,
        }))
    }
}

#[doc(hidden)]
#[derive(Debug)]
pub struct InvalidFileLock(());

impl From<std::convert::Infallible> for InvalidFileLock {
    fn from(infallible: std::convert::Infallible) -> Self {
        match infallible {}
    }
}

impl From<std::num::TryFromIntError> for InvalidFileLock {
    fn from(_: std::num::TryFromIntError) -> Self {
        Self(())
    }
}

impl fmt::Display for InvalidFileLock {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "invalid file lock")
    }
}

impl error::Error for InvalidFileLock {}

/// Filesystem statistics.
///
/// This type is ABI-compatible with `fuse_kstatfs`.
#[derive(Debug, Clone, Copy, Default)]
#[repr(transparent)]
pub struct StatFs(fuse_kstatfs);

impl StatFs {
    /// Return the block size.
    pub fn bsize(&self) -> u32 {
        self.0.bsize
    }

    /// Set the block size.
    pub fn set_bsize(&mut self, bsize: u32) {
        self.0.bsize = bsize;
    }

    /// Return the fragment size.
    pub fn frsize(&self) -> u32 {
        self.0.frsize
    }

    /// Set the fragment size.
    pub fn set_frsize(&mut self, frsize: u32) {
        self.0.frsize = frsize;
    }

    /// Return the number of blocks in the filesystem.
    pub fn blocks(&self) -> u64 {
        self.0.blocks
    }

    /// Return the number of blocks in the filesystem.
    pub fn set_blocks(&mut self, blocks: u64) {
        self.0.blocks = blocks;
    }

    /// Return the number of free blocks.
    pub fn bfree(&self) -> u64 {
        self.0.bfree
    }

    /// Return the number of free blocks.
    pub fn set_bfree(&mut self, bfree: u64) {
        self.0.bfree = bfree;
    }

    /// Return the number of free blocks for non-priviledge users.
    pub fn bavail(&self) -> u64 {
        self.0.bavail
    }

    /// Set the number of free blocks for non-priviledge users.
    pub fn set_bavail(&mut self, bavail: u64) {
        self.0.bavail = bavail;
    }

    /// Return the number of inodes.
    pub fn files(&self) -> u64 {
        self.0.files
    }

    /// Set the number of inodes.
    pub fn set_files(&mut self, files: u64) {
        self.0.files = files;
    }

    /// Return the number of free inodes.
    pub fn ffree(&self) -> u64 {
        self.0.ffree
    }

    /// Set the number of free inodes.
    pub fn set_ffree(&mut self, ffree: u64) {
        self.0.ffree = ffree;
    }

    /// Return the maximum length of file names.
    pub fn namelen(&self) -> u32 {
        self.0.namelen
    }

    /// Return the maximum length of file names.
    pub fn set_namelen(&mut self, namelen: u32) {
        self.0.namelen = namelen;
    }

    pub(crate) fn into_inner(self) -> fuse_kstatfs {
        self.0
    }
}

impl TryFrom<libc::statvfs> for StatFs {
    type Error = std::num::TryFromIntError;

    fn try_from(st: libc::statvfs) -> Result<Self, Self::Error> {
        Ok(Self(fuse_kstatfs {
            bsize: u32::try_from(st.f_bsize).map_err(Self::Error::from)?,
            frsize: u32::try_from(st.f_frsize).map_err(Self::Error::from)?,
            blocks: u64::try_from(st.f_blocks).map_err(Self::Error::from)?,
            bfree: u64::try_from(st.f_bfree).map_err(Self::Error::from)?,
            bavail: u64::try_from(st.f_bavail).map_err(Self::Error::from)?,
            files: u64::try_from(st.f_files).map_err(Self::Error::from)?,
            ffree: u64::try_from(st.f_ffree).map_err(Self::Error::from)?,
            namelen: u32::try_from(st.f_namemax).map_err(Self::Error::from)?,
            padding: 0,
            spare: [0u32; 6],
        }))
    }
}

/// A forget information.
///
/// This type is ABI-compatible with `fuse_forget_one`.
#[derive(Debug)]
#[repr(transparent)]
pub struct Forget(fuse_forget_one);

impl Forget {
    pub(crate) const fn new(ino: u64, nlookup: u64) -> Self {
        Self(fuse_forget_one {
            nodeid: ino,
            nlookup,
        })
    }

    /// Return the inode number of the target inode.
    pub fn ino(&self) -> u64 {
        self.0.nodeid
    }

    /// Return the released lookup count of the target inode.
    pub fn nlookup(&self) -> u64 {
        self.0.nlookup
    }
}