implement Vacput;

include "sys.m";
	sys: Sys;
	sprint: import sys;
include "draw.m";
include "arg.m";
include "daytime.m";
	dt: Daytime;
include "bufio.m";
	bufio: Bufio;
	Iobuf: import bufio;
include "dial.m";
	dial: Dial;
include "string.m";
	str: String;
include "tables.m";
	tables: Tables;
	Strhash: import tables;
include "venti.m";
	venti: Venti;
	Root, Entry, Score, Session: import venti;
include "vac.m";
	vac: Vac;
	Direntry, File, Sink, MSink: import vac;

Vacput: module {
	init:	fn(nil: ref Draw->Context, args: list of string);
};

addr := "$venti";
dflag: int;
iflag: int;
vflag: int;
xflag: int;
blocksize := vac->Dsize;
uid: string;
gid: string;

pathgen: big;

bout: ref Iobuf;
session: ref Session;
name := "vac";
itab,
xtab: ref Strhash[string]; # include/exclude paths

init(nil: ref Draw->Context, args: list of string)
{
	sys = load Sys Sys->PATH;
	dt = load Daytime Daytime->PATH;
	bufio = load Bufio Bufio->PATH;
	arg := load Arg Arg->PATH;
	dial = load Dial Dial->PATH;
	str = load String String->PATH;
	tables = load Tables Tables->PATH;
	venti = load Venti Venti->PATH;
	vac = load Vac Vac->PATH;
	if(venti == nil || vac == nil)
		fail("loading venti,vac");
	venti->init();
	vac->init();

	arg->init(args);
	arg->setusage(arg->progname()+" [-dv] [-i | -x] [-a addr] [-b blocksize] [-n name] [-u uid] [-g gid] path ...");
	while((c := arg->opt()) != 0)
		case c {
		'a' =>	addr = arg->earg();
		'b' =>	blocksize = int arg->earg();
		'n' =>	name = arg->earg();
		'd' =>	vac->dflag = dflag++;
		'i' =>	iflag++;
		'v' =>	vflag++;
		'x' =>	xflag++;
		'g' =>	gid = arg->earg();
		'u' =>	uid = arg->earg();
		* =>	arg->usage();
		}
	args = arg->argv();
	if(len args == 0)
		arg->usage();
	if(iflag && xflag) {
		warn("cannot have both -i and -x");
		arg->usage();
	}

	if(vflag)
		bout = bufio->fopen(sys->fildes(1), bufio->OWRITE);

	if(iflag || xflag) {
		t := readpaths();
		if(iflag)
			itab = t;
		else
			xtab = t;
	}

	addr = dial->netmkaddr(addr, "net", "venti");
	cc := dial->dial(addr, nil);
	if(cc == nil)
		fail(sprint("dialing %s: %r", addr));
	say("have connection");

	fd := cc.dfd;
	session = Session.new(fd);
	if(session == nil)
		fail(sprint("handshake: %r"));
	say("have handshake");

	topde: ref Direntry;
	if(len args == 1 && ((nil, d) := sys->stat(hd args)).t0 == 0 && (d.mode&Sys->DMDIR)) {
		topde = Direntry.mk(d);
		topde.elem = name;
	} else {
		topde = Direntry.new();
		topde.elem = name;
		topde.uid = topde.gid = user();
		topde.mode = 8r777|Vac->Modedir;
		topde.mtime = topde.atime = 0;
	}
	topde.qid = pathgen++;
	if(uid != nil)
		topde.uid = uid;
	if(gid != nil)
		topde.gid = gid;
	topde.ctime = dt->now();

	s := Sink.new(session, blocksize);
	ms := MSink.new(session, blocksize);
	for(; args != nil; args = tl args)
		writepath(hd args, s, ms);
	say("tree written");

	if(vflag && bout.flush() == bufio->ERROR)
		fail(sprint("write stdout: %r"));

	e0 := s.finish();
	if(e0 == nil)
		fail(sprint("writing top entry: %r"));
	e1 := ms.finish();
	if(e1 == nil)
		fail(sprint("writing top meta entry: %r"));
	topde.qidspace = 1;
	topde.qidoff = big 0;
	topde.qidmax = pathgen;
	s2 := MSink.new(session, blocksize);
	if(s2.add(topde) < 0)
		fail(sprint("adding direntry for top entries: %r"));
	e2 := s2.finish();
	say("top meta entry written, "+e2.score.text());

 	td := array[venti->Entrysize*3] of byte;
 	td[0*venti->Entrysize:] = e0.pack();
 	td[1*venti->Entrysize:] = e1.pack();
 	td[2*venti->Entrysize:] = e2.pack();
	(tok, tscore) := session.write(venti->Dirtype, td);
	if(tok < 0)
		fail(sprint("writing top-level entries: %r"));

	root := ref Root(venti->Rootversion, name, "vac", tscore, blocksize, nil);
	rd := root.pack();
	if(rd == nil)
		fail(sprint("root pack: %r"));
	(rok, rscore) := session.write(venti->Roottype, rd);
	if(rok < 0)
		fail(sprint("writing root score: %r"));
	sys->print("vac:%s\n", rscore.text());
	if(session.sync() < 0)
		fail(sprint("syncing server: %r"));
}

