//const Discord  = require("discord.js");
const { Client, GatewayIntentBits, ActivityType, ChannelType, PermissionsBitField, Partials} = require('discord.js')
const client = new Client({intents : [GatewayIntentBits.Guilds, 
									  GatewayIntentBits.GuildMembers,
	                                  GatewayIntentBits.GuildMessages,
	                                  GatewayIntentBits.GuildMessageReactions,
									  GatewayIntentBits.MessageContent,
									  GatewayIntentBits.DirectMessages
									   ],partials :[
								Partials.Message,
								Partials.Channel,
								Partials.GuildMember,
								Partials.User,
								Partials.GuildScheduledEvent,
								Partials.ThreadMember
							] })

const bot_secret_token = require("./auth.json")
const dbs = require('./db.js')
var channeltimer = [];
const TenMinutes = (1000 * 60 * 10 );
const MIN_INTERVAL = 1000 * 60
//const emojiFire = client.emojis.find(emoji => emoji.name === "fire");
const emojiFireTwo = "🔥"
let lastmessage; // undefined until myAsyncFunc is called
let findchannel;  // undefined until myAsyncFunc is called

const voteCommands = require('./voteQueue/voteCommands')

var vote_STATUS_MESSAGE = ""


function channelStatus(channelId, name, type, lastMessageID, lastMessageTimestamp, isActive){
	this.channelId = channelId;
	this.name = name;
	this.type = type;
	this.lastMessageID = lastMessageID;
	this.lastMessageTimestamp = lastMessageTimestamp;
	this.isActive = isActive;
}

///want to refactor these into an ENV
//Prod env
const GUILD_TEXT        = 0
const SERVER_ID         = '523659973402820609' //'373826318913241089'
const BOT_vote_CHANNEL = '1110947498685649046' //"692842860147638402"
const TESTING_CHANNEL   = '696544029134946375' //"593762203887468560"
const ADMIN_CHANNEL     = '1110947394914361516' // "686539139268476939"
///temporary


///Note SET_CODE needs to be all lowercase
var SET_CODES          = []

const getsetCodes = query => {
	return new Promise((resolve, reject) => {
		const setcoderaw  =  dbs.voteSets(query)
		//catch{reject(`Error returning query: ${error}`)}
		resolve(setcoderaw)
	}
)}

const pgLookup = (text, values) => {
	return new Promise((resolve, reject) => {
		const result = dbs.arenaLookup(text, values)
		//console.log(`pglookup: ${result.discordname}`)
		resolve(result)
	}
)}
	
const votesetSQL = 'SELECT setcode FROM public.voteformat WHERE active IS TRUE;'
//message = "**"
getsetCodes(votesetSQL).then(setcodes=> {
	console.log("Query Result " + setcodes)
	setcodes.forEach( (setcode) => {
		SET_CODES.push(setcode.setcode.toLowerCase())

	})
	
	console.log("Active Set codes - ")
	console.log(SET_CODES)
})
var MAX_POD_SIZE       = 2
const BOT_ID           = '696539865944162365' //'593757358413316096'

const botmessage       = new RegExp("[*]{0,2}(.*[A-Za-z]){3,} [Q]ueue [0-9]\/[0-9]\n(.*[A-Za-z]){3,} [Q]ueue [0-9]\/[0-9]\n[*]{0,2}")
const botmessagesimple = "Cube Queue"
var postsDontCount     = ['636359808747831296','695597868840386560','693178852603592719','693178764942770286','693178793996714056','693208159476514847','693178735171731456','693178814406328371']
var channelsNoSync     = ['486610426834976779','686539139268476939','769952999253868624','373826320343367684','691262619629256725','804667041189462036','575826903982669830','636359808747831296']
var judgebotCommands   = ['!card','!price','!legal','!ruling','!art','!stores','!events','!hangman','!standard','!cr','!define','!ipg','!mtr']
///these will be dynamically generated soon, static vote queues for now
//var voteLCI           = new vote("LCI")
//var voteCube          = new vote("Cube")

const StartTime = new Date().toLocaleString('en-us', { weekday:"long", year:"numeric", month:"short", day:"numeric", hour:"numeric", minute:"numeric", timeZone:"America/New_York"})
var voteStatusMessageID = ""
////
client.once('ready', () => {
    // List servers the bot is connected to
    //console.log("Servers:")
	client.users.fetch(BOT_ID, true)
		.then(user => user.setPresence({ activities: [{ name: 'your manabases!',
														type: ActivityType.Watching }],
										 status: 'online'
										}))
	clearvoteQueue("all")
	console.log("================Bot starting at: " + StartTime + "================")
	console.error("================Bot starting at: " + StartTime + "================")											
	console.log("Setting user activity...")
    checkChannels()
	setTimeout(justWait,5000, "Let the async finish")
	channeltimer.sort((a,b)=> (a.name > b.name ? 1 : -1 ))
	channeltimer.forEach(channel =>{
		console.log(`( ${channel.channelId} ) -- ${channel.name} `)
	})
	//console.log(channeltimer)
	setInterval(activeChannels, MIN_INTERVAL)

	sendvoteStatus(client)
	//  var generalChannel = client.channels.get("593762203887468560") // Replace with known channel ID
    // generalChannel.send("#ImwithEthan")
    //	generalChannel.send("Wait, I mean, #ImwithBen")
})

