/*
 * See the comment in vfs.h for what is expected of this function.
 *
 * When this function returns, the inode refcount should be decremented.
 *
 * You probably want to use s5_free_inode() if there are no more links to
 * the inode, and dont forget to unpin the page
 */
static void
s5fs_delete_vnode(vnode_t *vnode)
{
        NOT_YET_IMPLEMENTED("S5FS: s5fs_delete_vnode");
}

/*
 * range_perm is essentially a version of addr_perm that checks an entire
 * range of addresses (from avaddr to avaddr+len).  Though you will
 * probably want to use your addr_perm() function in your implementation of
 * range_perm, you don't need to check every possible address.  Remember
 * that page protections have, as the name suggests, page granularity.
 * Like addr_perm, this function should return 1 if the range is valid for
 * the given permissions, and 0 otherwise.
 */
int range_perm(struct proc *p, const void *avaddr, size_t len, int perm) {
  NOT_YET_IMPLEMENTED("VM: ***none***");
  return 0;
}

/*
 * Implementing this function is not required and strongly discouraged unless
 * you are absolutely sure your Weenix is perfect.
 *
 * This is the syscall entry point into vfs for mounting. You will need to
 * create the fs_t struct and populate its fs_dev and fs_type fields before
 * calling vfs's mountfunc(). mountfunc() will use the fields you populated
 * in order to determine which underlying filesystem's mount function should
 * be run, then it will finish setting up the fs_t struct. At this point you
 * have a fully functioning file system, however it is not mounted on the
 * virtual file system, you will need to call vfs_mount to do this.
 *
 * There are lots of things which can go wrong here. Make sure you have good
 * error handling. Remember the fs_dev and fs_type buffers have limited size
 * so you should not write arbitrary length strings to them.
 */
int
do_mount(const char *source, const char *target, const char *type)
{
        NOT_YET_IMPLEMENTED("MOUNTING: do_mount");
        return -EINVAL;
}

/*
 * Create a new directory entry in directory 'parent' with the given name, which
 * refers to the same file as 'child'.
 *
 * When this function returns, the inode refcount on the file that was linked to
 * should be incremented.
 *
 * Remember to incrament the ref counts appropriately
 *
 * You probably want to use s5_find_dirent(), s5_write_file(), and s5_dirty_inode().
 */
int
s5_link(vnode_t *parent, vnode_t *child, const char *name, size_t namelen)
{
        NOT_YET_IMPLEMENTED("S5FS: s5_link");
        return -1;
}

/*
 * Return the disk-block number for the given seek pointer (aka file
 * position).
 *
 * If the seek pointer refers to a sparse block, and alloc is false,
 * then return 0. If the seek pointer refers to a sparse block, and
 * alloc is true, then allocate a new disk block (and make the inode
 * point to it) and return it.
 *
 * Be sure to handle indirect blocks!
 *
 * If there is an error, return -errno.
 *
 * You probably want to use pframe_get, pframe_pin, pframe_unpin, pframe_dirty.
 */
int
s5_seek_to_block(vnode_t *vnode, off_t seekptr, int alloc)
{
        NOT_YET_IMPLEMENTED("S5FS: s5_seek_to_block");
        return -1;
}

/*
 * Write len bytes to the given inode, starting at seek bytes from the
 * beginning of the inode. On success, return the number of bytes
 * actually written (which should be 'len', unless there's only enough
 * room for a partial write); on failure, return -errno.
 *
 * This function should allow writing to files or directories, treating
 * them identically.
 *
 * Writing to a sparse block of the file should cause that block to be
 * allocated.  Writing past the end of the file should increase the size
 * of the file. Blocks between the end and where you start writing will
 * be sparse.
 *
 * Do not call s5_seek_to_block() directly from this function.  You will
 * use the vnode's pframe functions, which will eventually result in a
 * call to s5_seek_to_block().
 *
 * You will need pframe_dirty(), pframe_get(), memcpy().
 */
int
s5_write_file(vnode_t *vnode, off_t seek, const char *bytes, size_t len)
{
        NOT_YET_IMPLEMENTED("S5FS: s5_write_file");
        return -1;
}

