implement Palmdb;

#
# Copyright © 2001-2002 Vita Nuova Holdings Limited.  All rights reserved.
#
# Based on ``Palm® File Format Specification'', Document Number 3008-004, 1 May 2001, by Palm Inc.
# Doc compression based on description by Paul Lucas, 18 August 1998
#

include "sys.m";
	sys: Sys;

include "daytime.m";
	daytime: Daytime;

include "bufio.m";
	bufio: Bufio;
	Iobuf: import bufio;

include "palm.m";
	palm: Palm;
	DBInfo, Record, Resource, get2, get3, get4, put2, put3, put4, gets, puts: import palm;
	filename, dbname: import palm;

Entry: adt {
	id:	int;	# resource: id; record: unique ID
	offset:	int;
	size:	int;
	name:	int;	# resource entry only
	attr:	int;	# record entry only
};

Ofile: adt {
	fname:	string;
	f:	ref Iobuf;
	mode:	int;
	info:	ref DBInfo;
	appinfo:	array of byte;
	sortinfo:	array of int;
	uidseed:	int;
	entries:	array of ref Entry;
};

files:	array of ref Ofile;

Dbhdrlen: con 72+6;
Datahdrsize: con 4+1+3;
Resourcehdrsize: con 4+2+4;

# Exact value of "Jan 1, 1970 0:00:00 GMT" - "Jan 1, 1904 0:00:00 GMT"
Epochdelta: con 2082844800;
tzoff := 0;

init(m: Palm): string
{
	sys = load Sys Sys->PATH;
	bufio = load Bufio Bufio->PATH;
	daytime = load Daytime Daytime->PATH;
	if(bufio == nil || daytime == nil)
		return "can't load required module";
	palm = m;
	tzoff = daytime->local(0).tzoff;
	return nil;
}

Eshort: con "file format error: too small";

DB.open(name: string, mode: int): (ref DB, string)
{
	if(mode != Sys->OREAD)
		return (nil, "invalid mode");
	fd := sys->open(name, mode);
	if(fd == nil)
		return (nil, sys->sprint("%r"));
	(ok, d) := sys->fstat(fd);
	if(ok < 0)
		return (nil, sys->sprint("%r"));
	length := int d.length;
	if(length == 0)
		return (nil, "empty file");
	(pf, ofile, fx) := mkpfile(name, mode);

	f := bufio->fopen(fd, mode);	# automatically closed if open fails

	p := array[Dbhdrlen] of byte;
	if(f.read(p, Dbhdrlen) != Dbhdrlen)
		return (nil, "invalid file header: too short");

	ip := ofile.info;
	ip.name = gets(p[0:32]);
	ip.attr = get2(p[32:]);
	ip.version = get2(p[34:]);
	ip.ctime = pilot2epoch(get4(p[36:]));
	ip.mtime = pilot2epoch(get4(p[40:]));
	ip.btime = pilot2epoch(get4(p[44:]));
	ip.modno = get4(p[48:]);
	appinfo := get4(p[52:]);
	sortinfo := get4(p[56:]);
	if(appinfo < 0 || sortinfo < 0 || (appinfo|sortinfo)&1)
		return (nil, "invalid header: bad offset");
	ip.dtype = xs(get4(p[60:]));
	ip.creator = xs(get4(p[64:]));
	ofile.uidseed = ip.uidseed = get4(p[68:]);

	if(get4(p[72:]) != 0)
		return (nil, "chained headers not supported");	# Palm says to reject such files
	nrec := get2(p[76:]);
	if(nrec < 0)
		return (nil, sys->sprint("invalid header: bad record count: %d", nrec));

	esize := Datahdrsize;
	if(ip.attr & Palm->Fresource)
		esize = Resourcehdrsize;
	
	dataoffset := length;
	ofile.entries = array[nrec] of ref Entry;
	if(nrec > 0){
		laste: ref Entry;
		buf := array[esize] of byte;
		for(i := 0; i < nrec; i++){
			if(f.read(buf, len buf) != len buf)
				return (nil, Eshort);
			e := ref Entry;
			if(ip.attr & Palm->Fresource){
				# resource entry: type[4], id[2], offset[4]
				e.name = get4(buf);
				e.id = get2(buf[4:]);
				e.offset = get4(buf[6:]);
				e.attr = 0;
			}else{
				# record entry: offset[4], attr[1], id[3]
				e.offset = get4(buf);
				e.attr = int buf[4];
				e.id = get3(buf[5:]);
				e.name = 0;
			}
			if(laste != nil)
				laste.size = e.offset - laste.offset;
			laste = e;
			ofile.entries[i] = e;
		}
		if(laste != nil)
			laste.size = length - laste.offset;
		dataoffset = ofile.entries[0].offset;
	}else{
		if(f.read(p, 2) != 2)
			return (nil, Eshort);	# discard placeholder bytes
	}

	n := 0;
	if(appinfo > 0){
		n = appinfo - int f.offset();
		while(--n >= 0)
			f.getb();
		if(sortinfo)
			n = sortinfo - appinfo;
		else
			n = dataoffset - appinfo;
		ofile.appinfo = array[n] of byte;
		if(f.read(ofile.appinfo, n) != n)
			return (nil, Eshort);
	}
	if(sortinfo > 0){
		n = sortinfo - int f.offset();
		while(--n >= 0)
			f.getb();
		n = (dataoffset-sortinfo)/2;
		ofile.sortinfo = array[n] of int;
		tmp := array[2*n] of byte;
		if(f.read(tmp, len tmp) != len tmp)
			return (nil, Eshort);
		for(i := 0; i < n; i++)
			ofile.sortinfo[i] = get2(tmp[2*i:]);
	}
	ofile.f = f;	# safe to save open file reference
	files[fx] = ofile;
	return (pf, nil);
}

