#include <sourcemod>
#include <sdktools_voice>

enum MUTE_SQL_SLOTS {
	MUTE_SQL_SLOT_ID = 0,
	MUTE_SQL_SLOT_STEAM_ID,
	MUTE_SQL_SLOT_PLAYER_NAME,
	MUTE_SQL_SLOT_MUTE_LENGTH,
	MUTE_SQL_SLOT_MUTE_REASON,
	MUTE_SQL_SLOT_MUTE_BY,
	MUTE_SQL_SLOT_MUTE_BY_ID,
	MUTE_SQL_SLOT_TIMESTAMP,
	MUTE_SQL_SLOT_ACTIVE,
	MUTE_SQL_SLOT_UNMUTE_TIMESTAMP,
	MUTE_SQL_SLOT_UNMUTE_BY_ID,
	MUTE_SQL_SLOT_TIMESTAMP_UNIX
}

enum struct player_settings {
	bool muted;
	int muted_time;
	int last_ping;
}

player_settings g_MutePlayers[MAXPLAYERS];

//MYSQL QUERYS
char g_SQL_QUERY_SEARCH_MUTE[512] = "SELECT *, UNIX_TIMESTAMP(timestamp) FROM %s WHERE active = '1' AND steam_id = '%s' ORDER BY `id` DESC";
char g_SQL_QUERY_MUTE[512] = "INSERT INTO %s (steam_id, player_name, mute_length, mute_reason, mute_by, mute_by_id, timestamp) VALUES ('%s','%s','%i','%s','%s','%s',CURRENT_TIMESTAMP)";
char g_SQL_QUERY_UNMUTE[512] = "UPDATE %s SET active = '0', unmute_by_id = '%s', unmute_timestamp = CURRENT_TIMESTAMP WHERE id = %i";

//CONST
int g_ping_in_seconds = 300;
char g_MuteChatPrefix[16] = "[FSB.Mutes]";
char g_MuteTableName[32] = "light_mutes";
Handle g_hMuteDatabase = INVALID_HANDLE;
Handle g_MuteTimer = INVALID_HANDLE;

//FUNCTIONS
stock void MuteSetup(){
	RegConsoleCmd("sm_fsb_mutecheck", 	MuteSelfStatus);
	RegAdminCmd("sm_fsb_mute", MuteAddCmd, ADMFLAG_ROOT);
	RegAdminCmd("sm_fsb_unmute", MuteRemoveCmd, ADMFLAG_ROOT);

	if(g_MuteTimer != INVALID_HANDLE) KillTimer(g_MuteTimer);
	g_MuteTimer = CreateTimer(1.0, MuteTimerCallback, _, TIMER_REPEAT|TIMER_FLAG_NO_MAPCHANGE)
}

stock void MuteDeSetup(){
	if(g_MuteTimer != INVALID_HANDLE) KillTimer(g_MuteTimer);
}

stock void MuteSetPlayer(int client, int mute_end){
	g_MutePlayers[client].muted = true;
	g_MutePlayers[client].muted_time = mute_end;
	g_MutePlayers[client].last_ping = 0;
	SetClientListeningFlags(client, VOICE_MUTED);
	LogMessage("%L now muted", client);
}

stock void MuteClearPlayer(int client, bool broadcast = false){
	g_MutePlayers[client].muted = false;
	g_MutePlayers[client].muted_time = 0;
	g_MutePlayers[client].last_ping = 0;
	SetClientListeningFlags(client, VOICE_LISTENALL);
	if(broadcast) PrintToChat(client, "У тебя включен микрофон");
}

stock void MuteCheckPlayer(int client){
	char Query[1024], client_auth[32];
	GetClientAuthId(client, AuthId_Steam2, client_auth, sizeof(client_auth));
	Format(Query, sizeof(Query), g_SQL_QUERY_SEARCH_MUTE, g_MuteTableName, client_auth);
	SQL_TQuery(g_hMuteDatabase, Callback_MuteCheck, Query, GetClientUserId(client));
	return;
}

stock void SecondsToHuman(int seconds, char[] human, int human_size){
	if(seconds > 60){
		int minutes = seconds / 60;
		int seconds = seconds % 60;
		if(minutes > 60){
			int hours = minutes / 60;
			int minutes = minutes % 60;
			if(hours > 24){
				int days = hours / 24;
				int hours = hours % 24;
				Format(human, human_size, "%i дней %i часов %i минут %i секунд", days, hours, minutes, seconds);
			} else {
				Format(human, human_size, "%i часов %i минут %i секунд", hours, minutes, seconds);
			}
		} else {
			Format(human, human_size, "%i минут %i секунд", minutes, seconds);
		}
	} else {
		Format(human, human_size, "%i секунд", seconds);
	}
}

