filesystem/vfs/file.rs

use core::mem::MaybeUninit;

use alloc::{string::String, sync::Arc, vec::Vec};

use crate::{
    driver::{
        base::{block::SeekFrom, device::DevicePrivateData},
        tty::TtyFilePrivateData,
    },
    filesystem::procfs::ProcfsFilePrivateData,
    ipc::pipe::PipeFsPrivateData,
    kerror,
    libs::spinlock::SpinLock,
    process::ProcessManager,
    syscall::SystemError,
};

use super::{Dirent, FileType, IndexNode, InodeId, Metadata};

/// 文件私有信息的枚举类型
#[derive(Debug, Clone)]
pub enum FilePrivateData {
    /// 管道文件私有信息
    Pipefs(PipeFsPrivateData),
    /// procfs文件私有信息
    Procfs(ProcfsFilePrivateData),
    /// 设备文件的私有信息
    DevFS(DevicePrivateData),
    /// tty设备文件的私有信息
    Tty(TtyFilePrivateData),
    /// 不需要文件私有信息
    Unused,
}

impl Default for FilePrivateData {
    fn default() -> Self {
        return Self::Unused;
    }
}

bitflags! {
    /// @brief 文件打开模式
    /// 其中，低2bit组合而成的数字的值，用于表示访问权限。其他的bit，才支持通过按位或的方式来表示参数
    ///
    /// 与Linux 5.19.10的uapi/asm-generic/fcntl.h相同
    /// https://opengrok.ringotek.cn/xref/linux-5.19.10/tools/include/uapi/asm-generic/fcntl.h#19
    pub struct FileMode: u32{
    /* File access modes for `open' and `fcntl'.  */
    /// Open Read-only
    const O_RDONLY = 0o0;
    /// Open Write-only
    const O_WRONLY = 0o1;
    /// Open read/write
    const O_RDWR = 0o2;
    /// Mask for file access modes
    const O_ACCMODE = 0o00000003;

    /* Bits OR'd into the second argument to open.  */
    /// Create file if it does not exist
    const O_CREAT = 0o00000100;
    /// Fail if file already exists
    const O_EXCL = 0o00000200;
    /// Do not assign controlling terminal
    const O_NOCTTY = 0o00000400;
    /// 文件存在且是普通文件，并以O_RDWR或O_WRONLY打开，则它会被清空
    const O_TRUNC = 0o00001000;
    /// 文件指针会被移动到文件末尾
    const O_APPEND = 0o00002000;
    /// 非阻塞式IO模式
    const O_NONBLOCK = 0o00004000;
    /// 每次write都等待物理I/O完成，但是如果写操作不影响读取刚写入的数据，则不等待文件属性更新
    const O_DSYNC = 0o00010000;
    /// fcntl, for BSD compatibility
    const FASYNC = 0o00020000;
    /* direct disk access hint */
    const O_DIRECT = 0o00040000;
    const O_LARGEFILE = 0o00100000;
    /// 打开的必须是一个目录
    const O_DIRECTORY = 0o00200000;
    /// Do not follow symbolic links
    const O_NOFOLLOW = 0o00400000;
    const O_NOATIME = 0o01000000;
    /// set close_on_exec
    const O_CLOEXEC = 0o02000000;
    /// 每次write都等到物理I/O完成，包括write引起的文件属性的更新
    const O_SYNC = 0o04000000;
    }
}

impl FileMode {
    /// @brief 获取文件的访问模式的值
    #[inline]
    pub fn accmode(&self) -> u32 {
        return self.bits() & FileMode::O_ACCMODE.bits();
    }
}
/// @brief 抽象文件结构体
#[derive(Debug)]
pub struct File {
    inode: Arc<dyn IndexNode>,
    /// 对于文件，表示字节偏移量；对于文件夹，表示当前操作的子目录项偏移量
    offset: usize,
    /// 文件的打开模式
    mode: FileMode,
    /// 文件类型
    file_type: FileType,
    /// readdir时候用的，暂存的本次循环中，所有子目录项的名字的数组
    readdir_subdirs_name: Vec<String>,
    pub private_data: FilePrivateData,
}

