implement Bufferm;

include "common.m";

sys : Sys;
dat : Dat;
utils : Utils;
diskm : Diskm;
ecmd: Editcmd;

FALSE, TRUE, XXX, Maxblock, Astring : import Dat;
Block : import Dat;
disk : import dat;
Disk : import diskm;
File: import Filem;
error, warning, min : import utils;

init(mods : ref Dat->Mods)
{
	sys = mods.sys;
	dat = mods.dat;
	utils = mods.utils;
	diskm = mods.diskm;
	ecmd = mods.editcmd;
}

nullbuffer : Buffer;

newbuffer() : ref Buffer
{
	b := ref nullbuffer;
	return b;
}

Slop : con 100;	# room to grow with reallocation

Buffer.sizecache(b : self ref Buffer, n : int)
{
	if(n <= b.cmax)
		return;
	b.cmax = n+Slop;
	os := b.c;
	b.c = utils->stralloc(b.cmax);
	if (os != nil) {
		loss := len os.s;
		c := b.c;
		oss := os.s;
		for (i := 0; i < loss && i < b.cmax; i++)
			c.s[i] = oss[i];
		utils->strfree(os);
	}
}

#
# Move cache so b.cq <= q0 < b.cq+b.cnc.
# If at very end, q0 will fall on end of cache block.
#

Buffer.flush(b : self ref Buffer)
{
	if(b.cdirty || b.cnc==0){
		if(b.cnc == 0)
			b.delblock(b.cbi);
		else
			b.bl[b.cbi] = disk.write(b.bl[b.cbi], b.c.s, b.cnc);
		b.cdirty = FALSE;
	}
}

Buffer.setcache(b : self ref Buffer, q0 : int)
{
	blp, bl : ref Block;
	i, q : int;

	if (q0 > b.nc)
		error("bad assert in setcache");

	# flush and reload if q0 is not in cache.
	 
	if(b.nc == 0 || (b.cq<=q0 && q0<b.cq+b.cnc))
		return;

	# if q0 is at end of file and end of cache, continue to grow this block
	 
	if(q0==b.nc && q0==b.cq+b.cnc && b.cnc<Maxblock)
		return;
	b.flush();
	# find block 
	if(q0 < b.cq){
		q = 0;
		i = 0;
	}else{
		q = b.cq;
		i = b.cbi;
	}
	blp = b.bl[i];
	while(q+blp.n <= q0 && q+blp.n < b.nc){
		q += blp.n;
		i++;
		blp = b.bl[i];
		if(i >= b.nbl)
			error("block not found");
	}
	bl = blp;
	# remember position 
	b.cbi = i;
	b.cq = q;
	b.sizecache(bl.n);
	b.cnc = bl.n;
	#read block
	disk.read(bl, b.c, b.cnc);
}

Buffer.addblock(b : self ref Buffer, i : int, n : int)
{
	if (i > b.nbl)
		error("bad assert in addblock");

	obl := b.bl;
	b.bl = array[b.nbl+1] of ref Block;
	b.bl[0:] = obl[0:i];
	if(i < b.nbl)
		b.bl[i+1:] = obl[i:b.nbl];
	b.bl[i] = disk.new(n);
	b.nbl++;
	obl = nil;
}

Buffer.delblock(b : self ref Buffer, i : int)
{
	if (i >= b.nbl)
		error("bad assert in delblock");

	disk.release(b.bl[i]);
	obl := b.bl;
	b.bl = array[b.nbl-1] of ref Block;
	b.bl[0:] = obl[0:i];
	if(i < b.nbl-1)
		b.bl[i:] = obl[i+1:b.nbl];
	b.nbl--;
	obl = nil;
}

Buffer.insert(b : self ref Buffer, q0 : int, s : string, n : int)
{
	i, j,  m, t, off, p : int;

	if (q0>b.nc)
		error("bad assert in insert");
	p = 0;
	while(n > 0){
		b.setcache(q0);
		off = q0-b.cq;
		if(b.cnc+n <= Maxblock){
			# Everything fits in one block. 
			t = b.cnc+n;
			m = n;
			if(b.bl == nil){	# allocate 
				if (b.cnc != 0)
					error("bad assert in insert");
				b.addblock(0, t);
				b.cbi = 0;
			}
			b.sizecache(t);
			c := b.c;
			# cs := c.s;
			for (j = b.cnc-1; j >= off; j--)
				c.s[j+m] = c.s[j];
			for (j = 0; j < m; j++)
				c.s[off+j] = s[p+j];
			b.cnc = t;
		}
		#
		# We must make a new block.  If q0 is at
		# the very beginning or end of this block,
		# just make a new block and fill it.
		#
		else if(q0==b.cq || q0==b.cq+b.cnc){
			if(b.cdirty)
				b.flush();
			m = min(n, Maxblock);
			if(b.bl == nil){	# allocate 
				if (b.cnc != 0)
					error("bad assert in insert");
				i = 0;
			}else{
				i = b.cbi;
				if(q0 > b.cq)
					i++;
			}
			b.addblock(i, m);
			b.sizecache(m);
			c := b.c;
			for (j = 0; j < m; j++)
				c.s[j] = s[p+j];
			b.cq = q0;
			b.cbi = i;
			b.cnc = m;
		}
		else {
			#
		 	# Split the block; cut off the right side and
		 	# let go of it.
			#
		 
			m = b.cnc-off;
			if(m > 0){
				i = b.cbi+1;
				b.addblock(i, m);
				b.bl[i] = disk.write(b.bl[i], b.c.s[off:], m);
				b.cnc -= m;
			}
			#
			# Now at end of block.  Take as much input
			# as possible and tack it on end of block.
			#
		 
			m = min(n, Maxblock-b.cnc);
			b.sizecache(b.cnc+m);
			c := b.c;
			for (j = 0; j < m; j++)
				c.s[j+b.cnc] = s[p+j];
			b.cnc += m;
		}
		b.nc += m;
		q0 += m;
		p += m;
		n -= m;
		b.cdirty = TRUE;
	}
}