stock void MuteAddToDB(int client, int length, const char[] mute_reason, const char[] mute_by_id = "STEAM_0:0:0"){
	if(g_MutePlayers[client].muted) return;

	MuteSetPlayer(client, GetTime()+length);

	char steam_id[32], player_name[65];
	GetClientAuthId(client, AuthId_Steam2, steam_id, sizeof(steam_id));
	GetClientName(client, player_name, sizeof(player_name));

	char query[1024];
	Format(query, sizeof(query), g_SQL_QUERY_MUTE, g_MuteTableName, steam_id, player_name, length, mute_reason, "console", mute_by_id);
	SQL_TQuery(g_hMuteDatabase,  DB_MuteProcessing, query, GetClientUserId(client));
	return;
}

stock void MuteRemoveFromDB(int admin, const char[] steam_id){
	char query[1024];
	Format(query, sizeof(query), g_SQL_QUERY_SEARCH_MUTE, g_MuteTableName, steam_id);
	SQL_TQuery(g_hMuteDatabase, Callback_MuteUnMute, query, GetClientUserId(admin));
	ReplyToCommand(admin, "Try found %s on DB and unmute", steam_id);
	return;
}

stock bool MuteOnServerCheck(const char[] steam_id){
	char auth[32];

	for (int client = 1; client <= MaxClients; client++){
		if(g_MutePlayers[client].muted){
			GetClientAuthId(client, AuthId_Steam2, auth, sizeof(auth));
			if(strcmp(steam_id, auth) == 0){
				MuteClearPlayer(client, true);
				return true;
			}
			auth[0] = '\0';
		}
	}
}

stock MuteUserCheck(int client) {
	if(!g_MutePlayers[client].muted) return;

	bool ping_client = false;
	if(GetTime() - g_MutePlayers[client].last_ping > g_ping_in_seconds){
		g_MutePlayers[client].last_ping = GetTime();
		ping_client = true;
	}

	if(g_MutePlayers[client].muted_time > 0) {
		if(GetTime() > g_MutePlayers[client].muted_time){
			MuteCheckPlayer(client);
			return;
		} else {
			if(ping_client){
				int mute_range = g_MutePlayers[client].muted_time - GetTime();
				char human_time[128];
				SecondsToHuman(mute_range, human_time, sizeof(human_time));
				PrintToChat(client, "У тебя выключен микрофон на %s", human_time);
				//ShowSyncHudText(client, g_MuteHUD, "У тебя выключен микрофон на %s", human_time);
			}
			return;
		}
	} else {
		if(ping_client)	PrintToChat(client, "У тебя выключен микрофон навсегда!");
		return;
	}
}

//TIMERS
public Action MuteTimerCallback(Handle timer){
	for (int client = 1; client <= MaxClients; client++){
		MuteUserCheck(client);
	}
}

//LISTENERS
/*
public Action VoiceTransmit(int client, const char[] command, int args){
	if(!g_MutePlayers[client].muted)	return Plugin_Continue;

	if(g_MutePlayers[client].muted_time > 0) {
		if(GetTime() > g_MutePlayers[client].muted_time){
			MuteCheckPlayer(client);
			return Plugin_Continue;
		} else {
			int mute_range = g_MutePlayers[client].muted_time - GetTime();
			SetHudTextParams(-1.0, 0.55, 1.0, GetRandomInt(0, 255), GetRandomInt(0, 255), GetRandomInt(0, 255), 255);
			char human_time[128];
			SecondsToHuman(mute_range, human_time, sizeof(human_time));
			ShowSyncHudText(client, g_MuteHUD, "У тебя выключен микрофон на %s", human_time);
			return Plugin_Stop;
		}
	} else {
		ShowSyncHudText(client, g_MuteHUD, "У тебя выключен микрофон навсегда!");
		return Plugin_Stop;
	}
}
 */
//MYSQL
public DB_MuteProcessing(Handle:owner, Handle:hndl, const String:error[], any:data) {
	if (hndl == INVALID_HANDLE) {
		LogError("%s Query failed! %s", g_MuteChatPrefix, error);
	}
	return;
}

