'use strict';

const config = require('config');

const words = require('../../assets/mash-words.json');

let mash = null;

function getWordKey(word) {
	return word.split('').sort().join('');
}

function start(length, context, attempt = 0) {
	const lengthWords = words[length];

	if (!lengthWords) {
		context.sendMessage(`No words with ${length} letters available`, context.room.id);

		return;
	}

	if (mash) {
		context.sendMessage(`The mash **${mash.anagram}** was not guessed, possible answers: ${mash.answers.map((answer) => `**${answer.word}**`).join(', ')}`, context.room.id);
		context.logger.info(`Mash '${mash.anagram}' discarded`);

		mash = null;
	}

	const wordEntries = Object.entries(lengthWords);
	const [key, answers] = wordEntries[Math.floor(Math.random() * wordEntries.length)];

	const anagram = key.split('').sort(() => (Math.random() > 0.5 ? 1 : -1)).join('');

	if (answers.some((answer) => answer.word === anagram)) {
		if (attempt >= 10) {
			context.sendMessage(`Sorry, I did not find a mashable ${length}-letter word`);
			return;
		}

		start(length, context, attempt + 1);

		return;
	}

	mash = { key, anagram, answers };

	context.sendMessage(`Stomp stomp, here's your mash: **${mash.anagram}**`, context.room.id);
	context.logger.info(`Mash started, '${anagram}' with answers ${answers.map((answer) => `'${answer.word}'`).join(', ')}`);
}

function play(rawWord, context) {
	const word = rawWord.toLowerCase();

	if (word.length !== mash.key.length) {
		context.sendMessage(`Your answer needs to be ${mash.key.length} letters, @${context.user.username}`, context.room.id);
		return;
	}

	const key = getWordKey(word);

	if (key !== mash.key) {
		context.sendMessage(`You are not using the letters in **${mash.anagram}**, @${context.user.username}`, context.room.id);
		return;
	}

	if (word === mash.anagram) {
		context.sendMessage(`@${context.user.username}... :expressionless:`, context.room.id);
		return;
	}

	if (mash.answers.some((answer) => answer.word === word)) {
		const definition = mash.answers[0].definitions[0] ? `: *${mash.answers[0].definitions[0].slice(0, 100)}${mash.answers[0].definitions[0].length > 100 ? '...*' : '*'}` : '';

		context.sendMessage(mash.answers.length === 1
			? `**${word}** is the right answer${definition}, @${context.user.username} now has **${context.user.points + 1} ${context.user.points === 0 ? 'point' : 'points'}**! There were no other options for **${mash.anagram}**.`
			: `**${word}** is the right answer${definition}, @${context.user.username} now has **${context.user.points + 1} ${context.user.points === 0 ? 'point' : 'points'}**! Other options for **${mash.anagram}**: ${mash.answers.filter((answer) => answer.word !== word).map((answer) => `*${answer.word}*`).join(', ')}`, context.room.id);

		context.logger.info(`Mash '${mash.anagram}' guessed by '${context.user.username}' with '${word}'`);
		context.setPoints(context.user, 1);

		mash = null;

		setTimeout(() => start(word.length, context), 2000);
	}
}

function resolve(word, context) {
	if (!word) {
		context.sendMessage(`Please specify an anagram you would like to resolve, @${context.user.username}`, context.room.id);
		return;
	}

	const anagram = getWordKey(word);
	const answers = words[word.length]?.[anagram];

	if (answers?.length > 1 && answers.some((answer) => answer.word === word)) {
		context.sendMessage(`**${word}** is a valid word in itself, and has the following anagrams, @${context.user.username}: ${answers.filter((answer) => answer.word !== word).map((answer) => `*${answer.word}*`).join(', ')}`, context.room.id);
		return;
	}

	if (answers?.length === 1 && answers[0].word === word) {
		context.sendMessage(`**${word}** is a valid word in itself, but has no anagrams, @${context.user.username}`, context.room.id);
		return;
	}

	if (answers?.length > 0) {
		context.sendMessage(`Anagrams of **${word}**, @${context.user.username}: ${answers.map((answer) => `*${answer.word}*`).join(', ')}`, context.room.id);
		return;
	}

	context.sendMessage(`No anagrams found for **${word}**, @${context.user.username}`, context.room.id);
}

function define(word, context) {
	if (!word) {
		context.sendMessage(`Please specify word you would like to define, @${context.user.username}`, context.room.id);
		return;
	}

	const anagram = getWordKey(word);
	const answers = words[word.length]?.[anagram];
	const answer = answers?.find((answerX) => answerX.word === word);

	if (answer && answer.definitions?.length > 0) {
		context.sendMessage(`${word} can be defined as follows, @${context.user.username}: *${answer.definitions[0]}*`, context.room.id);
		return;
	}

	context.sendMessage(`No definition available for **${word}**, @${context.user.username}`, context.room.id);
}

function onCommand(args, context) {
	const word = args[0];
	const length = Number(word);

	if (['solve', 'resolve', 'lookup'].includes(context.subcommand)) {
		resolve(word, context);
		return;
	}

	if (['define', 'dict', 'dictionary'].includes(context.subcommand)) {
		define(word, context);
		return;
	}

	if (!Number.isNaN(length)) {
		start(length, context);
		return;
	}

	if (!word || !mash) {
		context.sendMessage(`Start a mash with ${config.prefix}mash {length}`, context.room.id);
		return;
	}

	if (!word && mash) {
		context.sendMessage(`The current mash is: **${mash.anagram}**`, context.room.id);
		return;
	}

	play(args[0], context);
}

module.exports = {
	name: 'Mash',
	onCommand,
};