/*
 * Allocate a new disk-block off the block free list and return it. If
 * there are no free blocks, return -ENOSPC.
 *
 * This will not initialize the contents of an allocated block; these
 * contents are undefined.
 *
 * If the super block's s5s_nfree is 0, you need to refill 
 * s5s_free_blocks and reset s5s_nfree.  You need to read the contents 
 * of this page using the pframe system in order to obtain the next set of
 * free block numbers.
 *
 * Don't forget to dirty the appropriate blocks!
 *
 * You'll probably want to use lock_s5(), unlock_s5(), pframe_get(),
 * and s5_dirty_super()
 */
static int
s5_alloc_block(s5fs_t *fs)
{
        NOT_YET_IMPLEMENTED("S5FS: s5_alloc_block");
        return -1;
}

/*
 * See the comment in vnode.h for what is expected of this function.
 *
 * You probably want to use s5_find_dirent() and vget().
 */
int
s5fs_lookup(vnode_t *base, const char *name, size_t namelen, vnode_t **result)
{
        NOT_YET_IMPLEMENTED("S5FS: s5fs_lookup");
        return -1;
}

/*
 * See the comment in vnode.h for what is expected of this function.
 *
 * When this function returns, the inode refcount of the unlinked file
 * should be decremented.
 *
 * You probably want to use s5_remove_dirent().
 */
static int
s5fs_unlink(vnode_t *dir, const char *name, size_t namelen)
{
        NOT_YET_IMPLEMENTED("S5FS: s5fs_unlink");
        return -1;
}

/*
 * See the comment in vnode.h for what is expected of this function.
 *
 * When this function returns, the inode refcount of the file should be 2
 * and the vnode refcount should be 1.
 *
 * You probably want to use s5_alloc_inode(), s5_link(), and vget().
 */
static int
s5fs_create(vnode_t *dir, const char *name, size_t namelen, vnode_t **result)
{
        NOT_YET_IMPLEMENTED("S5FS: s5fs_create");
        return -1;
}

/*
 * See the comment in vnode.h for what is expected of this function.
 *
 * This function is similar to s5fs_create, but it creates a special
 * file specified by 'devid'.
 *
 * You probably want to use s5_alloc_inode, s5_link(), vget(), and vput().
 */
static int
s5fs_mknod(vnode_t *dir, const char *name, size_t namelen, int mode, devid_t devid)
{
        NOT_YET_IMPLEMENTED("S5FS: s5fs_mknod");
        return -1;
}

/* Simply call s5_write_file. */
static int
s5fs_write(vnode_t *vnode, off_t offset, const void *buf, size_t len)
{
        NOT_YET_IMPLEMENTED("S5FS: s5fs_write");
        return -1;
}

/* Simply call s5_read_file. */
static int
s5fs_read(vnode_t *vnode, off_t offset, void *buf, size_t len)
{
        NOT_YET_IMPLEMENTED("S5FS: s5fs_read");
        return -1;
}

/*
 * See the comment in vfs.h for what is expected of this function.
 *
 * The vnode still exists on disk if it has a linkcount greater than 1.
 * (Remember, VFS takes a reference on the inode as long as it uses it.)
 *
 */
static int
s5fs_query_vnode(vnode_t *vnode)
{
        NOT_YET_IMPLEMENTED("S5FS: s5fs_query_vnode");
        return 0;
}

/* To link:
 *      o open_namev(from)
 *      o dir_namev(to)
 *      o call the destination dir's (to) link vn_ops.
 *      o return the result of link, or an error
 *
 * Remember to vput the vnodes returned from open_namev and dir_namev.
 *
 * Error cases you must handle for this function at the VFS level:
 *      o EEXIST
 *        to already exists.
 *      o ENOENT
 *        A directory component in from or to does not exist.
 *      o ENOTDIR
 *        A component used as a directory in from or to is not, in fact, a
 *        directory.
 *      o ENAMETOOLONG
 *        A component of from or to was too long.
 *      o EISDIR
 *        from is a directory.
 */
