/*
	Força: um (livre) clone do jogo Forca
	Copyright (C) 2020-2021  luca0N!

	This program is free software: you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation, either version 3 of the License, or
	(at your option) any later version.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with this program.  If not, see <https://www.gnu.org/licenses/>.

	Entre em contato comigo por e-mail via <luca0n@luca0n.com>.
*/

const WebSocket = require('ws');
const https = require('https');
const fs = require('fs');

const Query = require('./query.js');
const Client = require('./client.js');
const Room = require('./room.js');
const Util = require('./util.js');

const Pontos = require('./pontuação.js');

var vars = JSON.parse(fs.readFileSync('config.json', 'UTF8')).vars;

var versão = "v1.1";

const server = https.createServer({
		cert: fs.readFileSync('/etc/letsencrypt/live/luca0n.com/fullchain.pem'),
		key: fs.readFileSync('/etc/letsencrypt/live/luca0n.com/privkey.pem')
});

const wss = new WebSocket.Server({ server });

server.listen(vars["server.port"]);

var clientes = [],
	salas = [];

console.log("Servidor Força, " + versão);

var filtros = JSON.parse(fs.readFileSync('filtro.json', 'UTF8'));

var ids = {};

ids.pings = setInterval(verificarPings, vars["misc.time.pings"]);
ids.checarInativos = setInterval(checarInativos, vars["misc.time.checkAfk"]);

console.log('Disponível.');

