/*
 * Copyright (C) 2018 Richard Hughes <richard@hughsie.com>
 *
 * SPDX-License-Identifier: LGPL-2.1+
 */

#define G_LOG_DOMAIN				"XbSilo"

#include "config.h"

#include <string.h>
#include <gio/gio.h>

#include "xb-node-private.h"
#include "xb-opcode.h"
#include "xb-silo-private.h"
#include "xb-silo-query-private.h"
#include "xb-stack-private.h"
#include "xb-query-private.h"

static gboolean
xb_silo_query_node_matches (XbSilo *self,
			    XbMachine *machine,
			    XbSiloNode *sn,
			    XbQuerySection *section,
			    XbSiloQueryData *query_data,
			    gboolean *result,
			    GError **error)
{
	/* we have an index into the string table */
	if (section->element_idx != sn->element_name &&
	    section->kind != XB_SILO_QUERY_KIND_WILDCARD) {
		*result = FALSE;
		return TRUE;
	}

	/* for section */
	query_data->position += 1;

	/* check predicates */
	if (section->predicates != NULL) {
		for (guint i = 0; i < section->predicates->len; i++) {
			XbStack *opcodes = g_ptr_array_index (section->predicates, i);
			if (!xb_machine_run (machine, opcodes, result, query_data, error))
				return FALSE;
		}
	}

	/* success */
	return TRUE;
}

typedef struct {
	GPtrArray	*sections;	/* of XbQuerySection */
	GPtrArray	*results;	/* of XbNode */
	GHashTable	*results_hash;	/* of sn:1 */
	guint		 limit;
	XbSiloQueryData	*query_data;
} XbSiloQueryHelper;

static gboolean
xb_silo_query_section_add_result (XbSilo *self, XbSiloQueryHelper *helper, XbSiloNode *sn)
{
	if (g_hash_table_lookup (helper->results_hash, sn) != NULL)
		return FALSE;
	g_ptr_array_add (helper->results, xb_silo_node_create (self, sn));
	g_hash_table_add (helper->results_hash, sn);
	return helper->results->len == helper->limit;
}

/*
 * @parent: (allow-none)
 */
static gboolean
xb_silo_query_section_root (XbSilo *self,
			    XbSiloNode *sn,
			    guint i,
			    XbSiloQueryHelper *helper,
			    GError **error)
{
	XbMachine *machine = xb_silo_get_machine (self);
	XbSiloQueryData *query_data = helper->query_data;
	XbQuerySection *section = g_ptr_array_index (helper->sections, i);

	/* handle parent */
	if (section->kind == XB_SILO_QUERY_KIND_PARENT) {
		XbSiloNode *parent;
		if (sn == NULL) {
			g_set_error_literal (error,
					     G_IO_ERROR,
					     G_IO_ERROR_INVALID_ARGUMENT,
					     "cannot obtain parent for root");
			return FALSE;
		}
		parent = xb_silo_node_get_parent (self, sn);
		if (parent == NULL) {
			g_set_error (error,
				     G_IO_ERROR,
				     G_IO_ERROR_INVALID_ARGUMENT,
				     "no parent set for %s",
				     xb_silo_node_get_element (self, sn));
			return FALSE;
		}
		if (i == helper->sections->len - 1) {
			xb_silo_query_section_add_result (self, helper, parent);
			return TRUE;
		}
//		g_debug ("PARENT @%u",
//			 xb_silo_get_offset_for_node (self, parent));
		return xb_silo_query_section_root (self, parent, i + 1, helper, error);
	}

	/* no node means root */
	if (sn == NULL) {
		sn = xb_silo_get_sroot (self);
		if (sn == NULL) {
			g_set_error_literal (error,
					     G_IO_ERROR,
					     G_IO_ERROR_NOT_FOUND,
					     "silo root not found");
			return FALSE;
		}
	} else {
		sn = xb_silo_node_get_child (self, sn);
		if (sn == NULL)
			return TRUE;
	}

	/* set up level pointer */
	query_data->position = 0;

	/* continue matching children ".." */
	do {
		gboolean result = TRUE;
		query_data->sn = sn;
		if (!xb_silo_query_node_matches (self, machine, sn, section,
						 query_data, &result, error))
			return FALSE;
		if (result) {
			if (i == helper->sections->len - 1) {
//				g_debug ("add result %u",
//					 xb_silo_get_offset_for_node (self, sn));
				if (xb_silo_query_section_add_result (self, helper, sn))
					break;
			} else {
//				g_debug ("MATCH %s at @%u, deeper",
//					 xb_silo_node_get_element (self, sn),
//					 xb_silo_get_offset_for_node (self, sn));
				if (!xb_silo_query_section_root (self, sn, i + 1, helper, error))
					return FALSE;
				if (helper->results->len > 0 &&
				    helper->results->len == helper->limit)
					break;
			}
		}
		if (sn->next == 0x0)
			break;
		sn = xb_silo_get_node (self, sn->next);
	} while (TRUE);
	return TRUE;
}