client.on("warn", console.log)
client.on("debug", console.log)

client.on('messageCreate', (receivedMessage) => {
	let tarChannelUpdate = channeltimer.find(channel => channel.channelId == receivedMessage.channelId)
	if( !tarChannelUpdate){
		client.channels.fetch(receivedMessage.channelId)
			.then( channel => channeltimer.push(new channelStatus(channel.id, channel.name, channel.type, channel.lastMessageId, receivedMessage.createdTimestamp, false)) )
	}
	else{
		tarChannelUpdate.lastMessageID == receivedMessage.id
		tarChannelUpdate.lastMessageTimestamp == receivedMessage.createdTimestamp
	}
    if (receivedMessage.author == client.user) { // Prevent bot from responding to its own messages
		console.log("Nope, skipping bot message")
		if (receivedMessage.channel.id == BOT_vote_CHANNEL && receivedMessage.content.match(botmessage)  ){
			console.log("Gotta fix the pins...")
			receivedMessage.pin()
			var mycurrentpin = receivedMessage.id
			managebotpins(mycurrentpin)
		}
    }
	else if( postsDontCount.indexOf(receivedMessage.channel.id) == -1){
	//else {
		const msgSQL = 'INSERT INTO public.userdata(discordid, discordname, email, arenaname, postcount, firstfound) ' +
					   'VALUES ($1, $2, $3, $4, $5, now()) ' +
					   'ON CONFLICT (discordid) ' +
					   'DO UPDATE ' +
					   'SET postcount = (SELECT postcount FROM public.userdata WHERE discordid = $1) +1;'
		msgValues = [receivedMessage.author.id,receivedMessage.author.tag,'','',1]
		dbs.trackPost(msgSQL,msgValues)
	}

    if (receivedMessage.content.startsWith("!")) {
		if (judgebotCommands.includes(receivedMessage.content)){
			//Ignore this
		}
		else{
			processCommand(receivedMessage)
			//console.log("Finished processing command...")
		}

    }

	//if (receivedMessage.channel.id == "593762203887468560") {
	//	console.log(receivedMessage.content)
	//}
	//console.log("Finished message.create!")
})
// message.guild.channels.find("name", "general").setName("Testing");

function updateChannelStatus(channel, message){
	let tarChannel = channeltimer.find(objChannel => objChannel.channelId == channel)
	if(tarChannel && message != undefined){
		tarChannel.lastMessageID = message.id
		tarChannel.lastMessageTimestamp = message.createdTimestamp
	}
	else if(!tarChannel){
		if(message != undefined){
			channeltimer.push(new channelStatus(channel.id, channel.name, channel.type, message.id, message.createdTimestamp, false))
		}
		else{
			channeltimer.push(new channelStatus(channel.id, channel.name, channel.type, 0, 0, false))
		}
	}

}


const myAsyncFunc = (result) => {
	//console.log(result.channel.name + " " +  Date.now() + " " + TenMinutes + " " + result.createdTimestamp + ((Date.now() - TenMinutes) > result.createdTimestamp))
	if(result){
		let tarChannel = channeltimer.find(channel => channel.channelId == result.channelId)
		if(tarChannel){
			if( (Date.now() - TenMinutes) > result.createdTimestamp) {
				//The channel already isn't active, so set the isActive property to false	
				if( !tarChannel.isActive){
					tarChannel.isActive = false
				}
				else{
					//The channel was active, but it shouldn't be any longer
					try{
						console.log("Hey! " + result.channel.name + "(" + result.channelId + ") is no longer active!" )
					}
					catch{console.error(`Weird problem with ${result.channel}`)}
					tarChannel.lastMessageTimestamp = result.createdTimestamp
					tarChannel.lastMessageID = result.id
					tarChannel.isActive = false;
					client.channels.fetch(result.channelId)
						.then(channel => renameChannel(channel, false) )
				}
			}
			else{
				//The channel is already active, so set the isActive property to true
				if( tarChannel.isActive){
					tarChannel.isActive = true
				}
				else{
					try{
						console.log("Hey! " + result.channel.name + "(" + result.channelId + ") is now active!")
					}
					catch{console.error(`Weird problem with ${tarChannel} - ${result.channel}`)
						console.error("%o", tarChannel)}
					tarChannel.isActive = true;
					tarChannel.lastMessageTimestamp = result.createdTimestamp
					tarChannel.lastMessageID = result.id;
					client.channels.fetch(result.channelId, true)
						.then(channel => renameChannel(channel, true))
				}
			}
		}
		else{
			//If the channel doesn't exist in the array, let's add it and start with an activestatus of false
			client.channels.fetch(result.channelId)
				.then(channel => channeltimer.push(new channelStatus( channel.id, channel.name, channel.type, channel.lastMessageId, result.createdTimestamp, false)) )
		}
	}		
	//console.log("Async pulsed")	
};

function justWait(arg){
	console.log(arg)
}