impl File {
    /// @brief 创建一个新的文件对象
    ///
    /// @param inode 文件对象对应的inode
    /// @param mode 文件的打开模式
    pub fn new(inode: Arc<dyn IndexNode>, mode: FileMode) -> Result<Self, SystemError> {
        let file_type: FileType = inode.metadata()?.file_type;
        let mut f = File {
            inode,
            offset: 0,
            mode,
            file_type,
            readdir_subdirs_name: Vec::new(),
            private_data: FilePrivateData::default(),
        };
        // kdebug!("inode:{:?}",f.inode);
        f.inode.open(&mut f.private_data, &mode)?;
        return Ok(f);
    }

    /// @brief 从文件中读取指定的字节数到buffer中
    ///
    /// @param len 要读取的字节数
    /// @param buf 目标buffer
    ///
    /// @return Ok(usize) 成功读取的字节数
    /// @return Err(SystemError) 错误码
    pub fn read(&mut self, len: usize, buf: &mut [u8]) -> Result<usize, SystemError> {
        // 先检查本文件在权限等规则下，是否可读取。
        self.readable()?;

        if buf.len() < len {
            return Err(SystemError::ENOBUFS);
        }

        // 如果文件指针已经超过了文件大小，则返回0
        if self.offset > self.inode.metadata()?.size as usize {
            return Ok(0);
        }

        let len = self
            .inode
            .read_at(self.offset, len, buf, &mut self.private_data)?;
        self.offset += len;
        return Ok(len);
    }

    /// @brief 从buffer向文件写入指定的字节数的数据
    ///
    /// @param len 要写入的字节数
    /// @param buf 源数据buffer
    ///
    /// @return Ok(usize) 成功写入的字节数
    /// @return Err(SystemError) 错误码
    pub fn write(&mut self, len: usize, buf: &[u8]) -> Result<usize, SystemError> {
        // 先检查本文件在权限等规则下，是否可写入。
        self.writeable()?;
        if buf.len() < len {
            return Err(SystemError::ENOBUFS);
        }

        // 如果文件指针已经超过了文件大小，则需要扩展文件大小
        let file_size = self.inode.metadata()?.size as usize;
        if self.offset > file_size {
            self.inode.resize(self.offset)?;
        }
        let len = self
            .inode
            .write_at(self.offset, len, buf, &mut self.private_data)?;
        self.offset += len;
        return Ok(len);
    }

    /// @brief 获取文件的元数据
    pub fn metadata(&self) -> Result<Metadata, SystemError> {
        return self.inode.metadata();
    }

    /// @brief 根据inode号获取子目录项的名字
    pub fn get_entry_name(&self, ino: InodeId) -> Result<String, SystemError> {
        return self.inode.get_entry_name(ino);
    }

    /// @brief 调整文件操作指针的位置
    ///
    /// @param origin 调整的起始位置
    pub fn lseek(&mut self, origin: SeekFrom) -> Result<usize, SystemError> {
        let file_type = self.inode.metadata()?.file_type;
        match file_type {
            FileType::Pipe | FileType::CharDevice => {
                return Err(SystemError::ESPIPE);
            }
            _ => {}
        }

        let pos: i64;
        match origin {
            SeekFrom::SeekSet(offset) => {
                pos = offset;
            }
            SeekFrom::SeekCurrent(offset) => {
                pos = self.offset as i64 + offset;
            }
            SeekFrom::SeekEnd(offset) => {
                let metadata = self.metadata()?;
                pos = metadata.size + offset;
            }
            SeekFrom::Invalid => {
                return Err(SystemError::EINVAL);
            }
        }
        // 根据linux man page, lseek允许超出文件末尾，并且不改变文件大小
        // 当pos超出文件末尾时，read返回0。直到开始写入数据时，才会改变文件大小
        if pos < 0 {
            return Err(SystemError::EOVERFLOW);
        }
        self.offset = pos as usize;
        return Ok(self.offset);
    }

