use crate::ffi::{CStr, CString, OsStr, OsString};
use crate::fmt;
use crate::io::{self, IoVec, IoVecMut, SeekFrom};
use crate::iter;
use crate::mem::{self, ManuallyDrop};
use crate::os::wasi::ffi::{OsStrExt, OsStringExt};
use crate::path::{Path, PathBuf};
use crate::ptr;
use crate::sync::Arc;
use crate::sys::fd::{DirCookie, WasiFd};
use crate::sys::time::SystemTime;
use crate::sys::unsupported;
use crate::sys_common::FromInner;

pub use crate::sys_common::fs::copy;
pub use crate::sys_common::fs::remove_dir_all;

pub struct File {
    fd: WasiFd,
}

#[derive(Clone)]
pub struct FileAttr {
    meta: libc::__wasi_filestat_t,
}

pub struct ReadDir {
    inner: Arc<ReadDirInner>,
    cookie: Option<DirCookie>,
    buf: Vec<u8>,
    offset: usize,
    cap: usize,
}

struct ReadDirInner {
    root: PathBuf,
    dir: File,
}

pub struct DirEntry {
    meta: libc::__wasi_dirent_t,
    name: Vec<u8>,
    inner: Arc<ReadDirInner>,
}

#[derive(Clone, Debug, Default)]
pub struct OpenOptions {
    read: bool,
    write: bool,
    dirflags: libc::__wasi_lookupflags_t,
    fdflags: libc::__wasi_fdflags_t,
    oflags: libc::__wasi_oflags_t,
    rights_base: Option<libc::__wasi_rights_t>,
    rights_inheriting: Option<libc::__wasi_rights_t>,
}

#[derive(Clone, PartialEq, Eq, Debug)]
pub struct FilePermissions {
    readonly: bool,
}

#[derive(PartialEq, Eq, Hash, Debug, Copy, Clone)]
pub struct FileType {
    bits: libc::__wasi_filetype_t,
}

#[derive(Debug)]
pub struct DirBuilder {}

impl FileAttr {
    fn zero() -> FileAttr {
        FileAttr {
            meta: unsafe { mem::zeroed() },
        }
    }

    pub fn size(&self) -> u64 {
        self.meta.st_size
    }

    pub fn perm(&self) -> FilePermissions {
        // not currently implemented in wasi yet
        FilePermissions { readonly: false }
    }

    pub fn file_type(&self) -> FileType {
        FileType {
            bits: self.meta.st_filetype,
        }
    }

    pub fn modified(&self) -> io::Result<SystemTime> {
        Ok(SystemTime::from_wasi_timestamp(self.meta.st_mtim))
    }

    pub fn accessed(&self) -> io::Result<SystemTime> {
        Ok(SystemTime::from_wasi_timestamp(self.meta.st_atim))
    }

    pub fn created(&self) -> io::Result<SystemTime> {
        Ok(SystemTime::from_wasi_timestamp(self.meta.st_ctim))
    }

    pub fn as_wasi(&self) -> &libc::__wasi_filestat_t {
        &self.meta
    }
}

impl FilePermissions {
    pub fn readonly(&self) -> bool {
        self.readonly
    }

    pub fn set_readonly(&mut self, readonly: bool) {
        self.readonly = readonly;
    }
}

impl FileType {
    pub fn is_dir(&self) -> bool {
        self.bits == libc::__WASI_FILETYPE_DIRECTORY
    }

    pub fn is_file(&self) -> bool {
        self.bits == libc::__WASI_FILETYPE_REGULAR_FILE
    }

    pub fn is_symlink(&self) -> bool {
        self.bits == libc::__WASI_FILETYPE_SYMBOLIC_LINK
    }

    pub fn bits(&self) -> libc::__wasi_filetype_t {
        self.bits
    }
}

impl fmt::Debug for ReadDir {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("ReadDir").finish()
    }
}

impl Iterator for ReadDir {
    type Item = io::Result<DirEntry>;

