/*
 * telzozn.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-15 - created
 *
 */

/* $Platon$ */

#include <stdio.h>
#include <string.h>
#include <platon/compress/lz-rle.h>
#include <db.h>

#include "shared.h"

int sys_key_print(DB *dbp, char *sys_key, char *label);

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

	DB *dbp;
	DBT key, data, data_struct;
	DBC *dbc;
	int db_ret;

	/*
	 * Command line arguments check
	 */
	if (argc < 2) {
		printf("Usage: %s <GSM-number>\n", argv[0]);
		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_RDONLY, 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));
	memset(&data, 0, sizeof(data_struct));

	normalize_number(argv[1]);
	if (strlen(argv[1]) != 9) {
		fprintf(stderr, "%s: invalid number: %s\n", argv[0], argv[1]);
		return 2;
	}

#if 0
	key.data = "";
	key.size = 0;
#else
	key.data = argv[1];
	key.size = strlen(argv[1]);
#endif
	xor_memory(key.data, key.size);

	if ((db_ret = dbp->cursor(dbp, NULL, &dbc, 0)) != 0) {
		dbp->err(dbp, db_ret, "DB->cursor");
		return 1;
	}

	if ((db_ret = dbc->c_get(dbc, &key, &data, DB_SET)) == 0) {
		for (cnt = 1; ; cnt++) {
			if (cnt > 1)
				putchar('\n');
			printf("%14s: %d\n", "RESULT_NO", cnt);
			buflen = uncompress_lz_rle(
					(unsigned char *) data.data,
					(unsigned char *) buf,
					data.size);
			xor_memory(buf, buflen);

			type = ((char *) buf)[0];

			/*
			 * Table name retrieval
			 */

			snprintf(sys_key, MAX_SYS_KEY_SIZE, "name%c", type);
			if (sys_key_print(dbp, sys_key, "DATABASE_NAME") < 0)
				return 1;

			/*
			 * Index name retrieval
			 */

			snprintf(sys_key, MAX_SYS_KEY_SIZE, "key-%c", type);
			if (sys_key_print(dbp, sys_key, "TABLE_INDEX") < 0)
				return 1;

			/*
			 * Query text retrieval
			 */

			snprintf(sys_key, MAX_SYS_KEY_SIZE, "qry-%c", type);
			if (sys_key_print(dbp, sys_key, "IMPORT_QUERY") < 0)
				return 1;

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

			snprintf(sys_key, MAX_SYS_KEY_SIZE, "cols%c", type);
			key.data = sys_key;
			key.size = MAX_SYS_KEY_SIZE;

			if ((db_ret = dbp->get(dbp, NULL, &key, &data_struct, 0)) != 0) {
				dbp->err(dbp, db_ret, "DB->get [struct]");
				return 1;
			}

			/*
			 * Data printout
			 */

			for (i = 1, j = 0; i < buflen; ) {
				if (j < data_struct.size) {
					printf("%14s: ", (char *) data_struct.data + j);
					j += strlen((char *) data_struct.data + j);
					j++;
				} else {
					printf("%14s: ", "?");
				}
				puts(buf + i);
				i += strlen(buf + i);
				i++;
			}

			/*
			 * Next record fetch
			 */

			if ((db_ret = dbc->c_get(dbc, &key, &data, DB_NEXT_DUP)) != 0) {
				if (db_ret == DB_NOTFOUND)
					break;
				dbp->err(dbp, db_ret, "DB->c_get [DB_NEXT_DUP]");
				return 1;
			}

		}
	}

	dbp->close(dbp, 0);

	return 0;
} /* }}} */

int sys_key_print(DB *dbp, char *sys_key, char *label) /* {{{ */
{
	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;

	if ((db_ret = dbp->get(dbp, NULL, &key, &data, 0)) != 0) {
		dbp->err(dbp, db_ret, "DB->get");
		return -1;
	}

	printf("%14s: %s\n", label, (char *) data.data);

	return 0;
} /* }}} */

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