#include <string.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <assert.h>
#include <errno.h>

#include "syslog.h"

#define CONFIG_FILE "syslog.conf"

/* Data structures */

static struct
{
	int n; /* Number of config elements */
	struct config_element el[ETYPE_END];
} main_config;

/* Aquesta variable ha de reflexar l'ordre de la enum etype_config de syslog.h*/
const static struct config_element default_config[ETYPE_END+1] = {
	{ FROM_UNIX, "unixlog" },
	{ FROM_NPIPE, "disabled" },
	{ FROM_UDP, "disabled" },
	{ TO_UDP_HOST, "localhost" },
	{ TO_UDP_PORT, "1235" },
	{ TCP_MANAGER, "1234" },
	{ LOG_FILE, "file.log" },
	{ PID_FILE, "syslog.pid" },
	{ ETYPE_END, "" }};

/* Aquesta variable ha de reflexar l'ordre de la enum etype_config de syslog.h*/
const static struct {
	enum etype_config type;
	char string[MAX_STRING];
} etype_string[ETYPE_END+1] = {
	{ FROM_UNIX, "from_unix" },
	{ FROM_NPIPE, "from_npipe" },
	{ FROM_UDP, "from_udp" },
	{ TO_UDP_HOST, "to_udp_host" },
	{ TO_UDP_PORT, "to_udp_port" },
	{ TCP_MANAGER, "tcp_manager" },
	{ LOG_FILE, "log_file" },
	{ PID_FILE, "pid_file" },
	{ ETYPE_END, "" }};

/* Prototypes */
static int add_config_element(const char * restrict p, const char * restrict v,
		const int max);
static void read_config(char * restrict fname);

/* Functions' code */

void init_config()
{
	main_config.n = 0;
	read_config(CONFIG_FILE);
}

static void read_config(char * restrict fname)
{
	int file;
	char rchar;
	int res;
	char parameter[MAX_STRING];
	int nparameter;
	char value[MAX_STRING];
	int nvalue;
	enum {
		READ_PARAMETER,
		READ_VALUE
	} state;

	file = open(fname, O_RDONLY);
	if (file == -1)
	{
		fprintf(stderr,"The config file cannot be opened.\n");
		return;
	}

	nparameter=0;
	state=READ_PARAMETER;
	while ((res = read(file, &rchar, 1)) == 1)
	{
		switch (rchar)
		{
		case '=':
			assert(nparameter <= MAX_STRING);
			parameter[nparameter]='\0';
			nvalue=0;
			state=READ_VALUE;
			break;
		case '\n':
			if (state == READ_VALUE)
			{
				value[nvalue]='\0';
				assert( add_config_element(parameter,
							value, MAX_STRING)>=0);
			}
			nparameter=0;
			nvalue=0;
			state=READ_PARAMETER;
			break;
		default:
			switch(state)
			{
			case READ_PARAMETER:
				assert(nparameter <= MAX_STRING);
				parameter[nparameter++]=rchar;
				break;
			case READ_VALUE:
				assert(nvalue <= MAX_STRING);
				value[nvalue++]=rchar;
				break;
			}
		}
	}

	if (res == -1)
	{
		fprintf(stderr, "Error reading config file: %s\n",
				strerror(errno));
	}

	close(file);
}

/* Retorna el tipus si ha pogut afegir l'element, -1 si hi ha hagut error */
static int add_config_element(const char * restrict p, const char * restrict v,
		const int max)
{
	enum etype_config i, type;
	int j, pos;
	int my_max;

	my_max = max;
	if (my_max > MAX_STRING)
		my_max = MAX_STRING;

	/* busquem de quin paràmetre es tracta */
	for(i=0; i<ETYPE_END; i++)
	{
		/* a etype_string corresponen índex amb tipus */
		
		if (strncmp(p,etype_string[i].string, my_max) == 0)
		{
			type=i;
			break;
		}
	}
	if (i==ETYPE_END)
	{
		/* Si el paràmetre no és conegut... */
		return -1;
	}

	/* Busquem si el paràmetre ja està a la configuració main_config */
	for (j=0; j<main_config.n; j++)
	{
		if(main_config.el[j].type == type)
		{
			pos = j;
			break;
		}
	}
	if(j == main_config.n)
	{
		pos = j;
		main_config.n++;
		/* At maximum, there should be ETYPE_END elements) */
		assert(main_config.n <= ETYPE_END);
	}

	main_config.el[pos].type = type;
	strncpy(main_config.el[pos].value, v, MAX_STRING);

	return type;
}

/* Returns 2 on configured type, 1 on default value, 0 on disabled,
 * -1 on error */
int get_config(const enum etype_config type, char * restrict v, const int max)
{
	int j;
	enum {
		DISABLED=0,
		DEFAULT=1,
		CONFIGURED=2,
		ERROR=-1
	} ret;

	if (type < 0 || type >= ETYPE_END)
		return ERROR;

	for (j=0; j<main_config.n; j++)
	{
		if(main_config.el[j].type == type)
		{
			strncpy(v, main_config.el[j].value, max);
			ret = CONFIGURED;
			break;
		}
	}

	if(j == main_config.n)
	{
		strncpy(v, default_config[type].value, max);
		ret = DEFAULT;
	}

	if(strncmp(v, "disabled", max) == 0)
		return DISABLED;
	else
		return ret;
}