/* 
 * Copyright 2000 HelixCode (http://www.helixcode.com).
 *
 * Author : 
 *  Michael Zucchi <notzed@helixcode.com>

 * 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, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
 * USA
 */

#include <glib.h>
#include <stdio.h>
#include <time.h>
#include <string.h>

#include <camel/gmime-utils.h>
#include <camel/camel-log.h>
#include "camel/camel-mime-message.h"
#include "camel/camel-mime-part.h"
#include "camel/camel-stream.h"
#include "camel/camel-stream-fs.h"
#include "camel/camel.h"
#include "camel-mbox-folder.h"

#define HAVE_IBEX
#ifdef HAVE_IBEX
#include "ibex.h"
#endif

#define p(x)			/* parse debug */
#define r(x)			/* run debug */
#define d(x)			/* general debug */


/*

  This is not yet complete.

  The following s-exp's are supported:

  list = (and list*)
	perform an intersection of a number of lists, and return that.

  bool = (and bool*)
	perform a boolean AND of boolean values.

  list = (or list*)
	perform a union of a number of lists, returning the new list.

  bool = (or bool*)
	perform a boolean OR of boolean values.

  Comparison operators:

  bool = (lt int int)
  bool = (gt int int)
  bool = (eq int int)

  bool = (lt string string)
  bool = (gt string string)
  bool = (eq string string)
	Perform a comparision of 2 integers, or 2 string values.

  Matching operators:

  list = (contains string)
  	Returns a list of all messages containing the string in their body.

  list = (match-all bool-expr)
  	Returns a list of all messages for which the bool expression is true.
	The bool-expr is evaluated for each message in turn.
	It is more efficient not to perform body-content comparisons inside a
	match-all operator.

  int = (date-sent)
  	Returns a time_t of the date-sent of the message.

  bool = (header-contains string1 string2)
  	Returns true if the current message (inside a match-all operator)
	has a header 'string1', which contains 'string2'
*/

static GScannerConfig scanner_config =
{
  (
   " \t\r\n"
   )                    /* cset_skip_characters */,
  (
   G_CSET_a_2_z
   "_"
   G_CSET_A_2_Z
   )                    /* cset_identifier_first */,
  (
   G_CSET_a_2_z
   "_0123456789-"
   G_CSET_A_2_Z
   G_CSET_LATINS
   G_CSET_LATINC
   )                    /* cset_identifier_nth */,
  ( "#\n" )             /* cpair_comment_single */,
  
  FALSE                 /* case_sensitive */,
  
  TRUE                  /* skip_comment_multi */,
  TRUE                  /* skip_comment_single */,
  TRUE                  /* scan_comment_multi */,
  TRUE                  /* scan_identifier */,
  FALSE                 /* scan_identifier_1char */,
  FALSE                 /* scan_identifier_NULL */,
  TRUE                  /* scan_symbols */,
  FALSE                 /* scan_binary */,
  TRUE                  /* scan_octal */,
  TRUE                  /* scan_float */,
  TRUE                  /* scan_hex */,
  FALSE                 /* scan_hex_dollar */,
  TRUE                  /* scan_string_sq */,
  TRUE                  /* scan_string_dq */,
  TRUE                  /* numbers_2_int */,
  FALSE                 /* int_2_float */,
  FALSE                 /* identifier_2_string */,
  TRUE                  /* char_2_token */,
  FALSE                 /* symbol_2_token */,
  FALSE                 /* scope_0_fallback */,
};


enum _searchtermtype_t {
	SEARCH_AND,
	SEARCH_OR,
	SEARCH_LT,
	SEARCH_GT,
	SEARCH_EQ,
	SEARCH_CONTAINS,
	SEARCH_DATESENT,
	SEARCH_STRING,
	SEARCH_INT,
	SEARCH_FUNC,
};

struct _searchterm {
	enum _searchtermtype_t type;
	union {
		char *string;
		int number;
		struct {
			struct _searchterm_symbol *sym;
			struct _searchterm **terms;
			int termcount;
		} func;
	} value;
};

struct _searchcontext {
	int whatever;

	CamelFolder *folder;

#ifdef HAVE_IBEX
	ibex *index;		/* index of content for this folder */
#endif

