#include "kni_utils.h"
#include "kni_maat.h"

extern int g_iThreadNum;

void kni_maat_destroy(struct kni_maat_handle *handle){
	if(handle != NULL){
		if(handle->feather != NULL){
			Maat_burn_feather(handle->feather);
		}
	}
	FREE(&handle);
}

struct kni_maat_handle* kni_maat_init(const char* profile, void *logger){
	const char *section = "maat";
	int readconf_mode;
	char tableinfo_path[KNI_PATH_MAX];
	char tablename_intercept_compile[KNI_SYMBOL_MAX];
	MESA_load_profile_int_def(profile, section, "readconf_mode", &readconf_mode, KNI_MAAT_READCONF_IRIS);
	MESA_load_profile_string_def(profile, section, "tableinfo_path", tableinfo_path, sizeof(tableinfo_path), "unknown");
	MESA_load_profile_string_def(profile, section, "tablename_intercept_compile", tablename_intercept_compile, sizeof(tablename_intercept_compile), "unknown");
	KNI_LOG_INFO(logger, "MESA_prof_load, [%s]:\n readconf_mode: %d\n tableinfo_path: %s\n tablename_intercept_compile: %s\n", 
		section, readconf_mode, tableinfo_path, tablename_intercept_compile);
	Maat_feather_t feather = Maat_feather(g_iThreadNum, tableinfo_path, logger);
	if(feather == NULL){
		KNI_LOG_ERROR(logger, "Failed at Maat_feather, max_thread_num is %d, tableinfo_path is %s", g_iThreadNum, tableinfo_path);
		return NULL;
	}
	if(readconf_mode == KNI_MAAT_READCONF_JSON){
		char maatjson_path[KNI_PATH_MAX];
		MESA_load_profile_string_def(profile, section, "maatjson_path", maatjson_path, sizeof(maatjson_path), "unknown");
		KNI_LOG_INFO(logger, "MESA_prof_load, [%s]:\n maatjson_path: %s", section, maatjson_path);
		Maat_set_feather_opt(feather, MAAT_OPT_JSON_FILE_PATH, maatjson_path, strlen(maatjson_path));
	}
	if(readconf_mode == KNI_MAAT_READCONF_IRIS){
		//TODO
	}
	if(readconf_mode == KNI_MAAT_READCONF_REDIS){
		char redis_ip[KNI_SYMBOL_MAX];
		int redis_port;
		int redis_index;
		MESA_load_profile_string_def(profile, section, "redis_ip", redis_ip, sizeof(redis_ip), "unknown");
		MESA_load_profile_int_def(profile, section, "redis_port", &redis_port, -1);
		MESA_load_profile_int_def(profile, section, "redis_index", &redis_index, -1);
		KNI_LOG_INFO(logger, "MESA_prof_load, [%s]:\n redis_ip: %s\n redis_port: %s\n redis_index: %d", 
			section, redis_ip, redis_port, redis_index);
		Maat_set_feather_opt(feather, MAAT_OPT_REDIS_IP, (void*)redis_ip, strlen(redis_ip) + 1);
		Maat_set_feather_opt(feather, MAAT_OPT_REDIS_PORT, (void*)&redis_port, sizeof(redis_port));
		Maat_set_feather_opt(feather, MAAT_OPT_REDIS_INDEX, (void*)&redis_index, sizeof(redis_index));
	}
	int ret = Maat_initiate_feather(feather);
	if(ret < 0){
		KNI_LOG_ERROR(logger, "Failed at Maat_initiate_feather");
		return NULL;
	}
	int tableid_intercept_compile = Maat_table_register(feather, tablename_intercept_compile);
	if(tableid_intercept_compile < 0){
		KNI_LOG_ERROR(logger, "Failed at Maat_table_register, tablename is %d, ret is %d", 
					  tablename_intercept_compile, tableid_intercept_compile);
		return NULL;
	}
	struct kni_maat_handle *handle = ALLOC(struct kni_maat_handle, 1);
	handle->feather = feather;
	handle->tableid_intercept_compile = tableid_intercept_compile;
	handle->default_action = KNI_ACTION_INTERCEPT;
	handle->logger = logger;
	return handle;
}

static int maat_process_scan_result(struct kni_maat_handle *handle, int num, struct Maat_rule_t *result){
	//void *logger = handle->logger;
	int action = handle->default_action;
	for(int i = 0; i < num; i++){
		action = result[i].action;
		if(action == KNI_ACTION_BYPASS){
			return action;
		}
	}
	return action;
}


//TODO: Maat_rule_get_ex_new_index   compile_ex_param_new: config_id = 0, 取action即为全局变量, 一旦配置更新就回调, tableinfo怎么写，回调表， 编译配置表 
int kni_maat_scan_ip(struct kni_maat_handle *handle, struct ipaddr *addr, int thread_seq){
	void *logger = handle->logger;
	struct Maat_rule_t result[KNI_MAAT_RULE_NUM_MAX];
	int ret = Maat_scan_proto_addr(handle->feather, handle->tableid_intercept_compile, addr, 0, result, 
								KNI_MAAT_RULE_NUM_MAX, NULL, thread_seq);
	if(ret < 0){
		KNI_LOG_ERROR(logger, "Failed at Maat_scan_proto_addr, ret is %d", ret);
		return handle->default_action;
	}
	return maat_process_scan_result(handle, ret, result);
}

int kni_maat_scan_domain(struct kni_maat_handle* handle, char *domain, int domain_len, int thread_seq){
	void *logger = handle->logger;
	struct Maat_rule_t result[KNI_MAAT_RULE_NUM_MAX];
	//TODO: GBK
	int ret = Maat_full_scan_string(handle->feather, handle->tableid_intercept_compile, CHARSET_GBK, 
			domain, domain_len, result, NULL, KNI_MAAT_RULE_NUM_MAX, NULL, thread_seq);
	if(ret < 0){
		KNI_LOG_ERROR(logger, "Failed at Maat_full_scan_string, ret is %d", ret);
		return handle->default_action;
	}
	return maat_process_scan_result(handle, ret, result);
}