int
do_link(const char *from, const char *to)
{
	NOT_YET_IMPLEMENTED("Link ");
	return -1;
	/*size_t namelen=0;
	const char *name=NULL;
	vnode_t *base = NULL;
	vnode_t *res_vnode_to=NULL;
	vnode_t *res_vnode_from=NULL;
	vnode_t *temp_vnode=NULL;

	KASSERT(from);
	KASSERT(to);

	int from_namev_ret=open_namev(from,NULL,&res_vnode_from,NULL);
	if(from_namev_ret<0)
	{
		KASSERT(from_namev_ret<0);
		dbg(DBG_PRINT,"(GRADING2D 3.g): From component has failed.\n");
		return from_namev_ret;
	}
	KASSERT(res_vnode_from);
	if(S_ISDIR(res_vnode_from->vn_mode))
	{
		KASSERT(S_ISDIR(res_vnode_from->vn_mode));
		dbg(DBG_PRINT, "(GRADING2D 3.g): From is a directory.\n");
		vput(res_vnode_from);
		return -EISDIR;
	}

	int to_namev_ret=dir_namev(to, &namelen,&name,NULL,&res_vnode_to);
	if(to_namev_ret<0)
	{*/
	/* Here we have to check if the vnode from has occurred successfully.
	  * If yes then simply vput the from */
	/*	KASSERT(to_namev_ret<0);
		dbg(DBG_PRINT,"(GRADING2D 3.g): To component has failed.\n");

		vput(res_vnode_from);
		return to_namev_ret;
	}
	KASSERT(res_vnode_to);

	if(!S_ISDIR(res_vnode_to->vn_mode))
	{
		KASSERT(!S_ISDIR(res_vnode_to->vn_mode));
		dbg(DBG_PRINT, "(GRADING2D 3.g): Some directory component is not a directory\n");
		vput(res_vnode_to);
		vput(res_vnode_from);
		return -ENOTDIR;
	}*/

	/* Need to check res_vnode before we call this to avoid conflict */
	/* To check if the path exists */
	/*KASSERT(name!=NULL);
	dbg(DBG_PRINT, "(GRADING2D 3.g): The name component is present\n");

	int loookup_ret=lookup(res_vnode_to,name,namelen,&temp_vnode);
	if(0==loookup_ret)
	{
		KASSERT(0==loookup_ret);
		dbg(DBG_PRINT, "(GRADING2D 3.g): The path exists. Would not be able to create the directory.\n");
		vput(res_vnode_to);
		vput(res_vnode_from);
		vput(temp_vnode);
		return -EEXIST;
	}

	KASSERT(res_vnode_to->vn_ops->link);
	int link_ret=(res_vnode_to->vn_ops->link)(res_vnode_from,res_vnode_to,name,namelen);
	vput(res_vnode_to);
	vput(res_vnode_from);

	if(link_ret<0){
		dbg(DBG_PRINT, "(GRADING2D 3.g): There is a problem in linking.\n");
		return link_ret;
	}

//.........这里部分代码省略.........

/*
 * See the comment in vnode.h for what is expected of this function.
 *
 * When this function returns, the inode refcount on the parent should be
 * decremented (since ".." in the removed directory no longer references
 * it). Remember that the directory must be empty (except for "." and
 * "..").
 *
 * You probably want to use s5_find_dirent() and s5_remove_dirent().
 */
static int
s5fs_rmdir(vnode_t *parent, const char *name, size_t namelen)
{
        NOT_YET_IMPLEMENTED("S5FS: s5fs_rmdir");
        return -1;
}

void process( const std::string & file, ExportMode exportMode )
{
	auto start = clock( );

	std::cout << "\n\n OPERATING ON " << file << std::endl;
	
	gpu_triangle_array * tris = nullptr, * volumeTris = nullptr;


	//	Determine loading method
	std::string fileExt = getFileExtension( file );
	if( fileExt == "fbx" )
	{
		gpu_vertex_array * points;
		gpu_index_array * indices;

		workflow_import_fbx( file, &points, &indices );
		workflow_gen_tris( points, indices, &tris );
		workflow_gen_normals( tris );

		delete points;
		delete indices;
	}
	else if( fileExt == "msh" )
	{
		gpu_vertex_array * volumeData = nullptr;

		gpu_vertex_array * points;
		gpu_index_array * indices, * innerIndices;

		workflow_import_msh( file, &points, &indices, &innerIndices );
		int x = indices->data()[0];
		int y = innerIndices->data( )[0];
		workflow_gen_tris( points, indices, &tris );
		workflow_gen_tris( points, innerIndices, &volumeTris );
		workflow_gen_normals( tris );
		workflow_gen_normals( volumeTris );
		
		if( volumeData )
			delete volumeData;
		delete points;
		delete indices, innerIndices;
	}
	else
		NOT_YET_IMPLEMENTED( );



	workflow_render_mesh( tris );
	if( volumeTris ) workflow_render_mesh( volumeTris );

	if( should_generate_center )
	{
		if( !did_generate_center ) {
			collection_center = workflow_get_mesh_center( tris );
			did_generate_center = true;
		}

		workflow_recenter_mesh( tris, collection_center );
		if( volumeTris ) workflow_recenter_mesh( volumeTris, collection_center );
	}


	cpu_chunk_array * chunks, * volumeChunks = nullptr;
	generate_chunks( tris, &chunks );
	if( volumeTris ) generate_chunks( volumeTris, &volumeChunks );

	CreateDirectoryA( getFileName( file ).c_str( ), nullptr );

	typedef void( *ChunkExportWorkflow )(const std::string &, cpu_chunk_array *);
	//	Strategy pattern
	ChunkExportWorkflow exportWorkflow = nullptr;
	switch( exportMode )
	{
	case(EXPORT_FBX) :
		exportWorkflow = workflow_chunk_export_fbx;
		break;
	case(EXPORT_BINARY) :
		exportWorkflow = workflow_chunk_export_binary;
		break;
	}

	exportWorkflow( getFileName( file ) + "/surfaces", chunks );
	if( volumeChunks ) exportWorkflow( getFileName( file ) + "/volumes", volumeChunks );


	delete tris;
	if( volumeTris )
		delete volumeTris;
	delete chunks;
	if( volumeChunks )
		delete volumeChunks;

	std::cout << "\nDONE" << std::endl;
	std::cout << "Total operation took " << formatTime( clock( ) - start ) << std::endl;
}

/*
 * See the comment in vnode.h for what is expected of this function.
 *
 * Here you need to use s5_read_file() to read a s5_dirent_t from a directory
 * and copy that data into the given dirent. The value of d_off is dependent on
 * your implementation and may or may not b e necessary.  Finally, return the
 * number of bytes read.
 */
static int
s5fs_readdir(vnode_t *vnode, off_t offset, struct dirent *d)
{
        NOT_YET_IMPLEMENTED("S5FS: s5fs_readdir");
        return -1;
}

/*
 * Read up to len bytes from the given inode, starting at seek bytes
 * from the beginning of the inode. On success, return the number of
 * bytes actually read, or 0 if the end of the file has been reached; on
 * failure, return -errno.
 *
 * This function should allow reading from files or directories,
 * treating them identically.
 *
 * Reading from a sparse block of the file should act like reading
 * zeros; it should not cause the sparse blocks to be allocated.
 *
 * Similarly as in s5_write_file(), do not call s5_seek_to_block()
 * directly from this function.
 *
 * If the region to be read would extend past the end of the file, less
 * data will be read than was requested.
 *
 * You probably want to use pframe_get(), memcpy().
 */
int
s5_read_file(struct vnode *vnode, off_t seek, char *dest, size_t len)
{
        NOT_YET_IMPLEMENTED("S5FS: s5_read_file");
        return -1;
}

/*
 * See the comment in vnode.h for what is expected of this function.
 *
 * Don't worry if you don't know what some of the fields in struct stat
 * mean. The ones you should be sure to set are st_mode, st_ino,
 * st_nlink, st_size, st_blksize, and st_blocks.
 *
 * You probably want to use s5_inode_blocks().
 */
static int
s5fs_stat(vnode_t *vnode, struct stat *ss)
{
        NOT_YET_IMPLEMENTED("S5FS: s5fs_stat");
        return -1;
}