function processCommand(receivedMessage) {
    let fullCommand       = receivedMessage.content.substr(1) // Remove the leading exclamation mark
    let splitCommand      = fullCommand.split(" ") // Split the message up in to pieces for each space
    let primaryCommand    = splitCommand[0].toLowerCase() // The first word directly after the exclamation is the command
    let arguments         = splitCommand.slice(1) // All other words are arguments/parameters/options for the command
    let fullarguments     = fullCommand.replace(primaryCommand, '')
	let msgSender         = client.users.cache.find(user => user.id === receivedMessage.author.id); //go ahead and resolve who sent the message
    let msgChannelID      = receivedMessage.channelId
	let msgChannel        = client.channels.cache.get(msgChannelID)
	let message           = ""
	let myName            = ""
	let myArenaname       = ""
	const msgValues       = [receivedMessage.author.id,receivedMessage.author.tag,'',myName,1]
	const msgLookupSQL    = "SELECT * FROM public.userdata WHERE discordid = $1;"
	const msgLookupValues = [receivedMessage.author.id]
    console.log("Command received: " + primaryCommand)
    console.log("Arguments: " + arguments) // There may not be any arguments
	console.log("recievedMessage", receivedMessage)
    if (primaryCommand == "help") {

		message = "use !join then the set tag and your arena username to join the vote queue \n" +
		"!leave then the set tag and you will leave the given queue\n" +
		"!status then the set tag will give you the status of the pod. This is also pinned in the vote coordination channel "
		client.channels.fetch(msgChannelID, true)
				.then(channel=> channel.send(message))

    } else if (primaryCommand == "multiply") {
		multiplyCommand(arguments, receivedMessage)
	// Arena tags
	} else if (primaryCommand == "arena"  && receivedMessage.channel.id == "1170764621192364205"  /*636359808747831296*/) {
		if( arguments !== null && arguments !== '' ){
			const msgSQL = 'INSERT INTO public.userdata(discordid, discordname, email, arenaname, postcount, firstfound) ' +
						'VALUES ($1, $2, $3, $4, $5, now()) ' +
						'ON CONFLICT (discordid) ' +
						'DO UPDATE ' +
						'SET arenaname = $4;'
			//In case there's a space in the username, let's join it together.
			myName = arguments.join(' ')
			dbs.arenaUpdate(msgSQL,msgValues);
			client.users.cache.get(receivedMessage.author.id).send(`Your arenatag has been set to: ${arguments}`);
		}
		else{
			client.channels.fetch(msgChannelID, true)
				.then(channel=> channel.send(`${msgSender} -- the syntax is !arena <arenaname>`));
		}
    // Coop votes!
    } else if (primaryCommand == "coop" && receivedMessage.channel.id == "1170764621192364205" /*636359808747831296*/){
		console.log(receivedMessage.guild.roles, "roles")
        let coop = receivedMessage.guild.roles.cache.find(role => role.name === "coop");

        if(arguments == "on"){
            receivedMessage.member.roles.add(coop)
            client.channels.fetch(msgChannelID, true)
				.then(channel=> channel.send(`Welcome to the co-op votes team, ${msgSender}!`));
        }
        else if(arguments == "off"){
			receivedMessage.member.roles.remove(coop);client.channels.fetch(msgChannelID, true)
			.then(channel=> channel.send(`You will no longer see coop vote notifications, ${msgSender}.`));
        }
        else{
            if(receivedMessage.member.roles.cache.find(r => r.name === "coop")){
                receivedMessage.member.roles.remove(coop);
                client.channels.fetch(msgChannelID, true)
				.then(channel=> channel.send(`You will no longer see coop vote notifications, ${msgSender}.`));
            }
            else{
                receivedMessage.member.roles.add(coop);
                client.channels.fetch(msgChannelID, true)
				.then(channel=> channel.send(`Welcome to the co-op votes team, ${msgSender}!`));
            }
        }
    } else if (primaryCommand == "votewithme" && receivedMessage.channel.id == "1170764621192364205" /*636359808747831296*/){
		let cooprole = receivedMessage.guild.roles.cache.find(role => role.name === 'coop');
		let coopchannel = client.channels.cache.find(channel => channel.id === "688495149499547655");

		coopchannel.send(`Calling ${cooprole}! ${msgSender} is starting a vote!`);
        //var testchannel = client.channels.get("593762203887468560");
        //testchannel.send("Calling " + cooprole + "! " + receivedMessage.author + " is starting a vote!");
   		// Pronoun Ranks
    } else if (primaryCommand == "rank" && receivedMessage.channel.id == "1170764621192364205" /*636359808747831296*/){
		let he   = receivedMessage.guild.roles.cache.find(role => role.name === "he/him");
		let she  = receivedMessage.guild.roles.cache.find(role => role.name === "she/her");
		let they = receivedMessage.guild.roles.cache.find(role => role.name === "they/them");
		if(arguments == "he/him"){
			receivedMessage.member.roles.add(he);
			receivedMessage.member.roles.remove(she).catch(console.error);
			receivedMessage.member.roles.remove(they).catch(console.error);
			client.channels.fetch(msgChannelID, true)
				.then(channel=> channel.send(`${msgSender} you just joined **${he.name}**`));
		}
		else if(arguments == "she/her"){
			receivedMessage.member.roles.add(she);
			receivedMessage.member.roles.remove(he).catch(console.error);
			receivedMessage.member.roles.remove(they).catch(console.error);
			client.channels.fetch(msgChannelID, true)
				.then(channel=> channel.send(`${msgSender} you just joined **${she.name}**`));
		}
		else if(arguments == "they/them"){
			receivedMessage.member.roles.add(they);
			receivedMessage.member.roles.remove(he).catch(console.error);
			receivedMessage.member.roles.remove(she).catch(console.error);
			client.channels.fetch(msgChannelID, true)
				.then(channel=> channel.send(`${msgSender} you just joined **${they.name}**`));
		}
		else {
			client.channels.fetch(msgChannelID, true)
				.then(channel=> channel.send(`${msgSender} -- the role must be one of the following: he/him, she/her, they/them. Please try again using the correct syntax: !rank <pronoun>`));
		}
	}else if ( primaryCommand === "queue" ){
	}else if ( primaryCommand === "join" ){
		if (arguments[0] === undefined){
			client.channels.fetch(msgChannelID, true)
				.then(channel=> channel.send("Please provide a valid set code"))
			return;
		}
		else if (!SET_CODES.includes(arguments[0].toLowerCase())){
			client.channels.fetch(msgChannelID, true)
				.then(channel=> channel.send("Please provide a valid set code"))
			return;
		}
		else{
			pgLookup(msgLookupSQL,msgLookupValues)
				.then( userdata => {
					//console.log("%o", userdata)
					myArenaname = userdata[0].arenaname
					if (!arguments[1]){
						//Check if we already have a username, if so, we don't need one.
						const InvalidArenaNames = ['Default','','testing']
						if( InvalidArenaNames.includes(myArenaname) || myArenaname === undefined || myArenaname === null ){
							myArenaname ="NoArenaNameGiven"
						}
						else {
							myArenaname = userdata[0].arenaname
						}
					}
					else{
						myArenaname = arguments[1]
					}
					///TODO clean this up
					//console.log(`Sending to add to queue ${userdata[0].Discordid} \n ${userdata[0].Discordname} \n ${arguments[0]} \n ${myArenaname}`)
					voteCommands.addToQueue(receivedMessage, userdata[0], arguments[0], client, myArenaname)

				})
		}
	} else if ( primaryCommand === "ready"){
		console.log("Got a ready command.")
		if (arguments[0] === undefined){
			client.channels.fetch(msgChannelID, true)
				.then(channel=> channel.send("Please provide a valid set code"))
			return;
		}

		if (!SET_CODES.includes(arguments[0].toLowerCase())){
			client.channels.fetch(msgChannelID, true)
				.then(channel=> channel.send("Please provide a valid set code"))
			return;
		}
		//yuck	
		voteCommands.readyCheck(receivedMessage, arguments[0], client)
		//voteCommands.isvoteReady(receivedMessage,vote, client, arenaUserNames)



	}else if ( primaryCommand === "leave"){

		if (arguments[0] === undefined){
			client.channels.fetch(msgChannelID, true)
				.then(channel=> channel.send("Please provide a valid set code"))
			return;
		}

		if (!SET_CODES.includes(arguments[0].toLowerCase())){
			client.channels.fetch(msgChannelID, true)
				.then(channel=> channel.send("Please provide a valid set code"))
			return;
		}
		pgLookup(msgLookupSQL,msgLookupValues)
		.then( userdata => {
			voteCommands.leaveQueue(receivedMessage, userdata, arguments[0])
		})
	}else if ( primaryCommand === "status"){
		let statusSQLValues    = []
		let statusCheckMessage = ""
		let statusnewline      = ""
		if (arguments[0] === undefined){
			client.channels.fetch(msgChannelID, true)
				.then(channel=> channel.send("Please provide a valid argument"))
			return;
		}
		else if(arguments[0].toLowerCase() === 'all'){
			console.log("Getting ALL status")
			var statusSQL = 'SELECT setcode, (SELECT CASE WHEN EXISTS ( SELECT COUNT(discordname) '
			+ 'FROM vote ' 
			+ 'WHERE lower(format) = lower(dr.setcode)) '
			+ 'THEN (SELECT COUNT(discordname) FROM vote WHERE lower(format) = lower(dr.setcode)) '
			+ 'ELSE 0 '
			+ 'End as queuecount '
			+ 'UNION ALL '
			+ 'SELECT 0 '
			+ 'WHERE NOT EXISTS (SELECT COUNT(discordname) FROM vote WHERE lower(format) = lower(dr.setcode)) '
			+ ') '
			+ 'FROM voteformat dr '
			+ 'WHERE active = $1'
			statusSQLValues.push('true')
		}
		else if (!SET_CODES.includes(arguments[0].toLowerCase())){
			client.channels.fetch(msgChannelID, true)
				.then(channel=> channel.send("Please provide a valid set code"))
			return;
		}
		else{
			console.log(`Getting ${arguments[0]} status`)
			let statusSQL = 'SELECT setcode, (SELECT CASE WHEN EXISTS ( SELECT COUNT(discordname) '
			+ 'FROM vote ' 
			+ 'WHERE lower(format) = lower(dr.setcode)) '
			+ 'THEN (SELECT COUNT(discordname) FROM vote WHERE lower(format) = lower(dr.setcode)) '
			+ 'ELSE 0 '
			+ 'End as queuecount '
			+ 'UNION ALL '
			+ 'SELECT 0 '
			+ 'WHERE NOT EXISTS (SELECT COUNT(discordname) FROM vote WHERE lower(format) = lower(dr.setcode)) '
			+ ') '
			+ 'FROM voteformat dr '
			+ 'WHERE active = true and lower(dr.setcode) = lower($1)'
			statusSQLValues.push = (arguments[0])
		}
		
		if(arguments[0].toLowerCase() === 'all'){
			statusCheckMessage = `The status for **${arguments[0].toUpperCase()}** vote queues is: \n`
			statusnewline = true
		}
		else{
			statusCheckMessage = `The status for **${arguments[0].toUpperCase()}** vote is currently: `
			statusnewline = false
		}
		dbs.voteStatus(statusSQL, statusSQLValues)
			.then(statusCheck => {
				//console.log("%o",statusCheck)
				statusCheck.forEach( statusSetCode => {
					if(statusnewline){
						statusCheckMessage = statusCheckMessage + `**${statusSetCode.setcode}: ${statusSetCode.queuecount}/${MAX_POD_SIZE}** players`
						statusCheckMessage = statusCheckMessage + "\n"
					}
					else{
						statusCheckMessage = statusCheckMessage + `**${statusSetCode.queuecount}/${MAX_POD_SIZE}**`
					}
				})
				if(!statusnewline){
					statusCheckMessage = statusCheckMessage + " players"
				}
			})
			.finally( () => {receivedMessage.channel.send(statusCheckMessage) })
		//var vote = chosenvote(arguments)
	//Only look at the admin channel (686539139268476939)
	}else if ( primaryCommand.toLowerCase() === "newcategory" && ( receivedMessage.channel.id == ADMIN_CHANNEL || receivedMessage.channel.id ==  TESTING_CHANNEL)){
		if (arguments[0] === undefined){
			client.channels.fetch(msgChannelID, true)
				.then(channel=> channel.send("Please provide a name for the category (inside double quotes if the name contains spaces)."))
			return;
		}
		else{
			let catName = fullarguments.replace(/["']/g, "")			
			console.log("Creating Category: " + catName)
			client.channels.fetch(msgChannelID, true)
				.then(channel=> channel.send( "Creating Category: " + catName))
			
			receivedMessage.guild.channels.create( { name: catName,
													 type: ChannelType.GuildCategory, 
				                                             permissionOverwrites:[
					{	
						id: receivedMessage.guild.roles.everyone,
						deny: [PermissionsBitField.Flags.ViewChannel]
					},	
					{
						id: receivedMessage.guild.roles.cache.find(role => role.name === "Lord"),
						allow: [PermissionsBitField.Flags.ViewChannel,PermissionsBitField.Flags.ManageChannels,
							PermissionsBitField.Flags.ManageRoles,
							PermissionsBitField.Flags.ManageWebhooks, PermissionsBitField.Flags.CreateInstantInvite,
							PermissionsBitField.Flags.SendMessages, PermissionsBitField.Flags.SendMessagesInThreads,
							PermissionsBitField.Flags.CreatePublicThreads,PermissionsBitField.Flags.CreatePrivateThreads,
							PermissionsBitField.Flags.EmbedLinks,PermissionsBitField.Flags.AttachFiles,
							PermissionsBitField.Flags.AddReactions,	PermissionsBitField.Flags.UseExternalEmojis,
							PermissionsBitField.Flags.UseExternalStickers,PermissionsBitField.Flags.MentionEveryone,
							PermissionsBitField.Flags.ManageMessages, PermissionsBitField.Flags.ManageThreads,
							PermissionsBitField.Flags.ReadMessageHistory, PermissionsBitField.Flags.SendTTSMessages,
							PermissionsBitField.Flags.UseApplicationCommands,PermissionsBitField.Flags.Connect,
							PermissionsBitField.Flags.Speak,PermissionsBitField.Flags.Stream,
							PermissionsBitField.Flags.UseEmbeddedActivities,PermissionsBitField.Flags.UseVAD,
							PermissionsBitField.Flags.PrioritySpeaker,PermissionsBitField.Flags.MuteMembers,
							PermissionsBitField.Flags.DeafenMembers,PermissionsBitField.Flags.MoveMembers,
							PermissionsBitField.Flags.ManageEvents
						]
					},
					{
						id: receivedMessage.guild.roles.cache.find(role => role.name === "ChannelMod"),
						allow: [PermissionsBitField.Flags.ManageChannels]
					},
					{
						id: receivedMessage.guild.roles.cache.find(role => role.name === "Liege"),
						allow: [PermissionsBitField.Flags.ViewChannel,PermissionsBitField.Flags.SendMessages,
						PermissionsBitField.Flags.SendMessagesInThreads,PermissionsBitField.Flags.CreatePublicThreads,
						PermissionsBitField.Flags.CreatePrivateThreads,PermissionsBitField.Flags.EmbedLinks,
						PermissionsBitField.Flags.AttachFiles,PermissionsBitField.Flags.AddReactions,
						PermissionsBitField.Flags.UseExternalEmojis,PermissionsBitField.Flags.UseExternalStickers,
						PermissionsBitField.Flags.MentionEveryone,PermissionsBitField.Flags.ManageMessages,
						PermissionsBitField.Flags.ManageThreads,PermissionsBitField.Flags.ReadMessageHistory,
						PermissionsBitField.Flags.SendTTSMessages,PermissionsBitField.Flags.UseApplicationCommands]
					},
					
					{
						id: receivedMessage.guild.roles.cache.find(role => role.name === "Hero"),
						allow: [PermissionsBitField.Flags.ViewChannel,PermissionsBitField.Flags.SendMessages,
						PermissionsBitField.Flags.SendMessagesInThreads,PermissionsBitField.Flags.CreatePublicThreads,
						PermissionsBitField.Flags.CreatePrivateThreads,PermissionsBitField.Flags.EmbedLinks,
						PermissionsBitField.Flags.AttachFiles,PermissionsBitField.Flags.AddReactions,
						PermissionsBitField.Flags.UseExternalEmojis,PermissionsBitField.Flags.UseExternalStickers,
						PermissionsBitField.Flags.ReadMessageHistory,PermissionsBitField.Flags.SendTTSMessages,
						PermissionsBitField.Flags.UseApplicationCommands],
						deny:[PermissionsBitField.Flags.MentionEveryone,PermissionsBitField.Flags.ManageMessages,
							PermissionsBitField.Flags.ManageThreads]
					},
					{
						id: receivedMessage.guild.roles.cache.find(role => role.name === "Squire"),
						allow: [PermissionsBitField.Flags.ViewChannel,PermissionsBitField.Flags.SendMessages,
							PermissionsBitField.Flags.SendMessagesInThreads,PermissionsBitField.Flags.CreatePublicThreads,
							PermissionsBitField.Flags.CreatePrivateThreads,PermissionsBitField.Flags.EmbedLinks,
							PermissionsBitField.Flags.AttachFiles,PermissionsBitField.Flags.AddReactions,
							PermissionsBitField.Flags.UseExternalEmojis,PermissionsBitField.Flags.UseExternalStickers,
							PermissionsBitField.Flags.ReadMessageHistory,PermissionsBitField.Flags.SendTTSMessages,
							PermissionsBitField.Flags.UseApplicationCommands],
						deny:[PermissionsBitField.Flags.MentionEveryone,PermissionsBitField.Flags.ManageMessages,
								PermissionsBitField.Flags.ManageThreads]
					},
					{
						id: receivedMessage.guild.roles.cache.find(role => role.name === "bots"),
						allow: [PermissionsBitField.Flags.ViewChannel,PermissionsBitField.Flags.SendMessages,
							PermissionsBitField.Flags.ManageRoles,
							PermissionsBitField.Flags.SendMessagesInThreads,PermissionsBitField.Flags.CreatePublicThreads,
							PermissionsBitField.Flags.CreatePrivateThreads,PermissionsBitField.Flags.EmbedLinks,
							PermissionsBitField.Flags.AttachFiles,PermissionsBitField.Flags.AddReactions,
							PermissionsBitField.Flags.UseExternalEmojis,PermissionsBitField.Flags.UseExternalStickers,
							PermissionsBitField.Flags.ReadMessageHistory,PermissionsBitField.Flags.SendTTSMessages,
							PermissionsBitField.Flags.UseApplicationCommands]
					}
				] })
						
		}
	}
	else if ( primaryCommand.toLowerCase() === "sync" && ( receivedMessage.channel.id == ADMIN_CHANNEL || receivedMessage.channel.id ==  TESTING_CHANNEL)){
		if (arguments[0] === undefined){
			client.channels.fetch(msgChannelID, true)
				.then(channel=> channel.send("Please provide a name for the category to sync (inside double quotes if the name contains spaces)."))
			return;
		}
		else{
			let catName = fullarguments.replace(/["']/g, "")
			if( catName.startsWith(' ')){
				catName = catName.substr(1) // Remove a leading space
			}
			let targetCat = client.channels.cache.find(tarChannel => tarChannel.name === catName)		
			if(targetCat){
				console.log(`Found ${targetCat.name} (${targetCat.id})`)
				client.channels.fetch(msgChannelID, true)
					.then(channel=> channel.send(`Trying to reset permissions for Category: ${targetCat.name}`))
				targetCat.children.cache.forEach((tarChannel) => {
					try{
						if(channelsNoSync.indexOf(tarChannel.id) == -1){
							console.log(`Setting Permissions on ${tarChannel.name} (${tarChannel.id})`)
							tarChannel.lockPermissions()
						}
						else{
							client.channels.fetch(msgChannelID, true)
								.then(channel=> channel.send(`I'm not allowed to set permissions on **${tarChannel.name}.**`))
						}
					}
					catch {
						client.channels.fetch(msgChannelID, true)
							.then(channel=> channel.send(`Uh-oh, I wasn't able to set permissions for '${catName}'`))
						console.error(error)
					}
				})
				client.channels.fetch(msgChannelID, true)
					.then(channel=> channel.send(`Finished!`))
			}
			else{
				client.channels.fetch(msgChannelID, true)
					.then(channel=> channel.send(`Couldn't find a catgory with name: '${catName}'`))
				console.log(`Couldn't find a catgory with name: '${catName}'`)
			}
			
		}
	}
	else {
        receivedMessage.channel.send("I don't understand the command. Try `!help``")
    }
	//console.log("finished processcommand function")
}

function managebotpins(currentpin){
	client.channels.fetch(BOT_vote_CHANNEL, true)
		.then(channel => channel.messages.fetchPinned()
						.then((pinnedmessages) => {
								console.log("Checking pinned messages")
								pinnedmessages.forEach(pin => { if (pin.content.includes(botmessagesimple) && pin.id != currentpin){
								//pinnedmessages.forEach(pin => {if (pin.content.match(botmessage) && pin.id != currentpin){
																console.log(`Trying to unpin ${pin.id} current pin is ${currentpin}: eval '${botmessage.test(pin.content)}'`)
																							//msgToUnpin.push(pin.id)
																pin.unpin()
																							//channel.messages.fetch(pin.id)
																							//.then(msg => msg.unpin('Old message')
																							//			.then(console.log)
																							//			.catch(console.error))
																							//.catch(console.error);
															}
														})
							})
	)
}

function helpCommand(arguments, receivedMessage) {
    if (arguments.length > 0) {
        receivedMessage.channel.send("It looks like you might need help with " + arguments)
    } else {
        receivedMessage.channel.send("I'm not sure what you need help with. Try `!help [topic]`")
    }
}

function checkChannels() {
	client.guilds.cache.forEach((guild) => {
		guild.channels.cache.forEach((channel) => {
				//console.log( channel.name + "          " + channel.lastMessageId)
				//console.log(` -- ${channel.name} (${channel.type}) - ${channel.id}`)
				let tarChannel = channeltimer.find(objChannel => objChannel.channelId == channel.id)									
				if(channel.type == GUILD_TEXT){
					// Build our list of channels
					if(!tarChannel){
						channeltimer.push(new channelStatus(channel.id, channel.name,channel.type,0,0,false))
					}
					tarChannel = channeltimer.find(objChannel => objChannel.channelId == channel.id)
					let msgID = channel.lastMessageId;
					//console.log(` -- Found ${msgID}`)
					if(msgID != undefined){						
						if(!tarChannel){
							channel.messages.fetch(msgID)
								.then(message => updateChannelStatus(channel.id, message))
								.catch(error => console.error(`Error updating channeltimer ${channel.name} ${msgID} ${error}`))
							try{
								let mymessage = channel.messages.cache.find( message => message.id === channel.lastMessageId)
								myAsyncFunc(mymessage)
							}
							catch( error ){
								console.error(`Unable to find message ${error}`)
							}
						}
						else{
							channel.messages.fetch(msgID)
								.then(message => updateChannelStatus(channel.id, message))
								.catch(error => console.error(`Error updating channeltimer ${channel.name} ${msgID} ${error}`))
							try{
								let mymessage = channel.messages.cache.find( message => message.id === channel.lastMessageId)
									myAsyncFunc(mymessage)
							}
							catch( error ){
								console.error(`Unable to find message ${error}`)
							}
						}
					}
					else{
						if(tarChannel){
							let myresult;
							myresult = {
								name: tarChannel.name,
								id: tarChannel.lastMessageID,
								createdTimestamp: tarChannel.lastMessageTimestamp,
								channelId: tarChannel.channelId
	
							}
							myAsyncFunc(myresult)
						}
						else{
							channel.messages.fetch( {limit: 2} )
								.then(message => myAsyncFunc(message.last()))
								.catch(error => console.error('Cannot find potentially deleted message in ' + channel.name));
						}
					}
				}
				else{
					//console.log(`${channel.name} isn't a text channel, so skip it. ${channel.type}`)					
				}
		}) // End Channel Loop
	}) // End Guild Loop
}

function activeChannels() {
		console.log("")
		let myTime = new Date().toLocaleString('en-us', { weekday:"long", year:"numeric", month:"short", day:"numeric", hour:"numeric", minute:"numeric", timeZone:"America/New_York"})
		console.log("================ Rechecking for active channels ("+ myTime + ") ================")
		console.error("================ Rechecking for active channels ("+ myTime + ") ================")
		checkChannels()
		channeltimer.forEach(channel =>{
			if(channel.isActive){
				console.log( channel.name + "(" + channel.channelId + ")" )
			}
			else{
				//console.error(`Error finding channel: ${channel.name} (${channel.channelId})`)
			}
		})
}

function renameChannel(channel, active) {
	//var targetChannel = client.guilds.find("id",'373826318913241089').channels.find("id",channel)
	var targetChannel = channel;
	//console.log ("Channel:" + targetChannel.name + " " + targetChannel.id)

    const hasemojis =/\p{Extended_Pictographic}-*/u;
	if( !targetChannel.isThread()){
		if (targetChannel == null) {
			console.log("Channel: " + channel + " wasn't found")
		}
		else {
			//console.log(targetChannel)
			if(active){
				if(targetChannel.name.toString().match(hasemojis)) {
					console.log(targetChannel.name + "(" + targetChannel.id + ") is already marked active; skipping")
				} 
				else{
					targetChannel.setName(emojiFireTwo + "-" + targetChannel.name)
				}
			}
			else{
				if( !(targetChannel.name.toString().includes(emojiFireTwo)) ) {
					console.log(targetChannel.name + "(" + targetChannel.id + ") is already marked inactive; skipping")
				}
				else{
					targetChannel.setName(targetChannel.name.toString().replace(hasemojis,''))
				}
			}
		}
	}
	else{
		//Don't do anything with threads
	}
}

///REFACTOR ALL STATUS CODE
const clearvoteQueue = format => new Promise((resolve, reject) => {
		var clearvoteQueue = ""
		clearvoteQueueValues = []
		if(format = "all"){
			clearvoteQueue = "TRUNCATE vote RESTART IDENTITY"
			//clearvoteQueueValues.push("all")
		} 
		else{
			clearvoteQueue = "DELETE FROM vote WHERE format = $1"
			clearvoteQueueValues.push(format)
		}
		dbs.clearQueue(clearvoteQueue, clearvoteQueueValues)
		.then(truncatetable =>{
			resolve(truncatetable)
		})
		.catch(e => { alert(e); reject(`Error returning query: ${e}`); throw e  })
})

const getvoteStatus = query => new Promise((resolve, reject) => {
		dbs.voteStatus(query)
		.then(votestatusraw  => {
			resolve(votestatusraw)
		})
		//catch{reject(`Error returning query: ${error}`)}
		//console.log("Query Result " + votestatusraw)
		.catch(e => { alert(e); reject(`Error returning query: ${e}`); throw e  })
})

const sendvoteStatus = (client) => {
	const votestatusSQL = 'SELECT setcode, (SELECT CASE WHEN EXISTS ( SELECT COUNT(discordname) '
						+ 'FROM vote ' 
						+ 'WHERE lower(format) = lower(dr.setcode)) '
						+ 'THEN (SELECT COUNT(discordname) FROM vote WHERE lower(format) = lower(dr.setcode)) '
						+ 'ELSE 0 '
						+ 'End as queuecount '
						+ 'UNION ALL '
						+ 'SELECT 0 '
						+ 'WHERE NOT EXISTS (SELECT COUNT(discordname) FROM vote WHERE lower(format) = lower(dr.setcode)) '
						+ ') '
						+ 'FROM voteformat dr '
						+ 'WHERE active = true'
	message = "**"
	getvoteStatus(votestatusSQL)
	.then(votestatus => {
		//console.log("Query Result " + votestatus)
		votestatus.forEach( setcode => {
			//console.log(`${setcode.setcode} ${setcode.queuecount}`)
			message = `${message}${setcode.setcode} Queue ${setcode.queuecount}/${MAX_POD_SIZE}\n`
			})
	})
	.finally(() =>{
		message = `${message}**`
		//console.log(`Final bot channel status message:\n${message}`)
		client.channels.fetch(BOT_vote_CHANNEL, true)
			.then(channel=> channel.send(message)
							.then(post => vote_STATUS_MESSAGE = post))
	})
	.catch((err) => {console.log(err)})
}

const buildStatusMessage = ()  => new Promise ((resolve, reject) => {
	const statusMessageSQL = 'SELECT setcode, (SELECT CASE WHEN EXISTS ( SELECT COUNT(discordname) '
	+ 'FROM vote ' 
	+ 'WHERE lower(format) = lower(dr.setcode)) '
	+ 'THEN (SELECT COUNT(discordname) FROM vote WHERE lower(format) = lower(dr.setcode)) '
	+ 'ELSE 0 '
	+ 'End as queuecount '
	+ 'UNION ALL '
	+ 'SELECT 0 '
	+ 'WHERE NOT EXISTS (SELECT COUNT(discordname) FROM vote WHERE lower(format) = lower(dr.setcode)) '
	+ ') '
	+ 'FROM voteformat dr '
	+ 'WHERE active = true'
	let statusMessage = ""
	dbs.votestatusMessage(statusMessageSQL)
	.then(votestatus => {
		statusMessage = "**"
		//console.log("Query Result " + votestatus)
		votestatus.forEach( setcode => {
			//console.log(`${setcode.setcode} ${setcode.queuecount}`)
			statusMessage = `${statusMessage}${setcode.setcode} Queue ${setcode.queuecount}/${MAX_POD_SIZE}\n`
			})
		statusMessage = `${statusMessage}**`
	})
	.finally( () => {
		vote_STATUS_MESSAGE.edit(statusMessage)
		resolve(statusMessage)
	})
	.catch((err) => {reject(`Error updating status: ${e}`)})
})

client.login(bot_secret_token.token)

exports.buildStatusMessage = buildStatusMessage