Bot

const DubAPI = require('dubapi');
const YouTube = require('youtube-node');
const fs = require('fs');
const compArr = require('./composerArray.js');
let YT = new YouTube();
YT.setKey('-----');
// username
let un = '-----'

new DubAPI({username: un, password: '-----'}, function(err, bot) {
    if (err) return console.error(err);

    console.log('Running DubAPI v' + bot.version);

    function connect() {bot.connect('limitless');}
    connect();

    bot.on('connected', function(name) {
        console.log('Connected to ' + name);
        setTimeout(shouldUpDub, 2000);

    });


    bot.on('disconnected', function(name) {
        console.log('Disconnected from ' + name);
        setTimeout(connect, 15000);
    });

    bot.on('error', function(err) {
        console.error(err);
    });

    bot.on(bot.events.chatMessage, function(data) {
        console.log(data.user.username + ': ' + data.message);
        let message = data.message;
        let user = data.user.username;
        respondToMessage(message, user);
    });

    bot.on(bot.events.userJoin, (data) => {
        console.log(data.user.username + " has joined.");
        updateUser(data.user.username, () => {});
    })



    // My functions
    let currentId; // Current Music id - Changes on each new video.
    let radioMode = false; // if the radio is active this will be set to true.
    let roullete = false;
    let entered = [];
    let songStats;
    function addToRadio() {
        let ca = compArr.getArray();
        function getRandom(arr, remove) {
            return arr[Math.floor(Math.random() * arr.length)];
        }

        let artist = getRandom(ca);
        console.log(artist);
        let videos = [];
        YT.search(artist, 4, (err, results) => {
          results.items.forEach(item => {
            if(item.id.kind == 'youtube#video') {
                let vID = item.id.videoId;
                videos.push(vID);
            }
          })
          queueVideos();
        })
        // remove duplicates.
        function queueVideos() {
            videos = [... new Set(videos)];
            if(videos.length != 0) {
                for(let i = 0; i < 1; i++) {
                    let randVid = getRandom(videos);
                    let index = videos.indexOf(randVid);
                    videos.splice(index, 1);
                    bot.queueMedia('youtube', randVid);
                    fs.appendFile("songsQueued.txt", randVid + " artist: " + artist + '\n' , (err) => {
                        if(err){ console.log(err); }
                    })
                }
                bot.pauseQueue(false);
            } else {
                addToRadio();
            }
        }
    }

    /* shouldUpDub */
    /*  - If there is something being played and the bot has not regestered it before then the bot will updub the song. It will also send to chat a "Now Playing" message. It will then sent the currentId to this new songs id song it does not try to updub twice. It thens sets a timeout for the shouldUpDub function to be called again in 10 seconds.
        - If the song has already been registered then the shouldUpDub will be called again in 10 seconds via a setTimeout.
        - If no song is currently playing then first a 10 second timeout will call shouldUpDub with its only parameter called radio. If nothing has still not been queued after the 10 seconds then if the bot has it's radio mode enabled it will add to it's radio queue and start playing some music. It will also call shouldUpDub in a setTimeout as normal.
    */

    function shouldUpDub(radio) {
        if(bot.getMedia()) {
            let {id, name, type, fkid} = bot.getMedia();
            if (currentId != id) {
                console.log("updubing");
                fs.readFile('./stats.json',"utf8", (err, data) => {
                    let stats = JSON.parse(data);
                    stats[id] = stats[id] || {};
                    stats[id].count = stats[id].count + 1 || 1;
                    stats[id].totalGrabs = stats[id].totalGrabs || 0;
                    stats[id].name = stats[id].name || name;
                    stats[id].fkid = stats[id].fkid || fkid;
                    stats[id].type = stats[id].type || type;
                    // most grabs for song in a single play.
                    stats[id].mostGrabs = stats[id].mostGrabs || 0;
                    songStats = stats[id];

                    ((id) => {
                        setTimeout(() => {
                            // skipped track gets overwritten, FIX.
                            // Add grabs to total grans for song.
                            stats[id].totalGrabs += bot.getScore().grabs;
                            // if grabs for play are more then previous record for song.
                            if(stats[id].mostGrabs < bot.getScore().grabs) {
                                stats[id].mostGrabs = bot.getScore().grabs;
                            }
                            fs.writeFile('./stats.json', JSON.stringify(stats), (err) => {
                            if(err) throw err;
                                console.log(stats[id]);
                            })
                        }, +bot.getTimeRemaining());
                    })(id);
                })
                //bot.sendChat("Now Playing: " + name);
                bot.updub();
                currentId = id;
                setTimeout(() => {shouldUpDub()}, 10000);

            } else {
                setTimeout(() => {shouldUpDub()}, 10000);
            }
        } else {
            if(radio) {
                if(radioMode && bot.getQueue().length == 0) {
                    addToRadio();
                }
                setTimeout(() => {shouldUpDub()}, 10000);
            } else {
                setTimeout(() => {shouldUpDub(true)}, 10000);
            }
        }
    }
    let times = [3000000, 3600000, 2400000];
    let time = times[Math.floor(Math.random() * times.length)];
    setTimeout(() => { startRoullete() }, time);
    function startRoullete() {
        bot.sendChat("@----- !r");
        // random time

        time = times[Math.floor(Math.random() * times.length)];
        setTimeout(() => { startRoullete() }, time);
    }

    function updateUser(user, callback) {
        let uid = bot.getUserByName(user).id;
        fs.readFile('./users.json',"utf8", (err, data) => {
            let stats = JSON.parse(data);
            stats[uid] = stats[uid] || {"wins": 0, "username": user};
            if(typeof stats[uid].username == "undefined" || stats[uid].username != user) {
                stats[uid].username = user;
            }
            stats[uid].lastSeen = new Date;
            fs.writeFile('./users.json', JSON.stringify(stats), (err) => {
                if(err) throw err;
                callback();
            })
        })
    }

    function respondToMessage(message, user) {
        let bot_response = false;

        function checkMessage(command) {
            if(message.includes(command) && message.includes(`@${un}`) && bot_response == false && (user == "----" || user == "-----")) {
                return true;
            }
            return false;
        }



        if(message == "!stats") {
            bot.sendChat(`song stats: total grabs - ${songStats.totalGrabs + bot.getScore().grabs}, times played: - ${songStats.count}.`)
        }

        if(message == "!topgrabbed") {
            fs.readFile('./stats.json',"utf8", (err, data) => {
                let stats = JSON.parse(data);
                let topGrabbedKeys = Object.keys(stats).sort((a, b) => {
                    return stats[b].totalGrabs - stats[a].totalGrabs
                })
                bot.sendChat('Most grabbed songs (total grabs):');
                //let message = "";
                for(let x = 0; x < 3; x++) {
                    bot.sendChat(`${stats[topGrabbedKeys[x]].name} - ${stats[topGrabbedKeys[x]].totalGrabs}`);
                }
            })
        }

        if(message == "!hotplays") {
            fs.readFile('./stats.json',"utf8", (err, data) => {
                let stats = JSON.parse(data);
                let topGrabbedKeys = Object.keys(stats).sort((a, b) => {
                    return stats[b].totalGrabs - stats[a].totalGrabs
                })
                bot.sendChat('Most grabbed songs (single play):');
                //let message = "";
                for(let x = 0; x < 3; x++) {
                    bot.sendChat(`${stats[topGrabbedKeys[x]].name} - ${stats[topGrabbedKeys[x]].totalGrabs}`);
                }

            })
        }

        if(message.includes("!info") && message.split(' ').length == 2 && message.split(' ')[0] == "!info") {
            // Update user that asked in case they are not registered in users.
                //queried user for info.
            let queryUser = message.split(' ')[1];
            //bot.sendChat('This feature is still experimental.')
            fs.readFile('./users.json',"utf8", (err, data) => {
                let users = JSON.parse(data);
                let usernames = {};
                for(x in users) { usernames[users[x].username] = {id: x} }
                let sortedWins = Object.keys(users).sort((a, b) => {
                    return users[b].wins - users[a].wins
                })
                if(bot.getUserByName(queryUser) && !usernames[queryUser]) {
                    updateUser(queryUser, () => {
                        bot.sendChat('You have just been added to users, try again.');
                    })
                } else if (usernames[queryUser]) {
                    let uid = usernames[queryUser].id;

                    bot.sendChat(`User: ${queryUser}`);
                    bot.sendChat(`Wins: ${users[uid].wins} (${sortedWins.indexOf(uid)}/${sortedWins.length})`);
                    if(users[uid].lastSeen) {
                        bot.sendChat(`Last Seen: ${users[uid].lastSeen}`);
                    } else {
                        //bot.sendChat(`Last Seen has not been set yet.`);
                    }
                } else {
                    bot.sendChat('User is not registered.');
                }
            });
        }

        if(message == "!info") {
            bot.sendChat('Sorry, you need to specify a username after !info.');
        }

        if(message == "!commands") {
            bot.sendChat("Commands are: !stats, !sign, !mostplayed, !topgrabbed, !hotplays, !winners, !song, !info");
        }

        if(message == "!mostplayed") {
            fs.readFile('./stats.json',"utf8", (err, data) => {
                let stats = JSON.parse(data);
                let topPlayedKeys = Object.keys(stats).sort((a, b) => {
                    return stats[b].count - stats[a].count
                })
                bot.sendChat('Most played songs:');
                for(let x = 0; x < 3; x++) {
                    bot.sendChat(`${stats[topPlayedKeys[x]].name} - ${stats[topPlayedKeys[x]].count}`);
                };
            })
        }

        if(message == "!winners") {
            fs.readFile('./users.json',"utf8", (err, data) => {
                let stats = JSON.parse(data);
                let topPlayerKeys = Object.keys(stats).sort((a, b) => {
                    return stats[b].wins - stats[a].wins
                })
                bot.sendChat('Users with the most wins:');
                for(let x = 0; x < 3; x++) {
                    if(topPlayerKeys[x]) {
                        bot.sendChat(`${stats[topPlayerKeys[x]].username} - ${stats[topPlayerKeys[x]].wins}`);
                    }
                }
            })
        }

        if(checkMessage("!r")) {
            roullete = true;
            bot.sendChat("@djs The roulette is starting! Have a song queued and type anything in chat to enter the roulette!");

            setTimeout(() => {
                let n = Math.floor(Math.random() * entered.length);
                let position = Math.floor(Math.random() * 3);
                let users = bot.getQueue().reduce((obj, item) => {
                    obj[item.user.username] = item.user.id;
                    return obj;
                },[]);
                let winner = entered[n];
                if(winner != undefined) {
                    bot.sendChat(`@${winner} wins.`);
                    let uid = bot.getUserByName(winner).id;

                    fs.readFile('./users.json',"utf8", (err, data) => {
                        let users = JSON.parse(data);
                        users[uid] = users[uid] || {};
                        users[uid].wins = users[uid].wins + 1 || 1;

                        if(!users[uid].username || users[uid].username != winner) {
                            users[uid].username = winner;
                            console.log(users[uid].username);
                        }
                        fs.writeFile('./users.json', JSON.stringify(users), (err) => {
                            if(err) throw err;
                        })
                    })
                    bot.sendChat(`Moving ${winner} to position 1`);
                    bot.moderateMoveDJ(users[entered[n]], 0);
                } else {
                    bot.sendChat('Looks like no one wins.');
                }
                entered = [];
                roullete = false;
            }, 60000);
        }

        if(roullete) {
            let queuedUsers = bot.getQueue().reduce((arr, item) => {
                arr.push(item.user.username);
                return arr;
            },[]);
            if(user != "-----" && message && !entered.includes(user)) {
                if(!queuedUsers.includes(user)) {
                    //bot.sendChat(`Sorry ${user} you aren't in the queue.`)
                } else {
                    entered.push(user);
                    //bot.sendChat(`You've joined the roulette, ${user}.`)
                    entered = [...new Set(entered)];
                }
            }
        }

        if(checkMessage("!i")) {
            console.log(bot.getMedia());
            console.log(bot.getScore().grabs)
            setTimeout(() => { bot.sendChat(`Total of ${bot.getScore().grabs} grabs`)}, +bot.getTimeRemaining());
        }

        // !cq stands for clear queue, this will clear the bots queue.
        if(checkMessage("!cq")){
            console.log(`cleared by ${user}`);

            bot.pauseQueue(true, () => {
                bot.clearQueue();
            });
            fs.writeFile('songsQueued.txt','',(err) => {if(err) console.log(err) })
            bot_response = true;
        }

        if(checkMessage("!stopradio")) {
            radioMode = false;
            bot_response = true;
        }

        // !startradio stands for start radio
        if(checkMessage("!startradio")) {
            radioMode = true;
            //addToRadio();
            bot_response = true;
        }

        // !qr stands for queue related.
        if(checkMessage("!qr")) {
            let id = bot.getMedia().fkid;
            YT.related(id, 5, function(error, result) {
                if (error) throw error;

                let video = result;
                //fileVideos(video);
                video.items.forEach(vid => {
                    if(vid.id.videoId != undefined) {
                        let vID = vid.id.videoId.toString();
                        var vName = vid.snippet.title.toString();
                        bot.queueMedia('youtube', vID);
                        fs.appendFile("songsQueued.txt", vID + " name: " + vName + '\n' , (err) => {
                            if(err){
                                console.log(err);
                            }
                        });
                    }
                });
            });
            bot.pauseQueue(false);
            bot_response = true;
        }

        if(message == "!sign") {
            fs.appendFile("guestbook.txt", `${user} - ${new Date}\n`, () => {
                bot.sendChat(`Thankyou for signing the guestbook, ${user}!`)
            })
        }

    }
});