static gboolean
xb_silo_query_part (XbSilo *self,
		    XbSiloNode *sroot,
		    GPtrArray *results,
		    GHashTable *results_hash,
		    XbQuery *query,
		    XbSiloQueryData *query_data,
		    GError **error)
{
	XbSiloQueryHelper helper = {
		.results = results,
		.limit = xb_query_get_limit (query),
		.results_hash = results_hash,
		.query_data = query_data,
	};

	/* find each section */
	helper.sections = xb_query_get_sections (query);
	return xb_silo_query_section_root (self, sroot, 0, &helper, error);
}

/**
 * xb_silo_query_with_root: (skip)
 * @self: a #XbSilo
 * @n: (allow-none): a #XbNode
 * @xpath: an XPath, e.g. `/components/component[@type=desktop]/id[abe.desktop]`
 * @limit: maximum number of results to return, or 0 for "all"
 * @error: the #GError, or %NULL
 *
 * Searches the silo using an XPath query, returning up to @limit results.
 *
 * It is safe to call this function from a different thread to the one that
 * created the #XbSilo.
 *
 * Please note: Only a subset of XPath is supported.
 *
 * Returns: (transfer container) (element-type XbNode): results, or %NULL if unfound
 *
 * Since: 0.1.0
 **/
GPtrArray *
xb_silo_query_with_root (XbSilo *self, XbNode *n, const gchar *xpath, guint limit, GError **error)
{
	XbSiloNode *sn = NULL;
	g_auto(GStrv) split = NULL;
	g_autoptr(GHashTable) results_hash = g_hash_table_new (g_direct_hash, g_direct_equal);
	g_autoptr(GPtrArray) results = g_ptr_array_new_with_free_func ((GDestroyNotify) g_object_unref);
	g_autoptr(GTimer) timer = g_timer_new ();
	XbSiloQueryData query_data = {
		.sn = NULL,
		.position = 0,
	};

	g_return_val_if_fail (XB_IS_SILO (self), NULL);
	g_return_val_if_fail (xpath != NULL, NULL);
	g_return_val_if_fail (error == NULL || *error == NULL, NULL);

	/* empty silo */
	if (xb_silo_is_empty (self)) {
		g_set_error_literal (error,
				     G_IO_ERROR,
				     G_IO_ERROR_NOT_FOUND,
				     "silo has no data");
		return NULL;
	}

	/* subtree query */
	if (n != NULL) {
		sn = xb_node_get_sn (n);
		if (xpath[0] == '/') {
			g_set_error_literal (error,
					     G_IO_ERROR,
					     G_IO_ERROR_NOT_SUPPORTED,
					     "XPath node query not supported");
			return NULL;
		}
	} else {
		/* assume it's just a root query */
		if (xpath[0] == '/')
			xpath++;
	}

	/* do 'or' searches */
	split = g_strsplit (xpath, "|", -1);
	for (guint i = 0; split[i] != NULL; i++) {
		g_autoptr(GError) error_local = NULL;
		g_autoptr(XbQuery) query = xb_query_new (self, split[i], &error_local);
		if (query == NULL) {
			if (g_error_matches (error_local, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT) &&
			    (split[i + 1] != NULL || results->len > 0)) {
				g_debug ("ignoring for OR statement: %s",
					 error_local->message);
				continue;
			}
			g_propagate_prefixed_error (error,
						    g_steal_pointer (&error_local),
						    "failed to process %s: ",
						    xpath);
			return NULL;
		}
		xb_query_set_limit (query, limit);
		if (!xb_silo_query_part (self, sn,
					 results, results_hash,
					 query, &query_data,
					 error)) {
			return NULL;
		}
	}

	/* profile */
	if (xb_silo_get_profile_flags (self) & XB_SILO_PROFILE_FLAG_XPATH) {
		xb_silo_add_profile (self, timer,
				     "query on %s with `%s` limit=%u -> %u results",
				     n != NULL ? xb_node_get_element (n) : "/",
				     xpath, limit, results->len);
	}

	/* nothing found */
	if (results->len == 0) {
		g_set_error (error,
			     G_IO_ERROR,
			     G_IO_ERROR_NOT_FOUND,
			     "no results for XPath query '%s'",
			     xpath);
		return NULL;
	}
	return g_steal_pointer (&results);
}