    /// @brief 判断当前文件是否可读
    #[inline]
    pub fn readable(&self) -> Result<(), SystemError> {
        // 暂时认为只要不是write only, 就可读
        if self.mode == FileMode::O_WRONLY {
            return Err(SystemError::EPERM);
        }

        return Ok(());
    }

    /// @brief 判断当前文件是否可写
    #[inline]
    pub fn writeable(&self) -> Result<(), SystemError> {
        // 暂时认为只要不是read only, 就可写
        if self.mode == FileMode::O_RDONLY {
            return Err(SystemError::EPERM);
        }

        return Ok(());
    }

    /// @biref 充填dirent结构体
    /// @return 返回dirent结构体的大小
    pub fn readdir(&mut self, dirent: &mut Dirent) -> Result<u64, SystemError> {
        let inode: &Arc<dyn IndexNode> = &self.inode;

        // 如果偏移量为0
        if self.offset == 0 {
            self.readdir_subdirs_name = inode.list()?;
            self.readdir_subdirs_name.sort();
        }
        // kdebug!("sub_entries={sub_entries:?}");
        if self.readdir_subdirs_name.is_empty() {
            self.offset = 0;
            return Ok(0);
        }
        let name: String = self.readdir_subdirs_name.remove(0);
        let sub_inode: Arc<dyn IndexNode> = match inode.find(&name) {
            Ok(i) => i,
            Err(e) => {
                kerror!("Readdir error: Failed to find sub inode, file={self:?}");
                return Err(e);
            }
        };

        let name_bytes: &[u8] = name.as_bytes();

        self.offset += 1;
        dirent.d_ino = sub_inode.metadata().unwrap().inode_id.into() as u64;
        dirent.d_type = sub_inode.metadata().unwrap().file_type.get_file_type_num() as u8;
        // 根据posix的规定，dirent中的d_name是一个不定长的数组，因此需要unsafe来拷贝数据
        unsafe {
            let ptr = &mut dirent.d_name as *mut u8;
            let buf: &mut [u8] =
                ::core::slice::from_raw_parts_mut::<'static, u8>(ptr, name_bytes.len());
            buf.copy_from_slice(name_bytes);
        }

        // 计算dirent结构体的大小
        let size = (name_bytes.len() + ::core::mem::size_of::<Dirent>()
            - ::core::mem::size_of_val(&dirent.d_name)) as u64;

        dirent.d_reclen = size as u16;
        dirent.d_off += dirent.d_reclen as i64;

        return Ok(size);
    }

    pub fn inode(&self) -> Arc<dyn IndexNode> {
        return self.inode.clone();
    }

    /// @brief 尝试克隆一个文件
    ///
    /// @return Option<File> 克隆后的文件结构体。如果克隆失败，返回None
    pub fn try_clone(&self) -> Option<File> {
        let mut res = Self {
            inode: self.inode.clone(),
            offset: self.offset.clone(),
            mode: self.mode.clone(),
            file_type: self.file_type.clone(),
            readdir_subdirs_name: self.readdir_subdirs_name.clone(),
            private_data: self.private_data.clone(),
        };
        // 调用inode的open方法，让inode知道有新的文件打开了这个inode
        if self.inode.open(&mut res.private_data, &res.mode).is_err() {
            return None;
        }

        return Some(res);
    }

    /// @brief 获取文件的类型
    #[inline]
    pub fn file_type(&self) -> FileType {
        return self.file_type;
    }

    /// @brief 获取文件的打开模式
    #[inline]
    pub fn mode(&self) -> FileMode {
        return self.mode;
    }

    /// 获取文件是否在execve时关闭
    #[inline]
    pub fn close_on_exec(&self) -> bool {
        return self.mode.contains(FileMode::O_CLOEXEC);
    }

