/********************************************************************\
 * qofquery-serialize.c -- Convert QofQuery to XML                  *
 * Copyright (C) 2001,2002,2004 Linas Vepstas <linas@linas.org>     *
 *                                                                  *
 * This program is free software; you can redistribute it and/or    *
 * modify it under the terms of the GNU General Public License as   *
 * published by the Free Software Foundation; either version 2 of   *
 * the License, or (at your option) any later version.              *
 *                                                                  *
 * This program is distributed in the hope that it will be useful,  *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of   *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the    *
 * GNU General Public License for more details.                     *
 *                                                                  *
 * You should have received a copy of the GNU General Public License*
 * along with this program; if not, contact:                        *
 *                                                                  *
 * Free Software Foundation           Voice:  +1-617-542-5942       *
 * 51 Franklin Street, Fifth Floor    Fax:    +1-617-542-2652       *
 * Boston, MA  02110-1301,  USA       gnu@gnu.org                   *
 *                                                                  *
\********************************************************************/

#include "config.h"

#include "qofquery-serialize.h"
#include "qofquery-p.h"
#include "qofquerycore-p.h"
#include "kvp_frame.h"

/* NOTE: Development of this idea has ceased and this file is
no longer included in the QOF library. It remains in CVS for now.*/

/* ======================================================= */

#define PUT_STR(TOK,VAL) {                           \
   xmlNodePtr node;                                  \
   const char * str = (VAL);                         \
   if (str && 0 != str[0])                           \
   {                                                 \
      node = xmlNewNode (NULL, TOK);                 \
      xmlNodeAddContent(node, str);                  \
      xmlAddChild (topnode, node);                   \
   }                                                 \
}

#define PUT_INT32(TOK,VAL) {                         \
   xmlNodePtr node;                                  \
   char buff[80];                                    \
   g_snprintf (buff, sizeof(buff), "%d", (VAL));     \
   node = xmlNewNode (NULL, TOK);                    \
   xmlNodeAddContent(node, buff);                    \
   xmlAddChild (topnode, node);                      \
}

#define PUT_INT64(TOK,VAL) {                         \
   xmlNodePtr node;                                  \
   char buff[80];                                    \
   g_snprintf (buff, sizeof(buff), "%" G_GINT64_FORMAT, (VAL));   \
   node = xmlNewNode (NULL, TOK);                    \
   xmlNodeAddContent(node, buff);                    \
   xmlAddChild (topnode, node);                      \
}

#define PUT_DBL(TOK,VAL) {                           \
   xmlNodePtr node;                                  \
   char buff[80];                                    \
   g_snprintf (buff, sizeof(buff), "%.18g", (VAL));  \
   node = xmlNewNode (NULL, TOK);                    \
   xmlNodeAddContent(node, buff);                    \
   xmlAddChild (topnode, node);                      \
}

#define PUT_GUID(TOK,VAL) {                          \
   xmlNodePtr node;                                  \
   char buff[80];                                    \
   guid_to_string_buff ((VAL), buff);                \
   node = xmlNewNode (NULL, TOK);                    \
   xmlNodeAddContent(node, buff);                    \
   xmlAddChild (topnode, node);                      \
}

#define PUT_DATE(TOK,VAL) {                          \
   xmlNodePtr node;                                  \
   char buff[80];                                    \
   gnc_timespec_to_iso8601_buff ((VAL), buff);       \
   node = xmlNewNode (NULL, TOK);                    \
   xmlNodeAddContent(node, buff);                    \
   xmlAddChild (topnode, node);                      \
}

#define PUT_NUMERIC(TOK,VAL) {                       \
   xmlNodePtr node;                                  \
   char *str;                                        \
   str = gnc_numeric_to_string (VAL);                \
   node = xmlNewNode (NULL, TOK);                    \
   xmlNodeAddContent(node, str);                     \
   g_free (str);                                     \
   xmlAddChild (topnode, node);                      \
}

#define PUT_BOOL(TOK,VAL) {                          \
   xmlNodePtr node;                                  \
   gboolean boll = (VAL);                            \
   node = xmlNewNode (NULL, TOK);                    \
   if (boll) {                                       \
      xmlNodeAddContent(node, "T");                  \
   } else {                                          \
      xmlNodeAddContent(node, "F");                  \
   }                                                 \
   xmlAddChild (topnode, node);                      \
}