DB.close(db: self ref DB): string
{
	ofile := files[db.x];
	if(ofile.f != nil){
		ofile.f.close();
		ofile.f = nil;
	}
	files[db.x] = nil;
	return nil;
}

DB.stat(db: self ref DB): ref DBInfo
{
	return ref *files[db.x].info;
}

DB.create(name: string, mode: int, perm: int, info: ref DBInfo): (ref DB, string)
{
	return (nil, "DB.create not implemented");
}

DB.wstat(db: self ref DB, ip: ref DBInfo, flags: int)
{
	raise "DB.wstat not implemented";
}

#DB.wstat(db: self ref DB, ip: ref DBInfo): string
#{
#	ofile := files[db.x];
#	if(ofile.mode != Sys->OWRITE)
#		return "not open for writing";
#	if((ip.attr & Palm->Fresource) != (ofile.info.attr & Palm->Fresource))
#		return "cannot change file type";
#	# copy only a subset
#	ofile.info.name = ip.name;
#	ofile.info.attr = ip.attr;
#	ofile.info.version = ip.version;
#	ofile.info.ctime = ip.ctime;
#	ofile.info.mtime = ip.mtime;
#	ofile.info.btime = ip.btime;
#	ofile.info.modno = ip.modno;
#	ofile.info.dtype = ip.dtype;
#	ofile.info.creator = ip.creator;
#	return nil;
#}

DB.rdappinfo(db: self ref DB): (array of byte, string)
{
	return (files[db.x].appinfo, nil);
}

DB.wrappinfo(db: self ref DB, data: array of byte): string
{
	ofile := files[db.x];
	if(ofile.mode != Sys->OWRITE)
		return "not open for writing";
	ofile.appinfo = array[len data] of byte;
	ofile.appinfo[0:] = data;
	return nil;
}

DB.rdsortinfo(db: self ref DB): (array of int, string)
{
	return (files[db.x].sortinfo, nil);
}

DB.wrsortinfo(db: self ref DB, sort: array of int): string
{
	ofile := files[db.x];
	if(ofile.mode != Sys->OWRITE)
		return "not open for writing";
	ofile.sortinfo = array[len sort] of int;
	ofile.sortinfo[0:] = sort;
	return nil;
}

DB.readidlist(db: self ref DB, nil: int): array of int
{
	ent := files[db.x].entries;
	a := array[len ent] of int;
	for(i := 0; i < len a; i++)
		a[i] = ent[i].id;
	return a;
}

DB.nentries(db: self ref DB): int
{
	return len files[db.x].entries;
}

DB.resetsyncflags(db: self ref DB): string
{
	raise "DB.resetsyncflags not implemented";
}