	CamelFolderSummary *summary;
	const GArray *message_info;

	CamelMessageInfo *message_current;	/* when performing a (match  operation */
};

enum _searchresulttype_t {
	RESULT_ARRAY_PTR=0,
	RESULT_INT,
	RESULT_STRING,
	RESULT_BOOL,
	RESULT_UNDEFINED
};

struct _searchresult {
	enum _searchresulttype_t type;
	union {
		GPtrArray *ptrarray;
		int number;
		char *string;
		int bool;
	} value;
};

/* function callbacks */
static struct _searchresult *search_contains(struct _searchcontext *ctx, struct _searchterm *t);
static struct _searchresult *search_matches(struct _searchcontext *ctx, struct _searchterm *t);
static struct _searchresult *search_date_sent(struct _searchcontext *ctx, struct _searchterm *t);
static struct _searchresult *header_contains(struct _searchcontext *ctx, struct _searchterm *t);

struct _searchterm_symbol {
	char *name;
	int type;
	int argtype;
	struct _searchresult * (*func)(struct _searchcontext *ctx, struct _searchterm *t);
} symbols[] = {
	{ "and", SEARCH_AND, 0, NULL },
	{ "or", SEARCH_OR, 0, NULL },
	{ "lt", SEARCH_LT, 1, NULL },
	{ "gt", SEARCH_GT, 1, NULL },
	{ "eq", SEARCH_EQ, 1, NULL },
	{ "contains", SEARCH_FUNC, 1, search_contains },
	{ "match-all", SEARCH_FUNC, 1, search_matches },
	{ "date-sent", SEARCH_FUNC, 1, search_date_sent },
	{ "header-contains", SEARCH_FUNC, 1, header_contains },
};

static struct _searchterm * parse_list(GScanner *gs, int gotbrace);
static struct _searchterm * parse_value(GScanner *gs);

static struct _searchresult *term_eval(struct _searchcontext *ctx, struct _searchterm *t);
static void parse_dump_term(struct _searchterm *t, int depth);

/* can you tell, i dont like glib? */
struct _glib_sux_donkeys {
	int count;
	GPtrArray *uids;
};


/* ok, store any values that are in all sets */
static void
g_lib_sux_htand(char *key, int value, struct _glib_sux_donkeys *fuckup)
{
	if (value == fuckup->count) {
		g_ptr_array_add(fuckup->uids, key);
	}
}

/* or, store all unique values */
static void
g_lib_sux_htor(char *key, int value, struct _glib_sux_donkeys *fuckup)
{
	g_ptr_array_add(fuckup->uids, key);
}

static struct _searchresult *
result_new(int type)
{
	struct _searchresult *r = g_malloc0(sizeof(*r));
	r->type = type;
	return r;
}

static void
result_free(struct _searchresult *t)
{
	switch(t->type) {
	case RESULT_ARRAY_PTR:
		g_ptr_array_free(t->value.ptrarray, TRUE);
		break;
	case RESULT_BOOL:
	case RESULT_INT:
		break;
	case RESULT_STRING:
		g_free(t->value.string);
		break;
	case RESULT_UNDEFINED:
		break;
	}
	g_free(t);
}

static struct _searchresult *search_contains(struct _searchcontext *ctx, struct _searchterm *t)
{
	struct _searchresult *r, *r1;

	r = result_new(RESULT_UNDEFINED);

	if (t->value.func.termcount>0) {
		if (t->value.func.termcount!=1) {
			printf("warning, only looking for first string in contains clause\n");
		}
		r1 = term_eval(ctx, t->value.func.terms[0]);
		if (r1->type == RESULT_STRING) {
			if (ctx->message_current) {
				int truth = FALSE;
#ifdef HAVE_IBEX
				int i;
				GPtrArray *array;

				if (ctx->index) {
					array = ibex_find(ctx->index, r1->value.string);

					for (i=0;i<array->len;i++) {
						if (!strcmp(g_ptr_array_index(array, i), ctx->message_current->uid)) {
							truth = TRUE;
							break;
						}
					}
					g_ptr_array_free(array, TRUE);
				}
#endif
				r->type = RESULT_BOOL;
				r->value.bool = truth;
			} else {
				r->type = RESULT_ARRAY_PTR;
#ifdef HAVE_IBEX
				if (ctx->index) {
				/* blah, this should probably copy the index strings? */
					r->value.ptrarray = ibex_find(ctx->index, r1->value.string);
				} else {
					r->value.ptrarray = g_ptr_array_new();
				}
#endif
			}
		} else {
			printf("you can't search for a contents of a non-string, fool\n");
		}
		result_free(r1);
	}
	return r;
}