wss.on('connection', ws => {
	//var end = ws._socket.remoteAddress;
	let cliente = new Client(ws._socket.remoteAddress, undefined, ws);
	cliente.opções = JSON.parse(JSON.stringify(vars["client.options.default"])); // Definir opções padrão
	console.log('Nova conexão! Fonte: ' + cliente.address);

	let aguardandoEntrada = true;

	ws.on('message', msg => {
		console.log(' <' + cliente.address + '> ' + msg);
		try {
			resposta = JSON.parse(msg);
		} catch (e){
			// A resposta enviada não está no formato JSON válido.
				ws.send(JSON.stringify(new Query("ERRO", "SERVER", "RESPOSTA_CORROMPIDA" )));
			return;
		}
		if (aguardandoEntrada){
			aguardandoEntrada = false;
			cliente.apelido = resposta.source.split('.')[1];
			// Problema #2: O apelido é válido?
			let apelidoRegex = /[^A-Za-z0-9_]/g;
			if (
				cliente.apelido.length < 3 // O apelido tem menos que três caracteres?
				|| cliente.apelido.length > 16 // O apelido tem mais que 16 caracteres?
				|| apelidoRegex.exec(cliente.apelido) !== null // O apelido contém algum caractere que não seja permitido?
				|| Util.filtrarMensagem(cliente.apelido, filtros) != cliente.apelido // O apelido contém termos filtrados?
				){
				ws.send(JSON.stringify(new Query("ERRO", "SERVER", "NOME_ILEGAL" )));
				ws.terminate();
			}
		}

		let roomObj = cliente.sala !== undefined ? pesquisarSala(cliente.sala) : undefined;

		// Interpretar a mensagem do cliente.
		switch (resposta.request){
			case "JOIN":{
				// Entrar em uma sala ou criar ela caso inexistente.
				// O parâmetro extra "sala" é necessário. Caso inexistente, retornar um erro ao cliente.
				let room = resposta.extra.room,
				roomNo,
				adicionarCliente = false;

				if (room === undefined){
					ws.send(JSON.stringify(new Query("ERRO", "SERVER", undefined, { motivo: "PARÂMETRO_FALTANDO"})));
					break;
				}

				// Problema #2: O apelido é válido?
				let roomRegex = /[^a-z0-9]/g;
				if (
					room.length < 3 // O nome tem menos que três caracteres?
					|| room.length > 8 // O nome tem mais que 16 caracteres?
					|| roomRegex.exec(room) !== null // O nome contém algum caractere que não seja permitido?
					|| Util.filtrarMensagem(room, filtros) != room // O nome contém termos filtrados?
					){
					ws.send(JSON.stringify(new Query("ERRO", "SERVER", "NOME_ILEGAL" )));
					ws.terminate();
				}


				// Agora que verificamos que os parâmetros necessários foram providenciados, vamos verificar a existência da sala.
				if (salaExiste(room)){
					roomObj = pesquisarSala(room);
					// Encontrar a sala existente na lista de salas.
					for (var x = 0; x < salas.length; x++){
						if (salas[x].sala === room){
							//salas[x].clientes.push(cliente);
							roomNo = x;
							adicionarCliente = true;
							roomObj = salas[x];
							break;
						}
					}
					// O IP do cliente está banido?
					if (roomObj.banido(cliente.socket.remoteAddress)){
						ws.send(JSON.stringify(new Query("FATAL", "SERVER", "BANNED")));
						return;
					}
					// A sala está em partida?
					if (roomObj.estado === "IN_SESSION"){
						ws.send(JSON.stringify(new Query("FATAL", "SERVER", "ROOM_IN_SESSION")));
						return;
					}
					// A sala está cheia?
					let limiteJogadores = vars["room.clients.max"];
					if (roomObj.clientes.length >= limiteJogadores){
						// A sala está cheia. Retornar um código de erro ao jogador.
						ws.send(JSON.stringify(new Query("FATAL", "SERVER", "ROOM_FULL")));
						return;
					}

					// Gerar uma lista com os apelidos dos clientes conectados.
					let jogadores = [];
					for (let x = 0; x < roomObj.clientes.length; x++){
						let jogadorApelido = roomObj.clientes[x].apelido;
						// Verificar se já existe um usuário com o mesmo apelido na sala.
						if (jogadorApelido === cliente.apelido){
							// Alertar o cliente.
							ws.send(JSON.stringify(new Query("FATAL", "SERVER", "NICKNAME_IN_USE")));
							// Fechar a conexão.
							ws.terminate();
							return;
						}

						jogadores.push(jogadorApelido);
					}

					// Retornar um código de sucesso ao cliente, incluindo a lista de jogadores conectados, estado e o líder da sala.
					ws.send(JSON.stringify(new Query("SUCCESSFUL", "SERVER", "ROOM_EXISTS", { options: roomObj.opções, leader: roomObj.líder, roomStatus: roomObj.estado, players: jogadores })));
				} else {
					// A sala não existe. Vamos criar ela e adicionar o usuário nela.
					// salas.push(new Room(sala, [cliente]));
					// Retornar um código de sucesso ao cliente.
					ws.send(JSON.stringify(new Query("SUCCESSFUL", "SERVER", "ROOM_CREATED")));
				}

				cliente.sala = room;
				clientes.push(cliente);
				if (roomObj !== undefined){
					salas[roomNo].clientes.push(cliente);
					roomObj = salas[roomNo];
				} else {
					let salaNova = new Room(room, [cliente], undefined, undefined, JSON.parse(JSON.stringify(vars["room.options.default"])));

					salaNova.pontuaçãoMeta = vars['room.score.target'];
					salas.push(salaNova);
					roomObj = salaNova;
				}
				console.log(' [' + cliente.address + '] Conexão estabelecida.');
				// Alertar todos os jogadores sobre a entrada do jogador.
				alertarClientesEvento('EVENT_PLAYER_JOINED', room, { apelido:cliente.apelido });
				if (roomObj !== undefined)
				// A sala possui a quantidade suficiente de jogadores para iniciar?
				verificarPossibilidadeDePartida(roomObj);
				break;
			}
			case "ENVIAR_MENSAGEM":{
				// Verificar se a mensagem desejada foi providenciada pelo cliente.
				if (resposta.extra.mensagem === undefined){
					// A mensagem não foi providenciada pelo cliente. Retornar uma resposta de erro para o cliente.
					ws.send(JSON.stringify(new Query("ERRO", "SERVER", "PARAMETRO_FALTANDO")));
					return;
				}
				// Verificar se a mensagem excede o limite de caracteres proposto pelo cliente.
				if (resposta.extra.mensagem.length > 128) {
					// Cancelar este pedido e retornar uma mensagem de erro para o cliente.
					ws.send(JSON.stringify(new Query("PEDIDO_CANCELADO", "SERVER", "MENSAGEM_MUITO_LONGA")));
					return;
				}
				cliente.uas = Date.now();
				
				var mensagem = '<' + cliente.apelido + '> ' + resposta.extra.mensagem;
				// Enviar a mensagem para todos os clientes.
				alertarClientesEvento('EVENT_PLAYER_MESSAGE', cliente.sala, { apelido: cliente.apelido, mensagem: mensagem });
				break;
			}
			case "START_MATCH":{
				// O cliente que está tentando iniciar a partida é do líder?
				if (roomObj.líder !== cliente.apelido){
					// Este cliente não é do líder da sala. Retornar um erro ao cliente e cancelar a tarefa.
					ws.send(JSON.stringify(new Query("ERRO", "SERVER", "SEM_PERMISSÃO")));
					break;
				}
				// A sala já está em partida?
				if (roomObj.estado === "IN_SESSION"){
					ws.send(JSON.stringify(new Query("ERRO", "SERVER", "IN_SESSION")));
					break;
				}

				cliente.uas = Date.now();
				roomObj.uas = Date.now();

				// Agora que verificamos que o cliente é do líder da sala, vamos enviar a todos os usuários um evento alertando sobre o início da partida.

				roomObj.novaPartida();

				alertarClientesEvento("EVENT_ROOM_STATUS_CHANGED", cliente.sala, { roomStatus: roomObj.estado });

				// E vamos alertar todos os clientes sobre o jogador escolhido.
				alertarClientesEvento("EVENT_PLAYER_CHOSEN", cliente.sala, { nickname: roomObj.vezDe });
				break;
			}
			case "ESCOLHER_PALAVRA":{
				// A sala está em partida?
				if (roomObj.estado !== "IN_SESSION"){
					ws.send(JSON.stringify(new Query("ERRO", "SERVER", "SALA_ESTADO_NÃO_EM_PARTIDA")));
					break;
				}

				// Verificar se é realmente a vez do cliente que enviou este pedido.
				if (roomObj.vezDe !== cliente.apelido){
					// Não é a vez deste cliente!
					ws.send(JSON.stringify(new Query("ERRO", "SERVER", "SEM_PERMISSÃO")));
					break;
				}

				// Certo, é a vez deste cliente.
				
				// A palavra enviada está vazia?
				if (resposta.extra.palavra.replace(/ /g, "") === ""){
					ws.send(JSON.stringify(new Query("PEDIDO_CANCELADO", "SERVER", "PALAVRA_OU_TEMA_PROIBIDO")));
					return;
				}

				// Verificar tamanho da palavra.
				if (resposta.extra.palavra.length < vars["game.term.size.min"]
					|| resposta.extra.palavra.length > vars["game.term.size.max"]){
					ws.send(JSON.stringify(new Query("PEDIDO_CANCELADO", "SERVER", "TERMO_INVÁLIDO", { erroDescrição: "PALAVRA_TAMANHO_INVÁLIDO" })));
					return;
				}

				// Verificar tamanho do tema.
				if (resposta.extra.tema.length < vars["game.theme.size.min"]
					|| resposta.extra.tema.length > vars["game.theme.size.max"]){
					ws.send(JSON.stringify(new Query("PEDIDO_CANCELADO", "SERVER", "PALAVRA_OU_TEMA_PROIBIDO", { erroDescrição: "TEMA_TAMANHO_INVÁLIDO" })));
					return;
				}

				// Verificar palavra via expressão regular.
				let palavraRegexIlegal = new RegExp(vars["palavra.regex.caracteresIlegais"], 'g');
				if (palavraRegexIlegal.test(resposta.extra.palavra)){
					ws.send(JSON.stringify(new Query("PEDIDO_CANCELADO", "SERVER", "PALAVRA_OU_TEMA_PROIBIDO", { erroDescrição: "PALAVRA_CARACTERES_ILEGAIS" })));
					return;
				}

				cliente.uas = Date.now();
				roomObj.uas = Date.now();
				// A sala está com o filtro de temas adultos habilitado?
				if (roomObj.opções["game.filter.matureThemes.enabled"]){
					// Verificar se esta palavra está filtrada.
					let palavraFiltrada = Util.filtrarMensagem(resposta.extra.palavra, filtros);
					let temaFiltrado = Util.filtrarMensagem(resposta.extra.tema, filtros);
					// Caso há variação da palavra/tema, então a palavra/tema escolhido contém um ou mais termos impróprios.
					if (palavraFiltrada !== resposta.extra.palavra
						|| temaFiltrado !== resposta.extra.tema){
						ws.send(JSON.stringify(new Query("PEDIDO_CANCELADO", "SERVER", "PALAVRA_OU_TEMA_PROIBIDO")));
						break;
					}
				}

				// Redefinir tin (contagem de tentativas incorretas).
				alterarTin(roomObj, 0);

				roomObj.jpa = cliente.apelido;

				// Escolher um jogador aleatório para escolher a primeira letra.
				var clienteEscolhido = roomObj.gerarJogadorAleatório();

				roomObj.palavra = resposta.extra.palavra.toUpperCase();
				roomObj.definirPalavraLetrasQtd();
				roomObj.termoVezDe = roomObj.próxItemJf === undefined ? roomObj.jf[0] : roomObj.próxItemJf();

				if (roomObj.termoVezDe === roomObj.vezDe)
					roomObj.termoVezDe = roomObj.próxItemJf();

				roomObj.estadoTermo = "AGUARDANDO_LETRA";

				// Vamos alertar todos os clientes sobre este evento.
				alertarClientesEvento("EVENT_PALAVRA_ESCOLHIDA", cliente.sala, { palavra: { tamanho: resposta.extra.palavra.length, espaços: roomObj.procurar(' '), hífens: roomObj.procurar('-') }, tema: resposta.extra.tema, termoVezDe: roomObj.termoVezDe });
				break;
			}
			case "SEND_TERM":{
				// A sala está em partida?
				if (roomObj.estado !== "IN_SESSION"){
					ws.send(JSON.stringify(new Query("ERRO", "SERVER", "SALA_ESTADO_NÃO_EM_PARTIDA")));
					break;
				}

				// Verificar se é a vez do cliente que enviou este pedido.
				if (roomObj.termoVezDe !== cliente.apelido){
					ws.send(JSON.stringify(new Query("PEDIDO_CANCELADO", "SERVER", "AGUARDE_SUA_VEZ")));
					break;
				}

				// Verificar termo via expressão regular.
				let palavraRegexIlegal = new RegExp(vars["palavra.regex.caracteresIlegais"], 'g');
				if (palavraRegexIlegal.test(resposta.extra.termo)){
					ws.send(JSON.stringify(new Query("PEDIDO_CANCELADO", "SERVER", "TERMO_INVÁLIDO", { erroDescrição: "TERMO_CARACTERES_ILEGAIS" })));
					break;
				}

				// Verificar se o termo enviado possui termos filtrados CASO a sala tinha o filtro habilitado
				if (roomObj.opções["game.filter.matureThemes.enabled"] && Util.filtrarMensagem(resposta.extra.termo, filtros) !== resposta.extra.termo){
					ws.send(JSON.stringify(new Query("PEDIDO_CANCELADO", "SERVER", "TERMO_INVÁLIDO", { erroDescrição: "TERMO_IMPRÓPRIO" })));
					break;
				}

				// Verificar o tipo do termo enviado.
				let letra = resposta.extra.term.length === 1;
				let salaClientes = roomObj.clientes;
				let e = Util.receberClientePorApelido(roomObj, roomObj.vezDe); // escolhedor

				// O termo está vazio?
				if (resposta.extra.term.replace(/ /g, "") === ""){
					ws.send(JSON.stringify(new Query("PEDIDO_CANCELADO", "SERVER", "TERMO_INVÁLIDO", { erroDescrição: "TERMO_VAZIO" })));
					return;
				}

				// O jogador deseja pular?
				if (roomObj.estadoTermo === "AGUARDANDO_TERMO" &&
					resposta.extra.term === '?'){
					alertarClientesEvento("EVENT_PLAYER_SKIPPED_TERM_TURN", cliente.sala, { nickname: cliente.apelido });
					// Escolher outro jogador.
					escolherJogadorTermo(roomObj);
					return;
				}

				// A sala está aceitando apenas termos?
				if (roomObj.estadoTermo !== "AGUARDANDO_LETRA" && letra){
					// A sala não está esperando letras.
					ws.send(JSON.stringify(new Query("PEDIDO_CANCELADO", "SERVER", "TERMO_INVÁLIDO_LETRA_INESPERADA")));
					break;
				}

				cliente.uas = Date.now();
				roomObj.uas = Date.now();

				resposta.extra.term = resposta.extra.term.toUpperCase();

				let resultadoTermo = roomObj.processarTermo(resposta.extra.term);
				let lp = resultadoTermo.letrasPreenchidas;
				let r = resultadoTermo.resultado;

				let tentarNovamente = false;

				let dif = 0, // diferença da nova pontuação do jogador que enviou o termo
					dife = 0; // diferença da nova pontuação do jogador que enviou a palavra atual
				switch (r){
					case "LETTER_ALREADY_CHOSEN":{
						alertarClientesEvento("EVENT_TERM_CHOSEN", cliente.sala, { tipo: letra ? "LETRA" : "TERMO", termo: resposta.extra.termo, resultado: r });
						tentarNovamente = true;
						break;
					}
					case "TERM_ALREADY_CHOSEN":{
						alertarClientesEvento("EVENT_TERM_CHOSEN", cliente.sala, { tipo: letra ? "LETRA" : "TERMO", termo: resposta.extra.termo, resultado: r });
						tentarNovamente = true;
						break;
					}
					case "LETTER_PRESENT":{
						alertarClientesEvento("EVENT_TERMO_ESCOLHIDO", cliente.sala, { tipo: letra ? "LETRA" : "TERMO", termo: resposta.extra.termo, resultado: r, ldc: roomObj.ldc });

						// Também acrescentar pontuação ao jogador.
						for (let x = 0; x < lp; x++){
							dif += cliente.acrescentarPontos(Pontos.EVENT_JOGADOR_LETRA_ACERTADA);
							dife += e.acrescentarPontos(Pontos.EVENT_JOGADOR_SALA_LETRA_ACERTADA);
						}
						// Alertar os clientes da nova pontuação deste jogador.
						alertarClientesEvento("EVENT_JOGADOR_PONTUAÇÃO_ALTERADA", cliente.sala, { jogador: cliente.apelido, pontos: cliente.pontos, diferença: dif });
						alertarClientesEvento("EVENT_JOGADOR_PONTUAÇÃO_ALTERADA", cliente.sala, { jogador: e.apelido, pontos: e.pontos, diferença: dife });
						break;
					}
					case "LETTER_NOT_PRESENT":{
						alertarClientesEvento("EVENT_TERMO_ESCOLHIDO", cliente.sala, { tipo: letra ? "LETRA" : "TERMO", termo: resposta.extra.termo, resultado: r });
						if (alterarTin(roomObj)) return;
						break;
					}
					case "TERM_GUESSED":{
						alertarClientesEvento("EVENT_TERMO_ESCOLHIDO", cliente.sala, { acertou: true, palavra: roomObj.palavra, resultado: r });
						// Acrescentar pontos ao jogador por acertar a palavra.
						// Pontos pelos campos que antes estavam vazios e pontos por acertar a palavra.

						let extra = roomObj.estadoTermo === 'AGUARDANDO_LETRA'; // caso verdadeiro, dar pontos extras por acertar a palavra cedo
						for (let x = 0; x < lp; x++){
							dif += cliente.acrescentarPontos(extra ? Pontos.EVENT_JOGADOR_LETRA_ACERTADA_CEDO : Pontos.EVENT_JOGADOR_LETRA_ACERTADA);
							dife += e.acrescentarPontos(extra ? Pontos.EVENT_JOGADOR_SALA_LETRA_ACERTADA_CEDO : Pontos.EVENT_JOGADOR_SALA_LETRA_ACERTADA);
						}

						dif += cliente.acrescentarPontos(Pontos.EVENT_JOGADOR_PALAVRA_ACERTADA);
						dife += e.acrescentarPontos(Pontos.EVENT_JOGADOR_SALA_PALAVRA_ACERTADA);
						// Alertar os clientes da nova pontuação deste jogador.
						alertarClientesEvento("EVENT_JOGADOR_PONTUAÇÃO_ALTERADA", cliente.sala, { jogador: cliente.apelido, pontos: cliente.pontos, diferença: dif });
						alertarClientesEvento("EVENT_JOGADOR_PONTUAÇÃO_ALTERADA", cliente.sala, { jogador: e.apelido, pontos: e.pontos, diferença: dife });

						// Verificar se um jogador atingiu a meta de pontos.
						let vencedor = roomObj.receberVencedor();
						if (vencedor !== null){
							// Há um vencedor; alertar os clientes na sala que houve um vencedor.
							alertarClientesEvento("EVENT_JOGADOR_VITÓRIA", cliente.sala, { jogador: vencedor.apelido });
							// Encerrar esta partida.
							verificarPossibilidadeDePartida(roomObj, true);
							return;
						}

						// Escolher outro jogador para escolher a palavra.
						roomObj.novaRodada();
						// E vamos alertar todos os clientes sobre o jogador escolhido.
						alertarClientesEvento("EVENT_JOGADOR_ESCOLHIDO", cliente.sala, { jogador: roomObj.vezDe });
						return;
					}
					case "TERM_NOT_GUESSED":{
						alterarTin(roomObj);
						// Penalizar o jogador caso ele tenha errado a palavra cedo.
						if (roomObj.estadoTermo === 'AGUARDANDO_LETRA')
							for (let x = 0; x < resposta.extra.termo.length; x++)
								dif += cliente.acrescentarPontos(Pontos.EVENT_JOGADOR_LETRA_ERRADA_CEDO);
						alertarClientesEvento("EVENT_JOGADOR_PONTUAÇÃO_ALTERADA", cliente.sala, { jogador: cliente.apelido, pontos: cliente.pontos, diferença: dif });

						alertarClientesEvento("EVENT_TERMO_ESCOLHIDO", cliente.sala, { acertou: false, palavra: resposta.extra.termo, resultado: r });
						break;
					}
				}
				escolherJogadorTermo(roomObj, tentarNovamente? cliente.apelido : undefined);
				// Enviar um alerta para todos os clientes da sala.
				// Não é necessário especificar o apelido do jogador. Os clientes já vão estar esperando uma resposta do cliente em questão.
				/*alertarClientesEvento("EVENT_TERMO_ESCOLHIDO", cliente.sala, { tipo: letra ? "LETRA" : "TERMO", termo: resposta.extra.termo });*/
				break;
			}
			case "KICK_PLAYER":{
				// Problema #60: O cliente que enviou este pedido é o líder da sala?
				if (roomObj.líder !== cliente.apelido){
					ws.send(JSON.stringify(new Query("ERRO", "SERVER", "SEM_PERMISSÃO")));
					return;
				}
				let jogador = resposta.extra.nickname;
				if (jogador === undefined){
					ws.send(JSON.stringify(new Query("ERRO", "SERVER", undefined, { motivo: "PARÂMETRO_FALTANDO"})));
					break;
				}

				cliente.uas = Date.now();

				// Encerrar conexão com o cliente alvo.
				let clienteAlvo = Util.receberClientePorApelido(roomObj, jogador);
				alertarClientesEvento("EVENT_PLAYER_KICKED", cliente.sala, { nickname: clienteAlvo.apelido });
			
				// Remover o cliente da sala.
				clienteAlvo.socket.terminate();
				break;
			}
			case "BAN_PLAYER":{
				// Problema #60: O cliente que enviou este pedido é o líder da sala?
				if (roomObj.líder !== cliente.apelido){
					ws.send(JSON.stringify(new Query("ERRO", "SERVER", "SEM_PERMISSÃO")));
					return;
				}
				let jogador = resposta.extra.nickname;
				if (jogador === undefined){
					ws.send(JSON.stringify(new Query("ERRO", "SERVER", undefined, { motivo: "PARÂMETRO_FALTANDO" })));
					break;
				}
				cliente.uas = Date.now();
				
				// Encerrar conexão com o cliente alvo.
				let clienteAlvo = Util.receberClientePorApelido(roomObj, jogador);
				alertarClientesEvento("EVENT_PLAYER_BANNED", cliente.sala, { nickname: clienteAlvo.apelido });
	
				// Remover o cliente da sala.
				clienteAlvo.socket.terminate();
				// Adicionar o cliente na lista de banidos da sala.
				roomObj.banidos.push(clienteAlvo.socket.remoteAddress);
				break;
			}
			case "UPDATE_OPTION":{
				let option = resposta.extra.option,
					value = resposta.extra.value,
					target = resposta.extra.target;
				if (option === undefined || value === undefined || target === undefined){
					ws.send(JSON.stringify(new Query("ERRO", "SERVER", undefined, { motivo: "PARÂMETRO_FALTANDO"})));
					break;
				}
				cliente.uas = Date.now();

				// Definir opção.
				if (resposta.extra.target === "CLIENT"){
					cliente.opções[option] = value;

					ws.send(JSON.stringify(new Query("SUCCESSFUL", "SERVER", "OPTION_UPDATED", { option: option, newValue: cliente.opções[option] })));
				} else if (resposta.extra.target === "ROOM") {
					// O cliente que está enviando este pedido é o líder da sala?
					if (roomObj.líder !== cliente.apelido){
						ws.send(JSON.stringify(new Query("ERRO", "SERVER", "SEM_PERMISSÃO")));
						break;
					}

					// A sala já está em partida?
					if (roomObj.estado === "IN_SESSION"){
						ws.send(JSON.stringify(new Query("ERRO", "SERVER", "ROOM_IN_SESSION")));
						break;
					}
					// Agora que verificamos que este cliente é o líder, vamos alterar a configuração da sala.
					roomObj.opções[option] = value;
					ws.send(JSON.stringify(new Query("SUCCESSFUL", "SERVER", "OPTION_UPDATED", { target: resposta.extra.target, option: option, newValue: roomObj.opções[option] })));
					// Vamos alertar os clientes a opção alterada.
					alertarClientesEvento("EVENT_ROOM_OPTION_CHANGED", cliente.sala, { option: option, value: value});
				}
				break;
			}
			case "PING":{
				// Adicionar tempo para a lista de pings do cliente.
				cliente.pings.push(Date.now());
				ws.send(JSON.stringify(new Query("SUCCESSFUL", "SERVER", "PONG", { tempo: resposta.extra.tempo })));
				break;
			}
		}
	});

	ws.on('error', erro => {
		console.log(' [' + cliente.address + '] Conexão fechada devido a erro.');
		// Remover o cliente da lista de clientes.
		removerCliente(cliente.address);
	});

	ws.on('close', function(){
		console.log(' [' + cliente.address + '] Conexão fechada.');
		// Remover o cliente da lista de clientes.
		removerCliente(cliente, 'REASON_CONNECTION_CLOSED');
	});
	let resposta = new Query("TEST_CON", "SERVER");
	ws.send(JSON.stringify(resposta));
});

