/*
 * I/O for a Wiki document set.
 * 
 * The files are kept in one flat directory.
 * There are three files for each document:
 *	nnn	- current version of the document
 *	nnn.hist	- history (all old versions) of the document
 *		append-only
 *	L.nnn	- write lock file for the document
 * 
 * At the moment, since we don't have read/write locks
 * in the file system, we use the L.nnn file as a read lock too.
 * It's a hack but there aren't supposed to be many readers
 * anyway.
 *
 * The nnn.hist file is in the format read by Brdwhist.
 * The nnn file is in that format too, but only contains the
 * last entry of the nnn.hist file.
 *
 * In addition to this set of files, there is an append-only
 * map file that provides a mapping between numbers and titles.
 * The map file is a sequence of lines of the form
 *	nnn Title Here
 * The lock file L.map must be held to add to the end, to
 * make sure that the numbers are allocated sequentially.
 * 
 * We assume that writes to the map file will fit in one message,
 * so that we don't have to read-lock the file.
 */

#include <u.h>
#include <libc.h>
#include <bio.h>
#include <String.h>
#include <thread.h>
#include "wiki.h"

enum {
	Nhash = 64,
	Mcache = 128,
};

typedef struct Wcache Wcache;
struct Wcache {
	int n;
	ulong use;
	RWLock;
	ulong tcurrent;
	ulong thist;
	Whist *hist;
	Whist *current;
	Qid qid;
	Qid qidhist;
	Wcache *hash;
};

static RWLock cachelock;
static Wcache *tab[Nhash];
int ncache;

void
closewhist(Whist *wh)
{
	int i;

	if(wh && decref(wh) == 0){
		free(wh->title);
		for(i=0; i<wh->ndoc; i++){
			free(wh->doc[i].author);
			free(wh->doc[i].comment);
			freepage(wh->doc[i].wtxt);
		}
		free(wh->doc);
		free(wh);
	}
}

void
freepage(Wpage *p)
{
	Wpage *next;

	for(; p; p=next){
		next = p->next;
		free(p->text);
		free(p->url);
		free(p);
	}
}

static Wcache*
findcache(int n)
{
	Wcache *w;

	for(w=tab[n%Nhash]; w; w=w->hash)
		if(w->n == n){
			w->use = time(0);
			return w;
		}
	return nil;
}

static int
getlock(char *lock)
{
	char buf[ERRMAX];
	int i, fd;
	enum { SECS = 200 };

	for(i=0; i<SECS*10; i++){
		fd = wcreate(lock, ORDWR, DMEXCL|0666);
		if(fd >= 0)
			return fd;
		buf[0] = '\0';
		rerrstr(buf, sizeof buf);
		if(strstr(buf, "locked") == nil)
			break;
		sleep(1000/10);
	}
	werrstr("couldn't acquire lock %s: %r", lock);
	return -1;
}

static Whist*
readwhist(char *file, char *lock, Qid *qid)
{
	int lfd;
	Biobuf *b;
	Dir *d;
	Whist *wh;

	if((lfd=getlock(lock)) < 0)	// LOG?
		return nil;

	if(qid){
		if((d = wdirstat(file)) == nil){
			close(lfd);
			return nil;
		}
		*qid = d->qid;
		free(d);
	}

	if((b = wBopen(file, OREAD)) == nil){	//LOG?
		close(lfd);
		return nil;
	}

	wh = Brdwhist(b);

	Bterm(b);
	close(lfd);
	return wh;
}

static void
gencurrent(Wcache *w, Qid *q, char *file, char *lock, ulong *t, Whist **wp, int n)
{
	Dir *d;
	Whist *wh;

	if(*wp && *t+Tcache >= time(0))
		return;

	wlock(w);
	if(*wp && *t+Tcache >= time(0)){
		wunlock(w);
		return;
	}

	if(((d = wdirstat(file)) == nil) || (d->qid.path==q->path && d->qid.vers==q->vers)){
		*t = time(0);
		wunlock(w);
		free(d);
		return;
	}

	free(d);
	if(wh = readwhist(file, lock, q)){
		wh->n = n;
		*t = time(0);
		closewhist(*wp);
		*wp = wh;
	}
else fprint(2, "error file=%s lock=%s %r\n", file, lock);
	wunlock(w);
}