#define PUT_HOW(TOK,VAL,A,B,C,D,E,F) {               \
   xmlNodePtr node;                                  \
   const char * str = "EQUAL";                       \
   switch (VAL)                                      \
   {                                                 \
      case QOF_COMPARE_##A: str = #A; break;         \
      case QOF_COMPARE_##B: str = #B; break;         \
      case QOF_COMPARE_##C: str = #C; break;         \
      case QOF_COMPARE_##D: str = #D; break;         \
      case QOF_COMPARE_##E: str = #E; break;         \
      case QOF_COMPARE_##F: str = #F; break;         \
   }                                                 \
   node = xmlNewNode (NULL, TOK);                    \
   xmlNodeAddContent(node, str);                     \
   xmlAddChild (topnode, node);                      \
}

#define PUT_MATCH2(TOK,VAL,PFX,A,B) {                \
   xmlNodePtr node;                                  \
   const char * str = #A;                            \
   switch (VAL)                                      \
   {                                                 \
      case QOF_##PFX##_##A: str = #A; break;         \
      case QOF_##PFX##_##B: str = #B; break;         \
   }                                                 \
   node = xmlNewNode (NULL, TOK);                    \
   xmlNodeAddContent(node, str);                     \
   xmlAddChild (topnode, node);                      \
}

#define PUT_MATCH3(TOK,VAL,PFX,A,B,C) {              \
   xmlNodePtr node;                                  \
   const char * str = #A;                            \
   switch (VAL)                                      \
   {                                                 \
      case QOF_##PFX##_##A: str = #A; break;         \
      case QOF_##PFX##_##B: str = #B; break;         \
      case QOF_##PFX##_##C: str = #C; break;         \
   }                                                 \
   node = xmlNewNode (NULL, TOK);                    \
   xmlNodeAddContent(node, str);                     \
   xmlAddChild (topnode, node);                      \
}

#define PUT_MATCH5(TOK,VAL,PFX,A,B,C,D,E) {          \
   xmlNodePtr node;                                  \
   const char * str = #A;                            \
   switch (VAL)                                      \
   {                                                 \
      case QOF_##PFX##_##A: str = #A; break;         \
      case QOF_##PFX##_##B: str = #B; break;         \
      case QOF_##PFX##_##C: str = #C; break;         \
      case QOF_##PFX##_##D: str = #D; break;         \
      case QOF_##PFX##_##E: str = #E; break;         \
   }                                                 \
   node = xmlNewNode (NULL, TOK);                    \
   xmlNodeAddContent(node, str);                     \
   xmlAddChild (topnode, node);                      \
}

/* ======================================================= */

static void
qof_kvp_value_to_xml (KvpValue *kval, xmlNodePtr topnode)
{
	KvpValueType kvt = kvp_value_get_type (kval);

	switch (kvt)
	{
		case KVP_TYPE_GINT64:
			PUT_INT64 ("qofquery:int64", kvp_value_get_gint64(kval));
			break;
		case KVP_TYPE_DOUBLE:
			PUT_DBL ("qofquery:double", kvp_value_get_double(kval));
			break;
		case KVP_TYPE_NUMERIC:
			PUT_NUMERIC ("qofquery:numeric", kvp_value_get_numeric(kval));
			break;
		case KVP_TYPE_GUID:
			PUT_GUID ("qofquery:guid", kvp_value_get_guid(kval));
			break;
		case KVP_TYPE_STRING:
			PUT_STR ("qofquery:string", kvp_value_get_string(kval));
			break;
		case KVP_TYPE_TIMESPEC:
			PUT_DATE ("qofquery:date", kvp_value_get_timespec(kval));
			break;
		case KVP_TYPE_BINARY:
		case KVP_TYPE_GLIST:
		case KVP_TYPE_FRAME:
			// XXX don't know how to support these.
			break;
	}
}

/* ======================================================= */