/**
 * Remove um cliente da lista de clientes e da sala conectada.
 * @param Cliente O objeto Cliente.
 * @param string O motivo pelo qual o jogador está sendo removido.
 * @since 12 de outubro de 2020, 12:51 (UTC -03:00).
 */
function removerCliente(cliente, motivo){
	let sala = pesquisarSala(cliente.sala);

	// Verifica se o cliente está em uma sala.
	if (sala === undefined){
		//cliente.socket.send(JSON.stringify(new Query("ERRO", "SERVER", "SEM_SALA")));
		return -1;
	}

	// Remover o cliente da lista de clientes.
	clientes.splice(clientes.indexOf(cliente), 1);

	// Verificar se este é o único cliente conectado na sala. Se este for o caso, então apagar a sala.
	if (sala.clientes.length === 1){
		salas.splice(salas.indexOf(sala));
		return;
	}

	let líder = sala.líder === cliente.apelido;

	if (líder) // Caso o líder sair da sala, então apagar a sala.
		alertarClientesEvento('EVENT_LÍDER_SAIU', sala.sala, {});

	// Este cliente está na sala?
	//if (sala.clientes.indexOf(cliente.apelido) === -1)
		//return;

	// Alertar os clientes na sala sobre o jogador que está sendo removido caso um motivo tenha sido especificado.
	alertarClientesEvento('EVENT_PLAYER_LEFT', cliente.sala, { nickname: cliente.apelido, reason: motivo });

	if(líder)	// Remover todos os jogadores da sala.
		for (let x = sala.clientes.length; x > 0; x--)
			sala.clientes[x-1].socket.terminate();

	// Remover o cliente da lista de clientes da sala.
	let índice = sala.clientes.indexOf(cliente);
	sala.clientes.splice(índice, 1);

	// Remover o jogador das filas geradas.
	sala.jfr.splice(sala.jfr.indexOf(cliente.apelido), 1);
	if (sala.jf !== undefined)
		sala.jf.splice(sala.jf.indexOf(cliente.apelido), 1);

	// Este jogador havia escolhido a palavra atual?
	if (sala.clientes.length !== 1 && sala.vezDe === cliente.apelido){
		// Escolher outro jogador.
		sala.novaRodada();
		// E vamos alertar todos os clientes sobre o jogador escolhido.
		alertarClientesEvento("EVENT_JOGADOR_ESCOLHIDO", cliente.sala, { jogador: sala.vezDe });
	}
	// Este jogador estava escolhendo um termo?
	else if (sala.clientes.length !== 1 && sala.termoVezDe === cliente.apelido){
		// Removê-lo da fila de jogadores.
		for (let x = 0; x < sala.jf.length; x++)
			if (sala.jf[x] === cliente.apelido){
				sala.jf.splice(x, 1);
				break;
			}
		// Escolher outro jogador.
		escolherJogadorTermo(sala);
	}
	
	// Se a sala estiver pronta para iniciar uma nova partida, ela ainda continuará preparada após a saída deste cliente?
	if (!líder) verificarPossibilidadeDePartida(sala);
}

