/*
 * file_c.c -- File cache management 
 */

#include <dirent.h>
#include "copyright.h"
#include "config.h"

#include "config.h"
#include "interface.h"
#include "mudconf.h"
#include "command.h"
#include "file_c.h"
#include "alloc.h"
#include "externs.h"

typedef struct filecache_hdr FCACHE;
typedef struct filecache_block_hdr FBLKHDR;
typedef struct filecache_block FBLOCK;

struct filecache_hdr {
	char *filename;
	FBLOCK *fileblock;
	const char *desc;
};

struct filecache_block {
	struct filecache_block_hdr {
		struct filecache_block *nxt;
		int nchars;
	} hdr;
	char data[MBUF_SIZE - sizeof(FBLKHDR)];
};

#define FBLOCK_SIZE (MBUF_SIZE - sizeof(FBLKHDR))

FCACHE fcache[] = {
	{mudconf.conn_file, NULL, "Conn"}
	,
	{mudconf.site_file, NULL, "Conn/Badsite"}
	,
	{mudconf.down_file, NULL, "Conn/Down"}
	,
	{mudconf.full_file, NULL, "Conn/Full"}
	,
	{mudconf.guest_file, NULL, "Conn/Guest"}
	,
	{mudconf.creg_file, NULL, "Conn/Reg"}
	,
	{mudconf.crea_file, NULL, "Crea/Newuser"}
	,
	{mudconf.regf_file, NULL, "Crea/RegFaill"}
	,
	{mudconf.motd_file, NULL, "Motd"}
	,
	{mudconf.wizmotd_file, NULL, "Wizmotd"}
	,
	{mudconf.quit_file, NULL, "Quit"}
	,
	{NULL, NULL, NULL}
};

NAMETAB list_files[] = {
	{(char *) "badsite_connect", 1, CA_WIZARD, FC_CONN_SITE},
	{(char *) "connect", 2, CA_WIZARD, FC_CONN},
	{(char *) "create_register", 2, CA_WIZARD, FC_CREA_REG},
	{(char *) "down", 1, CA_WIZARD, FC_CONN_DOWN},
	{(char *) "full", 1, CA_WIZARD, FC_CONN_FULL},
	{(char *) "guest_motd", 1, CA_WIZARD, FC_CONN_GUEST},
	{(char *) "motd", 1, CA_WIZARD, FC_MOTD},
	{(char *) "newuser", 1, CA_WIZARD, FC_CREA_NEW},
	{(char *) "quit", 1, CA_WIZARD, FC_QUIT},
	{(char *) "register_connect", 1, CA_WIZARD, FC_CONN_REG},
	{(char *) "wizard_motd", 1, CA_WIZARD, FC_WIZMOTD},
	{NULL, 0, 0, 0}
};

#define MAX_CONN 100
int fcache_conn_c = 0;
FCACHE fcache_conn[MAX_CONN];

void do_list_file(dbref player, dbref cause, int extra, char *arg)
{
	int flagvalue;

	flagvalue = search_nametab(player, list_files, arg);
	if(flagvalue < 0) {
		display_nametab(player, list_files,
						(char *) "Unknown file.  Use one of:", 1);
		return;
	}
	fcache_send(player, flagvalue);
}

static FBLOCK *fcache_fill(FBLOCK * fp, char ch)
{
	FBLOCK *tfp;

	if(fp->hdr.nchars >= (MBUF_SIZE - sizeof(FBLKHDR))) {

		/*
		 * We filled the current buffer.  Go get a new one. 
		 */

		tfp = fp;
		fp = (FBLOCK *) alloc_mbuf("fcache_fill");
		fp->hdr.nxt = NULL;
		fp->hdr.nchars = 0;
		tfp->hdr.nxt = fp;
	}
	fp->data[fp->hdr.nchars++] = ch;
	return fp;
}

