
#include <stdio.h>
#include <stdlib.h>
#include <tfe_http.h>
#include <tfe_plugin.h>

const char * __str_std_header_field_map[] =
{
	[TFE_HTTP_UNKNOWN_FIELD] = NULL,
	[TFE_HTTP_HOST] = "Host",
	[TFE_HTTP_REFERER] = "Referer",
	[TFE_HTTP_USER_AGENT] = "User-Agent",
	[TFE_HTTP_COOKIE] = "Cookie",
	[TFE_HTTP_SET_COOKIE]="Set-Cookie",
	[TFE_HTTP_PROXY_AUTHORIZATION] = "Proxy-Authorization",
	[TFE_HTTP_AUTHORIZATION] = "Authorization",
	[TFE_HTTP_LOCATION] = "Location",
	[TFE_HTTP_SERVER] = "Server",
	[TFE_HTTP_ETAG] = "Etag",
	[TFE_HTTP_DATE] = "Date",
	[TFE_HTTP_TRAILER] = "Trailer",
	[TFE_HTTP_TRANSFER_ENCODING] = "Transfer-Encoding",
	[TFE_HTTP_VIA] = "Via",
	[TFE_HTTP_PRAGMA] = "Pragma",
	[TFE_HTTP_CONNECTION] = "Connection",
	[TFE_HTTP_CONT_ENCODING] = "Content-Encoding",
	[TFE_HTTP_CONT_LANGUAGE] = "Content-Language",
	[TFE_HTTP_CONT_LOCATION] = "Content-Location",
	[TFE_HTTP_CONT_RANGE] = "Content-Range",
	[TFE_HTTP_CONT_LENGTH] = "Content-Length",
	[TFE_HTTP_CONT_TYPE] = "Content-Type",
	[TFE_HTTP_CONT_DISPOSITION] = "Content-Disposition",
	[TFE_HTTP_EXPIRES] = "Expires",
	[TFE_HTTP_ACCEPT_ENCODING] = "Accept-Encoding",
	[TFE_HTTP_CACHE_CONTROL] = "Cache-Control",
	[TFE_HTTP_IF_MATCH] = "If-Match",
	[TFE_HTTP_IF_NONE_MATCH] = "If-None-Match",
	[TFE_HTTP_IF_MODIFIED_SINCE] = "If-Modified-Since",
	[TFE_HTTP_IF_UNMODIFIED_SINCE] = "If-Unmodified-Since",
 	[TFE_HTTP_LAST_MODIFIED] = "Last-Modified"
};
const unsigned int __str_std_header_field_map_size = sizeof(__str_std_header_field_map) / sizeof(__str_std_header_field_map[0]);

static const char * __str_std_method_map[1024] = {};
void __str_std_method_map_init() __attribute__((constructor, used));
void __str_std_method_map_init()
{
#define XX(num, name, string) __str_std_method_map[TFE_HTTP_METHOD_##name] = #string;
	__HTTP_METHOD_MAP(XX)
#undef XX
}

static const char * __str_std_status_map[1024] = {};
void __str_std_status_map_init() __attribute__((constructor, used));
void __str_std_status_map_init()
{
#define XX(num, name, string) __str_std_status_map[TFE_HTTP_STATUS_##name] = #string;
	__HTTP_STATUS_MAP(XX)
#undef XX
}

const char * http_std_method_to_string(enum tfe_http_std_method method)
{
	return __str_std_method_map[method];
}

const char * http_std_status_to_string(enum tfe_http_std_status status)
{
	return __str_std_status_map[status];
}

struct http_field_name * http_field_name_duplicate(const struct http_field_name * orig)
{
	struct http_field_name * __duplicated = ALLOC(struct http_field_name, 1);
	assert(__duplicated != NULL);

	if (orig->field_id == TFE_HTTP_UNKNOWN_FIELD)
	{
		__duplicated->field_id = TFE_HTTP_UNKNOWN_FIELD;
		__duplicated->field_name = tfe_strdup(orig->field_name);
	}
	else
	{
		__duplicated->field_id = orig->field_id;
		__duplicated->field_name = NULL;
	}

	return __duplicated;
}

int http_field_name_compare(const struct http_field_name * lvalue, const struct http_field_name * rvalue)
{
	if (lvalue->field_id != rvalue->field_id)
	{
		return (lvalue->field_id - rvalue->field_id);
	}

	/* unknown field, compare field_name in string */
	if (lvalue->field_id == TFE_HTTP_UNKNOWN_FIELD)
	{
		return strcasecmp(lvalue->field_name, rvalue->field_name);
	}

	/* field_id is equal, but not unknown, hit */
	return 0;
}

struct http_field_name * http_field_construct_from_string(const char * str_field)
{
	return NULL;
}

const char * http_field_name_to_string(const struct http_field_name * field)
{
	if (field->field_id != TFE_HTTP_UNKNOWN_FIELD) return __str_std_header_field_map[field->field_id];
	return field->field_name;
}

void http_field_name_destory(struct http_field_name * field)
{
	if(field->field_id == TFE_HTTP_UNKNOWN_FIELD) free((void*)field->field_name);
	FREE(&(field));
}