/**
 * Verifica a existência de uma sala.
 * @param string sala O código da sala.
 * @returns boolean Verdadeiro caso a sala seja existente.
 * @since 12 de outubro de 2020, 13:15 (UTC -03:00).
 */
function salaExiste(sala){
	for (var x = 0; x < salas.length; x++)
		if (salas[x].sala === sala)
			return true;

	// Nenhuma sala foi encontrada no ciclo. Retornar falso.
	return false;
}

/**
 * Alerta todos os clientes de uma sala sobre um evento.
 * @param string O ID do evento.
 * @param string salaNome A sala desejada.
 * @param object extra Os dados extra do evento.
 * @since 12 de outubro de 2020, 13:32 (UTC -03:00).
 */
function alertarClientesEvento(evento, salaNome, extra){
	// Pesquisar pela sala desejada.
	let sala = pesquisarSala(salaNome);

	// Cancelar alerta caso a sala não seja existente.
	if (sala === undefined)
		return;

	let msgFiltrada = null;
	let ogMsg;
	if (extra !== undefined)
		ogMsg = extra.mensagem;

	for (let x = 0; x < sala.clientes.length; x++){
		let e = extra;
		if (e !== undefined)
			e.mensagem = ogMsg;

		if (e !== undefined && e.mensagem !== undefined){
			// Evitar problemas de formatação com colchetes.
			e.mensagem = e.mensagem.replace(/\[/g, "\\[")
				.replace(/\]/g, "\\]");
			if (sala.clientes[x].opções["chat.filter.enabled"]){
				if (msgFiltrada === null) // Evitar de filtrar a mensagem caso ela já tenha sido filtrada.
					msgFiltrada = Util.filtrarMensagem(e.mensagem, filtros);
				e.mensagem = msgFiltrada;
			}
		}

		sala.clientes[x].socket.send(JSON.stringify(new Query("EVENT", "SERVER", evento.substring(6), e)));
	}
}