    /// 设置文件是否在execve时关闭
    #[inline]
    pub fn set_close_on_exec(&mut self, close_on_exec: bool) {
        if close_on_exec {
            self.mode.insert(FileMode::O_CLOEXEC);
        } else {
            self.mode.remove(FileMode::O_CLOEXEC);
        }
    }

    pub fn set_mode(&mut self, mode: FileMode) -> Result<(), SystemError> {
        // todo: 是否需要调用inode的open方法，以更新private data（假如它与mode有关的话）?
        // 也许需要加个更好的设计，让inode知晓文件的打开模式发生了变化，让它自己决定是否需要更新private data

        // 直接修改文件的打开模式
        self.mode = mode;
        return Ok(());
    }

    /// @brief 重新设置文件的大小
    ///
    /// 如果文件大小增加，则文件内容不变，但是文件的空洞部分会被填充为0
    /// 如果文件大小减小，则文件内容会被截断
    ///
    /// @return 成功：Ok()
    ///         失败：Err(错误码)
    pub fn ftruncate(&self, len: usize) -> Result<(), SystemError> {
        // 如果文件不可写，返回错误
        self.writeable()?;

        // 调用inode的truncate方法
        self.inode.resize(len)?;
        return Ok(());
    }
}

impl Drop for File {
    fn drop(&mut self) {
        let r: Result<(), SystemError> = self.inode.close(&mut self.private_data);
        // 打印错误信息
        if r.is_err() {
            kerror!(
                "pid: {:?} failed to close file: {:?}, errno={:?}",
                ProcessManager::current_pcb().pid(),
                self,
                r.unwrap_err()
            );
        }
    }
}

/// @brief pcb里面的文件描述符数组
#[derive(Debug)]
pub struct FileDescriptorVec {
    /// 当前进程打开的文件描述符
    fds: [Option<Arc<SpinLock<File>>>; FileDescriptorVec::PROCESS_MAX_FD],
}

impl FileDescriptorVec {
    pub const PROCESS_MAX_FD: usize = 32;

    pub fn new() -> FileDescriptorVec {
        // 先声明一个未初始化的数组
        let mut data: [MaybeUninit<Option<Arc<SpinLock<File>>>>;
            FileDescriptorVec::PROCESS_MAX_FD] = unsafe { MaybeUninit::uninit().assume_init() };

        // 逐个把每个元素初始化为None
        for i in 0..FileDescriptorVec::PROCESS_MAX_FD {
            data[i] = MaybeUninit::new(None);
        }
        // 由于一切都初始化完毕，因此将未初始化的类型强制转换为已经初始化的类型
        let data: [Option<Arc<SpinLock<File>>>; FileDescriptorVec::PROCESS_MAX_FD] = unsafe {
            core::mem::transmute::<
                _,
                [Option<Arc<SpinLock<File>>>; FileDescriptorVec::PROCESS_MAX_FD],
            >(data)
        };

        // 初始化文件描述符数组结构体
        return FileDescriptorVec { fds: data };
    }

    /// @brief 克隆一个文件描述符数组
    ///
    /// @return FileDescriptorVec 克隆后的文件描述符数组
    pub fn clone(&self) -> FileDescriptorVec {
        let mut res = FileDescriptorVec::new();
        for i in 0..FileDescriptorVec::PROCESS_MAX_FD {
            if let Some(file) = &self.fds[i] {
                if let Some(file) = file.lock().try_clone() {
                    res.fds[i] = Some(Arc::new(SpinLock::new(file)));
                }
            }
        }
        return res;
    }

    /// @brief 判断文件描述符序号是否合法
    ///
    /// @return true 合法
    ///
    /// @return false 不合法
    #[inline]
    pub fn validate_fd(fd: i32) -> bool {
        if fd < 0 || fd as usize > FileDescriptorVec::PROCESS_MAX_FD {
            return false;
        } else {
            return true;
        }
    }

