const Fs = require('fs');
const Discord = require('discord.js');

const Config = require('./config.js');
const Functions = require('./functions.js');

const Client = new Discord.Client();

Client.on('message', Message => {
	if (Message.author.id === Client.user.id)
		return;

	const serverId = Message.guild.id;
	const serverConfig = Config.getConfig(serverId);

	if (serverConfig.activeChannels.length && !serverConfig.activeChannels.includes(Message.channel.id))
		return;

	if (Message.content.toUpperCase().startsWith(Config.masterPrefix) && Functions.isMod(serverId, Message.member)) {
		const Command = Message.content.toUpperCase().replace(Config.masterPrefix, '');
		const Args = Command.split(' ');

		if (Args[0] === 'SET-PREFIX') {
			if (Args.length === 2) {
				serverConfig.prefix = Args[1];
				Config.setMainConfig(serverId, serverConfig);
				Message.channel.send('Prefix set');
			} else {
				Message.channel.send('Command ``SET-PREFIX`` requires 1 argument');
			}
		}

		if (Args[0] === 'MODROLE') {
			if (Args[1] === 'ADD') {
				const newModRoleName = Command.replace('MODROLE ADD ', '');
				const newModRole = Message.guild.roles.find(role => {
					return role.name.toUpperCase() === newModRoleName;
				});

				if (newModRole) {
					if (serverConfig.modRoles.includes(newModRole.id)) {
						Message.channel.send(`Role \`\`${newModRole.Name}\`\` is already a mod role`);
					} else {
						serverConfig.modRoles.push(newModRole.id);
						Config.setMainConfig(serverId, serverConfig);
						Message.channel.send(`Added \`\`${newModRole.name}\`\` as mod role`)
					}
				} else {
					Message.channel.send(`Role \`\`${newModRoleName}\`\` could not be found`);
				}
			}

			if (Args[1] === 'REMOVE') {
				const removeModRoleName = Command.replace('MODROLE REMOVE ', '');
				const removeModRole = Message.guild.roles.find(role => {
					return role.name.toUpperCase() === removeModRoleName;
				});

				if (removeModRole) {
					if (serverConfig.modRoles.includes(removeModRole.id)) {
						serverConfig.modRoles.splice(serverConfig.modRoles.indexOf(removeModRole.id, 1));
						Config.setMainConfig(serverId, serverConfig);
						Message.channel.send(`Removed \`\`${removeModRole.name}\`\` as mod role`);
					} else {
						Message.channel.send(`Role \`\`${removeModRole.Name}\`\` is not a mod role`);
					}
				} else {
					Message.channel.send(`Role \`\`${removeModRoleName}\`\` could not be found`);
				}
			}

			if (Args[1] === 'LIST') {
				if (!serverConfig.modRoles.length) {
					Message.channel.send('No mod roles set');
					return;
				}

				const modRoles = [];
				serverConfig.modRoles.forEach(roleId => {
					let guildRole = Message.guild.roles.find(role => {
						return role.id === roleId;
					})

					if (guildRole)
						modRoles.push(guildRole.name);
				});
				Message.channel.send(`Current mod roles: \`\`\`\n${modRoles.join('\n')}\`\`\``);
			}
		}

		if (Args[0] === 'SELF-ASSIGN') {
			if (Args[1] === 'CATEGORY') {
				if (Args[2] === 'ADD') {
					const newCategoryName = Command.replace('SELF-ASSIGN CATEGORY ADD ', '');
					if (serverConfig.selfAssign[newCategoryName]) {
						Message.channel.send(`Self-Assign category \`\`${newCategoryName}\`\` already exists`);
						return;
					}

					serverConfig.selfAssign[newCategoryName] = [];
					Config.setMainConfig(serverId, serverConfig);

					Message.channel.send(`Self-Assign category \`\`${newCategoryName}\`\` has been added`)
				}

				if (Args[2] === 'REMOVE') {
					const removeCategoryName = Command.replace('SELF-ASSIGN CATEGORY REMOVE ', '');
					if (!serverConfig.selfAssign[removeCategoryName]) {
						Message.channel.send(`Self-Assign category \`\`${removeCategoryName}\`\` doesn't exists`);
						return;
					}

					delete serverConfig.selfAssign[removeCategoryName];
					Config.setMainConfig(serverId, serverConfig);

					Message.channel.send(`Self-Assign category \`\`${removeCategoryName}\`\` has been removed`)
				}
			}

			if (Args[1] === 'ROLE') {
				if (Args[2] === 'ADD') {
					let roleName = /ROLE:{(.*?)}/.exec(Command);
					let categoryName = /CATEGORY:{(.*?)}/.exec(Command)[1];

					if(roleName && categoryName) {
						roleName = roleName[1];
						categoryName = categoryName[1];

						Message.channel.send('This command requires ``role`` and ``category`` arguments');
					}

					if (!serverConfig.selfAssign[categoryName]) {
						Message.channel.send(`Self-Assign category \`\`${categoryName}\`\` doesn't exists`);
						return;
					}

					const role = Message.guild.roles.find(role => {
						return role.name.toUpperCase() === roleName;
					});

					if (!role) {
						Message.channel.send(`Role \`\`${roleName}\`\` doesn't exist`);
						return;
					}

					if (serverConfig.selfAssign[categoryName].includes(role.id)) {
						Message.channel.send(`Role \`\`${role.name}\`\` is already in category \`\`${categoryName}\`\``);
						return;
					}

					serverConfig.selfAssign[categoryName].push(role.id);
					Config.setMainConfig(serverId, serverConfig);

					Message.channel.send(`Role \`\`${role.name}\`\` added to category \`\`${categoryName}\`\``);
				}

				if (Args[2] === 'REMOVE') {
					let roleName = /ROLE:{(.*?)}/.exec(Command);
					let categoryName = /CATEGORY:{(.*?)}/.exec(Command)[1];

					if(roleName && categoryName) {
						roleName = roleName[1];
						categoryName = categoryName[1];

						Message.channel.send('This command requires ``role`` and ``category`` arguments');
					}

					if (!serverConfig.selfAssign[categoryName]) {
						Message.channel.send(`Self-Assign category \`\`${categoryName}\`\` doesn't exists`);
						return;
					}

					const role = Message.guild.roles.find(role => {
						return role.name.toUpperCase() === roleName;
					});

					if (!role) {
						Message.channel.send(`Role \`\`${roleName}\`\` doesn't exist`);
						return;
					}

					if (!serverConfig.selfAssign[categoryName].includes(role.id)) {
						Message.channel.send(`Role \`\`${role.name}\`\` is not in category \`\`${categoryName}\`\``);
						return;
					}

					serverConfig.selfAssign[categoryName].splice(serverConfig.selfAssign[categoryName].indexOf(role.id), 1);
					Config.setMainConfig(serverId, serverConfig);

					Message.channel.send(`Role \`\`${role.name}\`\` removed from category \`\`${categoryName}\`\``);
				}
			}
		}

		if (Args[0] === 'ACTIVE-CHANNELS') {
			if (Args[1] === 'ADD') {
				const channels = [];
				Message.mentions.channels.forEach(channel => {
					channels.push(channel);
				});

				const channel = channels[0];

				if (serverConfig.activeChannels.includes(channel.id)) {
					Message.channel.send(`Channel \`\`${channel.name}\`\` is already an active channel`);
					return;
				}

				serverConfig.activeChannels.push(channel.id);
				Config.setMainConfig(serverId, serverConfig);

				Message.channel.send(`Channel \`\`${channel.name}\`\` is now an active channel`);
			}

			if (Args[1] === 'REMOVE') {
				const channels = [];
				Message.mentions.channels.forEach(channel => {
					channels.push(channel);
				});

				const channel = channels[0];

				if (!serverConfig.activeChannels.includes(channel.id)) {
					Message.channel.send(`Channel \`\`${channel.name}\`\` is not an active channel`);
					return;
				}

				serverConfig.activeChannels.splice(serverConfig.activeChannels.indexOf(channel.id), 1);
				Config.setMainConfig(serverId, serverConfig);

				Message.channel.send(`Channel \`\`${channel.name}\`\` is no longer an active channel`);
			}

			if (Args[1] === 'LIST') {

				if (!serverConfig.activeChannels.length) {
					Message.channel.send('Currently active in all channels');
					return;
				}

				const channels = [];
				serverConfig.activeChannels.forEach(channelId => {
					let chan = Message.guild.channels.find(channel => {
						return channel.id === channelId;
					})

					if (chan)
						channels.push(chan.name);
				});

				Message.channel.send(`Currently active in \`\`\`\n${channels.join('\n')}\`\`\``);
			}
		}
	}

	if (Message.content.toUpperCase().startsWith(serverConfig.prefix)) {
		const Command = Message.content.toUpperCase().replace(serverConfig.prefix, '');
		const Args = Command.split(' ');

		if (Args[0] === 'GETROLE') {
			const roleName = Command.replace('GETROLE ', '');

			const role = Message.guild.roles.find(role => {
				return role.name.toUpperCase() === roleName;
			});

			if (!role) {
				Message.channel.send(`Role \`\`${roleName}\`\` doesn't exist`);
				return;
			}

			let selfAssignable = false;
			for (category in serverConfig.selfAssign) {
				if (serverConfig.selfAssign[category].includes(role.id))
					selfAssignable = true;
			}

			if (!selfAssignable) {
				Message.channel.send(`Role \`\`${role.name}\`\` is not self-assignable`);
				return;
			}

			const currentUserRoles = [];
			Message.member.roles.forEach(role => {
				currentUserRoles.push(role);
			})

			if (currentUserRoles.includes(role)) {
				Message.channel.send(`You already have role \`\`${role.name}\`\``);
				return;
			}

			Message.member.addRole(role)
				.then(Message.react('👍'))
			;
		}

		if (Args[0] === 'REMOVEROLE') {
			const roleName = Command.replace('REMOVEROLE ', '');

			const role = Message.guild.roles.find(role => {
				return role.name.toUpperCase() === roleName;
			});

			if (!role) {
				Message.channel.send(`Role \`\`${roleName}\`\` doesn't exist`);
				return;
			}

			let selfAssignable = false;
			for (category in serverConfig.selfAssign) {
				if (serverConfig.selfAssign[category].includes(role.id))
					selfAssignable = true;
			}

			if (!selfAssignable) {
				Message.channel.send(`Role \`\`${role.name}\`\` is not self-assignable`);
				return;
			}

			const currentUserRoles = [];
			Message.member.roles.forEach(role => {
				currentUserRoles.push(role);
			})

			if (!currentUserRoles.includes(role)) {
				Message.channel.send(`You don't have role \`\`${role.name}\`\``);
				return;
			}

			Message.member.removeRole(role)
				.then(Message.react('👍'))
			;
		}

		if(Args[0] === 'ROLES') {
			const guildRoles = [];
			Message.guild.roles.forEach(role => {
				guildRoles.push(role);
			});

			const categoryMessages = [];
			for (category in serverConfig.selfAssign) {
				let message = `${category}: \n\n`;
				serverConfig.selfAssign[category].forEach(roleId => {
					let role = guildRoles.find(role => {
						return role.id === roleId;
					});

					if(role)
						message += ` - ${role.name}\n`;
				});

				categoryMessages.push(message);
			}

			Message.channel.send(`Self-assignable roles for ${Message.guild.name}\n\n\`\`\`${categoryMessages.join('\n\n')}\`\`\``);
		}
	}
});

Client.on('ready', () => {
    console.log(`Logged in as ${Client.user.tag}`);
});

Client.on('error', console.error);

Client.login(Config.token);