function alertarClienteEvento(evento, salaNome, extra, cliente){
	// Pesquisar pela sala desejada.
	let sala = pesquisarSala(salaNome);

	// Cancelar alerta caso a sala não seja existente.
	if (sala === undefined)
		return;
	for (let x = 0; x < sala.clientes.length; x++){
		if (sala.clientes[x].apelido === cliente.apelido){
			let mensagem = '<' + extra.apelido + '> ' + extra.mensagem;
			sala.clientes[x].socket.send(JSON.stringify(new Query("EVENT", "SERVER", evento.substring(7), extra)));
			break;
		}
	}
}

/**
 * Pesquisa por uma sala com o nome desejado e retorna um objeto Room correspondente.
 * @param string sala O nome da sala.
 * @returns Room O objeto da sala.
 * @since 12 de outubro de 2020, 19:49 (UTC -03:00).
 */
function pesquisarSala(sala){
	for (var x = 0; x < salas.length; x++)
		if (salas[x].sala === sala)
			return salas[x];
}

/**
 * Verifica se há a possibilidade de iniciar uma nova partida baseado na quantidade de clientes conectados à sala especificada. Caso exista essa possibilidade, então alterar o estado da sala e alertar todos os jogadores (incluindo o líder) sobre isso.
 * @param Room sala O objeto da sala.
 * @return boolean Verdadeiro caso exista a possibilidade, falso caso contrário.
 * @since 14 de outubro de 2020.
 */