    fn next(&mut self) -> Option<io::Result<DirEntry>> {
        loop {
            // If we've reached the capacity of our buffer then we need to read
            // some more from the OS, otherwise we pick up at our old offset.
            let offset = if self.offset == self.cap {
                let cookie = self.cookie.take()?;
                match self.inner.dir.fd.readdir(&mut self.buf, cookie) {
                    Ok(bytes) => self.cap = bytes,
                    Err(e) => return Some(Err(e)),
                }
                self.offset = 0;
                self.cookie = Some(cookie);

                // If we didn't actually read anything, this is in theory the
                // end of the directory.
                if self.cap == 0 {
                    self.cookie = None;
                    return None;
                }

                0
            } else {
                self.offset
            };
            let data = &self.buf[offset..self.cap];

            // If we're not able to read a directory entry then that means it
            // must have been truncated at the end of the buffer, so reset our
            // offset so we can go back and reread into the buffer, picking up
            // where we last left off.
            let dirent_size = mem::size_of::<libc::__wasi_dirent_t>();
            if data.len() < dirent_size {
                assert!(self.cookie.is_some());
                assert!(self.buf.len() >= dirent_size);
                self.offset = self.cap;
                continue;
            }
            let (dirent, data) = data.split_at(dirent_size);
            let dirent =
                unsafe { ptr::read_unaligned(dirent.as_ptr() as *const libc::__wasi_dirent_t) };

            // If the file name was truncated, then we need to reinvoke
            // `readdir` so we truncate our buffer to start over and reread this
            // descriptor. Note that if our offset is 0 that means the file name
            // is massive and we need a bigger buffer.
            if data.len() < dirent.d_namlen as usize {
                if offset == 0 {
                    let amt_to_add = self.buf.capacity();
                    self.buf.extend(iter::repeat(0).take(amt_to_add));
                }
                assert!(self.cookie.is_some());
                self.offset = self.cap;
                continue;
            }
            self.cookie = Some(dirent.d_next);
            self.offset = offset + dirent_size + dirent.d_namlen as usize;

            let name = &data[..(dirent.d_namlen as usize)];

            // These names are skipped on all other platforms, so let's skip
            // them here too
            if name == b"." || name == b".." {
                continue;
            }

            return Some(Ok(DirEntry {
                meta: dirent,
                name: name.to_vec(),
                inner: self.inner.clone(),
            }));
        }
    }
}

impl DirEntry {
    pub fn path(&self) -> PathBuf {
        let name = OsStr::from_bytes(&self.name);
        self.inner.root.join(name)
    }

    pub fn file_name(&self) -> OsString {
        OsString::from_vec(self.name.clone())
    }

    pub fn metadata(&self) -> io::Result<FileAttr> {
        metadata_at(
            &self.inner.dir.fd,
            0,
            OsStr::from_bytes(&self.name).as_ref(),
        )
    }

    pub fn file_type(&self) -> io::Result<FileType> {
        Ok(FileType {
            bits: self.meta.d_type,
        })
    }

    pub fn ino(&self) -> libc::__wasi_inode_t {
        self.meta.d_ino
    }
}

impl OpenOptions {
    pub fn new() -> OpenOptions {
        let mut base = OpenOptions::default();
        base.dirflags = libc::__WASI_LOOKUP_SYMLINK_FOLLOW;
        return base;
    }

    pub fn read(&mut self, read: bool) {
        self.read = read;
    }

    pub fn write(&mut self, write: bool) {
        self.write = write;
    }

    pub fn truncate(&mut self, truncate: bool) {
        self.oflag(libc::__WASI_O_TRUNC, truncate);
    }

    pub fn create(&mut self, create: bool) {
        self.oflag(libc::__WASI_O_CREAT, create);
    }

    pub fn create_new(&mut self, create_new: bool) {
        self.oflag(libc::__WASI_O_EXCL, create_new);
        self.oflag(libc::__WASI_O_CREAT, create_new);
    }

