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

#include "filter.h"
#include "filter-private.h"


static int xfilter_debug_mode = 1;


int xfilter_init(void)
{
	return 0;
}

void xfilter_done(void)
{
}

XFilter *xfilter_new(XFilterType type, const char *name)
{
	XFilter *filter;

	if (type == XF_CONTENT) {
		filter = XFILTER(g_new0(XContentFilter, 1));
	} else {
		filter = XFILTER(g_new0(XTestFilter, 1));
	}

	filter->type = type;
	filter->name = g_strdup(name);

	return filter;
}

void xfilter_free(XFilter *filter)
{
	if (!filter)
		return;
	g_free(filter->name);
	g_free(filter);
}

XFilterType xfilter_get_type(XFilter *filter)
{
	g_return_val_if_fail(filter != NULL, -1);

	return filter->type;
}

const char *xfilter_get_name(XFilter *filter)
{
	g_return_val_if_fail(filter != NULL, NULL);

	return filter->name;
}

void xfilter_set_input_mime_types(XFilter *filter, const char **types)
{
}

void xfilter_set_output_mime_type(XFilter *filter, const char *type)
{
}

XMessageData *xfilter_message_data_new(const char *src, const char *mime_type)
{
	XMessageData *data;

	data = g_new0(XMessageData, 1);
	data->content = g_strdup(src);
	data->mime_type = g_strdup(mime_type);
	return data;
}

void xfilter_message_data_free(XMessageData *msgdata)
{
	if (!msgdata)
		return;
	g_free(msgdata->mime_type);
	g_free(msgdata->content);
	g_free(msgdata);
}

void xfilter_message_data_set_content(XMessageData *msgdata, char *content)
{
	msgdata->content = content;
}

const char *xfilter_message_data_get_mime_type(const XMessageData *msgdata)
{
	g_return_val_if_fail(msgdata != NULL, NULL);

	return msgdata->mime_type;
}

const char *xfilter_message_data_get_content(const XMessageData *msgdata)
{
	g_return_val_if_fail(msgdata != NULL, NULL);

	return msgdata->content;
}

void xfilter_set_content_filter_func(XContentFilter *filter, XContentFilterFunc func)
{
	g_return_if_fail(XFILTER(filter)->type == XF_CONTENT);

	filter->content_filter_func = func;
}

void xfilter_set_test_filter_func(XTestFilter *filter, XTestFilterFunc func)
{
	g_return_if_fail(XFILTER(filter)->type == XF_TEST);

	filter->test_filter_func = func;
}

XFilterStatus xfilter_exec(XFilter *filter, const XMessageData *msgdata, XMessageData **retdata)
{
	g_return_val_if_fail(filter != NULL, XF_ERROR);
	g_return_val_if_fail(msgdata != NULL, XF_ERROR);

	if (filter->type == XF_CONTENT) {
		if (!X_CONTENT_FILTER(filter)->content_filter_func)
			return XF_ERROR;
		return X_CONTENT_FILTER(filter)->content_filter_func(filter, msgdata, retdata);
	} else {
		if (!X_TEST_FILTER(filter)->test_filter_func)
			return XF_ERROR;
		return X_TEST_FILTER(filter)->test_filter_func(filter, msgdata);
	}
}

void xfilter_result_print(XFilterResult *result)
{
	printf("XFilterResult: status = %d, probability = %f\n", result->status, result->probability);
}

XFilterResult *xfilter_result_new(void)
{
	XFilterResult *res;

	res = g_new0(XFilterResult, 1);
	res->status = XF_NONE;
	res->probability = 0.5;
	return res;
}

XFilterStatus xfilter_result_get_status(XFilterResult *result)
{
	g_return_val_if_fail(result != NULL, XF_ERROR);

	return result->status;
}

XMessageData *xfiltrer_result_get_message_data(XFilterResult *result)
{
	g_return_val_if_fail(result != NULL, NULL);

	return result->msgdata;
}

void xfilter_result_free(XFilterResult *result)
{
	if (!result)
		return;
	xfilter_message_data_free(result->msgdata);
	g_free(result);
}

void xfilter_debug_print(const char *format, ...)
{
	va_list args;
	char buf[1024];

	if (!xfilter_debug_mode)
		return;

	va_start(args, format);
	g_vsnprintf(buf, sizeof(buf), format, args);
	va_end(args);

	fputs(buf, stderr);
}