function verificarPossibilidadeDePartida(sala, forçar){
	if (sala.estado === "IN_SESSION" && sala.clientes.length > 1 && !forçar)
		return true;

	// Alterar o estado da sala.
	sala.estado = sala.clientes.length === 1 ? "AGUARDANDO_JOGADORES" : "AGUARDANDO_LÍDER";

	// Alertar os clientes.
	alertarClientesEvento("EVENT_ROOM_STATUS_CHANGED", sala.sala, { roomStatus: sala.estado });
	return sala.clientes.length > 1;
}

/**
 * Incrementa o tin da sala especificada e alerta a todos os clientes sobre o tin atualizado.
 * @param Object sala O objeto da sala.
 * @param int valor O novo valor do tin. Caso este parâmetro não esteja definido, então o tin terá seu valor incrementado por 1.
 * @returns Verdadeiro caso uma nova partida tenha sido iniciada.
 * @since 24 de dezembro de 2020.
 */
function alterarTin(sala, valor){
	if (valor === undefined)
		sala.tin++;
	else
		sala.tin = valor;
	alertarClientesEvento("EVENT_TIN_ATUALIZADO", sala.sala, { tin: sala.tin });
	// Tin máximo atingido?
	if (sala.tin >= vars['room.tin.max']){
		alertarClientesEvento("EVENT_TIN_MÁXIMO_ATINGIDO", sala.sala, { palavra: sala.palavra });
		// Nova rodada.
		// Escolher outro jogador para escolher a palavra.
		sala.novaRodada();
		// E vamos alertar todos os clientes sobre o jogador escolhido.
		alertarClientesEvento("EVENT_JOGADOR_ESCOLHIDO", sala.sala, { jogador: sala.vezDe });
		return true;
	}
}