    pub fn directory(&mut self, directory: bool) {
        self.oflag(libc::__WASI_O_DIRECTORY, directory);
    }

    fn oflag(&mut self, bit: libc::__wasi_oflags_t, set: bool) {
        if set {
            self.oflags |= bit;
        } else {
            self.oflags &= !bit;
        }
    }

    pub fn append(&mut self, set: bool) {
        self.fdflag(libc::__WASI_FDFLAG_APPEND, set);
    }

    pub fn dsync(&mut self, set: bool) {
        self.fdflag(libc::__WASI_FDFLAG_DSYNC, set);
    }

    pub fn nonblock(&mut self, set: bool) {
        self.fdflag(libc::__WASI_FDFLAG_NONBLOCK, set);
    }

    pub fn rsync(&mut self, set: bool) {
        self.fdflag(libc::__WASI_FDFLAG_RSYNC, set);
    }

    pub fn sync(&mut self, set: bool) {
        self.fdflag(libc::__WASI_FDFLAG_SYNC, set);
    }

    fn fdflag(&mut self, bit: libc::__wasi_fdflags_t, set: bool) {
        if set {
            self.fdflags |= bit;
        } else {
            self.fdflags &= !bit;
        }
    }

    pub fn fs_rights_base(&mut self, rights: libc::__wasi_rights_t) {
        self.rights_base = Some(rights);
    }

    pub fn fs_rights_inheriting(&mut self, rights: libc::__wasi_rights_t) {
        self.rights_inheriting = Some(rights);
    }

    fn rights_base(&self) -> libc::__wasi_rights_t {
        if let Some(rights) = self.rights_base {
            return rights;
        }

        // If rights haven't otherwise been specified try to pick a reasonable
        // set. This can always be overridden by users via extension traits, and
        // implementations may give us fewer rights silently than we ask for. So
        // given that, just look at `read` and `write` and bucket permissions
        // based on that.
        let mut base = 0;
        if self.read {
            base |= libc::__WASI_RIGHT_FD_READ;
            base |= libc::__WASI_RIGHT_FD_READDIR;
        }
        if self.write {
            base |= libc::__WASI_RIGHT_FD_WRITE;
            base |= libc::__WASI_RIGHT_FD_DATASYNC;
            base |= libc::__WASI_RIGHT_FD_ALLOCATE;
            base |= libc::__WASI_RIGHT_FD_FILESTAT_SET_SIZE;
        }

        // FIXME: some of these should probably be read-only or write-only...
        base |= libc::__WASI_RIGHT_FD_ADVISE;
        base |= libc::__WASI_RIGHT_FD_FDSTAT_SET_FLAGS;
        base |= libc::__WASI_RIGHT_FD_FILESTAT_SET_TIMES;
        base |= libc::__WASI_RIGHT_FD_SEEK;
        base |= libc::__WASI_RIGHT_FD_SYNC;
        base |= libc::__WASI_RIGHT_FD_TELL;
        base |= libc::__WASI_RIGHT_PATH_CREATE_DIRECTORY;
        base |= libc::__WASI_RIGHT_PATH_CREATE_FILE;
        base |= libc::__WASI_RIGHT_PATH_FILESTAT_GET;
        base |= libc::__WASI_RIGHT_PATH_LINK_SOURCE;
        base |= libc::__WASI_RIGHT_PATH_LINK_TARGET;
        base |= libc::__WASI_RIGHT_PATH_OPEN;
        base |= libc::__WASI_RIGHT_PATH_READLINK;
        base |= libc::__WASI_RIGHT_PATH_REMOVE_DIRECTORY;
        base |= libc::__WASI_RIGHT_PATH_RENAME_SOURCE;
        base |= libc::__WASI_RIGHT_PATH_RENAME_TARGET;
        base |= libc::__WASI_RIGHT_PATH_SYMLINK;
        base |= libc::__WASI_RIGHT_PATH_UNLINK_FILE;
        base |= libc::__WASI_RIGHT_POLL_FD_READWRITE;

        return base;
    }