static xmlNodePtr
qof_query_pred_data_to_xml (QofQueryPredData *pd)
{
	GList *n;
	GSList *ns;
	xmlNodePtr topnode;
	query_guid_t pdata_g;
	query_string_t pdata_s;
	query_numeric_t pdata_n;
	query_kvp_t pdata_k;
	query_date_t pdata_d;
	query_int64_t pdata_i64;
	query_int32_t pdata_i32;
	query_double_t pdata_db;
	query_boolean_t pdata_bool;
	query_char_t pdata_c;
	
	if (!safe_strcmp (pd->type_name, QOF_TYPE_GUID))
	{
		topnode = xmlNewNode (NULL, "qofquery:pred-guid");
		/* GUID Predicate doesn't do a PUT_HOW */

		pdata_g = (query_guid_t) pd;
		PUT_MATCH5("qofquery:guid-match", pdata_g->options, 
		                GUID_MATCH, ANY, ALL, NONE, NULL, LIST_ANY);

		for (n = pdata_g->guids; n; n = n->next)
		{
			PUT_GUID ("qofquery:guid", n->data);
		}
		return topnode;
	}
	if (!safe_strcmp (pd->type_name, QOF_TYPE_STRING))
	{
		topnode = xmlNewNode (NULL, "qofquery:pred-string");
		PUT_HOW ("qofquery:compare", pd->how, LT, LTE, EQUAL, GT, GTE, NEQ);

		pdata_s = (query_string_t) pd;
		PUT_MATCH2("qofquery:string-match", pdata_s->options,
                       STRING_MATCH, NORMAL, CASEINSENSITIVE);
		PUT_BOOL ("qofquery:is-regex", pdata_s->is_regex);
		PUT_STR ("qofquery:string", pdata_s->matchstring);
		return topnode;
	}
	if (!safe_strcmp (pd->type_name, QOF_TYPE_NUMERIC))
	{
		topnode = xmlNewNode (NULL, "qofquery:pred-numeric");
		PUT_HOW ("qofquery:compare", pd->how, LT, LTE, EQUAL, GT, GTE, NEQ);

		pdata_n = (query_numeric_t) pd;
		PUT_MATCH3("qofquery:numeric-match", pdata_n->options,
		                 NUMERIC_MATCH, DEBIT, CREDIT, ANY);
		
		PUT_NUMERIC ("qofquery:numeric", pdata_n->amount);
		return topnode;
	}
	if (!safe_strcmp (pd->type_name, QOF_TYPE_KVP))
	{
		topnode = xmlNewNode (NULL, "qofquery:pred-kvp");
		PUT_HOW ("qofquery:compare", pd->how, LT, LTE, EQUAL, GT, GTE, NEQ);

		pdata_k = (query_kvp_t) pd;
		for (ns=pdata_k->path; ns; ns=ns->next)
		{
			PUT_STR ("qofquery:kvp-path", ns->data);
		}
		qof_kvp_value_to_xml (pdata_k->value, topnode);
		return topnode;
	}
	if (!safe_strcmp (pd->type_name, QOF_TYPE_DATE))
	{
		topnode = xmlNewNode (NULL, "qofquery:pred-date");
		PUT_HOW ("qofquery:compare", pd->how, LT, LTE, EQUAL, GT, GTE, NEQ);

		pdata_d = (query_date_t) pd;
		
		PUT_MATCH2("qofquery:date-match", pdata_d->options,
		                 DATE_MATCH, NORMAL, DAY);

		PUT_DATE ("qofquery:date", pdata_d->date);
		return topnode;
	}
	if (!safe_strcmp (pd->type_name, QOF_TYPE_INT64))
	{
		topnode = xmlNewNode (NULL, "qofquery:pred-int64");
		PUT_HOW ("qofquery:compare", pd->how, LT, LTE, EQUAL, GT, GTE, NEQ);

		pdata_i64 = (query_int64_t) pd;
		PUT_INT64 ("qofquery:int64", pdata_i64->val);
		return topnode;
	}
	if (!safe_strcmp (pd->type_name, QOF_TYPE_INT32))
	{
		topnode = xmlNewNode (NULL, "qofquery:pred-int32");
		PUT_HOW ("qofquery:compare", pd->how, LT, LTE, EQUAL, GT, GTE, NEQ);

		pdata_i32 = (query_int32_t) pd;
		
		PUT_INT32 ("qofquery:int32", pdata_i32->val);
		return topnode;
	}
	if (!safe_strcmp (pd->type_name, QOF_TYPE_DOUBLE))
	{
		topnode = xmlNewNode (NULL, "qofquery:pred-double");
		PUT_HOW ("qofquery:compare", pd->how, LT, LTE, EQUAL, GT, GTE, NEQ);

		pdata_db = (query_double_t) pd;
		
		PUT_DBL ("qofquery:double", pdata_db->val);
		return topnode;
	}
	if (!safe_strcmp (pd->type_name, QOF_TYPE_BOOLEAN))
	{
		topnode = xmlNewNode (NULL, "qofquery:pred-boolean");
		PUT_HOW ("qofquery:compare", pd->how, LT, LTE, EQUAL, GT, GTE, NEQ);

		pdata_bool = (query_boolean_t) pd;
		
		PUT_BOOL ("qofquery:boolean", pdata_bool->val);
		return topnode;
	}
	if (!safe_strcmp (pd->type_name, QOF_TYPE_CHAR))
	{
		topnode = xmlNewNode (NULL, "qofquery:pred-char");
		/* There is no PUT_HOW for char-match */
		pdata_c = (query_char_t) pd;
		
		PUT_MATCH2("qofquery:char-match", pdata_c->options,
		                 CHAR_MATCH, ANY, NONE);
		
		PUT_STR ("qofquery:char-list", pdata_c->char_list);
		return topnode;
	}
	return NULL;
}

