#include <u.h>
#include <libc.h>
#include <fcall.h>
#include <thread.h>
#include <9p.h>

/*
 * To avoid deadlock, the following rules must be followed.
 * Always lock child then parent, never parent then child.
 * If holding the free file lock, do not lock any Files.
 */
struct Filelist
{
	File *f;
	Filelist *link;
};

struct Readdir
{
	File *dir;
	Filelist *fl;
};

static QLock filelk;
static File *freefilelist;

static File*
allocfile(void)
{
	int i, a;
	File *f;
	enum { N = 16 };

	qlock(&filelk);
	if(freefilelist == nil){
		f = emalloc9p(N*sizeof(*f));
		for(i=0; i<N-1; i++)
			f[i].aux = &f[i+1];
		f[N-1].aux = nil;
		f[0].allocd = 1;
		freefilelist = f;
	}

	f = freefilelist;
	freefilelist = f->aux;
	qunlock(&filelk);

	a = f->allocd;
	memset(f, 0, sizeof *f);
	f->allocd = a;
	return f;
}

static void
freefile(File *f)
{
	Filelist *fl, *flnext;

	for(fl=f->filelist; fl; fl=flnext){
		flnext = fl->link;
		assert(fl->f == nil);
		free(fl);
	}

	free(f->name);
	free(f->uid);
	free(f->gid);
	free(f->muid);
	qlock(&filelk);
	assert(f->ref == 0);
	f->aux = freefilelist;
	freefilelist = f;
	qunlock(&filelk);
}

static void
cleanfilelist(File *f)
{
	Filelist **l;
	Filelist *fl;
	
	/*
	 * can't delete filelist structures while there
	 * are open readers of this directory, because
	 * they might have references to the structures.
	 * instead, just leave the empty refs in the list
	 * until there is no activity and then clean up.
	 */
	if(f->readers.ref != 0)
		return;
	if(f->nxchild == 0)
		return;

	/*
	 * no dir readers, file is locked, and
	 * there are empty entries in the file list.
	 * clean them out.
	 */
	for(l=&f->filelist; fl=*l; ){
		if(fl->f == nil){
			*l = (*l)->link;
			free(fl);
		}else
			l = &(*l)->link;
	}
	f->nxchild = 0;
}

void
closefile(File *f)
{
	if(decref(f) == 0){
		f->tree->destroy(f);
		freefile(f);
	}
}

static void
nop(File*)
{
}

int
removefile(File *f)
{
	File *fp;
	Filelist *fl;
	
	fp = f->parent;
	if(fp == nil){
		werrstr("no parent");
		closefile(f);
		return -1;
	}

	if(fp == f){
		werrstr("cannot remove root");
		closefile(f);
		return -1;
	}

	wlock(f);
	wlock(fp);
	if(f->nchild != 0){
		werrstr("has children");
		wunlock(fp);
		wunlock(f);
		closefile(f);
		return -1;
	}

	if(f->parent != fp){
		werrstr("parent changed underfoot");
		wunlock(fp);
		wunlock(f);
		closefile(f);
		return -1;
	}

	for(fl=fp->filelist; fl; fl=fl->link)
		if(fl->f == f)
			break;
	assert(fl != nil && fl->f == f);

	fl->f = nil;
	fp->nchild--;
	fp->nxchild++;
	f->parent = nil;
	wunlock(f);

	cleanfilelist(fp);
	wunlock(fp);

	closefile(fp);	/* reference from child */
	closefile(f);	/* reference from tree */
	closefile(f);
	return 0;
}

File*
createfile(File *fp, char *name, char *uid, ulong perm, void *aux)
{
	File *f;
	Filelist **l, *fl;
	Tree *t;

	if((fp->qid.type&QTDIR) == 0){
		werrstr("create in non-directory");
		return nil;
	}

	wlock(fp);
	if(fp->parent == nil){
		wunlock(fp);
		werrstr("create in deleted directory");
		return nil;
	}

	/*
	 * We might encounter blank spots along the
	 * way due to deleted files that have not yet
	 * been flushed from the file list.  Don't reuse
	 * those - some apps (e.g., omero) depend on
	 * the file order reflecting creation order. 
	 * Always create at the end of the list.
	 */
	for(l=&fp->filelist; fl=*l; l=&fl->link){
		if(fl->f && strcmp(fl->f->name, name) == 0){
			wunlock(fp);
			werrstr("file already exists");
			return nil;
		}
	}
	
	fl = emalloc9p(sizeof *fl);
	*l = fl;

	f = allocfile();
	f->name = estrdup9p(name);
	f->uid = estrdup9p(uid ? uid : fp->uid);
	f->gid = estrdup9p(fp->gid);
	f->muid = estrdup9p(uid ? uid : "unknown");
	f->aux = aux;
	f->mode = perm;

	t = fp->tree;
	lock(&t->genlock);
	f->qid.path = t->qidgen++;
	unlock(&t->genlock);
	if(perm & DMDIR)
		f->qid.type |= QTDIR;
	if(perm & DMAPPEND)
		f->qid.type |= QTAPPEND;
	if(perm & DMEXCL)
		f->qid.type |= QTEXCL;

	f->atime = f->mtime = time(0);
	f->length = 0;
	f->parent = fp;
	incref(fp);
	f->tree = fp->tree;

	incref(f);	/* being returned */
	incref(f);	/* for the tree */
	fl->f = f;
	fp->nchild++;
	wunlock(fp);

	return f;
}