    fn rights_inheriting(&self) -> libc::__wasi_rights_t {
        self.rights_inheriting.unwrap_or_else(|| self.rights_base())
    }

    pub fn lookup_flags(&mut self, flags: libc::__wasi_lookupflags_t) {
        self.dirflags = flags;
    }
}

impl File {
    pub fn open(path: &Path, opts: &OpenOptions) -> io::Result<File> {
        let (dir, file) = open_parent(path, libc::__WASI_RIGHT_PATH_OPEN)?;
        open_at(&dir, &file, opts)
    }

    pub fn open_at(&self, path: &Path, opts: &OpenOptions) -> io::Result<File> {
        open_at(&self.fd, path, opts)
    }

    pub fn file_attr(&self) -> io::Result<FileAttr> {
        let mut ret = FileAttr::zero();
        self.fd.filestat_get(&mut ret.meta)?;
        Ok(ret)
    }

    pub fn metadata_at(
        &self,
        flags: libc::__wasi_lookupflags_t,
        path: &Path,
    ) -> io::Result<FileAttr> {
        metadata_at(&self.fd, flags, path)
    }

    pub fn fsync(&self) -> io::Result<()> {
        self.fd.sync()
    }

    pub fn datasync(&self) -> io::Result<()> {
        self.fd.datasync()
    }

    pub fn truncate(&self, size: u64) -> io::Result<()> {
        self.fd.filestat_set_size(size)
    }

    pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
        self.read_vectored(&mut [IoVecMut::new(buf)])
    }

    pub fn read_vectored(&self, bufs: &mut [IoVecMut<'_>]) -> io::Result<usize> {
        self.fd.read(bufs)
    }

    pub fn write(&self, buf: &[u8]) -> io::Result<usize> {
        self.write_vectored(&[IoVec::new(buf)])
    }

    pub fn write_vectored(&self, bufs: &[IoVec<'_>]) -> io::Result<usize> {
        self.fd.write(bufs)
    }

    pub fn flush(&self) -> io::Result<()> {
        Ok(())
    }

    pub fn seek(&self, pos: SeekFrom) -> io::Result<u64> {
        self.fd.seek(pos)
    }

    pub fn duplicate(&self) -> io::Result<File> {
        // https://github.com/CraneStation/wasmtime/blob/master/docs/WASI-rationale.md#why-no-dup
        unsupported()
    }

    pub fn set_permissions(&self, _perm: FilePermissions) -> io::Result<()> {
        // Permissions haven't been fully figured out in wasi yet, so this is
        // likely temporary
        unsupported()
    }

    pub fn fd(&self) -> &WasiFd {
        &self.fd
    }

    pub fn into_fd(self) -> WasiFd {
        self.fd
    }

    pub fn read_link(&self, file: &Path) -> io::Result<PathBuf> {
        read_link(&self.fd, file)
    }
}

impl FromInner<u32> for File {
    fn from_inner(fd: u32) -> File {
        unsafe {
            File {
                fd: WasiFd::from_raw(fd),
            }
        }
    }
}

impl DirBuilder {
    pub fn new() -> DirBuilder {
        DirBuilder {}
    }

    pub fn mkdir(&self, p: &Path) -> io::Result<()> {
        let (dir, file) = open_parent(p, libc::__WASI_RIGHT_PATH_CREATE_DIRECTORY)?;
        dir.create_directory(file.as_os_str().as_bytes())
    }
}

impl fmt::Debug for File {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("File")
            .field("fd", &self.fd.as_raw())
            .finish()
    }
}

pub fn readdir(p: &Path) -> io::Result<ReadDir> {
    let mut opts = OpenOptions::new();
    opts.directory(true);
    opts.read(true);
    let dir = File::open(p, &opts)?;
    Ok(ReadDir {
        cookie: Some(0),
        buf: vec![0; 128],
        offset: 0,
        cap: 0,
        inner: Arc::new(ReadDirInner {
            dir,
            root: p.to_path_buf(),
        }),
    })
}