/* ======================================================= */

static xmlNodePtr
qof_query_param_path_to_xml (GSList *param_path)
{
	xmlNodePtr topnode;
	GSList *n;
	QofIdTypeConst path;
	
	n = param_path;
	topnode = xmlNewNode (NULL, "qofquery:param-path");
	for ( ; n; n=n->next)
	{
		path = n->data;
		if (!path) continue;
		PUT_STR ("qofquery:param", path);
	}
	return topnode;
}

/* ======================================================= */

static xmlNodePtr
qof_query_one_term_to_xml (QofQueryTerm *qt)
{
	xmlNodePtr node;
	xmlNodePtr term;
	xmlNodePtr topnode;
	gboolean invert;
	GSList *path;
	QofQueryPredData *pd;

	invert = qof_query_term_is_inverted (qt);
	term = xmlNewNode (NULL, "qofquery:term");
	topnode = term;
	path = qof_query_term_get_param_path (qt);
	pd = qof_query_term_get_pred_data (qt);
	if (invert)
	{
		/* inverter becomes new top mode */
		topnode = xmlNewNode (NULL, "qofquery:invert");
		xmlAddChild (term, topnode);
	}

	node = qof_query_param_path_to_xml (path);
	if (node) xmlAddChild (topnode, node);

	node = qof_query_pred_data_to_xml (pd);
	if (node) xmlAddChild (topnode, node);

	return term;
}

/* ======================================================= */

static xmlNodePtr
qof_query_and_terms_to_xml (GList *and_terms)
{
	xmlNodePtr terms;
	GList *n;
	QofQueryTerm *qt;
	xmlNodePtr t;
	
	terms = xmlNewNode (NULL, "qofquery:and-terms");
	n = and_terms;
	for ( ; n; n=n->next)
	{
		qt = n->data;
		if (!qt) continue;

		t = qof_query_one_term_to_xml (n->data);
		if (t) xmlAddChild (terms, t);
	}
	return terms;
}

/* ======================================================= */

static xmlNodePtr
qof_query_terms_to_xml (QofQuery *q)
{
	xmlNodePtr terms;
	GList *n;
	xmlNodePtr andt;
	
	terms = NULL;
	n = qof_query_get_terms (q);
	if (!n) return NULL;
	terms = xmlNewNode (NULL, "qofquery:or-terms");

	for ( ; n; n=n->next)
	{
		andt = qof_query_and_terms_to_xml (n->data);
		if (andt) xmlAddChild (terms, andt);
	}
	return terms;
}

/* ======================================================= */