function escolherJogadorTermo(sala, jogador){
	if (jogador !== undefined)
		sala.termoVezDe = jogador;
	else {
		// Escolher outro jogador para enviar o próximo termo.
		if (sala.jf.indexOf(sala.termoVezDe) === sala.jf.length - 1)
			sala.termoVezDe = null;

		sala.termoVezDe = sala.próxItemJf();

		if (sala.termoVezDe === sala.vezDe)
			sala.termoVezDe = sala.próxItemJf();
	}

	let ja = sala.termoVezDe;

	// É hora de descobrir a palavra inteira?
	let possívelDescoberta = sala.possívelDescoberta();
	if (possívelDescoberta)
	sala.estadoTermo = "AGUARDANDO_TERMO";

	alertarClientesEvento("EVENT_JOGADOR_ESCOLHIDO_TERMO", sala.sala, { jogador: ja, tipo: sala.possívelDescoberta() ? "TERMO" : "LETRA" });
}

/**
 * Verifica os pings enviados pelos clientes. Caso um ping recente não tenha sido enviado pelo cliente, então a sua conexão será terminada.
 * @since 30 de dezembro de 2020.
 */
function verificarPings(){
	for (let x = 0; x < clientes.length; x++){
		let cliente = clientes[x],
			pings = cliente.pings;
		if (pings.length >= 10)
			pings.splice(0, 1);

		let delta = Date.now() - pings[pings.length - 1],
			máx = vars["client.ping.time.max"];

		if (delta >= máx){
			console.log("[" + cliente.address + "] O cliente não enviou pings recentemente. Fechando conexão.");
			cliente.socket.terminate();
		}
	}
}

