/*
 * Copyright 2004-2008, François Revol, <revol@free.fr>.
 * Distributed under the terms of the MIT License.
 */

#define _BUILDING_fs 1

//#define TEST_RB

#include <sys/param.h>
#ifndef TEST_RB
//#include "lock.h"
#include "websearchfs.h"
#endif

#ifdef TEST_RB
#include <OS.h>
struct ring_buffer {
        size_t size;
        size_t current; /* index of next byte to read */
        size_t avail;   /* number of bytes in */
        unsigned char data[0];
};
#define ASSERT(op) if (!(op)) debugger("ASSERT: " #op " in " __FILE__ ":" __FUNCTION__)
#else
#define ASSERT(op) if (!(op)) panic("ASSERT: %s in %s:%s", #op, __FILE__, __FUNCTION__)
#endif

void rb_init(struct ring_buffer *rb, size_t size)
{
	rb->size = size;
	rb->current = 0;
	rb->avail = 0;
}

void rb_clear(struct ring_buffer *rb)
{
	rb->avail = 0;
	rb->current = 0;
}

size_t rb_can_write(struct ring_buffer *rb)
{
	if (!rb)
		return 0;
	return (rb->size - rb->avail);
}

size_t rb_can_read(struct ring_buffer *rb)
{
	if (!rb)
		return 0;
	return rb->avail;
}

size_t rb_write(struct ring_buffer *rb, void *data, size_t len)
{
	size_t index, towrite, written;
	if (!rb)
		return 0;
	index = (rb->current + rb->avail) % rb->size;
	towrite = rb_can_write(rb);
	towrite = MIN(len, towrite);
	if (towrite < 1)
		return 0;
	len = rb->size - index;
	len = MIN(len, towrite);
	memcpy(((char *)rb->data)+index, data, len);
	rb->avail += len;
	written = len;
	if (len < towrite) {
		towrite -= len;
		len = MIN(towrite, rb_can_write(rb));
		index = 0;
		memcpy(((char *)rb->data)+index, ((char *)data)+written, len);
		rb->avail += len;
		written += len;
	}
	ASSERT(rb->avail <= rb->size);
	return written;
}

size_t rb_read(struct ring_buffer *rb, void *data, size_t len)
{
	size_t index, toread, got;
	if (!rb)
		return 0;
	index = rb->current;
	toread = rb_can_read(rb);
	toread = MIN(len, toread);
	if (toread < 1)
		return 0;
	len = rb->size - index;
	len = MIN(len, toread);
	memcpy(data, ((char *)rb->data)+index, len);
	rb->avail -= len;
	rb->current += len;
	got = len;
	if (len < toread) {
		toread -= len;
		len = MIN(toread, rb_can_read(rb));
		index = 0;
		memcpy(((char *)data)+got, ((char *)rb->data)+index, len);
		rb->current = len;
		rb->avail -= len;
		got += len;
	}
	ASSERT(rb->avail <= rb->size);
	return got;
}

#ifdef TEST_RB
int main(void)
{
	struct _myrb {
		struct ring_buffer rb;
		char buff[10];
	} myrb;
	char buffer[10];
	char obuffer[10];
	int got, tow;
	rb_init(&myrb.rb, 10);
	while ((got = read(0, buffer, 10))) {
		int len, olen;
		len = rb_write(&myrb.rb, buffer, got);
		olen = rb_read(&myrb.rb, obuffer, 10);
		write(1, obuffer, olen);
	}
	return 1;
}
#endif