// Copyright (c) Hercules Dev Team & hemagx, licensed under GNU GPL.
// See the LICENSE file

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

#include "../common/HPMi.h"
#include "../common/mmo.h"
#include "../common/malloc.h"
#include "../common/strlib.h"
#include "../map/atcommand.h"
#include "../map/pc.h"
#include "../map/clif.h"
#include "../../3rdparty/pcre/include/pcre.h"


#include "../common/HPMDataCheck.h" // should always be the last file included! (if you don't make it last, it'll intentionally break compile time)

HPExport struct hplugin_info pinfo = {
	"PCRE Chat Filter",
	SERVER_TYPE_MAP,
	"0.1",
	HPM_VERSION,
};

struct manner_pcre {
	pcre *regex;
	pcre_extra *extra;
};

struct manner_config {
	int min_gm_level;
	int mute_after;
	int mute_time;
	char bypass_var[64];
};

struct manner_pcre *mannerlist = NULL;
struct manner_config config = {60, 0, 0, "chat_filter"};
unsigned int mannersize = 0;
unsigned int bypass_chat_filter = UINT_MAX - 1;

bool filter_chat(bool retVal, struct map_session_data *sd, int *format, char **name_, size_t *namelen_, char **message_, size_t *messagelen_) {
	char *message = *message_;
	unsigned int i;
	int mute_times;

	if( !retVal || !message )
		return false;

	if( !mannersize || pc_has_permission(sd, bypass_chat_filter) )
		return true;

	if ((pc_get_group_level(sd) >= config.min_gm_level) || (pc_readglobalreg(sd, script->add_str(config.bypass_var))))
		return true;

	for(i = 0; i < mannersize; i++) {
		if(pcre_exec(mannerlist[i].regex, mannerlist[i].extra, message, (int)strlen(message), 0, 0, NULL, 0) != PCRE_ERROR_NOMATCH) {
			char output[254];
			safesnprintf(output, 254, "Chat Filter: Yeah, uh, I don't think so, buddy...");
			clif->colormes(sd->fd, COLOR_RED, output);
			if ( config.mute_after > 0 ) {
				mute_times = pc_readglobalreg(sd, script->add_str("mute_filter"));
				if ( mute_times == config.mute_after ) {
					status->change_start( NULL, &sd->bl, SC_NOCHAT, 100, 0, 0,0,0,config.mute_time * 60 * 1000, 0);
	//				status->change_start( NULL, &sd->bl, SC_TRICKDEAD, 10000, 1, 0, 0, 0, 1000, 0);
					clif->GM_silence(sd, sd, 1);
					pc_setglobalreg(sd, script->add_str("mute_filter"), 0);
				}else{
					pc_setglobalreg(sd, script->add_str("mute_filter"), mute_times + 1);
				}
			}
			return false;
		}
	}

	return true;
}

bool read_manner(const char* confpath) {
	FILE* fp;
	char line[1024], param[1024];
	const char *error = NULL;
	int offset;
	pcre *regex = NULL;
	pcre_extra *extra = NULL;

	fp = fopen(confpath, "r");
	if (fp == NULL) {
		ShowError("File not found: '%s'.\n", confpath);
		return false;
	}
	while(fgets(line, sizeof(line), fp)) {

		if((line[0] == '/' && line[1] == '/') || ( line[0] == '\0' || line[0] == '\n' || line[0] == '\r'))
			continue;

		if (sscanf(line, "%1023s", param) != 1)
			continue;

		regex = pcre_compile(param, 0, &error, &offset, NULL);
		if ( regex == NULL ) {
			ShowError("Could not compile regex '%s'. Error: '%s'.\n", param, error);
			continue;
		}
		extra = pcre_study(regex, 0, &error);
		if (error != NULL) {
			ShowError("Could not optimize '%s' Error: '%s'.\n", param, error);
			continue;
		}
		//ShowDebug("Loaded '%s'\n", param);
		RECREATE(mannerlist, struct manner_pcre, mannersize + 1);
		mannerlist[mannersize].regex = regex;
		mannerlist[mannersize].extra = extra;
		mannersize++;
	}
	ShowStatus("Done reading '"CL_WHITE"%d"CL_RESET"' entries in '"CL_WHITE"%s"CL_RESET"'.\n", mannersize, confpath);
	return true;
}

bool read_manner_config(const char* confpath) {
	char line[1024], w1[1024], w2[1024];
	FILE* fp;

	fp = fopen(confpath, "r");
	if (fp == NULL) {
		ShowError("File not found: '%s' \n", confpath);
		return false;
	}
	while(fgets(line, sizeof(line), fp))
	{
		if(line[0] == '/' && line[1] == '/')
			continue;

		if (sscanf(line, "%[^:]: %[^\r\n]", w1, w2) != 2)
			continue;

		if(!strcmpi(w1, "gm_min_level"))
			config.min_gm_level = atoi(w2);
		else if (!strcmpi(w1, "mute_after"))
			config.mute_after = atoi(w2);
		else if (!strcmpi(w1, "mute_time"))
			config.mute_time = atoi(w2);
		else if (!strcmpi(w1, "bypass_var"))
			strncpy(config.bypass_var, w2, sizeof(config.bypass_var));
	}

	ShowStatus("Chat filter configuration has been loaded.\n");
	return true;
}

void clean_manner(void) {
	unsigned int i;

	for (i = 0; i < mannersize; i++) {

		pcre_free(mannerlist[i].regex);

		if (mannerlist[i].extra)
			pcre_free(mannerlist[i].extra);
	}
	aFree(mannerlist);
	mannerlist = NULL;
	mannersize = 0;
}

ACMD(reloadmanner) {
	
	clean_manner();
	read_manner("conf/plugin/manner.txt");
	read_manner_config("conf/plugin/manner.conf");
	return true;
}

HPExport void plugin_init(void) {

	clif = GET_SYMBOL("clif");
	pc = GET_SYMBOL("pc");
	iMalloc = GET_SYMBOL("iMalloc");
	strlib = GET_SYMBOL("strlib");
	script = GET_SYMBOL("script");
	status = GET_SYMBOL("status");
	addGroupPermission("bypass_chat_filter", bypass_chat_filter);
	addHookPost("clif->process_message", filter_chat);
	addAtcommand("reloadmanner", reloadmanner);
	read_manner("conf/plugin/manner.txt");
	read_manner_config("conf/plugin/manner.conf");
}
HPExport void plugin_final(void) {
	clean_manner();
}