static void
current(Wcache *w)
{
	char tmp[40];
	char tmplock[40];

	sprint(tmplock, "d/L.%d", w->n);
	sprint(tmp, "d/%d", w->n);
	gencurrent(w, &w->qid, tmp, tmplock, &w->tcurrent, &w->current, w->n);
}

static void
currenthist(Wcache *w)
{
	char hist[40], lock[40];

	sprint(hist, "d/%d.hist", w->n);
	sprint(lock, "d/L.%d", w->n);

	gencurrent(w, &w->qidhist, hist, lock, &w->thist, &w->hist, w->n);
}

void
voidcache(int n)
{
	Wcache *c;

	rlock(&cachelock);
	if(c = findcache(n)){
		wlock(c);
		c->tcurrent = 0;
		c->thist = 0;
		/* aggressively free memory */
		closewhist(c->hist);
		c->hist = nil;
		closewhist(c->current);
		c->current = nil;
		wunlock(c);
	}
	runlock(&cachelock);
}

static Whist*
getcache(int n, int hist)
{
	int i, isw;
	ulong t;
	Wcache *c, **cp, **evict;
	Whist *wh;

	isw = 0;
	rlock(&cachelock);
	if(c = findcache(n)){
	Found:
		current(c);
		if(hist)
			currenthist(c);
		rlock(c);
		if(hist)
			wh = c->hist;
		else
			wh = c->current;
		if(wh)
			incref(wh);
		runlock(c);
		if(isw)
			wunlock(&cachelock);
		else
			runlock(&cachelock);
		return wh;
	}
	runlock(&cachelock);

	wlock(&cachelock);
	if(c = findcache(n)){
		isw = 1;	/* better to downgrade lock but can't */
		goto Found;
	}

	if(ncache < Mcache){
	Alloc:
		c = emalloc(sizeof *c);
		ncache++;
	}else{
		/* find something to evict. */
		t = ~0;
		evict = nil;
		for(i=0; i<Nhash; i++){
			for(cp=&tab[i], c=*cp; c; cp=&c->hash, c=*cp){
				if(c->use < t
				&& (!c->hist || c->hist->ref==1)
				&& (!c->current || c->current->ref==1)){
					evict = cp;
					t = c->use;
				}
			}
		}

		if(evict == nil){
			fprint(2, "wikifs: nothing to evict\n");
			goto Alloc;
		}

		c = *evict;
		*evict = c->hash;

		closewhist(c->current);
		closewhist(c->hist);
		memset(c, 0, sizeof *c);
	}

	c->n = n;
	c->hash = tab[n%Nhash];
	tab[n%Nhash] = c;
	isw = 1;
	goto Found;
}

Whist*
getcurrent(int n)
{
	return getcache(n, 0);
}

Whist*
gethistory(int n)
{
	return getcache(n, 1);
}

RWLock maplock;
Map *map;

static int
mapcmp(const void *va, const void *vb)
{
	Mapel *a, *b;

	a = (Mapel*)va;
	b = (Mapel*)vb;

	return strcmp(a->s, b->s);
}

void
closemap(Map *m)
{
	if(decref(m)==0){
		free(m->buf);
		free(m->el);
		free(m);
	}
}