/* run a sub-tree of commands which match on header fields etc */
static struct _searchresult *search_matches(struct _searchcontext *ctx, struct _searchterm *t)
{
	int i;
	struct _searchresult *r, *r1;

	if (t->value.func.termcount == 1) {
		r = result_new(RESULT_ARRAY_PTR);
		r->value.ptrarray = g_ptr_array_new();

		for (i=0;i<ctx->message_info->len;i++) {
			ctx->message_current = &g_array_index(ctx->message_info, CamelMessageInfo, i);
			r1 = term_eval(ctx, t->value.func.terms[0]);
			if (r1->type == RESULT_BOOL) {
				if (r1->value.bool) {
					r(printf("adding message %s\n", ctx->message_current->uid));
					g_ptr_array_add(r->value.ptrarray, ctx->message_current->uid);
				}
			} else {
				printf("invalid syntax, matches require a single bool result\n");
			}
			result_free(r1);
		}
		ctx->message_current = NULL;
	} else {
		r = result_new(RESULT_UNDEFINED);
		printf("invalid syntax, matches only allows a single bool arg\n");
	}
	return r;
}

/* these variable-getting things could be put into 1 function */
static struct _searchresult *search_date_sent(struct _searchcontext *ctx, struct _searchterm *t)
{
	struct _searchresult *r;

	if (ctx->message_current) {
		r = result_new(RESULT_INT);
		r->value.number = time(0);
		/*		r->value.number = ctx->current_message->date_sent;*/
	} else {
		r = result_new(RESULT_UNDEFINED);
	}
	return r;
}

/* header contains - can only be used inside a match-all construct */
/* all headers should be inside a lookup table, so this can search
   all header types */
static struct _searchresult *header_contains(struct _searchcontext *ctx, struct _searchterm *t)
{
	struct _searchresult *r;

	r(printf("executing header-contains\n"));

	/* are we inside a match-all? */
	if (ctx->message_current
	    && t->value.func.termcount == 2) {
		char *header, *substring;
		int truth = FALSE;
		struct _searchresult *r1, *r2;

		r1 = term_eval(ctx, t->value.func.terms[0]);
		r2 = term_eval(ctx, t->value.func.terms[1]);

		if (r1->type == RESULT_STRING
		    && r2->type == RESULT_STRING) {

			header = r1->value.string;
			substring = r2->value.string;
			if (!strcasecmp(header, "subject")) {
				r(printf("comparing subject: %s\n", ctx->message_current->subject));
				if (ctx->message_current->subject)
					truth = (strstr(ctx->message_current->subject, substring)) != NULL;
				else
					printf("Warning: no subject line in message?\n");
			}
			r(printf("header-contains %s %s = %s\n", header, substring, truth?"TRUE":"FALSE"));
		}

		result_free(r1);
		result_free(r2);

		r = result_new(RESULT_BOOL);
		r->value.number = truth;
	} else {
		r = result_new(RESULT_UNDEFINED);
	}
	return r;
}