static int fcache_read(FBLOCK ** cp, char *filename)
{
	int n, nmax, tchars, fd;
	char *buff;
	FBLOCK *fp, *tfp;

	/*
	 * Free a prior buffer chain 
	 */

	fp = *cp;
	while (fp != NULL) {
		tfp = fp->hdr.nxt;
		free_mbuf(fp);
		fp = tfp;
	}
	*cp = NULL;

	/*
	 * Read the text file into a new chain 
	 */

	if((fd = open(filename, O_RDONLY)) == -1) {

		/*
		 * Failure: log the event 
		 */

		log_error(LOG_PROBLEMS, "FIL", "OPEN", "Couldn't open file '%s'.",
				  filename);

		return -1;
	}
	buff = alloc_lbuf("fcache_read.temp");

	/*
	 * Set up the initial cache buffer to make things easier 
	 */

	fp = (FBLOCK *) alloc_mbuf("fcache_read.first");
	fp->hdr.nxt = NULL;
	fp->hdr.nchars = 0;
	*cp = fp;
	tchars = 0;

	/*
	 * Process the file, one lbuf at a time 
	 */

	nmax = read(fd, buff, LBUF_SIZE);
	while (nmax > 0) {

		for(n = 0; n < nmax; n++) {
			switch (buff[n]) {
			case '\n':
				fp = fcache_fill(fp, '\r');
				fp = fcache_fill(fp, '\n');
				tchars += 2;
			case '\0':
			case '\r':
				break;
			default:
				fp = fcache_fill(fp, buff[n]);
				tchars++;
			}
		}
		nmax = read(fd, buff, LBUF_SIZE);
	}
	free_lbuf(buff);
	close(fd);

	/*
	 * If we didn't read anything in, toss the initial buffer 
	 */

	if(fp->hdr.nchars == 0) {
		*cp = NULL;
		free_mbuf(fp);
	}
	return tchars;
}

void fcache_read_dir(char *dir, FCACHE foo[], int *cnt, int max)
{
	DIR *d;
	struct dirent *de;
	char buf[LBUF_SIZE];

	bzero(&foo[0], sizeof(FCACHE) * max);
	if(!(d = opendir(dir)))
		return;
	for(*cnt = 0; *cnt < max;) {
		if(!(de = readdir(d)))
			break;
		if(de->d_name[0] == '.')
			continue;
		if(!strstr(de->d_name, ".txt"))
			continue;
		sprintf(buf, "%s/%s", dir, de->d_name);
		fcache_read(&(foo[*cnt].fileblock), buf);
		(*cnt)++;
	}
	closedir(d);
}

void fcache_rawdump(int fd, int num)
{
	int cnt, remaining;
	char *start;
	FBLOCK *fp;

	if((num < 0) || (num > FC_LAST))
		return;
	fp = fcache[num].fileblock;

	while (fp != NULL) {
		start = fp->data;
		remaining = fp->hdr.nchars;
		while (remaining > 0) {

			cnt = WRITE(fd, start, remaining);
			if(cnt < 0)
				return;
			remaining -= cnt;
			start += cnt;
		}
		fp = fp->hdr.nxt;
	}
	return;
}

void fcache_dumpbase(DESC * d, FCACHE fc[], int num)
{
	FBLOCK *fp;

	fp = fc[num].fileblock;

	while (fp != NULL) {
		queue_write(d, fp->data, fp->hdr.nchars);
		fp = fp->hdr.nxt;
	}
}

void fcache_dump(DESC * d, int num)
{
	if((num < 0) || (num > FC_LAST))
		return;
	fcache_dumpbase(d, fcache, num);
}

void fcache_dump_conn(DESC * d, int num)
{
	fcache_dumpbase(d, fcache_conn, num);
}

void fcache_send(dbref player, int num)
{
	DESC *d;

	DESC_ITER_PLAYER(player, d) {
		fcache_dump(d, num);
	}
}

void fcache_load(dbref player)
{
	FCACHE *fp;
	char *buff, *bufc, *sbuf;
	int i;

	buff = bufc = alloc_lbuf("fcache_load.lbuf");
	sbuf = alloc_sbuf("fcache_load.sbuf");
	for(fp = fcache; fp->filename; fp++) {
		i = fcache_read(&fp->fileblock, fp->filename);
		if((player != NOTHING) && !Quiet(player)) {
			sprintf(sbuf, "%d", i);
			if(fp == fcache)
				safe_str((char *) "File sizes: ", buff, &bufc);
			else
				safe_str((char *) "  ", buff, &bufc);
			safe_str((char *) fp->desc, buff, &bufc);
			safe_str((char *) "...", buff, &bufc);
			safe_str(sbuf, buff, &bufc);
		}
	}
	*bufc = '\0';
	if(*mudconf.conn_dir)
		fcache_read_dir(mudconf.conn_dir, fcache_conn, &fcache_conn_c,
						MAX_CONN);
	if((player != NOTHING) && !Quiet(player)) {
		notify(player, buff);
	}
	free_lbuf(buff);
	free_sbuf(sbuf);
}

void fcache_init(void)
{
	FCACHE *fp;

	for(fp = fcache; fp->filename; fp++) {
		fp->fileblock = NULL;
	}
	fcache_load(NOTHING);
}