void
currentmap(int force)
{
	char *p, *q, *r;
	int lfd, fd, m, n;
	Dir *d;
	Map *nmap;
	char *err = nil;

	lfd = -1;
	fd = -1;
	d = nil;
	nmap = nil;
	if(!force && map && map->t+Tcache >= time(0))
		return;

	wlock(&maplock);
	if(!force && map && map->t+Tcache >= time(0))
		goto Return;

	if((lfd = getlock("d/L.map")) < 0){
		err = "can't lock";
		goto Return;
	}

	if((d = wdirstat("d/map")) == nil)
		goto Return;

	if(map && d->qid.path == map->qid.path && d->qid.vers == map->qid.vers){
		map->t = time(0);
		goto Return;
	}

	if(d->length > Maxmap){
		//LOG
		err = "too long";
		goto Return;
	}

	if((fd = wopen("d/map", OREAD)) < 0)
		goto Return;

	nmap = emalloc(sizeof *nmap);
	nmap->buf = emalloc(d->length+1);
	n = readn(fd, nmap->buf, d->length);
	if(n != d->length){
		err = "bad length";
		goto Return;
	}
	nmap->buf[n] = '\0';

	n = 0;
	for(p=nmap->buf; p; p=strchr(p+1, '\n'))
		n++;
	nmap->el = emalloc(n*sizeof(nmap->el[0]));

	m = 0;
	for(p=nmap->buf; p && *p && m < n; p=q){
		if(q = strchr(p+1, '\n'))
			*q++ = '\0';
		nmap->el[m].n = strtol(p, &r, 10);
		if(*r == ' ')
			r++;
		else
			{}//LOG?
		nmap->el[m].s = strcondense(r, 1);
		m++;
	}
	//LOG if m != n

	nmap->qid = d->qid;
	nmap->t = time(0);
	nmap->nel = m;
	qsort(nmap->el, nmap->nel, sizeof(nmap->el[0]), mapcmp);
	if(map)
		closemap(map);
	map = nmap;
	incref(map);
	nmap = nil;
	
Return:
	free(d);
	if(nmap){
		free(nmap->el);
		free(nmap->buf);
		free(nmap);
	}
	if(map == nil)
		sysfatal("cannot get map: %s: %r", err);

	if(fd >= 0)
		close(fd);
	if(lfd >= 0)
		close(lfd);
	wunlock(&maplock);
}

int
allocnum(char *title, int mustbenew)
{
	char *p, *q;
	int lfd, fd, n;
	Biobuf b;

	if(strcmp(title, "map")==0 || strcmp(title, "new")==0){
		werrstr("reserved title name");
		return -1;
	}

	if(title[0]=='\0' || strpbrk(title, "/<>:?")){
		werrstr("invalid character in name");
		return -1;
	}
	if((n = nametonum(title)) >= 0){
		if(mustbenew){
			werrstr("duplicate title");
			return -1;
		}
		return n;
	}

	title = estrdup(title);
	strcondense(title, 1);
	strlower(title);
	if(strchr(title, '\n') || strlen(title) > 200){
		werrstr("bad title");
		free(title);
		return -1;
	}

	if((lfd = getlock("d/L.map")) < 0){
		free(title);
		return -1;
	}

	if((fd = wopen("d/map", ORDWR)) < 0){	// LOG?
		close(lfd);
		free(title);
		return -1;
	}

	/*
	 * What we really need to do here is make sure the 
	 * map is up-to-date, then make sure the title isn't
	 * taken, and then add it, all without dropping the locks.
	 *
	 * This turns out to be a mess when you start adding
	 * all the necessary dolock flags, so instead we just
	 * read through the file ourselves, and let our 
	 * map catch up on its own.
	 */
	Binit(&b, fd, OREAD);
	n = 0;
	while(p = Brdline(&b, '\n')){
		p[Blinelen(&b)-1] = '\0';
		n = atoi(p)+1;
		q = strchr(p, ' ');
		if(q == nil)
			continue;
		if(strcmp(q+1, title) == 0){
			free(title);
			close(fd);
			close(lfd);
			if(mustbenew){
				werrstr("duplicate title");
				return -1;
			}else
				return n;
		}
	}

	seek(fd, 0, 2);	/* just in case it's not append only */
	fprint(fd, "%d %s\n", n, title);
	close(fd);
	close(lfd);
	free(title);
	/* kick the map */
	currentmap(1);
	return n;
}

int
nametonum(char *s)
{
	char *p;
	int i, lo, hi, m, rv;

	s = estrdup(s);
	strlower(s);
	for(p=s; *p; p++)
		if(*p=='_')
			*p = ' ';

	currentmap(0);
	rlock(&maplock);
	lo = 0;
	hi = map->nel;
	while(hi-lo > 1){
		m = (lo+hi)/2;
		i = strcmp(s, map->el[m].s);
		if(i < 0)
			hi = m;
		else
			lo = m;
	}
	if(hi-lo == 1 && strcmp(s, map->el[lo].s)==0)
		rv = map->el[lo].n;
	else
		rv = -1;
	runlock(&maplock);
	free(s);
	return rv;
}