DB.records(db: self ref DB): ref PDB
{
	if(db == nil || db.attr & Palm->Fresource)
		return nil;
	return ref PDB(db);
}

DB.resources(db: self ref DB): ref PRC
{
	if(db == nil || (db.attr & Palm->Fresource) == 0)
		return nil;
	return ref PRC(db);
}

PDB.read(pdb: self ref PDB, i: int): ref Record
{
	ofile := files[pdb.db.x];
	if(i < 0 || i >= len ofile.entries){
		if(i == len ofile.entries)
			return nil; # treat as end-of-file
		#return "index out of range";
		return nil;
	}
	e := ofile.entries[i];
	nb := e.size;
	r := ref Record(e.id, e.attr & 16rF0, e.attr & 16r0F, array[nb] of byte);
	ofile.f.seek(big e.offset, 0);
	if(ofile.f.read(r.data, nb) != nb)
		return nil;
	return r;
}

PDB.readid(pdb: self ref PDB, id: int): (ref Record, int)
{
	ofile := files[pdb.db.x];
	ent := ofile.entries;
	for(i := 0; i < len ent; i++)
		if((e := ent[i]).id == id){
			nb := e.size;
			r := ref Record(e.id, e.attr & 16rF0, e.attr & 16r0F, array[e.size] of byte);
			ofile.f.seek(big e.offset, 0);
			if(ofile.f.read(r.data, nb) != nb)
				return (nil, -1);
			return (r, id);
		}
	sys->werrstr("ID not found");
	return (nil, -1);
}

PDB.resetnext(db: self ref PDB): int
{
	raise "PDB.resetnext not implemented";
}

PDB.readnextmod(db: self ref PDB): (ref Record, int)
{
	raise "PDB.readnextmod not implemented";
}

PDB.write(db: self ref PDB, r: ref Record): string
{
	return "PDB.write not implemented";
}

PDB.truncate(db: self ref PDB): string
{
	return "PDB.truncate not implemented";
}

PDB.delete(db: self ref PDB, id: int): string
{
	return "PDB.delete not implemented";
}

PDB.deletecat(db: self ref PDB, cat: int): string
{
	return "PDB.deletecat not implemented";
}

PDB.purge(db: self ref PDB): string
{
	return "PDB.purge not implemented";
}

PDB.movecat(db: self ref PDB, old: int, new: int): string
{
	return "PDB.movecat not implemented";
}

PRC.read(db: self ref PRC, index: int): ref Resource
{
	return nil;
}

PRC.readtype(db: self ref PRC, name: int, id: int): (ref Resource, int)
{
	return (nil, -1);
}

PRC.write(db: self ref PRC, r: ref Resource): string
{
	return "PRC.write not implemented";
}

PRC.truncate(db: self ref PRC): string
{
	return "PRC.truncate not implemented";
}

PRC.delete(db: self ref PRC, name: int, id: int): string
{
	return "PRC.delete not implemented";
}

#
# internal function to extend entry list if necessary, and return a
# pointer to the next available slot
#
entryensure(db: ref DB, i: int): ref Entry
{
	ofile := files[db.x];
	if(i < len ofile.entries)
		return ofile.entries[i];
	e := ref Entry(0, -1, 0, 0, 0);
	n := len ofile.entries;
	if(n == 0)
		n = 64;
	else
		n = (i+63) & ~63;
	a := array[n] of ref Entry;
	a[0:] = ofile.entries;
	a[i] = e;
	ofile.entries = a;
	return e;
}

