/*
 * db-replication.c
 *
 * Developed by Ondrej Jombik <nepto@platon.sk>
 * Copyright (c) 2004 Platon SDG, http://platon.sk/
 * Licensed under terms of GNU General Public License.
 * All rights reserved.
 *
 * Changelog:
 * 2004-05-09 - created
 *
 */

/* $Platon$ */

#include <sys/types.h>
#include <stdio.h>
#include <string.h>
#include <platon/str/strplus.h>
#include <platon/compress/rle.h>
#include <platon/compress/lz-rle.h>
#include <mysql/mysql.h>
#include <db.h>

#include "shared.h"

int sys_key_store(DB *dbp, char *sys_key, char *value, int size);

struct
{
	char *name;
	char *index;
	char *query;
} tel_zozn_queries[] =
{
	/* name, primary key, query */
	/* Example: {"TYP", "CISLO", "SELECT * FROM tabulka"} */
	#include "queries.txt"
	{NULL, NULL, NULL}
};

int main(int argc, char **argv) /* {{{ */
{
	unsigned char type;
	register int i, index_idx, buflen;
	unsigned int num_fields;
	char buf[BUFSIZE], buf2[BUFSIZE], sys_key[MAX_SYS_KEY_SIZE];

	MYSQL mysql;
	MYSQL_RES *mysql_res;
	MYSQL_FIELD *mysql_field;
	MYSQL_ROW mysql_row;
	register unsigned long *mysql_len;

	DB *dbp;
	DBT key, data;
	int db_ret;

	/*
	 * MySQL initialization
	 */

	if (mysql_init(&mysql) == NULL) {
		fprintf(stderr, "%s: cannot create MySQL handle\n", argv[0]);
		return 1;
	}

	if (mysql_real_connect(&mysql,
				DB_HOST, DB_USER, DB_PASS, DB_NAME, 0, NULL, 0) == NULL) {
		fprintf(stderr, "%s: cannot connect to database:\n  %s\n",
				argv[0], mysql_error(&mysql));
		return 1;
	}

	/*
	 * Berkeley DB initialization
	 */

	if ((db_ret = db_create(&dbp, NULL, 0)) != 0) {
		fprintf(stderr, "%s: db_create: %s\n", argv[0], db_strerror(db_ret));
		return 1;
	}

	if ((db_ret = dbp->set_flags(dbp, DB_DUP)) != 0
			|| (db_ret = dbp->open(dbp, NULL, DB_FILE, NULL,
					DB_BTREE, DB_CREATE|DB_TRUNCATE, 0664)) != 0) {
		dbp->err(dbp, db_ret, "%s: %s", argv[0], DB_FILE);
		return 1;
	}

	memset(&key,  0, sizeof(key));
	memset(&data, 0, sizeof(data));

	for (type = 0; tel_zozn_queries[type].query != NULL; type++) {

		printf("[%02d] %s\n     Query: %s\n     Key: %s\n", type + 1,
				tel_zozn_queries[type].name,
				tel_zozn_queries[type].query,
				tel_zozn_queries[type].index);

		if (mysql_query(&mysql, tel_zozn_queries[type].query)) {
			fprintf(stderr, "%s: error executing query:\n  %s\n",
					argv[0], mysql_error(&mysql));
			return 1;
		}

		if ((mysql_res = mysql_store_result(&mysql)) == 0) {
			fprintf(stderr, "%s: error storing result:\n  %s\n",
					argv[0], mysql_error(&mysql));
			return 1;
		}
		num_fields = mysql_num_fields(mysql_res);
		printf("     Column count: %u\n     Columns: ", num_fields);
		mysql_field = mysql_fetch_fields(mysql_res);
		for (index_idx = -1, buflen = 0, i = 0; i < num_fields; i++) {
			if (i > 0)
				fputs("|", stdout);
			fputs(mysql_field[i].name, stdout);
			if (! strcasecmp(tel_zozn_queries[type].index, mysql_field[i].name)) {
				index_idx = i;
				fputs("[*]", stdout);
			}
			memcpy((void *) (buf + buflen), mysql_field[i].name, strlen(mysql_field[i].name));
			buflen += strlen(mysql_field[i].name);
			buf[buflen] = '\0';
			buflen++;
		}
		puts("");
		if (index_idx < 0) {
			fprintf(stderr, "%s: cannot find key index\n", argv[0]);
			return 1;
		}
		printf("     Key index: %u\n", index_idx);

		/*
		 * Table name storage
		 */

		snprintf(sys_key, MAX_SYS_KEY_SIZE, "name%c", type);
		if (sys_key_store(dbp, sys_key, tel_zozn_queries[type].name, -1) < 0)
			return 1;

		/*
		 * Index name storage
		 */

		snprintf(sys_key, MAX_SYS_KEY_SIZE, "key-%c", type);
		if (sys_key_store(dbp, sys_key, tel_zozn_queries[type].index, -1) < 0)
			return 1;

		/*
		 * Query text storage
		 */

		snprintf(sys_key, MAX_SYS_KEY_SIZE, "qry-%c", type);
		if (sys_key_store(dbp, sys_key, tel_zozn_queries[type].query, -1) < 0)
			return 1;

		/*
		 * Table structure (column names) storage
		 */

		snprintf(sys_key, MAX_SYS_KEY_SIZE, "cols%c", type);
		if (sys_key_store(dbp, sys_key, buf, buflen) < 0)
			return 1;

		/*
		 * Data storage
		 */

		while ((mysql_row = mysql_fetch_row(mysql_res))) {
			mysql_len = mysql_fetch_lengths(mysql_res);
			buf[0] = type;
			for (buflen = 1, i = 0; i < num_fields; i++) {
				if (buflen + mysql_len[i] + 1 > BUFSIZE) {
					fprintf(stderr, "%s: WARNING: buffer overflow, skipping\n", argv[0]);
					continue;
				}
				nul_to_spaces(mysql_row[i], mysql_len[i]);
				memcpy((void *) (buf + buflen), mysql_row[i], mysql_len[i]);
				buflen += mysql_len[i];
				buf[buflen] = '\0';
				buflen++;
			}

			xor_memory(buf, buflen);
			buflen = compress_lz_rle(
					(unsigned char *) buf,
					(unsigned char *) buf2,
					buflen);
			data.data = buf2;
			data.size = buflen;

			if (mysql_row[index_idx] == NULL) {
				fprintf(stderr, "%s: index is NULL\n", argv[0]);
				return 1;
			}
			normalize_number(mysql_row[index_idx]);
			key.data = mysql_row[index_idx];
			key.size = strlen(mysql_row[index_idx]);
			if (key.size != 9) {
				fprintf(stderr, "%s: WARNING: key.size != 9 for '%s'\n",
						argv[0], (char *) key.data);
			}

			xor_memory(key.data, key.size);
			if ((db_ret = dbp->put(dbp, NULL, &key, &data, 0)) != 0) {
				dbp->err(dbp, db_ret, "DB->put");
				return 1;
			}
		}
		mysql_free_result(mysql_res);
	}

	dbp->close(dbp, 0);
	mysql_close(&mysql);
	return 0;
} /* }}} */

int sys_key_store(DB *dbp, char *sys_key, char *value, int size) /* {{{ */
{
	DBT key, data;
	int db_ret;

	memset(&key,  0, sizeof(key));
	memset(&data, 0, sizeof(data));

	key.data  = sys_key;
	key.size  = MAX_SYS_KEY_SIZE;
	data.data = value;
	data.size = size < 0 ? strlen(value) + 1 : size;
	if ((db_ret = dbp->put(dbp, NULL, &key, &data, 0)) != 0) {
		dbp->err(dbp, db_ret, "DB->put");
		return -1;
	}

	return 0;
} /* }}} */

/* Modeline for ViM {{{
 * vim: set ts=4:
 * vim600: fdm=marker fdl=0 fdc=3:
 * }}} */