const status = require('../draebot.js')
const dbs = require('../db.js')
const strict = true;
//hex string for URL
const getRanHex = size => {
    let result = [];
    let hexRef = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'];
  
    for (let n = 0; n < size; n++) {
      result.push(hexRef[Math.floor(Math.random() * 16)]);
    }
    return result.join('');
}
// const BOT_vote_CHANNEL = "696045401240895522"

//Prod env
const BOT_vote_CHANNEL = "1110947498685649046"
const MAX_POD_SIZE = 2

const mentionUsers = (vote) => new Promise ((resolve, reject) => {
    "use strict";
    let message_string    = ""
    const userQuery       = "SELECT * FROM vote WHERE format = $1;"
    const userQueryValues = [vote]
    dbs.voteQueue(userQuery, userQueryValues)
        .then(queued => {
            //console.log("%o",queued)
            queued.forEach(voter =>{
                //console.log("%o",voter)
                message_string = message_string.concat(' ', "<@"+voter.discordid+">") 
            })
        })
        .finally( () =>{
            //console.log(message_string)
            resolve(message_string)
        })
	.catch((err) => {console.error(`Error building vote message: ${e}`)})
})

const sendMessageTovoteChannel = (client, message ) => {
    "use strict";
    client.channels.cache.get(BOT_vote_CHANNEL, true)
        .send({content: message})
}

const startReadyCheckSequence = (receivedMessage, vote, client) => {
    "use strict";
    console.log("entering start ready check loop")
    //message =  "It's time to vote! The queue will be open for the next **5 minutes**.  Reply `!ready " + vote + "` in the channel or DM if you are ready to vote."
    let message           = "\nIt's time to vote **" + vote.toUpperCase() + "**! DMs have been sent out to the pod!"
    let message_string    = ""
    const userQuery       = "SELECT * FROM vote WHERE format = $1;"
    const userQueryValues = [vote]
    let votermessage    = ""
    let DMtoSend          = ""
    dbs.voteQueue(userQuery, userQueryValues)
        .then(queued => {
                //console.log("%o",queued)
                queued.forEach( voter => {
                    //console.log("%o",voter)
                    DMtoSend = `Hello **${voter.discordname}**! Your pod for **${vote.toUpperCase()}** is ready!`
                    console.log(`Sending Message to ${voter.discordname}`)
                    client.users.send(voter.discordid, DMtoSend)
                    //readyuser = client.users.fetch(voter.discordid)
                    //console.log("%o", readyuser)    
                    //readyuser.messages.send({content:message}) 
                })
        })
        .finally( () => {
            mentionUsers(vote)
            .then( finishedmessage => {
                votermessage = `${finishedmessage}${message}`
                //receivedMessage.channel.send(finishedmessage)
                //receivedMessage.channel.send(message)
                client.channels.cache.get(BOT_vote_CHANNEL, true)
                    .send({content: votermessage})
                //receivedMessage.channel.send({content: votermessage})
                console.log ("BEFORE SET TIMEOUT")
            })
            .finally( () => {
                const reminder = setTimeout(reminderForUsers,     60000, vote, client)
            })
            //sendMessageTovoteChannel(client,mentionUsers(vote) + message)  
        })
};

const voteWhosMissing = (vote, client, thecount) => {
    "use strict";
    let place = ""
    let remaining = ""
    switch(thecount){
        case 1: place = "1st"; remaining = "3 minutes"; break;
        case 2: place = "2nd"; remaining = "2 minutes"; break;
        case 3: place = "3rd"; remaining = "1 minute"; break;
    }
    console.log(`[voteWhosMissing] Sending ${place} who's missing`)
    let missingMessage    = "voters not ready"
    let message_string    = ""
    let combinedmessage   = ""
    const userQuery       = "SELECT * FROM vote WHERE format = $1 and status != 'ready';"
    const userQueryValues = [vote]
    isvoteReady(vote)
        .then( voteStatus => {
            if( voteStatus.ready){
                console.log(`Got: ${voteStatus.ready} from isvoteReady function`)
                return;
            }
            else{
                console.log(`Got: ${voteStatus.ready} from isvoteReady function`)
                voteStatus.usersNotReady.forEach( voter => {
                    message_string = `${message_string}     ${voter}`
                })
                combinedmessage = `**${vote.toUpperCase()} ${missingMessage}**  *(${remaining} remaining)*: ${message_string}`    
                client.channels.cache.get(BOT_vote_CHANNEL, true)
                    //.send({content: combinedmessage})
                    .send({content: `Some folks aren't ready...`})
                if(thecount < 3 ){
                    const nextWhosMissing = setTimeout(voteWhosMissing, 60000, vote, client, thecount+1);
                }
                else{
                    const timeBadUsers = setTimeout(removeNotReadyUsers, 60000, vote, client)
                }
            }
        })
}

const reminderForUsers = (vote, client) => {
    "use strict";
    message = `*Reminder for ${vote.toUpperCase()} voters to ready up*` //: Please mark yourself ready with \`!ready ${vote}\``
    sendMessageTovoteChannel(client, message)
    const whosMissing = setTimeout(voteWhosMissing,    60000, vote, client, 1)
}