/**
 * Fecha conexões e salas inativas.
 * @since 30 de dezembro de 2020.
 */
function checarInativos(){
	///////////////
	// Jogadores //
	///////////////
	for (let x = 0; x < clientes.length; x++){
		if (Date.now() - clientes[x].uas >= vars["client.uas.max"]){
			console.log("[" + clientes[x].endereço + "] O jogador parece estar inativo. Fechando conexão.");
			// Alertar os clientes.
			alertarClientesEvento("EVENT_PLAYER_KICKED_FOR_INACTIVITY", clientes[x].sala, { nickname: clientes[x].apelido });
			clientes[x].socket.terminate();
		}
	}

	///////////
	// Rooms //
	///////////
	for (let x = 0; x < salas.length; x++)
		if (Date.now() - salas[x].uas >= vars["room.uas.max"]){
			console.log(salas[x].sala + ": esta sala parece estar inativa. Removendo ela.");
			// Esta sala está inativa. Alertar aos clientes de que eles serão desconectados desta sala por inatividade.
			alertarClientesEvento("EVENT_ROOM_INACTIVE", salas[x].sala);
			// Terminar conexão com o líder, que automaticamente irá desconectar todos da sala.
			Util.receberClientePorApelido(salas[x], salas[x].líder).socket.terminate();
		}
}