#include <stdlib.h>
#include <string.h>

#include "debug.h"
#include "config.h"
#include "rrdtool.h"
#include "parser.h"

#define RRD_DATABASE_LIST "rrd_database"
#define RRD_DATABASE_NAME "name"

static int read_strings_from_list(config_setting_t *list, const char ***strings)
{
	config_setting_t *string;
	int j;
	int str_count = config_setting_length(list);
	const char **strs;

	strs = calloc(sizeof(*strs), str_count + 1);

	for (j = 0; j < str_count; j++) {
		const char *str;

		string = config_setting_get_elem(list, j);
		str = config_setting_get_string(string);
		strs[j] = strdup(str);
	}
	*strings = strs;

	return 0;
}

static int parse_images(config_setting_t *list, struct rrd_database *db)
{
	int i, count;
	config_setting_t *image, *str_list;
	const char *database = NULL, *filename = NULL, *timestart = NULL;
	const char *timeend = NULL, *imageformat = NULL;
	const char **options = NULL, **text = NULL;
	const char *updatestr = NULL;
	int width = 0, height = 0, text_lead = 0;

	count = config_setting_length(list);

	pr_info("%s: Parsing %d images\n", db->name, count);
	db->images = calloc(sizeof(*db->images), count + 1);

	for (i = 0; i < count; i++) {
		image = config_setting_get_elem(list, i);
		db->images[i] = calloc(sizeof(*db->images[i]), 1);

		config_setting_lookup_string(image, "database", &database);
		config_setting_lookup_int(image, "text_lead", &text_lead);

		/*
		 * The config_setting_lookup_* functions will leave
		 * the destination unchanged in case requested value
		 * is not found. If that is the case, the value from
		 * previous image group is used. That makes it
		 * possible for the user to only define once all
		 * fields and then leave identical fields unset on the
		 * following groups, making it easier to define many
		 * almost identical images.
		 */

		config_setting_lookup_string(image, "filename", &filename);
		if (!filename) {
			pr_err("Database %s does not have \"filename\" entry "
				" in image data\n",
				db->name);
			return -1;
		}

		config_setting_lookup_int(image, "width", &width);
		if (!width) {
			pr_err("Database %s does not have \"width\" entry "
				" in image data\n",
				db->name);
			return -1;
		}

		config_setting_lookup_int(image, "height", &height);
		if (!height) {
			pr_err("Database %s does not have \"height\" entry "
				" in image data\n",
				db->name);
			return -1;
		}

		config_setting_lookup_string(image, "timestart", &timestart);
		if (!timestart) {
			pr_err("Database %s does not have \"timestart\" entry "
				" in image data\n",
				db->name);
			return -1;
		}

		config_setting_lookup_string(image, "timeend", &timeend);
		if (!timeend) {
			pr_err("Database %s does not have \"timeend\" entry "
				" in image data\n",
				db->name);
			return -1;
		}

		config_setting_lookup_string(image, "imageformat",
					&imageformat);
		if (!imageformat) {
			pr_err("Database %s does not have \"imageformat\" "\
				"entry in image data\n",
				db->name);
			return -1;
		}

		config_setting_lookup_string(image, "update_string",
					&updatestr);

		str_list = config_setting_get_member(image, "options");
		if (str_list)
			read_strings_from_list(str_list, &options);

		str_list = config_setting_get_member(image, "text");
		if (str_list)
			read_strings_from_list(str_list, &text);

		db->images[i]->rrd_database	=
			database ? strdup(database) : NULL;
		db->images[i]->image_filename	= strdup(filename);
		db->images[i]->width		= width;
		db->images[i]->height		= height;
		strncpy(db->images[i]->timestart, timestart,
			sizeof(db->images[i]->timestart) - 1);
		strncpy(db->images[i]->timeend, timeend,
			sizeof(db->images[i]->timeend) - 1);
		strncpy(db->images[i]->imageformat, imageformat,
			sizeof(db->images[i]->imageformat) - 1);
		db->images[i]->options		= options;
		db->images[i]->text_lead	= text_lead;
		db->images[i]->text		= text;

		if (updatestr)
			db->images[i]->updatestr = strdup(updatestr);
	}

	return 0;
}

static int parse_data_sources(config_setting_t *rrd, struct rrd_database *db)
{
	config_setting_t *list, *group;
	int i, count;
	const char *type = NULL, *name = NULL;
	int heartbeat = 0;
	double min = 0;
	double max = 0;

	list = config_setting_get_member(rrd, "sources");
	if (!list) {
		pr_info("No data sources\n");
		return 0;
	}

	if (!config_setting_is_list(list)) {
		pr_err("Data sources have no list\n");
		return 0;
	}

	count = config_setting_length(list);
	db->sources = calloc(sizeof(*db->sources), count + 1);

	for (i = 0; i < count; i++) {
		group = config_setting_get_elem(list, i);

		config_setting_lookup_string(group, "type", &type);
		config_setting_lookup_string(group, "name", &name);
		config_setting_lookup_float(group, "min", &min);
		config_setting_lookup_float(group, "max", &max);
		config_setting_lookup_int(group, "heartbeat", &heartbeat);

		db->sources[i].type = strdup(type);
		db->sources[i].name = strdup(name);
		db->sources[i].heartbeat = heartbeat;
		db->sources[i].min = min;
		db->sources[i].max = max;
	}

	return 0;
}