const removeNotReadyUsers = (vote, client) => {
    "use strict";
    const removeSQL  = "DELETE FROM vote WHERE format = $1 and status != 'ready'"
    let badUsers     = []
    let message      = ""
    let removeValues = [vote]
    isvoteReady(vote)
        .then(voteStatus => {
            dbs.voteRemoveUsers(removeSQL, removeValues)
            voteStatus.usersNotReady.forEach(user => {
                badUsers.push(user)
            })
            message     = `** ${badUsers.length} users not ready removed from the ${vote.toUpperCase()} queue, queue is now at ${voteStatus.usersReady.length}**`
            status.buildStatusMessage()
            sendMessageTovoteChannel(client, message)
        })
}

const addToQueueSQL = 'INSERT INTO public.vote(format, discordid, discordname, arenaname, status) ' +
'VALUES ($1, $2, $3, $4, $5) ' +
'ON CONFLICT (id) '

const addToQueue = (receivedMessage, userdata, vote, client, arenaName) => {
    "use strict";
    var message_string    = ""
    var voteStatusQuery  = "SELECT * FROM vote WHERE format = $1;"
    var voteStatusValues = [vote]
    const voteAddSQL = 'INSERT INTO public.vote(format, discordid, discordname, arenaname, status) ' +
    'VALUES ($1, $2, $3, $4, $5) ' +
    'ON CONFLICT (id) DO NOTHING'
    let voteAddValues = [vote.toLowerCase(), userdata.discordid, userdata.discordname, arenaName, "queued"]
    dbs.voteAddStatus(voteStatusQuery, voteStatusValues)
        .then( (statusresult) =>{ 
            //console.log(`[vote Add] Return from query:`)
            //console.log("%o", statusresult)
            var currentPod = []
            var currentCount = 0
            if(statusresult.length === 0|| statusresult === undefined || statusresult === null){
                currentCount = 0;
            }
            else{
                currentCount = statusresult.length
                statusresult.forEach( (id) => {
                    currentPod.push(id.discordid)
                })
            }
            if(currentCount == MAX_POD_SIZE){
                receivedMessage.channel.send({content: `${vote} Queue is in progress of ready check`})
                return;
            }
            else if (currentPod.includes(receivedMessage.author.id)){
                receivedMessage.channel.send({content: "You are already in the queue"})
                return;
            }
            else{
                dbs.voteStatus(voteAddSQL, voteAddValues)
                    .then(result =>{
                        const userName = receivedMessage.author.username
                        if ( (currentCount+1) == MAX_POD_SIZE){
                            console.log(`Starting ready check for ${vote}`)
                            status.buildStatusMessage();
                            startReadyCheckSequence(receivedMessage, vote, client);
                            //finishPod(receivedMessage, vote, client)
                        }
                        else{                        
                            status.buildStatusMessage();
                            receivedMessage.channel.send({content: `${userName} was added to the ${vote.toUpperCase()} queue ${currentCount+1}/${MAX_POD_SIZE}`})    
                        }
                    })
                }
        })
}

const finishPod = (receivedMessage, vote, client) => {
    "use strict";
    console.log("AT FINISH POD")
    let URL               = "https://www.mtgavote.tk/?session="+ getRanHex(12)
    let podMessage        = ""
    const userQuery       = "SELECT * FROM vote WHERE format = $1;"
    const userQueryValues = [vote]
    let arenaUserMessage  = `Arena User Names for this Pod:`
    dbs.voteQueue(userQuery, userQueryValues)
        .then( queued => {
            queued.forEach(voter => {
                podMessage = podMessage.concat(' ', "<@"+voter.discordid+">") 
                arenaUserMessage = arenaUserMessage.concat("\n" , voter.discordname + ": " + voter.arenaname)
            })
        })
        .finally( () => {
            //console.log(`Arena Usernames: \n ${arenaUserMessage}`)
            podMessage = `${podMessage} \nYour pod is ready! Navigate to ${URL} to start your vote.`
            //sendMessageTovoteChannel(client, `${podMessage}\n${arenaUserMessage}`)
            sendMessageTovoteChannel(client, `Pod's done, hooray!`)
            let clearQuery = "DELETE FROM vote WHERE format = $1"
            let clearQueryValues = [vote]
            dbs.clearQueue(clearQuery, clearQueryValues)
                .then ( () =>{
                    status.buildStatusMessage()
                })
            
        })
};