static struct _searchresult *
term_eval(struct _searchcontext *ctx, struct _searchterm *t)
{
	struct _searchresult *r, *r1, *r2;
	int i;

	r(printf("eval term :\n"));
	r(parse_dump_term(t, 0));

	r = g_malloc0(sizeof(*r));
	r->type = RESULT_UNDEFINED;

	switch (t->type) {
	case SEARCH_AND: {
		GHashTable *ht = g_hash_table_new(g_str_hash, g_str_equal);
		struct _glib_sux_donkeys lambdafoo;
		int type=-1;
		int bool = TRUE;

		r(printf("( and\n"));

		for (i=0;bool && i<t->value.func.termcount;i++) {
			r1 = term_eval(ctx, t->value.func.terms[i]);
			if (type == -1)
				type = r1->type;
			if (type != r1->type) {
				printf("invalid types in and operation, all types must be the same\n");
			} else if ( r1->type == RESULT_ARRAY_PTR ) {
				char **a1;
				int l1, j;

				a1 = (char **)r1->value.ptrarray->pdata;
				l1 = r1->value.ptrarray->len;
				for (j=0;i<l1;j++) {
					int n;
					n = (int)g_hash_table_lookup(ht, a1[i]);
					g_hash_table_insert(ht, a1[i], (void *)n+1);
				}
			} else if ( r1->type == RESULT_BOOL ) {
				bool &= r1->value.bool;
			}
			result_free(r1);
		}

		if (type == RESULT_ARRAY_PTR) {
			lambdafoo.count = t->value.func.termcount;
			lambdafoo.uids = g_ptr_array_new();
			g_hash_table_foreach(ht, (GHFunc)g_lib_sux_htand, &lambdafoo);
			r->type = RESULT_ARRAY_PTR;
			r->value.ptrarray = lambdafoo.uids;
		} else if (type == RESULT_BOOL) {
			r->type = RESULT_BOOL;
			r->value.bool = bool;
		}

		g_hash_table_destroy(ht);

		break; }
	case SEARCH_OR: {
		GHashTable *ht = g_hash_table_new(g_str_hash, g_str_equal);
		struct _glib_sux_donkeys lambdafoo;
		int type = -1;
		int bool = FALSE;
		
		r(printf("(or \n"));

		for (i=0;!bool && i<t->value.func.termcount;i++) {
			r1 = term_eval(ctx, t->value.func.terms[i]);
			if (type == -1)
				type = r1->type;
			if (r1->type != type) {
				printf("wrong types in or operation\n");
			} else if (r1->type == RESULT_ARRAY_PTR) {
				char **a1;
				int l1, j;

				a1 = (char **)r1->value.ptrarray->pdata;
				l1 = r1->value.ptrarray->len;
				for (j=0;i<l1;j++) {
					g_hash_table_insert(ht, a1[j], (void *)1);
				}
			} else if (r1->type == RESULT_BOOL) {
				bool |= r1->value.bool;				
			}
			result_free(r1);
		}

		if (type == RESULT_ARRAY_PTR) {
			lambdafoo.count = t->value.func.termcount;
			lambdafoo.uids = g_ptr_array_new();
			g_hash_table_foreach(ht, (GHFunc)g_lib_sux_htor, &lambdafoo);
			r->type = RESULT_ARRAY_PTR;
			r->value.ptrarray = lambdafoo.uids;
		} else if (type == RESULT_BOOL) {
			r->type = RESULT_BOOL;
			r->value.bool = bool;
		}
		g_hash_table_destroy(ht);

		break; }
	case SEARCH_LT:
		r(printf("(lt \n"));
		if (t->value.func.termcount == 2) {
			r1 = term_eval(ctx, t->value.func.terms[0]);
			r2 = term_eval(ctx, t->value.func.terms[1]);
			if (r1->type != r2->type) {
				printf("error, invalid types in compare\n");
			} else if (r1->type == RESULT_INT) {
				r->type = RESULT_BOOL;
				r->value.bool = r1->value.number < r2->value.number;
			} else if (r1->type == RESULT_STRING) {
				r->type = RESULT_BOOL;
				r->value.bool = strcmp(r1->value.string, r2->value.string) < 0;
			}
		}
		break;
	case SEARCH_GT:
		r(printf("(gt \n"));
		if (t->value.func.termcount == 2) {
			r1 = term_eval(ctx, t->value.func.terms[0]);
			r2 = term_eval(ctx, t->value.func.terms[1]);
			if (r1->type != r2->type) {
				printf("error, invalid types in compare\n");
			} else if (r1->type == RESULT_INT) {
				r->type = RESULT_BOOL;
				r->value.bool = r1->value.number > r2->value.number;
			} else if (r1->type == RESULT_STRING) {
				r->type = RESULT_BOOL;
				r->value.bool = strcmp(r1->value.string, r2->value.string) > 0;
			}
		}
		break;
	case SEARCH_STRING:
		r(printf(" (string \"%s\")\n", t->value.string));
		r->type = RESULT_STRING;
		/* erk, this shoul;dn't need to strdup this ... */
		r->value.string = g_strdup(t->value.string);
		break;
	case SEARCH_INT:
		r(printf(" (int %d)\n", t->value.number));
		r->type = RESULT_INT;
		r->value.number = t->value.number;
		break;
	case SEARCH_FUNC:
		g_free(r);	/* <---- FIXME: ICK !! */
		r(printf("function '%s'\n", t->value.func.sym->name));
		return t->value.func.sym->func(ctx, t);
	default:
		printf("Warning: Unknown type encountered in parse tree: %d\n", t->type);
		r->type = RESULT_UNDEFINED;
	}

	return r;
}