    /// 申请文件描述符，并把文件对象存入其中。
    ///
    /// ## 参数
    ///
    /// - `file` 要存放的文件对象
    /// - `fd` 如果为Some(i32)，表示指定要申请这个文件描述符，如果这个文件描述符已经被使用，那么返回EBADF
    ///
    /// ## 返回值
    ///
    /// - `Ok(i32)` 申请成功，返回申请到的文件描述符
    /// - `Err(SystemError)` 申请失败，返回错误码，并且，file对象将被drop掉
    pub fn alloc_fd(&mut self, file: File, fd: Option<i32>) -> Result<i32, SystemError> {
        if fd.is_some() {
            // 指定了要申请的文件描述符编号
            let new_fd = fd.unwrap();
            let x = &mut self.fds[new_fd as usize];
            if x.is_none() {
                *x = Some(Arc::new(SpinLock::new(file)));
                return Ok(new_fd);
            } else {
                return Err(SystemError::EBADF);
            }
        } else {
            // 没有指定要申请的文件描述符编号
            for i in 0..FileDescriptorVec::PROCESS_MAX_FD {
                if self.fds[i].is_none() {
                    self.fds[i] = Some(Arc::new(SpinLock::new(file)));
                    return Ok(i as i32);
                }
            }
            return Err(SystemError::EMFILE);
        }
    }

    /// 根据文件描述符序号，获取文件结构体的Arc指针
    ///
    /// ## 参数
    ///
    /// - `fd` 文件描述符序号
    pub fn get_file_by_fd(&self, fd: i32) -> Option<Arc<SpinLock<File>>> {
        if !FileDescriptorVec::validate_fd(fd) {
            return None;
        }
        return self.fds[fd as usize].clone();
    }

    /// 释放文件描述符，同时关闭文件。
    ///
    /// ## 参数
    ///
    /// - `fd` 文件描述符序号
    pub fn drop_fd(&mut self, fd: i32) -> Result<(), SystemError> {
        // 判断文件描述符的数字是否超过限制
        if !FileDescriptorVec::validate_fd(fd) {
            return Err(SystemError::EBADF);
        }

        self.get_file_by_fd(fd).ok_or(SystemError::EBADF)?;

        // 把文件描述符数组对应位置设置为空
        let file = self.fds[fd as usize].take().unwrap();

        assert!(Arc::strong_count(&file) == 1);
        return Ok(());
    }

    pub fn iter(&self) -> FileDescriptorIterator {
        return FileDescriptorIterator::new(self);
    }

    pub fn close_on_exec(&mut self) {
        for i in 0..FileDescriptorVec::PROCESS_MAX_FD {
            if let Some(file) = &self.fds[i] {
                let to_drop = file.lock().close_on_exec();
                if to_drop {
                    let r = self.drop_fd(i as i32);
                    if let Err(r) = r {
                        kerror!(
                            "Failed to close file: pid = {:?}, fd = {}, error = {:?}",
                            ProcessManager::current_pcb().pid(),
                            i,
                            r
                        );
                    }
                }
            }
        }
    }
}

#[derive(Debug)]
pub struct FileDescriptorIterator<'a> {
    fds: &'a FileDescriptorVec,
    index: usize,
}

impl<'a> FileDescriptorIterator<'a> {
    pub fn new(fds: &'a FileDescriptorVec) -> Self {
        return Self { fds, index: 0 };
    }
}

impl<'a> Iterator for FileDescriptorIterator<'a> {
    type Item = (i32, Arc<SpinLock<File>>);

    fn next(&mut self) -> Option<Self::Item> {
        while self.index < FileDescriptorVec::PROCESS_MAX_FD {
            let fd = self.index as i32;
            self.index += 1;
            if let Some(file) = self.fds.get_file_by_fd(fd) {
                return Some((fd, file));
            }
        }
        return None;
    }
}