readpaths(): ref Strhash[string]
{
	t := Strhash[string].new(199, nil);
	b := bufio->fopen(sys->fildes(0), bufio->OREAD);
	if(b == nil)
		fail(sprint("fopen: %r"));
	for(;;) {
		s := b.gets('\n');
		if(s == nil)
			break;
		if(s[len s-1] == '\n')
			s = s[:len s-1];
		t.add(s, s);
	}
	return t;
}

usepath(p: string): int
{
	if(itab != nil)
		return itab.find(p) != nil;
	if(xtab != nil)
		return xtab.find(p) == nil;
	return 1;
}

writepath(path: string, s: ref Sink, ms: ref MSink)
{
	if(!usepath(path))
		return;

	if(vflag && bout.puts(path+"\n") == bufio->ERROR)
		fail(sprint("write stdout: %r"));

	fd := sys->open(path, sys->OREAD);
	if(fd == nil)
		fail(sprint("opening %s: %r", path));
	(ok, dir) := sys->fstat(fd);
	if(ok < 0)
		fail(sprint("fstat %s: %r", path));
	if(dir.mode&sys->DMAUTH)
		return warn(path+": is auth file, skipping");
	if(dir.mode&sys->DMTMP)
		return warn(path+": is temporary file, skipping");

	e, me: ref Entry;
	de: ref Direntry;
	qid := pathgen++;
	if(dir.mode & sys->DMDIR) {
		ns := Sink.new(session, blocksize);
		nms := MSink.new(session, blocksize);
		for(;;) {
			(n, dirs) := sys->dirread(fd);
			if(n == 0)
				break;
			if(n < 0)
				fail(sprint("dirread %s: %r", path));
			for(i := 0; i < len dirs; i++) {
				d := dirs[i];
				npath := path+"/"+d.name;
				writepath(npath, ns, nms);
			}
		}
		e = ns.finish();
		if(e == nil)
			fail(sprint("error flushing dirsink for %s: %r", path));
		me = nms.finish();
		if(me == nil)
			fail(sprint("error flushing metasink for %s: %r", path));
	} else {
		e = writefile(path, fd);
		if(e == nil)
			fail(sprint("error flushing filesink for %s: %r", path));
	}

	case dir.name {
	"/" =>	dir.name = "root";
	"." =>	dir.name = "dot";
	}
	de = Direntry.mk(dir);
	de.qid = qid;
	if(uid != nil)
		de.uid = uid;
	if(gid != nil)
		de.gid = gid;

	i := s.add(e);
	if(i < 0)
		fail(sprint("adding entry to sink: %r"));
	mi := 0;
	if(me != nil)
		mi = s.add(me);
	if(mi < 0)
		fail(sprint("adding mentry to sink: %r"));
	de.entry = i;
	de.mentry = mi;
	i = ms.add(de);
	if(i < 0)
		fail(sprint("adding direntry to msink: %r"));
}

writefile(path: string, fd: ref Sys->FD): ref Entry
{
	bio := bufio->fopen(fd, bufio->OREAD);
	if(bio == nil)
		fail(sprint("bufio opening %s: %r", path));

	f := File.new(session, venti->Datatype, blocksize);
	for(;;) {
		buf := array[blocksize] of byte;
		n := 0;
		while(n < len buf) {
			want := len buf - n;
			have := bio.read(buf[n:], want);
			if(have == 0)
				break;
			if(have < 0)
				fail(sprint("reading %s: %r", path));
			n += have;
		}

		if(f.write(buf[:n]) < 0)
			fail(sprint("writing %s: %r", path));
		if(n != len buf)
			break;
	}
	bio.close();
	return f.finish();
}

user(): string
{
	fd := sys->open("/dev/user", Sys->OREAD);
	if(fd != nil)
	if((n := sys->read(fd, d := array[128] of byte, len d)) > 0)
		return string d[:n];
	return "nobody";
}

fd2: ref Sys->FD;
warn(s: string)
{
	if(fd2 == nil)
		fd2 = sys->fildes(2);
	sys->fprint(fd2, "%s\n", s);
}

say(s: string)
{
	if(dflag)
		warn(s);
}

fail(s: string)
{
	warn(s);
	raise "fail:"+s;
}