static void
parse_dump_term(struct _searchterm *t, int depth)
{
	int dumpvals = FALSE;
	int i;

	if (t==NULL) {
		printf("null term??\n");
		return;
	}

	for (i=0;i<depth;i++)
		printf("   ");
	
	switch (t->type) {
	case SEARCH_AND:
		printf("(and \n");
		dumpvals = 1;
		break;
	case SEARCH_OR:
		printf("(or \n");
		dumpvals = 1;
		break;
	case SEARCH_LT:
		printf("(lt \n");
		dumpvals = 1;
		break;
	case SEARCH_GT:
		printf("(gt \n");
		dumpvals = 1;
		break;
	case SEARCH_STRING:
		printf(" \"%s\"", t->value.string);
		break;
	case SEARCH_INT:
		printf(" %d", t->value.number);
		break;
	case SEARCH_FUNC:
		printf(" (function %s", t->value.func.sym->name);
		dumpvals = 1;
		break;
	default:
		printf("unknown type: %d\n", t->type);
	}

	if (dumpvals) {
		/*printf(" [%d] ", t->value.func.termcount);*/
		for (i=0;i<t->value.func.termcount;i++) {
			parse_dump_term(t->value.func.terms[i], depth+1);
		}
		for (i=0;i<depth;i++)
			printf("   ");
		printf(")\n");
	}
	printf("\n");
}

/*
  PARSER
*/

static struct _searchterm *
parse_new_term(int type)
{
	struct _searchterm *s = g_malloc0(sizeof(*s));
	s->type = type;
	return s;
}

static void
parse_term_free(struct _searchterm *t)
{
	int i;

	if (t==NULL) {
		return;
	}
	
	switch (t->type) {
	case SEARCH_AND:
	case SEARCH_OR:
	case SEARCH_LT:
	case SEARCH_GT:
	case SEARCH_FUNC:
		for (i=0;i<t->value.func.termcount;i++) {
			parse_term_free(t->value.func.terms[i]);
		}
		g_free(t->value.func.terms);
		break;
	case SEARCH_STRING:
		g_free(t->value.string);
		break;
	case SEARCH_INT:
		break;
	default:
		printf("parse_term_free: unknown type: %d\n", t->type);
	}
	g_free(t);
}

static struct _searchterm **
parse_lists(GScanner *gs, int *len)
{
	int token;
	struct _searchterm **terms;
	int i=0;

	p(printf("parsing lists\n"));

	terms = g_malloc0(20*sizeof(*terms));

	while ( (token = g_scanner_peek_next_token(gs)) != G_TOKEN_EOF
		&& token != ')') {
		terms[i]=parse_list(gs, FALSE);
		i++;
	}

	if (len)
		*len = i;

	p(printf("found %d subterms\n", i));

	p(printf("done parsing lists, token= %d %c\n", token, token));
	return terms;
}

static struct _searchterm **
parse_values(GScanner *gs, int *len)
{
	int token;
	struct _searchterm **terms;
	int i=0;

	p(printf("parsing values\n"));

	terms = g_malloc0(20*sizeof(*terms));

	while ( (token = g_scanner_peek_next_token(gs)) != G_TOKEN_EOF
		&& token != ')') {
		terms[i]=parse_value(gs);
		i++;
	}

	p(printf("found %d subterms\n", i));
	*len = i;
	
	p(printf("dont parsing values\n"));
	return terms;
}

