#inlcude <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <uthash/uthash.h>

#include "session_exporter.h"

struct transaction_unique_key
{
	const char decode_as[16];
	long long transaction_sequence;
};

struct exporter_transaction
{
	struct utable_kv *context;
	long long unique_index;
	struct transaction_unique_key key;
	UT_hash_handle hh;
};

struct exporter_context
{
	struct utable_kv *default_cotext;
	long long transaction_offset;
	struct exporter_transaction *transactions;
};

int is_session_record_enabled(struct exporter *exporter)
{
	return 0;
}

const char *exporter_get_security_settings(struct exporter *exporter, int t_vsys_id)
{
	return NULL;
}

void exporter_enable_brief_session_record(struct exporter *exporter, struct session *session)
{

}

void exporter_enable_elaborate_session_record(struct exporter *exporter, struct session *session)
{

}

struct exporter_context *exporter_get_default_context_on_session(struct exporter *exporter, struct session *sess)
{
	if(is_session_record_enabled(exporter))
	{
	}

	struct exporter_context *context=(struct exporter_context *)session_get_exdata(sess, exporter->exdata_idx);
	if(context==NULL)
	{
		context=(struct exporter_context *)CALLOC(struct exporter_context, 1);
		context->default_ctx=kv_new();
		session_set_exdata(sess, exporter->exdata_idx, context);
	}

	return context;
}

struct exporter_context *exporter_release_transaction_context(struct exporter *exporter, struct session *sess, struct exporter_context *context)
{

}

struct exporter_context *exporter_aquire_transaction_context(struct exporter *exporter, struct session *sess, const char *decode_as, long long transaction_sequence)
{
	if(is_session_record_enabled(exporter))
	{
	}

	struct exporter_context *context=(struct exporter_context *)session_get_exdata(sess, exporter->exdata_idx);
	if(context==NULL)
	{
		context=(struct exporter_context *)CALLOC(struct exporter_context, 1);
		context->default_ctx=kv_new();
		session_set_exdata(sess, exporter->exdata_idx, context);
	}

	struct transaction_unique_key key;
	memcpy(key.decode_as, decode_as, MIN(sizeof(key.decode_as), strlen(decode_as)));
	key.transaction_sequence=transaction_sequence;

	struct exporter_transaction *transaction=NULL;
	HASH_FIND(hh, context->transactions, &key, sizeof(struct transaction_unique_key), transaction);
	if(transaction!=NULL)
	{
		return transaction->context;
	}

	struct exporter_transaction *transaction=(struct exporter_transaction *)CALLOC(struct exporter_transaction, 1);
	transaction->transaction_ctx=kv_new();
	transaction->unique_index=context->transaction_offset++;
	strncpy(transaction->key.decode_as, decode_as, MIN(sizeof(transaction->key.decode_as), strlen(decode_as)));
	transaction->key.transaction_sequence=transaction_sequence;
	HASH_ADD(hh, context->transactions, key, sizeof(struct transaction_unique_key), transaction);
}

void exporter_context_add_kv(struct exporter_context *ctx, struct utable_kv *kv)
{
	
}

static void session_exporter_callback_on_session(struct session *sess, enum session_state state, struct packet *pkt, void *args)
{

}

struct exporter *exporter_module_to_exporter(struct module *mod)
{
	if(mod==NULL)return NULL;
	if(strcmp(module_get_name(mod), EXPORTER_MODULE_NAME)!=0)return NULL;
	return (struct exporter *)module_get_ctx(mod);
}

struct module *exporter_module_init(struct module_manager *mod_mgr)
{
	if(mod_mgr==NULL)return NULL;

	struct exporter *exporter=CALLOC(struct exporter, 1);
	struct module *mod=module_new(EXPORTER_MODULE_NAME, (void *)exporter);
	if(mod==NULL)
	{
		goto INIT_ERROR;
	}

	exporter->mod_mgr=mod_mgr;
	exporter->logger=module_manager_get_logger(mod_mgr);

	struct module *sess_mgr_mod=module_manager_get_module(mod_mgr, SESSION_MANAGER_MODULE_NAME);
	struct session_manager *sess_mgr=module_to_session_manager(sess_mgr_mod);
	struct mq_schema *mq_s=module_manager_get_mq_schema(mod_mgr);

	if(sess_mgr==NULL || mq_s==NULL)
	{
		STELLAR_LOG_FATAL(exporter->logger, EXPORTER_MODULE_NAME, "session_scanner_new failed to get session manager or mq schema");
		goto INIT_ERROR;
	}

	session_manager_subscribe_tcp(sess_mgr, session_exporter_callback_on_session, exporter);
	session_manager_subscribe_udp(sess_mgr, session_exporter_callback_on_session, exporter);

	// int max_thread_num=module_manager_get_max_thread_num(mod_mgr);
	// const char *toml_path=module_manager_get_toml_path(mod_mgr);

	// return -1 if failed
	kafka_parameter_get(struct kafka_parameter *kafka);

	return mod;

INIT_ERROR:
	exporter_module_exit(mod_mgr, mod);
	exit(-1);
	return NULL;
}

void exporter_module_exit(struct module_manager *mod_mgr, struct module *mod)
{
	if(mod_mgr==NULL)return;
	if(mod)
	{
		struct exporter *exporter=(struct exporter *)module_get_ctx(mod);
		FREE(exporter);
		module_free(mod);
	}
}