static void
_g_ptr_array_reverse (GPtrArray *array)
{
	guint last_idx = array->len - 1;
	for (guint i = 0; i < array->len / 2; i++) {
		gpointer tmp = array->pdata[i];
		array->pdata[i] = array->pdata[last_idx - i];
		array->pdata[last_idx - i] = tmp;
	}
}

/**
 * xb_silo_query_with_root_full: (skip)
 * @self: a #XbSilo
 * @n: (allow-none): a #XbNode
 * @query: an #XbQuery
 * @error: the #GError, or %NULL
 *
 * Searches the silo using an XPath query, returning up to @limit results.
 *
 * It is safe to call this function from a different thread to the one that
 * created the #XbSilo.
 *
 * Please note: Only a subset of XPath is supported.
 *
 * Returns: (transfer container) (element-type XbNode): results, or %NULL if unfound
 *
 * Since: 0.1.4
 **/
GPtrArray *
xb_silo_query_with_root_full (XbSilo *self, XbNode *n, XbQuery *query, GError **error)
{
	XbSiloNode *sn = NULL;
	g_autoptr(GHashTable) results_hash = g_hash_table_new (g_direct_hash, g_direct_equal);
	g_autoptr(GPtrArray) results = g_ptr_array_new_with_free_func ((GDestroyNotify) g_object_unref);
	g_autoptr(GTimer) timer = g_timer_new ();
	XbSiloQueryData query_data = {
		.sn = NULL,
		.position = 0,
	};

	/* empty silo */
	if (xb_silo_is_empty (self)) {
		g_set_error_literal (error,
				     G_IO_ERROR,
				     G_IO_ERROR_NOT_FOUND,
				     "silo has no data");
		return NULL;
	}

	/* subtree query */
	if (n != NULL)
		sn = xb_node_get_sn (n);

	/* only one query allowed */
	if (!xb_silo_query_part (self, sn, results, results_hash,
				 query, &query_data, error))
		return NULL;

	/* profile */
	if (xb_silo_get_profile_flags (self) & XB_SILO_PROFILE_FLAG_XPATH) {
		g_autofree gchar *tmp = xb_query_to_string (query);
		xb_silo_add_profile (self, timer,
				     "query on %s with `%s` limit=%u -> %u results",
				     n != NULL ? xb_node_get_element (n) : "/",
				     tmp,
				     xb_query_get_limit (query),
				     results->len);
	}

	/* nothing found */
	if (results->len == 0) {
		g_autofree gchar *tmp = xb_query_to_string (query);
		g_set_error (error,
			     G_IO_ERROR,
			     G_IO_ERROR_NOT_FOUND,
			     "no results for XPath query '%s'",
			     tmp);
		return NULL;
	}

	/* reverse order */
	if (xb_query_get_flags (query) & XB_QUERY_FLAG_REVERSE)
		_g_ptr_array_reverse (results);

	return g_steal_pointer (&results);
}

/**
 * xb_silo_query_full:
 * @self: a #XbSilo
 * @query: an #XbQuery
 * @error: the #GError, or %NULL
 *
 * Searches the silo using an XPath query.
 *
 * It is safe to call this function from a different thread to the one that
 * created the #XbSilo.
 *
 * Please note: Only a subset of XPath is supported.
 *
 * Returns: (transfer container) (element-type XbNode): results, or %NULL if unfound
 *
 * Since: 0.1.13
 **/
GPtrArray *
xb_silo_query_full (XbSilo *self, XbQuery *query, GError **error)
{
	g_return_val_if_fail (XB_IS_SILO (self), NULL);
	g_return_val_if_fail (XB_IS_QUERY (query), NULL);
	g_return_val_if_fail (error == NULL || *error == NULL, NULL);
	return xb_silo_query_with_root_full (self, NULL, query, error);
}

/**
 * xb_silo_query_first_full:
 * @self: a #XbSilo
 * @query: an #XbQuery
 * @error: the #GError, or %NULL
 *
 * Searches the silo using an XPath query, returning up to one result.
 *
 * It is safe to call this function from a different thread to the one that
 * created the #XbSilo.
 *
 * Please note: Only a tiny subset of XPath 1.0 is supported.
 *
 * Returns: (transfer none): a #XbNode, or %NULL if unfound
 *
 * Since: 0.1.13
 **/