const readyCheck = (receivedMessage, vote, client) => {
    "use strict";
    const userQuery         = "SELECT * FROM vote WHERE format = $1;"
    const userQueryValues   = [vote]
    let usersReady          = []
    let usersinPod          = []
    const readyQuery        = "UPDATE vote SET status = 'ready' WHERE discordid = $1"
    const readyQueryValues  = [receivedMessage.author.id]
    const userRCQuery       = "SELECT * FROM vote WHERE format = $1 and status = 'ready';"
    const userRCQueryValues = [vote]
    dbs.voteQueue(userQuery, userQueryValues)
        .then(queued => {
                queued.forEach(voter =>{
                    usersinPod.push(voter.discordname)
                    if(voter.status === 'ready'){
                        usersReady.push(voter.discordname)
                    }
                })
        })
        .finally( () =>{
            if(usersinPod.length < MAX_POD_SIZE){
                receivedMessage.channel.send({content: `Your vote (${vote.toUpperCase()}) is not ready: ${usersinPod.length}/${MAX_POD_SIZE} seats full`})
            }
            else if (usersReady.includes(receivedMessage.author.username)){
                receivedMessage.channel.send({content: `You are already marked as ready`})
                return;
            
            }
            else if (!usersinPod.includes(receivedMessage.author.username)){
                receivedMessage.channel.send({content: `You are not in the queue for ${vote.toUpperCase()}`})
                return;
            }
            else{
                dbs.voteReady(readyQuery, readyQueryValues)
                    .then( () => {
                        receivedMessage.channel.send({content: `${receivedMessage.author.username}, you are now marked as ready in ${vote.toUpperCase()}`})
                    })
                    .finally( () => {
                        console.log(`[Ready Check] Checking if ${vote} is ready!`)
                        isvoteReady(vote)
                            .then( votestatus => {
                                if( votestatus.usersReady.length === MAX_POD_SIZE){
                                    //ReceivedMessage.channel.send("Pod is ready!")
                                    finishPod(receivedMessage, vote, client)
                                }
                                else{
                                   // console.log("%o", usersReadyRC)
                                    console.log (`Only ${votestatus.usersReady.length} users ready`)
                                }
                        })
                    })
                }
        })
        .catch (error => (console.log(error)))
}

const leaveQueue = (receivedMessage, userdata, vote) => {
    "use strict";
    let message_string    = ""
    let voteStatusQuery  = "SELECT * FROM vote WHERE format = $1;"
    let voteStatusValues = [vote]
    let currentPod        = []
    let currentCount      = 0
    const voteLeaveSQL = 'DELETE FROM public.vote WHERE format = $1 AND discordid = $2'
    voteLeaveValues = [vote, userdata[0].discordid]
    dbs.voteLeaveStatus(voteStatusQuery, voteStatusValues)
        .then( (statusresult) =>{ 
            console.log(`[vote Leave] Return from query:`)
            console.log("%o", statusresult)
            if(statusresult.length === 0|| statusresult === undefined || statusresult === null){
                //currentCount = 0;
            }
            else{
                //currentCount = statusresult.length
                statusresult.forEach( (id) => {
                    currentPod.push(id.discordid)
                })
            }
            if (!currentPod.includes(receivedMessage.author.id)){
                receivedMessage.channel.send({content: "You are not currently in the queue"})
                return;
            }
            else{
                dbs.voteLeaveStatus(voteLeaveSQL, voteLeaveValues)
                    .then(result =>{
                        const userName = receivedMessage.author.username
                        receivedMessage.channel.send({content: `${userName} has been removed from the ${vote.toUpperCase()} queue ${currentCount}/${MAX_POD_SIZE}`})    
                        status.buildStatusMessage();
                    })
                }
        })
}

const isvoteReady = (vote) => new Promise((resolve, reject) =>{
    "use strict";
    console.log(`[isvoteReady] Checking if ${vote} is ready!`)
    const userQuery       = "SELECT * FROM vote WHERE format = $1;"
    const userQueryValues = [vote]
    let voteStatus = {
        "ready": false,
        "usersReady": [],
        "usersNotReady": []
    }
    dbs.voteReady(userQuery, userQueryValues)
        .then(queued => {
            //console.log("%o",queued)
            queued.forEach(voter =>{
                //console.log("%o",voter)
                if(voter.status === 'ready'){
                    voteStatus.usersReady.push(voter.discordname)
                }
                else{
                    voteStatus.usersNotReady.push(voter.discordname)
                }
            })
        })
        .finally( () => {
            //console.log("%o", usersReady)
            if(voteStatus.usersReady.length === MAX_POD_SIZE){
                console.log(`Readycheck result: true ${voteStatus.usersReady.length}/${MAX_POD_SIZE}`)
                //console.log(voteStatus.usersReady)
                //console.log(voteStatus.usersNotReady)
                voteStatus.ready = true;
                resolve( voteStatus);
            }
            else{
                console.log(`Readycheck result: false ${voteStatus.usersReady.length}/${MAX_POD_SIZE}`)
                //console.log(voteStatus.usersReady)
                //console.log(voteStatus.usersNotReady)
                voteStatus.ready = false;
                resolve(voteStatus);
            }
        })
    .catch(err => {reject(`Error in checking vote table ${err}`)})
})

exports.addToQueue = addToQueue;
exports.readyCheck = readyCheck;
exports.isvoteReady = isvoteReady;
exports.leaveQueue = leaveQueue;