pub fn unlink(p: &Path) -> io::Result<()> {
    let (dir, file) = open_parent(p, libc::__WASI_RIGHT_PATH_UNLINK_FILE)?;
    dir.unlink_file(file.as_os_str().as_bytes())
}

pub fn rename(old: &Path, new: &Path) -> io::Result<()> {
    let (old, old_file) = open_parent(old, libc::__WASI_RIGHT_PATH_RENAME_SOURCE)?;
    let (new, new_file) = open_parent(new, libc::__WASI_RIGHT_PATH_RENAME_TARGET)?;
    old.rename(
        old_file.as_os_str().as_bytes(),
        &new,
        new_file.as_os_str().as_bytes(),
    )
}

pub fn set_perm(_p: &Path, _perm: FilePermissions) -> io::Result<()> {
    // Permissions haven't been fully figured out in wasi yet, so this is
    // likely temporary
    unsupported()
}

pub fn rmdir(p: &Path) -> io::Result<()> {
    let (dir, file) = open_parent(p, libc::__WASI_RIGHT_PATH_REMOVE_DIRECTORY)?;
    dir.remove_directory(file.as_os_str().as_bytes())
}

pub fn readlink(p: &Path) -> io::Result<PathBuf> {
    let (dir, file) = open_parent(p, libc::__WASI_RIGHT_PATH_READLINK)?;
    read_link(&dir, &file)
}

fn read_link(fd: &WasiFd, file: &Path) -> io::Result<PathBuf> {
    // Try to get a best effort initial capacity for the vector we're going to
    // fill. Note that if it's not a symlink we don't use a file to avoid
    // allocating gigabytes if you read_link a huge movie file by accident.
    // Additionally we add 1 to the initial size so if it doesn't change until
    // when we call `readlink` the returned length will be less than the
    // capacity, guaranteeing that we got all the data.
    let meta = metadata_at(fd, 0, file)?;
    let initial_size = if meta.file_type().is_symlink() {
        (meta.size() as usize).saturating_add(1)
    } else {
        1 // this'll fail in just a moment
    };

    // Now that we have an initial guess of how big to make our buffer, call
    // `readlink` in a loop until it fails or reports it filled fewer bytes than
    // we asked for, indicating we got everything.
    let file = file.as_os_str().as_bytes();
    let mut destination = vec![0u8; initial_size];
    loop {
        let len = fd.readlink(file, &mut destination)?;
        if len < destination.len() {
            destination.truncate(len);
            destination.shrink_to_fit();
            return Ok(PathBuf::from(OsString::from_vec(destination)));
        }
        let amt_to_add = destination.len();
        destination.extend(iter::repeat(0).take(amt_to_add));
    }
}

pub fn symlink(src: &Path, dst: &Path) -> io::Result<()> {
    let (dst, dst_file) = open_parent(dst, libc::__WASI_RIGHT_PATH_SYMLINK)?;
    dst.symlink(src.as_os_str().as_bytes(), dst_file.as_os_str().as_bytes())
}

pub fn link(src: &Path, dst: &Path) -> io::Result<()> {
    let (src, src_file) = open_parent(src, libc::__WASI_RIGHT_PATH_LINK_SOURCE)?;
    let (dst, dst_file) = open_parent(dst, libc::__WASI_RIGHT_PATH_LINK_TARGET)?;
    src.link(
        libc::__WASI_LOOKUP_SYMLINK_FOLLOW,
        src_file.as_os_str().as_bytes(),
        &dst,
        dst_file.as_os_str().as_bytes(),
    )
}

pub fn stat(p: &Path) -> io::Result<FileAttr> {
    let (dir, file) = open_parent(p, libc::__WASI_RIGHT_PATH_FILESTAT_GET)?;
    metadata_at(&dir, libc::__WASI_LOOKUP_SYMLINK_FOLLOW, &file)
}