Buffer.delete(b : self ref Buffer, q0 : int, q1 : int)
{
	m, n, off : int;

	if (q0>q1 || q0>b.nc || q1>b.nc)
		error("bad assert in delete");

	while(q1 > q0){
		b.setcache(q0);
		off = q0-b.cq;
		if(q1 > b.cq+b.cnc)
			n = b.cnc - off;
		else
			n = q1-q0;
		m = b.cnc - (off+n);
		if(m > 0) {
			c := b.c;
			# cs := c.s;
			p := m+off;
			for (j := off; j < p; j++)
				c.s[j] = c.s[j+n];
		}
		b.cnc -= n;
		b.cdirty = TRUE;
		q1 -= n;
		b.nc -= n;
	}
}

# Buffer.replace(b: self ref Buffer, q0: int, q1: int, s: string, n: int)
# {
#	if(q0>q1 || q0>b.nc || q1>b.nc || n != q1-q0)
#		error("bad assert in replace");
#	p := 0;
#	while(q1 > q0){
#		b.setcache(q0);
#		off := q0-b.cq;
#		if(q1 > b.cq+b.cnc)
#			n = b.cnc-off;
#		else
#			n = q1-q0;
#		c := b.c;
#		for(i := 0; i < n; i++)
#			c.s[i+off] = s[i+p];
#		b.cdirty = TRUE;
#		q0 += n;
#		p += n;
#	}	
# }

pbuf : array of byte;

bufloader(b: ref Buffer, q0: int, r: string, nr: int): int
{
	b.insert(q0, r, nr);
	return nr;
}

loadfile(fd: ref Sys->FD, q0: int, fun: int, b: ref Buffer, f: ref File): int
{
	p : array of byte;
	r : string;
	m, n, nb, nr : int;
	q1 : int;

	if (pbuf == nil)
		pbuf = array[Maxblock+Sys->UTFmax] of byte;
	p = pbuf;
	m = 0;
	n = 1;
	q1 = q0;
	#
	# At top of loop, may have m bytes left over from
	# last pass, possibly representing a partial rune.
	#	 
	while(n > 0){
		n = sys->read(fd, p[m:], Maxblock);
		if(n < 0){
			warning(nil, "read error in Buffer.load");
			break;
		}
		m += n;
		nb = sys->utfbytes(p, m);
		r = string p[0:nb];
		p[0:] = p[nb:m];
		m -= nb;
		nr = len r;
		if(fun == Dat->BUFL)
			q1 += bufloader(b, q1, r, nr);
		else
			q1 += ecmd->readloader(f, q1, r, nr);
	}
	p = nil;
	r = nil;
	return q1-q0;
}

Buffer.loadx(b : self ref Buffer, q0 : int, fd : ref Sys->FD) : int
{
	if (q0>b.nc)
		error("bad assert in load");
	return loadfile(fd, q0, Dat->BUFL, b, nil);
}

Buffer.read(b : self ref Buffer, q0 : int, s : ref Astring, p : int, n : int)
{
	m : int;

	if (q0>b.nc || q0+n>b.nc)
		error("bad assert in read");
	while(n > 0){
		b.setcache(q0);
		m = min(n, b.cnc-(q0-b.cq));
		c := b.c;
		cs := c.s;
		for (j := 0; j < m; j++)
			s.s[p+j] = cs[j+q0-b.cq];
		q0 += m;
		p += m;
		n -= m;
	}
}

Buffer.reset(b : self ref Buffer)
{
	i : int;

	b.nc = 0;
	b.cnc = 0;
	b.cq = 0;
	b.cdirty = 0;
	b.cbi = 0;
	# delete backwards to avoid n² behavior 
	for(i=b.nbl-1; --i>=0; )
		b.delblock(i);
}

Buffer.close(b : self ref Buffer)
{
	b.reset();
	if (b.c != nil) {
		utils->strfree(b.c);
		b.c = nil;
	}
	b.cnc = 0;
	b.bl = nil;
	b.nbl = 0;
}