static struct _searchterm *
parse_value(GScanner *gs)
{
	int token;
	struct _searchterm *t = NULL;

	p(printf("parsing value\n"));

	token = g_scanner_get_next_token(gs);
	switch(token) {
	case G_TOKEN_LEFT_PAREN:
		p(printf("got brace, its a list!\n"));
		return parse_list(gs, TRUE);
	case G_TOKEN_STRING:
		p(printf("got string\n"));
		t = parse_new_term(SEARCH_STRING);
		t->value.string = g_strdup(g_scanner_cur_value(gs).v_string);
		break;
	case G_TOKEN_INT:
		t = parse_new_term(SEARCH_INT);
		t->value.number = g_scanner_cur_value(gs).v_int;
		p(printf("got int\n"));
		break;
	default:
		printf("Innvalid token trying to parse a list of values\n");
	}
	p(printf("done parsing value\n"));
	return t;
}

/* FIXME: this needs some robustification */
static struct _searchterm *
parse_list(GScanner *gs, int gotbrace)
{
	int token;
	struct _searchterm *t = NULL;

	p(printf("parsing list\n"));
	if (gotbrace)
		token = '(';
	else
		token = g_scanner_get_next_token(gs);
	if (token =='(') {
		token = g_scanner_get_next_token(gs);
		if (token == G_TOKEN_SYMBOL) {
			struct _searchterm_symbol *s;

			s = g_scanner_cur_value(gs).v_symbol;
			p(printf("got funciton: %s\n", s->name));
			t = parse_new_term(s->type);
			t->value.func.sym = s;
			p(printf("created new list %p\n", t));
			switch(s->argtype) {
			case 0:	/* it MUST be a list of lists */
				t->value.func.terms = parse_lists(gs, &t->value.func.termcount);
				break;
			case 1:
				t->value.func.terms = parse_values(gs, &t->value.func.termcount);
				break;
			default:
				printf("Error, internal error parsing symbols\n");
			}
		} else {
			printf("unknown sequence encountered, type = %d\n", token);
		}
		token = g_scanner_get_next_token(gs);
		if (token != ')') {
			printf("Error, expected ')' not found\n");
		}
	} else {
		printf("Error, list term without opening (\n");
	}

	p(printf("returning list %p\n", t));
	return t;
}

GList *
camel_mbox_folder_search_by_expression(CamelFolder *folder, char *expression, CamelException *ex)
{
	GScanner *gs;
	int i;
	struct _searchterm *t;
	struct _searchcontext *ctx;
	struct _searchresult *r;
	GList *matches = NULL;

	gs = g_scanner_new(&scanner_config);
	for(i=0;i<sizeof(symbols)/sizeof(symbols[0]);i++)
		g_scanner_scope_add_symbol(gs, 0, symbols[i].name, &symbols[i]);

	g_scanner_input_text(gs, expression, strlen(expression));
	t = parse_list(gs, 0);

	if (t) {
		ctx = g_malloc0(sizeof(*ctx));
		ctx->folder = folder;
		ctx->summary = camel_folder_get_summary(folder, ex);
		ctx->message_info = camel_folder_summary_get_message_info_list(ctx->summary);
#ifdef HAVE_IBEX
		ctx->index = ibex_open(CAMEL_MBOX_FOLDER(folder)->index_file_path, FALSE);
		if (!ctx->index) {
			perror("Cannot open index file, body searches will be ignored\n");
		}
#endif
		r = term_eval(ctx, t);

		/* now create a folder summary to return?? */
		if (r
		    && r->type == RESULT_ARRAY_PTR) {
			d(printf("got result ...\n"));
			for (i=0;i<r->value.ptrarray->len;i++) {
				d(printf("adding match: %s\n", (char *)g_ptr_array_index(r->value.ptrarray, i)));
				matches = g_list_prepend(matches, g_strdup(g_ptr_array_index(r->value.ptrarray, i)));
			}
			result_free(r);
		}

		if (ctx->index)
			ibex_close(ctx->index);

		gtk_object_unref((GtkObject *)ctx->summary);
		g_free(ctx);
		parse_term_free(t);
	} else {
		printf("Warning, Could not parse expression!\n %s\n", expression);
	}

	g_scanner_destroy(gs);

	return matches;
}