pub fn lstat(p: &Path) -> io::Result<FileAttr> {
    let (dir, file) = open_parent(p, libc::__WASI_RIGHT_PATH_FILESTAT_GET)?;
    metadata_at(&dir, 0, &file)
}

fn metadata_at(
    fd: &WasiFd,
    flags: libc::__wasi_lookupflags_t,
    path: &Path,
) -> io::Result<FileAttr> {
    let mut ret = FileAttr::zero();
    fd.path_filestat_get(flags, path.as_os_str().as_bytes(), &mut ret.meta)?;
    Ok(ret)
}

pub fn canonicalize(_p: &Path) -> io::Result<PathBuf> {
    // This seems to not be in wasi's API yet, and we may need to end up
    // emulating it ourselves. For now just return an error.
    unsupported()
}

fn open_at(fd: &WasiFd, path: &Path, opts: &OpenOptions) -> io::Result<File> {
    let fd = fd.open(
        opts.dirflags,
        path.as_os_str().as_bytes(),
        opts.oflags,
        opts.rights_base(),
        opts.rights_inheriting(),
        opts.fdflags,
    )?;
    Ok(File { fd })
}

/// Attempts to open a bare path `p`.
///
/// WASI has no fundamental capability to do this. All syscalls and operations
/// are relative to already-open file descriptors. The C library, however,
/// manages a map of preopened file descriptors to their path, and then the C
/// library provides an API to look at this. In other words, when you want to
/// open a path `p`, you have to find a previously opened file descriptor in a
/// global table and then see if `p` is relative to that file descriptor.
///
/// This function, if successful, will return two items:
///
/// * The first is a `ManuallyDrop<WasiFd>`. This represents a preopened file
///   descriptor which we don't have ownership of, but we can use. You shouldn't
///   actually drop the `fd`.
///
/// * The second is a path that should be a part of `p` and represents a
///   relative traversal from the file descriptor specified to the desired
///   location `p`.
///
/// If successful you can use the returned file descriptor to perform
/// file-descriptor-relative operations on the path returned as well. The
/// `rights` argument indicates what operations are desired on the returned file
/// descriptor, and if successful the returned file descriptor should have the
/// appropriate rights for performing `rights` actions.
///
/// Note that this can fail if `p` doesn't look like it can be opened relative
/// to any preopened file descriptor.
fn open_parent(
    p: &Path,
    rights: libc::__wasi_rights_t,
) -> io::Result<(ManuallyDrop<WasiFd>, PathBuf)> {
    let p = CString::new(p.as_os_str().as_bytes())?;
    unsafe {
        let mut ret = ptr::null();
        let fd = __wasilibc_find_relpath(p.as_ptr(), rights, 0, &mut ret);
        if fd == -1 {
            let msg = format!(
                "failed to find a preopened file descriptor \
                 through which {:?} could be opened",
                p
            );
            return Err(io::Error::new(io::ErrorKind::Other, msg));
        }
        let path = Path::new(OsStr::from_bytes(CStr::from_ptr(ret).to_bytes()));

        // FIXME: right now `path` is a pointer into `p`, the `CString` above.
        // When we return `p` is deallocated and we can't use it, so we need to
        // currently separately allocate `path`. If this becomes an issue though
        // we should probably turn this into a closure-taking interface or take
        // `&CString` and then pass off `&Path` tied to the same lifetime.
        let path = path.to_path_buf();

        return Ok((ManuallyDrop::new(WasiFd::from_raw(fd as u32)), path));
    }

    // FIXME(rust-lang/libc#1314) use the `libc` crate for this when the API
    // there is published
    extern "C" {
        pub fn __wasilibc_find_relpath(
            path: *const libc::c_char,
            rights_base: libc::__wasi_rights_t,
            rights_inheriting: libc::__wasi_rights_t,
            relative_path: *mut *const libc::c_char,
        ) -> libc::c_int;
    }
}