char*
numtoname(int n)
{
	int i;
	char *s;

	currentmap(0);
	rlock(&maplock);
	for(i=0; i<map->nel; i++){
		if(map->el[i].n==n)
			break;
	}
	if(i==map->nel){
		runlock(&maplock);
		return nil;
	}
	s = estrdup(map->el[i].s);
	runlock(&maplock);
	return s;
}

Whist*
getcurrentbyname(char *s)
{
	int n;

	if((n = nametonum(s)) < 0)
		return nil;
	return getcache(n, 0);
}

static String*
Brdstring(Biobuf *b)
{
	long len;
	String *s;
	Dir *d;

	d = dirfstat(Bfildes(b));
	if (d == nil)	/* shouldn't happen, we just opened it */
		len = 0;
	else
		len = d->length;
	free(d);
	s = s_newalloc(len);
	s_read(b, s, len);
	return s;
}

/*
 * Attempt to install a new page.  If t==0 we are creating.
 * Otherwise, we are editing and t must be set to the current
 * version (t is the version we started with) to avoid conflicting
 * writes.
 *
 * If there is a conflicting write, we still write the page to 
 * the history file, but mark it as a failed write.
 */
int
writepage(int num, ulong t, String *s, char *title)
{
	char tmp[40], tmplock[40], err[ERRMAX], hist[40], *p;
	int conflict, lfd, fd;
	Biobuf *b;
	String *os;

	sprint(tmp, "d/%d", num);
	sprint(tmplock, "d/L.%d", num);
	sprint(hist, "d/%d.hist", num);
	if((lfd = getlock(tmplock)) < 0)
		return -1;

	conflict = 0;
	if(b = wBopen(tmp, OREAD)){
		Brdline(b, '\n');	/* title */
		if(p = Brdline(b, '\n'))		/* version */
			p[Blinelen(b)-1] = '\0';
		if(p==nil || p[0] != 'D'){
			snprint(err, sizeof err, "bad format in extant file");
			conflict = 1;
		}else if(strtoul(p+1, 0, 0) != t){
			os = Brdstring(b);	/* why read the whole file? */
			p = strchr(s_to_c(s), '\n');
			if(p!=nil && strcmp(p+1, s_to_c(os))==0){	/* ignore dup write */
				close(lfd);
				s_free(os);
				Bterm(b);
				return 0;
			}
			s_free(os);
			snprint(err, sizeof err, "update conflict %lud != %s", t, p+1);
			conflict = 1;
		}
		Bterm(b);
	}else{
		if(t != 0){
			close(lfd);
			werrstr("did not expect to create");
			return -1;
		}
	}

	if((fd = wopen(hist, OWRITE)) < 0){
		if((fd = wcreate(hist, OWRITE, 0666)) < 0){
			close(lfd);
			return -1;
		}else
			fprint(fd, "%s\n", title);
	}
	if(seek(fd, 0, 2) < 0
	|| (conflict && write(fd, "X\n", 2) != 2)
	|| write(fd, s_to_c(s), s_len(s)) != s_len(s)){
		close(fd);
		close(lfd);
		return -1;
	}
	close(fd);

	if(conflict){
		close(lfd);
		voidcache(num);
		werrstr(err);
		return -1;
	}

	if((fd = wcreate(tmp, OWRITE, 0666)) < 0){
		close(lfd);
		voidcache(num);
		return -1;
	}
	if(write(fd, title, strlen(title)) != strlen(title)
	|| write(fd, "\n", 1) != 1
	|| write(fd, s_to_c(s), s_len(s)) != s_len(s)){
		close(fd);
		close(lfd);
		voidcache(num);
		return -1;
	}
	close(fd);
	close(lfd);
	voidcache(num);
	return 0;
}