struct http_frame_session_ctx
{
	struct http_frame_plugin_status * plugin_status;
	unsigned int nr_plugin_status;

	struct tfe_plugin * calling_plugin;
	struct http_frame_plugin_status * calling_plugin_status;
};

struct http_frame_plugin_status * http_frame_current_plugin_status(struct http_frame_session_ctx * ht_frame)
{
	return ht_frame->calling_plugin_status;
}

struct http_frame_session_ctx * http_frame_alloc()
{
	struct http_frame_session_ctx * ht_frame = ALLOC(struct http_frame_session_ctx, 1);
	ht_frame->nr_plugin_status = tfe_plugin_total_counts();
	ht_frame->plugin_status = ALLOC(struct http_frame_plugin_status, ht_frame->nr_plugin_status);
	return ht_frame;
}

int http_frame_raise_session_begin(struct http_frame_session_ctx * ht_frame,
	const struct tfe_stream * stream, struct tfe_http_session * ht_session, unsigned int thread_id)
{
	unsigned int __for_each_iterator = 0;
	unsigned int __plugin_id = 0;

	struct tfe_plugin * plugin_info_iter;
	TFE_PLUGIN_FOREACH(plugin_info_iter, &__for_each_iterator)
	{
		__plugin_id++;
		if (plugin_info_iter->on_session_begin == NULL) continue;

		/* Calling ctx, in callback can fetch by calling frame_plugin_status_get_XXX */
		ht_frame->calling_plugin = plugin_info_iter;
		ht_frame->calling_plugin_status = &ht_frame->plugin_status[__plugin_id - 1];

		/* Call session begin */
		void ** calling_pme = &ht_frame->calling_plugin_status->pme;
		plugin_info_iter->on_session_begin(stream, ht_session, thread_id, calling_pme);
	}

	/* Clear calling ctx */
	ht_frame->calling_plugin = NULL;
	ht_frame->calling_plugin_status = NULL;
	return 0;
};

void http_frame_raise_session_end(struct http_frame_session_ctx * ht_frame, const tfe_stream * stream,
	struct tfe_http_session * ht_session, unsigned int thread_id)
{
	unsigned int __for_each_iterator = 0;
	unsigned int __plugin_id = 0;
	struct tfe_plugin * plugin_info_iter;

	TFE_PLUGIN_FOREACH(plugin_info_iter, &__for_each_iterator)
	{
		__plugin_id++;
		if (plugin_info_iter->on_session_end == NULL) continue;

		/* Calling ctx, in callback can fetch by calling frame_plugin_status_get_XXX */
		ht_frame->calling_plugin = plugin_info_iter;
		ht_frame->calling_plugin_status = &ht_frame->plugin_status[__plugin_id - 1];

		/* Call session end */
		void ** calling_pme = &ht_frame->calling_plugin_status->pme;
		plugin_info_iter->on_session_end(stream, ht_session, thread_id, calling_pme);
	}

	ht_frame->calling_plugin = NULL;
	ht_frame->calling_plugin_status = NULL;

	free(ht_frame->plugin_status);
	free(ht_frame);
}

void http_frame_raise_event(struct http_frame_session_ctx * ht_frame,
	const struct tfe_stream * stream, struct tfe_http_session * ht_session, enum tfe_http_event event,
	const unsigned char * data, size_t datalen, unsigned int thread_id)
{
	unsigned int __for_each_iterator = 0;
	unsigned int __plugin_id = 0;

	struct tfe_plugin * plugin_info_iter;
	TFE_PLUGIN_FOREACH(plugin_info_iter, &__for_each_iterator)
	{
		__plugin_id++;
		if (plugin_info_iter->on_session_data == NULL)
		{
			continue;
		}

		/* Calling ctx, in callback can fetch by calling frame_plugin_status_get_XXX */
		ht_frame->calling_plugin = plugin_info_iter;
		ht_frame->calling_plugin_status = &ht_frame->plugin_status[__plugin_id - 1];

		if (ht_frame->calling_plugin_status->detached)
		{
			continue;
		}

		void ** calling_pme = &ht_frame->calling_plugin_status->pme;
		if (plugin_info_iter->on_session_data(stream, ht_session, event, data, datalen, thread_id, calling_pme) == NO_CALL_NEXT_PLUGIN)
		{
			break;
		}
	}

	ht_frame->calling_plugin = NULL;
	ht_frame->calling_plugin_status = NULL;
}

void http_frame_currect_plugin_detach(struct http_frame_session_ctx * ht_frame)
{
	ht_frame->calling_plugin_status->detached = 1;
}

int http_frame_currect_plugin_preempt(struct http_frame_session_ctx * ht_frame)
{
	for(unsigned int i = 0; i < ht_frame->nr_plugin_status; i++)
	{
		struct http_frame_plugin_status * __plugin_status = &ht_frame->plugin_status[i];
		if (__plugin_status->is_preempted) return -1;
	}

	//TODO:
	//assert(ht_frame->calling_plugin_status != NULL);
	//ht_frame->calling_plugin_status->is_preempted = 1;
	return 0;
}