//MYSQL CALLBACKS
public Callback_MuteCheck(Handle:owner, Handle:hndl, const String:error[], any:data) {
	int client;
	if ((client = GetClientOfUserId(data)) == 0) {
		return;
	}

	if (hndl == INVALID_HANDLE) {
		LogError("%s Query failed! %s", g_MuteChatPrefix, error);
		return;
	}

	if (SQL_FetchRow(hndl)) {
		int length = SQL_FetchInt(hndl, MUTE_SQL_SLOT_MUTE_LENGTH);
		if(length > 0){
			int mute_end = SQL_FetchInt(hndl, MUTE_SQL_SLOT_TIMESTAMP_UNIX) + length;
			if (GetTime() > mute_end){
				MuteClearPlayer(client);
				char Query[1024];
				int mute_id = SQL_FetchInt(hndl, MUTE_SQL_SLOT_ID);
				Format(Query, sizeof(Query), g_SQL_QUERY_UNMUTE, g_MuteTableName, "STEAM_0:0:0", mute_id);
				SQL_TQuery(g_hMuteDatabase, DB_MuteProcessing, Query);
				LogMessage("%s Player: %L unmuted by elapse of time: %i seconds", g_MuteChatPrefix, client, GetTime() - mute_end);
				return;
			} else {
				MuteSetPlayer(client, mute_end);
			}
		} else {
			MuteSetPlayer(client, 0);
		}
	} else {
		MuteClearPlayer(client);
		return;
	}
}

public Callback_MuteUnMute(Handle:owner, Handle:hndl, const String:error[], any:data) {
	int client;
	if ((client = GetClientOfUserId(data)) == 0) {
		return;
	}

	if (hndl == INVALID_HANDLE) {
		LogError("%s Query failed! %s", g_MuteChatPrefix, error);
		return;
	}

	if (SQL_FetchRow(hndl)) {
		char query[1024];
		int mute_id = SQL_FetchInt(hndl, MUTE_SQL_SLOT_ID);

		char steam_id[32];
		SQL_FetchString(hndl, MUTE_SQL_SLOT_STEAM_ID, steam_id, sizeof(steam_id));
		MuteOnServerCheck(steam_id);

		char admin_auth[32];
		if(client == 0) admin_auth = "STEAM_0:0:0";
		else GetClientAuthId(client, AuthId_Steam2, admin_auth, sizeof(admin_auth));

		Format(query, sizeof(query), g_SQL_QUERY_UNMUTE, g_MuteTableName, admin_auth, mute_id);
		SQL_TQuery(g_hMuteDatabase, DB_MuteProcessing, query);
		LogMessage("%s Player: %L unmuted by command", g_MuteChatPrefix, client);
		ReplyToCommand(client, "SteamID now unmuted!");
		return;
	} else {
		ReplyToCommand(client, "SteamID not found");
		return;
	}
}

//COMMANDS

public Action MuteAddCmd(int client, int args){
	if(args != 3){
		ReplyToCommand(client, "[SM] Usage: sm_fsb_mute \"target\" \"seconds\"\"reason\"");
		return Plugin_Handled;
	}

	char arg_target[MAX_TARGET_LENGTH], target_name[MAX_TARGET_LENGTH];
	int target_count, target_list[MAXPLAYERS];
	bool tn_is_ml;

	GetCmdArg(1, arg_target, sizeof(arg_target));
	if((target_count = ProcessTargetString(arg_target, client, target_list, MAXPLAYERS, 0, target_name, sizeof(target_name), tn_is_ml)) <= 0){
		ReplyToCommand(client, "Cannot mute, none targets found!");
		return Plugin_Handled;
	}

	char arg_length[32]; int length;
	GetCmdArg(2, arg_length, sizeof(arg_length));
	length = StringToInt(arg_length);

	char reason[64];
	GetCmdArg(3, reason, sizeof(reason));

	char admin_auth[32];
	if (client == 0) admin_auth = "STEAM_0:0:0";
	else GetClientAuthId(client, AuthId_Steam2, admin_auth, sizeof(admin_auth));

	for(int i = 0; i < target_count; i++){
		MuteAddToDB(target_list[i], length, reason, admin_auth);
	}

	ReplyToCommand(client, "Targeted on %i clients", target_count);
	return Plugin_Handled;
}

public Action MuteRemoveCmd(int client, int args){
	if(args == 0){
		ReplyToCommand(client, "[SM] Usage: sm_fsb_unmute \"steam_id\" ");
		return Plugin_Handled;
	}

	char steam_id[32];
	GetCmdArgString(steam_id, sizeof(steam_id));

	MuteRemoveFromDB(client, steam_id);
	return Plugin_Handled;
}

public Action MuteSelfStatus(int client, int args){
	if(g_MutePlayers[client].muted){
		if(g_MutePlayers[client].muted_time){
			char human_time[256];
			SecondsToHuman(g_MutePlayers[client].muted_time - GetTime(), human_time, sizeof(human_time));
			ReplyToCommand(client, "Ты в муте! Кончается: %s", human_time);
		} else {
			ReplyToCommand(client, "Ты в муте! НАВСЕГДА");
		}
	} else {
		ReplyToCommand(client, "Ты НЕ в муте!");
	}
	return Plugin_Handled;
}