static File*
walkfile1(File *dir, char *elem)
{
	File *fp;
	Filelist *fl;

	rlock(dir);
	if(strcmp(elem, "..") == 0){
		fp = dir->parent;
		if(fp != nil)
			incref(fp);
		runlock(dir);
		closefile(dir);
		return fp;
	}

	fp = nil;
	for(fl=dir->filelist; fl; fl=fl->link)
		if(fl->f && strcmp(fl->f->name, elem)==0){
			fp = fl->f;
			incref(fp);
			break;
		}

	runlock(dir);
	closefile(dir);
	return fp;
}

File*
walkfile(File *f, char *path)
{
	char *os, *s, *nexts;

	if(strchr(path, '/') == nil)
		return walkfile1(f, path);	/* avoid malloc */

	os = s = estrdup9p(path);
	for(; *s; s=nexts){
		if(nexts = strchr(s, '/'))
			*nexts++ = '\0';
		else
			nexts = s+strlen(s);
		f = walkfile1(f, s);
		if(f == nil)
			break;
	}
	free(os);
	return f;
}
			
Tree*
alloctree(char *uid, char *gid, ulong mode, void (*destroy)(File*))
{
	char *muid;
	Tree *t;
	File *f;

	t = emalloc9p(sizeof *t);
	f = allocfile();
	f->name = estrdup9p("/");
	if(uid == nil){
		uid = getuser();
		if(uid == nil)
			uid = "none";
	}
	uid = estrdup9p(uid);

	if(gid == nil)
		gid = estrdup9p(uid);
	else
		gid = estrdup9p(gid);

	muid = estrdup9p(uid);

	f->qid = (Qid){0, 0, QTDIR};
	f->length = 0;
	f->atime = f->mtime = time(0);
	f->mode = DMDIR | mode;
	f->tree = t;
	f->parent = f;
	f->uid = uid;
	f->gid = gid;
	f->muid = muid;

	incref(f);
	t->root = f;

	/* t->qidgen starts at 1 because root Qid.path is 0 */
	t->qidgen = 1;
	if(destroy == nil)
		destroy = nop;
	t->destroy = destroy;

	return t;
}

static void
_freefiles(File *f)
{
	Filelist *fl, *flnext;

	for(fl=f->filelist; fl; fl=flnext){
		flnext = fl->link;
		_freefiles(fl->f);
		free(fl);
	}

	f->tree->destroy(f);
	freefile(f);
}

void
freetree(Tree *t)
{
	_freefiles(t->root);
	free(t);
}

Readdir*
opendirfile(File *dir)
{
	Readdir *r;

	rlock(dir);
	if((dir->mode & DMDIR)==0){
		runlock(dir);
		return nil;
	}
	r = emalloc9p(sizeof(*r));

	/*
	 * This reference won't go away while we're 
	 * using it because file list entries are not freed
	 * until the directory is removed and all refs to
	 * it (our fid is one!) have gone away.
	 */
	r->fl = dir->filelist;
	r->dir = dir;
	incref(&dir->readers);
	runlock(dir);
	return r;
}

long
readdirfile(Readdir *r, uchar *buf, long n, long o)
{
	long x, m;
	Filelist *fl;

	if(o == 0)
		fl = r->dir->filelist;
	else
		fl = r->fl;
	for(m=0; fl && m+2<=n; fl=fl->link, m+=x){
		if(fl->f == nil)
			x = 0;
		else if((x=convD2M(fl->f, buf+m, n-m)) <= BIT16SZ)
			break;
	}
	r->fl = fl;
	return m;
}

void
closedirfile(Readdir *r)
{
	if(decref(&r->dir->readers) == 0){
		wlock(r->dir);
		cleanfilelist(r->dir);
		wunlock(r->dir);
	}
	free(r);
}