static xmlNodePtr
qof_query_sorts_to_xml (QofQuery *q)
{
	QofQuerySort *s[3];
	xmlNodePtr sortlist;
	GSList *plist;
	xmlNodePtr sort;
	xmlNodePtr topnode;
	gboolean increasing;
	gint opt;
	xmlNodePtr pl;
	int i;
	
	qof_query_get_sorts (q, &s[0], &s[1], &s[2]);

	if (NULL == s[0]) return NULL;

	sortlist = xmlNewNode (NULL, "qofquery:sort-list");
	for (i=0; i<3; i++)
	{
		if (NULL == s[i]) continue;

		plist = qof_query_sort_get_param_path (s[i]);
		if (!plist) continue;

		sort = xmlNewNode (NULL, "qofquery:sort");
		xmlAddChild (sortlist, sort);

		topnode = sort;

		increasing = qof_query_sort_get_increasing (s[i]);
		PUT_STR ("qofquery:order", increasing ? "DESCENDING" : "ASCENDING");

		opt = qof_query_sort_get_sort_options (s[i]);
		PUT_INT32 ("qofquery:options", opt);

		pl = qof_query_param_path_to_xml (plist);
		if (pl) xmlAddChild (sort, pl);
	}

	return sortlist;
}

/* ======================================================= */

static void
do_qof_query_to_xml (QofQuery *q, xmlNodePtr topnode)
{
	QofIdType search_for;
	xmlNodePtr terms;
	xmlNodePtr sorts;
	gint max_results;
	
	search_for = qof_query_get_search_for (q);
	PUT_STR ("qofquery:search-for", search_for);

	terms = qof_query_terms_to_xml(q);
	if (terms) xmlAddChild (topnode, terms);

	sorts = qof_query_sorts_to_xml (q);
	if (sorts) xmlAddChild (topnode, sorts);

	max_results = qof_query_get_max_results (q);
	PUT_INT32 ("qofquery:max-results", max_results);
}

/* ======================================================= */

xmlNodePtr
qof_query_to_xml (QofQuery *q)
{
	xmlNodePtr topnode;
	xmlNodePtr node;
	xmlNsPtr   ns;

	topnode = xmlNewNode(NULL, "qof:qofquery");
	xmlSetProp(topnode, "version", "1.0.1");

	// XXX path to DTD is wrong
	// ns = xmlNewNs (topnode, "file:" "/usr/share/lib" "/qofquery.dtd", "qof");

	do_qof_query_to_xml (q, topnode);

	return topnode;
}

/* =============================================================== */

#ifdef UNIT_TEST

#include <stdio.h>
#include <qof/qofsql.h>

int main (int argc, char * argv[])
{
	QofQuery *q;
	QofSqlQuery *sq;
	xmlDocPtr doc;
	xmlNodePtr topnode;
	xmlChar *xbuf;
	int bufsz;
	xmlOutputBufferPtr xbuf;
	
	qof_query_init();
	qof_object_initialize ();

	static QofParam params[] = {
		{ "adate",  QOF_TYPE_DATE, NULL, NULL},
		{ "aint",   QOF_TYPE_INT32, NULL, NULL},
		{ "aint64", QOF_TYPE_INT64, NULL, NULL},
		{ "astr",   QOF_TYPE_STRING, NULL, NULL},
		{ NULL },
	};

	qof_class_register ("GncABC", NULL, params);
	sq = qof_sql_query_new();

	qof_sql_query_parse (sq, 
	    "SELECT * from GncABC WHERE aint = 123 "
	    "or not astr=\'asdf\' "
	    "and aint64 = 9876123456789;");
	// qof_sql_query_parse (sq, "SELECT * from GncABC;");
	q = qof_sql_query_get_query (sq);

	qof_query_print (q);

	doc = doc = xmlNewDoc("1.0");
	topnode = qof_query_to_xml (q);
	xmlDocSetRootElement(doc,topnode);

	xmlDocDumpFormatMemory (doc, &xbuf, &bufsz, 1);

	printf ("%s\n", xbuf);
	xmlFree (xbuf);
	xmlFreeDoc(doc);

#if 0
printf ("duude\n");
	// xmlOutputBufferPtr xbuf = xmlAllocOutputBuffer (enc);
	xbuf = xmlOutputBufferCreateFile (stdout, NULL);
printf ("duude\n");

	xbuf = xmlOutputBufferCreateFd (1, NULL);
printf ("duude\n");
	xmlNodeDumpOutput (xbuf, NULL, topnode, 99, 99, "iso-8859-1");
	// xmlElemDump (stdout, NULL, topnode);
#endif

	return 0;
}

#endif /* UNIT_TEST */

/* ======================== END OF FILE =================== */