writefilehdr(db: ref DB, mode: int, perm: int): string
{
	ofile := files[db.x];
	if(len ofile.entries >= 64*1024)
		return "too many records for Palm file";	# is there a way to extend it?

	if((f := bufio->create(ofile.fname, mode, perm)) == nil)
		return sys->sprint("%r");

	ip := ofile.info;

	esize := Datahdrsize;
	if(ip.attr & Palm->Fresource)
		esize = Resourcehdrsize;
	offset := Dbhdrlen + esize*len ofile.entries + 2;
	offset += 2;	# placeholder bytes or gap bytes
	appinfo := 0;
	if(len ofile.appinfo > 0){
		appinfo = offset;
		offset += len ofile.appinfo;
	}
	sortinfo := 0;
	if(len ofile.sortinfo > 0){
		sortinfo = offset;
		offset += 2*len ofile.sortinfo;	# 2-byte entries
	}
	p := array[Dbhdrlen] of byte;	# bigger than any entry as well
	puts(p[0:32], ip.name);
	put2(p[32:], ip.attr);
	put2(p[34:], ip.version);
	put4(p[36:], epoch2pilot(ip.ctime));
	put4(p[40:], epoch2pilot(ip.mtime));
	put4(p[44:], epoch2pilot(ip.btime));
	put4(p[48:], ip.modno);
	put4(p[52:], appinfo);
	put4(p[56:], sortinfo);
	put4(p[60:], sx(ip.dtype));
	put4(p[64:], sx(ip.creator));
	put4(p[68:], ofile.uidseed);
	put4(p[72:], 0);		# next record list ID
	put2(p[76:], len ofile.entries);

	if(f.write(p, Dbhdrlen) != Dbhdrlen)
		return ewrite(f);
	if(len ofile.entries > 0){
		for(i := 0; i < len ofile.entries; i++) {
			e := ofile.entries[i];
			e.offset = offset;
			if(ip.attr & Palm->Fresource) {
				put4(p, e.name);
				put2(p[4:], e.id);
				put4(p[6:], e.offset);
			} else {
				put4(p, e.offset);
				p[4] = byte e.attr;
				put3(p[5:], e.id);
			}
			if(f.write(p, esize) != esize)
				return ewrite(f);
			offset += e.size;
		}
	}

	f.putb(byte 0);	# placeholder bytes (figure 1.4) or gap bytes (p. 15)
	f.putb(byte 0);

	if(appinfo != 0){
		if(f.write(ofile.appinfo, len ofile.appinfo) != len ofile.appinfo)
			return ewrite(f);
	}

	if(sortinfo != 0){
		tmp := array[2*len ofile.sortinfo] of byte;
		for(i := 0; i < len ofile.sortinfo; i++)
			put2(tmp[2*i:], ofile.sortinfo[i]);
		if(f.write(tmp, len tmp) != len tmp)
			return ewrite(f);
	}

	if(f.flush() != 0)
		return ewrite(f);

	return nil;
}

ewrite(f: ref Iobuf): string
{
	e := sys->sprint("write error: %r");
	f.close();
	return e;
}

xs(i: int): string
{
	if(i == 0)
		return "";
	if(i & int 16r80808080)
		return sys->sprint("%8.8ux", i);
	return sys->sprint("%c%c%c%c", (i>>24)&16rFF, (i>>16)&16rFF, (i>>8)&16rFF, i&16rFF);
}

sx(s: string): int
{
	n := 0;
	for(i := 0; i < 4; i++){
		c := 0;
		if(i < len s)
			c = s[i] & 16rFF;
		n = (n<<8) | c;
	}
	return n;
}

mkpfile(name: string, mode: int): (ref DB, ref Ofile, int)
{
	ofile := ref Ofile(name, nil, mode, DBInfo.new(name, 0, nil, 0, nil),
		array[0] of byte, array[0] of int, 0, nil);
	for(x := 0; x < len files; x++)
		if(files[x] == nil)
			return (ref DB(x, mode, 0), ofile, x);
	a := array[x] of ref Ofile;
	a[0:] = files;
	files = a;
	return (ref DB(x, mode, 0), ofile, x);
}

#
# because PalmOS treats all times as local times, and doesn't associate
# them with time zones, we'll convert using local time on Plan 9 and Inferno
#

pilot2epoch(t: int): int
{
	if(t == 0)
		return 0;	# we'll assume it's not set
	return t - Epochdelta + tzoff;
}

epoch2pilot(t: int): int
{
	if(t == 0)
		return t;
	return t - tzoff + Epochdelta;
}

#
# map Palm name to string, assuming iso-8859-1,
# but remap space and /
#
latin1(a: array of byte, remap: int): string
{
	s := "";
	for(i := 0; i < len a; i++){
		c := int a[i];
		if(c == 0)
			break;
		if(remap){
			if(c == ' ')
				c = 16r00A0;	# unpaddable space
			else if(c == '/')
				c = 16r2215;	# division /
		}
		s[len s] = c;
	}
	return s;
}