XbNode *
xb_silo_query_first_full (XbSilo *self, XbQuery *query, GError **error)
{
	g_autoptr(GPtrArray) results = NULL;
	results = xb_silo_query_full (self, query, error);
	if (results == NULL)
		return NULL;
	return g_object_ref (g_ptr_array_index (results, 0));
}

/**
 * xb_silo_query:
 * @self: a #XbSilo
 * @xpath: an XPath, e.g. `/components/component[@type=desktop]/id[abe.desktop]`
 * @limit: maximum number of results to return, or 0 for "all"
 * @error: the #GError, or %NULL
 *
 * Searches the silo using an XPath query, returning up to @limit results.
 *
 * It is safe to call this function from a different thread to the one that
 * created the #XbSilo.
 *
 * Please note: Only a subset of XPath is supported.
 *
 * Returns: (transfer container) (element-type XbNode): results, or %NULL if unfound
 *
 * Since: 0.1.0
 **/
GPtrArray *
xb_silo_query (XbSilo *self, const gchar *xpath, guint limit, GError **error)
{
	g_return_val_if_fail (XB_IS_SILO (self), NULL);
	g_return_val_if_fail (xpath != NULL, NULL);
	g_return_val_if_fail (error == NULL || *error == NULL, NULL);
	return xb_silo_query_with_root (self, NULL, xpath, limit, error);
}

/**
 * xb_silo_query_first:
 * @self: a #XbSilo
 * @xpath: An XPath, e.g. `/components/component[@type=desktop]/id[abe.desktop]`
 * @error: the #GError, or %NULL
 *
 * Searches the silo using an XPath query, returning up to one result.
 *
 * It is safe to call this function from a different thread to the one that
 * created the #XbSilo.
 *
 * Please note: Only a tiny subset of XPath 1.0 is supported.
 *
 * Returns: (transfer none): a #XbNode, or %NULL if unfound
 *
 * Since: 0.1.0
 **/
XbNode *
xb_silo_query_first (XbSilo *self, const gchar *xpath, GError **error)
{
	g_autoptr(GPtrArray) results = NULL;
	results = xb_silo_query_with_root (self, NULL, xpath, 1, error);
	if (results == NULL)
		return NULL;
	return g_object_ref (g_ptr_array_index (results, 0));
}

/**
 * xb_silo_query_build_index:
 * @self: a #XbSilo
 * @xpath: An XPath, e.g. `/components/component[@type=desktop]/id[abe.desktop]`
 * @attr: (nullable): Attribute name, e.g. `type`, or NULL
 * @error: the #GError, or %NULL
 *
 * Adds the `attr()` or `text()` results of a query to the index.
 *
 * Returns: %TRUE for success
 *
 * Since: 0.1.4
 **/
gboolean
xb_silo_query_build_index (XbSilo *self,
			   const gchar *xpath,
			   const gchar *attr,
			   GError **error)
{
	g_autoptr(GError) error_local = NULL;
	g_autoptr(GPtrArray) array = NULL;

	g_return_val_if_fail (XB_IS_SILO (self), FALSE);
	g_return_val_if_fail (xpath != NULL, FALSE);
	g_return_val_if_fail (error == NULL || *error == NULL, FALSE);

	/* do the query */
	array = xb_silo_query_with_root (self, NULL, xpath, 0, &error_local);
	if (array == NULL) {
		if (g_error_matches (error_local,
				     G_IO_ERROR,
				     G_IO_ERROR_INVALID_ARGUMENT) ||
		    g_error_matches (error_local,
				     G_IO_ERROR,
				     G_IO_ERROR_NOT_FOUND)) {
			g_debug ("ignoring index: %s", error_local->message);
			return TRUE;
		}
		g_propagate_error (error, g_steal_pointer (&error_local));
		return FALSE;
	}

	/* add each attribute name AND value */
	for (guint i = 0; i < array->len; i++) {
		XbNode *n = g_ptr_array_index (array, i);
		XbSiloNode *sn = xb_node_get_sn (n);
		if (attr != NULL) {
			guint32 off = xb_silo_get_offset_for_node (self, sn);
			for (guint8 j = 0; j < sn->nr_attrs; j++) {
				XbSiloAttr *a = xb_silo_get_attr (self, off, j);
				xb_silo_strtab_index_insert (self, a->attr_name);
				xb_silo_strtab_index_insert (self, a->attr_value);
			}
		} else {
			xb_silo_strtab_index_insert (self, sn->text);
		}
	}

	/* success */
	return TRUE;
}