static int parse_archives(config_setting_t *rrd, struct rrd_database *db)
{
	config_setting_t *list, *group;
	int i, count;
	const char *type = NULL;
	double xff = 0;
	int steps = 0;
	int rows = 0;

	list = config_setting_get_member(rrd, "archives");
	if (!list) {
		pr_info("No archive found\n");
		return 0;
	}

	if (!config_setting_is_list(list)) {
		pr_err("Archive does not contain a list\n");
		return 0;
	}

	count = config_setting_length(list);
	db->archives = calloc(sizeof(*db->archives), count + 1);

	for (i = 0; i < count; i++) {
		group = config_setting_get_elem(list, i);

		config_setting_lookup_string(group, "type", &type);
		config_setting_lookup_float(group, "xff", &xff);
		config_setting_lookup_int(group, "steps", &steps);
		config_setting_lookup_int(group, "rows", &rows);

		db->archives[i].type = strdup(type);
		db->archives[i].xff = xff;
		db->archives[i].steps = steps;
		db->archives[i].rows = rows;
	}

	return 0;
}

static int parse_database(config_setting_t *rrd, struct rrd_database *db)
{
	config_setting_t *list, *str_list;
	const char *name, *parser = NULL, *filename, **parser_data;
	const char **pre_draw_cmd;
	const char **post_draw_cmd;
	const char *logfile = NULL, *logfile_timestamp_fmt = NULL;

	if (!config_setting_lookup_string(rrd, "name", &name)) {
		pr_err("Database entry does not contain name\n");
		return -1;
	}

	pr_info("parsing database %s\n", name);
	db->name = strdup(name);

	if (!config_setting_lookup_string(rrd, "filename", &filename))
		pr_err("Database %s does not contain filename\n", db->name);

	db->filename = strdup(filename);

	if (!config_setting_lookup_int(rrd, "interval", &db->interval)) {
		pr_err("Database %s does not have interval set\n", name);
		return -1;
	}

	/* Parser is not a mandatory parameter */
	config_setting_lookup_string(rrd, "parser", &parser);
	db->parser = str_to_parser(parser);

	list = config_setting_get_member(rrd, "image");
	parse_images(list, db);
	parse_data_sources(rrd, db);
	parse_archives(rrd, db);

	str_list = config_setting_get_member(rrd, "parser_data");
	if (str_list) {
		read_strings_from_list(str_list, &parser_data);
		db->parser_data = parser_data;
	}

	str_list = config_setting_get_member(rrd, "pre_draw_cmd");
	if (str_list) {
		read_strings_from_list(str_list, &pre_draw_cmd);
		db->pre_draw_cmd = (char *const *)pre_draw_cmd;
	}

	str_list = config_setting_get_member(rrd, "post_draw_cmd");
	if (str_list) {
		read_strings_from_list(str_list, &post_draw_cmd);
		db->post_draw_cmd = (char *const *)post_draw_cmd;
	}

	config_setting_lookup_string(rrd, "logfile", &logfile);
	if (logfile)
		db->logfile = strdup(logfile);

	config_setting_lookup_string(rrd, "logfile_timestamp_fmt",
				&logfile_timestamp_fmt);
	if (logfile_timestamp_fmt)
		db->logfile_timestamp_fmt = strdup(logfile_timestamp_fmt);


	return 0;
}

struct rrd_database **populate_database(const char *conffile)
{
	struct rrd_database **rrd_db = NULL;
	config_t config;
	config_setting_t *rrd_database;
	int i, count;

	config_init(&config);

	if (!config_read_file(&config, conffile)) {
		pr_err("%s:%d - %s\n", config_error_file(&config),
			config_error_line(&config),
			config_error_text(&config));
		goto out;
	}

	rrd_database = config_lookup(&config, "rrd_database");
	count = config_setting_length(rrd_database);

	/*
	 * Allocate one element extra. The last one is zeroed out to
	 * indicate the end of the db list
	 */
	rrd_db = calloc(count + 1, sizeof(*rrd_db));

	pr_info("There are %d database entries\n", count);

	for (i = 0; i < count; i++) {
		config_setting_t *rrd;
		rrd_db[i] = calloc(1, sizeof(*rrd_db[i]));
		rrd = config_setting_get_elem(rrd_database, i);
		parse_database(rrd, rrd_db[i]);
	}

out:
	config_destroy(&config);
	return rrd_db;
}