/*Canopy - The next generation of stoner streaming software
Copyright (C) 2024-2025 Rainbownapkin and the TTN Community

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Affero General Public License for more details.

You should have received a copy of the GNU Affero General Public License
along with this program.  If not, see <https://www.gnu.org/licenses/>.*/

//NPM imports
const validator = require('validator');

//Local imports
const queuedMedia = require('./queuedMedia');
const yanker = require('../../../utils/media/yanker');
const loggerUtils = require('../../../utils/loggerUtils');
const channelModel = require('../../../schemas/channel/channelSchema');

module.exports = class{
    constructor(server, chanDB, channel){
        //Set server
        this.server = server
        //Set channel
        this.channel = channel;

        //Create map to hold currently queued media
        this.schedule = new Map();

        //Create variable to hold sync delta in ms
        this.syncDelta = 1000;
        //Create variable to hold current timestamp within the video
        this.timestamp = 0;

        //Create variable to hold sync timer
        this.syncTimer = null;
        //Create variable to hold next playing item timer
        this.nextTimer = null;
        //Create variable to hold currently playing media object
        this.nowPlaying = null;

        //create boolean to hold schedule lock
        this.locked = false;

        //Rehydrate channel queue from database
        this.rehydrateQueue(chanDB);
    }

    defineListeners(socket){
        socket.on("queue", (data) => {this.queueURL(socket, data)});
        socket.on("stop", (data) => {this.stopMedia(socket)});
        socket.on("delete", (data) => {this.deleteMedia(socket, data)});
        socket.on("clear", (data) => {this.deleteRange(socket, data)});
        socket.on("move", (data) => {this.moveMedia(socket, data)});
        socket.on("lock", () => {this.toggleLock(socket)});
    }

    //--- USER FACING QUEUEING FUNCTIONS ---
    async queueURL(socket, data){
        //Get the current channel from the database
        const chanDB = await channelModel.findOne({name: socket.chan});

        if((!this.locked && await chanDB.permCheck(socket.user, 'scheduleMedia')) || await chanDB.permCheck(socket.user, 'scheduleAdmin')){
            try{
                //Set url
                let url = data.url;

                //If we where given a bad URL
                if(!validator.isURL(url)){
                    //Attempt to fix the situation by encoding it
                    url = encodeURI(url);

                    //If it's still bad
                    if(!validator.isURL(url)){
                        //Bitch, moan, complain...
                        loggerUtils.socketErrorHandler(socket, "Bad URL!", "validation");
                        //and ignore it!
                        return;
                    }
                }

                //If the title is too long
                if(!validator.isLength(data.title, {max:30})){
                    //Bitch, moan, complain...
                    loggerUtils.socketErrorHandler(socket, "Title too long!", "validation");
                    //and ignore it!
                    return;
                }
    
                //Set title
                const title = validator.escape(validator.trim(data.title));

                //set start
                let start = this.getStart(data.start);

                //Pull media list
                const mediaList = await yanker.yankMedia(url, title);

                //If we didn't find any media
                if(mediaList == null || mediaList.length <= 0){
                    //Bitch, moan, complain...
                    loggerUtils.socketErrorHandler(socket, "No media found!", "queue");
                    //and ignore it!
                    return;
                } 

                //Convert media list
                let queuedMediaList = queuedMedia.fromMediaArray(mediaList, start);

                //schedule the media
                this.scheduleMedia(queuedMediaList, socket);
            }catch(err){
                return loggerUtils.socketExceptionHandler(socket, err);
            }
        }
    }

    stopMedia(socket){
        //If we're not currently playing anything
        if(this.nowPlaying == null){
            //If an originating socket was provided for this request
            if(socket != null){
                //Yell at the user for being an asshole
                loggerUtils.socketErrorHandler(socket, "No media playing!", "queue");
            }

            //Ignore it
            return false;
        }

        //Stop playing
        const stoppedMedia = this.nowPlaying;

        //Get difference between current time and start time and set as early end
        stoppedMedia.earlyEnd = (new Date().getTime() - stoppedMedia.startTime) / 1000;

        //End the media
        this.end();
    }

    async deleteMedia(socket, data){
        //Get the current channel from the database
        const chanDB = await channelModel.findOne({name: socket.chan});

        if((!this.locked && await chanDB.permCheck(socket.user, 'scheduleMedia')) || await chanDB.permCheck(socket.user, 'scheduleAdmin')){
            try{
                //If we don't have a valid UUID
                if(!validator.isUUID(data.uuid)){
                    //Bitch, moan, complain...
                    loggerUtils.socketErrorHandler(socket, "Bad UUID!", "queue");
                    //and ignore it!
                    return;
                }

                //Remove media by UUID
                await this.removeMedia(data.uuid, socket);
            }catch(err){
                return loggerUtils.socketExceptionHandler(socket, err);
            }
        }
    }

    async deleteRange(socket, data){
        //Get the current channel from the database
        const chanDB = await channelModel.findOne({name: socket.chan});

        if((!this.locked && await chanDB.permCheck(socket.user, 'clearSchedule')) || await chanDB.permCheck(socket.user, 'scheduleAdmin')){
            try{
                //If start time isn't an integer
                if(data.start != null && !validator.isInt(String(data.start))){
                    //Bitch, moan, complain...
                    loggerUtils.socketErrorHandler(socket, "Bad start date!", "queue");
                    //and ignore it!
                    return;
                }
                //If end time isn't an integer
                if(data.end != null && !validator.isInt(String(data.end))){
                    //Bitch, moan, complain...
                    loggerUtils.socketErrorHandler(socket, "Bad end date!", "queue");
                    //and ignore it!
                    return;
                }

                this.removeRange(data.start, data.end, socket);
            }catch(err){
                return loggerUtils.socketExceptionHandler(socket, err);
            }
        }
    }

    async moveMedia(socket, data){
        //Get the current channel from the database
        const chanDB = await channelModel.findOne({name: socket.chan});

        if((!this.locked && await chanDB.permCheck(socket.user, 'scheduleMedia')) || await chanDB.permCheck(socket.user, 'scheduleAdmin')){
            try{
                //If we don't have a valid UUID
                if(!validator.isUUID(data.uuid)){
                    //Bitch, moan, complain...
                    loggerUtils.socketErrorHandler(socket, "Bad UUID!", "queue");
                    //and ignore it!
                    return;
                }

                //If start time isn't an integer
                if(data.start != null && !validator.isInt(String(data.start))){
                    //Null out time to tell the later parts of the function to start it now
                    data.start = undefined;
                }

                //Move media by UUID
                this.rescheduleMedia(data.uuid, data.start, socket);
            }catch(err){
                return loggerUtils.socketExceptionHandler(socket, err);
            }
        }
    }

    async toggleLock(socket){
        //Get the current channel from the database
        const chanDB = await channelModel.findOne({name: socket.chan});

        //If the user is a schedule admin
        if(await chanDB.permCheck(socket.user, 'scheduleAdmin')){
            //Toggle the schedule lock
            this.locked = !this.locked;
            
            //Update schedule lock status for everyone in the channel
            this.server.io.in(this.channel.name).emit("lock", {locked: this.locked});
        }
    }

    //--- INTERNAL USE ONLY QUEUEING FUNCTIONS ---
    getStart(start){
        //Pull current time
        const now = new Date().getTime();

        //If start time is null, or it isn't a valid integer after the current epoch
        if(start == null || !validator.isInt(String(start), {min: now})){
            //Get last item from schedule
            const lastItem = (Array.from(this.schedule)[this.schedule.size - 1]);

            //if we have a last item
            if(lastItem != null){
                //If the last item has ended
                if(lastItem[1].getEndTime() < now){
                    //Throw it on in five ms
                    return now;
                //If it hasn't ended yet
                }else{
                    //Throw it on five ms after the last item
                    return lastItem[1].getEndTime() + 5;
                }
            //If we don't have a last item
            }else{
                //Throw it on in five ms
                return now;
            }
        }
    }

    refreshNextTimer(volatile = false){
        //Grab the next item
        const nextItem = this.getNextItem();

        //If we have no next item
        if(nextItem == null){
            //Get current item
            const currentItem = this.getItemAtEpoch()

            //If we have a current item and it isn't currently playing
            if(currentItem != null && (this.nowPlaying == null || currentItem.uuid != this.nowPlaying.uuid)){
                //Start the found item at w/ a pre-calculated time stamp to reflect the given start time
                this.start(currentItem, Math.round((new Date().getTime() - currentItem.startTime) / 1000) + currentItem.startTimeStamp, volatile);
            }
        //otherwise if we have an item
        }else{
            //Calculate the amount of time in ms that the next item will start in
            const startsIn = nextItem.startTime - new Date().getTime();

            //Clear out any item that might be up next
            clearTimeout(this.nextTimer);
            //Set the next timer
            this.nextTimer = setTimeout(()=>{this.start(nextItem, nextItem.startTimeStamp, volatile)}, startsIn);
        }
    }

    async removeRange(start = new Date().getTime() - 60 * 1000, end = new Date().getTime(), socket){
        //Find items within given range
        const foundItems = this.getItemsBetweenEpochs(start, end);

        try{
            //DO everything ourselves since we don't have a fance end() function to do it
            const chanDB = await channelModel.findOne({name:this.channel.name});

            //If we couldn't find the channel
            if(chanDB == null){
                //FUCK
                throw new Error(`Unable to find channel document ${this.channel.name} while queue item!`);
            }

            //For each item
            for(let item of foundItems){
                //Remove media, passing down chanDB so we're not looking again and again
                await this.removeMedia(item.uuid, socket, chanDB);
            }

        }catch(err){
            //If this was originated by someone
            if(socket != null){
                //Bitch at them
                loggerUtils.socketExceptionHandler(socket, err);
            //If not 
            }else{
                //Bitch to the console
                loggerUtils.localExceptionHandler(err);
            }
        }
    }

    async rescheduleMedia(uuid, start = new Date().getTime(), socket){
        //Find our media, don't remove it yet since we want to do some more testing first
        const media = this.getItemByUUID(uuid);

        //If we got a bad request
        if(media == null){
            //If an originating socket was provided for this request
            if(socket != null){
                //Yell at the user for being an asshole
                loggerUtils.socketErrorHandler(socket, "Cannot move non-existant item!", "queue");
            }
            //Ignore it
            return;
        }

        //If someone is trying to re-schedule something that starts in the past
        if(media.startTime < new Date().getTime()){
            //If an originating socket was provided for this request
            if(socket != null){

                //If the item is currently playing
                if(media.getEndTime() > new Date().getTime()){
                    //Yell at the user for being an asshole
                    loggerUtils.socketErrorHandler(socket, "You cannot move an actively playing video!", "queue");
                //Otherwise, if it's already ended 
                }else{
                //Yell at the user for being an asshole
                loggerUtils.socketErrorHandler(socket, "You cannot alter the past!", "queue");
                }
            }


            //Ignore it
            return;
        }

        //Remove the media from the schedule
        await this.removeMedia(uuid);

        //Grab the old start time for safe keeping
        const oldStart = media.startTime;

        //Set media time
        media.startTime = start;

        //Reset the start time stamp for re-calculation
        media.startTimeStamp = 0;

        //Attempt to schedule media at given time
        //Otherwise, if it returns false for fuckup
        if(!(await this.scheduleMedia([media], socket))){
            //Reset start time
            media.startTime = oldStart;

            //Reset the start time stamp for re-calculation
            media.startTimeStamp = 0;

            //Schedule in old slot
            this.scheduleMedia([media], socket, null, true);
        }
    }

    async removeMedia(uuid, socket, chanDB){
        //Get requested media
        const media = this.getItemByUUID(uuid);

        //If we got a bad request
        if(media == null){
            try{
                //DO everything ourselves since we don't have a fance end() function to do it
                chanDB = await channelModel.findOne({name:this.channel.name});

                //If we couldn't find the channel
                if(chanDB == null){
                    //FUCK
                    throw new Error(`Unable to find channel document ${this.channel.name} while queue item!`);
                }

                //Keep a copy of the archive that hasn't been changed
                const preArchive = chanDB.media.archived;

                //Filter out the requested item from the archive
                chanDB.media.archived = chanDB.media.archived.filter((record)=>{
                    return record.uuid.toString() != uuid;
                })

                //If nothing changed in the archive
                if(preArchive.length == chanDB.media.archived.length){
                    //If an originating socket was provided for this request
                    if(socket != null){
                        //Yell at the user for being an asshole
                        loggerUtils.socketErrorHandler(socket, "Cannot delete non-existant item!", "queue");
                    }
                //Otherwise
                }else{
                    //Broadcast changes
                    this.broadcastQueue(chanDB);

                    //Save changes to the DB
                    await chanDB.save();
                }
            }catch(err){
                //If this was originated by someone
                if(socket != null){
                    //Bitch at them
                    loggerUtils.socketExceptionHandler(socket, err);
                //If not 
                }else{
                    //Bitch to the console
                    loggerUtils.localExceptionHandler(err);
                }
            }

            //Ignore it
            return false;
        }

        //Take the item out of the schedule map
        this.schedule.delete(media.startTime);

        //Refresh next timer
        this.refreshNextTimer();

        //If we're currently playing the requested item.
        if(this.nowPlaying != null && this.nowPlaying.uuid == uuid){
            //End playback
            this.end(false, true);
        //otherwise
        }else{
            try{
                //DO everything ourselves since we don't have a fance end() function to do it
                chanDB = await channelModel.findOne({name:this.channel.name});

                //If we couldn't find the channel
                if(chanDB == null){
                    //FUCK
                    throw new Error(`Unable to find channel document ${this.channel.name} while queue item!`);
                }

                //Filter media out by UUID
                chanDB.media.scheduled = chanDB.media.scheduled.filter((record) => {
                    return record.uuid != uuid;
                });

                await chanDB.save();

                //Broadcast the channel
                this.broadcastQueue(chanDB);

            }catch(err){
                //Broadcast the channel
                this.broadcastQueue();

                //If this was originated by someone
                if(socket != null){
                    //Bitch at them
                    loggerUtils.socketExceptionHandler(socket, err);
                //If not 
                }else{
                    //Bitch to the console
                    loggerUtils.localExceptionHandler(err);
                }
            }
        }

        //return found media in-case our calling function needs it :P
        return media;
    }

    async scheduleMedia(media, socket, chanDB, force = false, volatile = false, startVolatile = false){
        /* This is a fun method and I think it deserves it's own little explination...
        Since we're working with a time based schedule, using start epochs as keys for our iterable seemed the best option
        I don't want to store everything in a sparse array because that *feels* icky, and would probably be a pain in the ass.
        Maps seem like a good choice, if it wheren't for the issue of keeping them ordered...

        That's where this comes in. You see if we temporarily store it in a sparse array and convert into a map,
        we can quickly and easily create a properly sorted schedule map that, out side of adding items, behaves normally.

        Also a note on preformance:
        While .forEach ONLY runs through populated items in sparse arrays, many JS implementations run through them in the background,
        simply skipping them before executing the provided function. Looping through object.keys(arr), however, avoids this entirely,
        since it ONLY loops through defiened items within the array. No skipped empties for your runtime to worry about.
        Even more preformance benefits can be had by using a real for loop on the arrays keys, skipping the overhead of forEach entirely.
        This might seem gross but it completely avoids the computational workload of a sorting algo, especially when you consider
        that, no matter what, re-ordering the schedule map would've required us to iterate through and rebuild the map anyways...


        Also it looks like due to implementation limitations, epochs stored as MS are too large for array elements, so we store them there as seconds.
        This also means that our current implementation will break exactly on unix epoch 4294967295 (Feb 7, 2106 6:28:15 AM UTC)
        Hopefully javascript arrays will allow for larger lengths by then. If not blame the W3C :P

        If for some reason they haven't and we're not dead, we could probably implement an object that wraps a 2d array and set/gets it using modulo/devision/multiplication

        Further Reading:
        https://stackoverflow.com/questions/59480871/foreach-vs-object-keys-foreach-performance-on-sparse-arrays
        https://community.appsmith.com/content/blog/dark-side-foreach-why-you-should-think-twice-using-it
        */

        let mediaObj = media[0];

        //If someone is trying to schedule something that starts and ends in the past
        if((mediaObj.getEndTime() < new Date().getTime()) && !force){
            //If an originating socket was provided for this request
            if(socket != null){
                //Yell at the user for being an asshole
                loggerUtils.socketErrorHandler(socket, "You cannot alter the past!", "queue");
            }
            return false;
        }

        //If the item has already started
        if((mediaObj.startTime < new Date().getTime()) && !force){
            //Set time stamp to existing timestamp plus the difference between the orginal start-date and now
            const calculatedTimeStamp = mediaObj.startTimeStamp + ((new Date().getTime() - mediaObj.startTime) / 1000)

            //If the calculated time stamp is more than negligible, and therefore not simply caused by serverside processing time
            if(calculatedTimeStamp > 5){
                //Set the media timestamp
                mediaObj.startTimeStamp = calculatedTimeStamp;

                //Start the item now
                mediaObj.startTime = new Date().getTime();
            }
        }

        //If there's already something queued right now
        if(this.getItemAtEpoch(mediaObj.startTime) != null || this.getItemAtEpoch(mediaObj.getEndTime())){
            //If an originating socket was provided for this request
            if(socket != null){
                //Yell at the user for being an asshole
                loggerUtils.socketErrorHandler(socket, "This time slot has already been taken in the queue!", "queue");
            }
            //Ignore it
            return false;
        } 

        //Create an empty temp array to sparsley populate with our schedule
        const tempSchedule = [];
        //Create new map to replace our current schedule map
        const newSchedule = new Map();

        //For every item that's already been scheduled
        for(let item of this.schedule){
            //add it to the slot corresponding to it's start epoch in seconds
            tempSchedule[Math.round(item[0] / 1000)] = item[1];
        }

        //Inject the media object into the slot corresponding to it's epoch in the temp schedule array
        tempSchedule[Math.round(mediaObj.startTime / 1000)] = mediaObj;

        //For every populated key in our array
        for(let startTime of Object.keys(tempSchedule)){
            //Add item to replacement schedule map
            newSchedule.set(tempSchedule[startTime].startTime, tempSchedule[startTime]);
        }

        //Replace the existing schedule map with our new one
        this.schedule = newSchedule;

        //Broadcast the channel queue
        this.broadcastQueue();

        //Refresh the next timer to ensure whatever comes on next is right
        this.refreshNextTimer(startVolatile);

        //If media has more than a minute before starting and DB transactions are enabled
        if(mediaObj.startTime - new Date().getTime() > 1000 && !volatile){
            //fuck you yoda you fucking nerd
            try{
                //If we didn't get handed a freebie
                if(chanDB == null){
                    //Go out and get it done ourselves
                    chanDB = await channelModel.findOne({name:this.channel.name});
                }

                //If we couldn't find the channel
                if(chanDB == null){
                    //FUCK
                    throw new Error(`Unable to find channel document ${this.channel.name} while saving item to queue!`);
                }

                //Add media to the persistant schedule
                chanDB.media.scheduled.push(mediaObj);

                //Save the database
                chanDB.save();

            //If something fucked up
            }catch(err){
                //If this was originated by someone
                if(socket != null){
                    //Bitch at them
                    loggerUtils.socketExceptionHandler(socket, err);
                //If not 
                }else{
                    //Bitch to the console
                    loggerUtils.localExceptionHandler(err);
                }
            }
        }

        //return media object for use
        return mediaObj;
    }

    async start(mediaObj, timestamp = mediaObj.startTimeStamp, volatile = false){
        //If something is already playing
        if(this.nowPlaying != null){
            //Silently end the media in RAM so the database isn't stepping on itself up ahead
            //Alternatively we could've used await, but then we'd be doubling up on DB transactions :P
            this.end(true, true, true);
        }

        //reset current timestamp
        this.timestamp = timestamp;

        //Set current playing media
        this.nowPlaying = mediaObj;

        //if DB transactions are enabled
        if(!volatile){
            try{
                //Get our channel
                const chanDB = await channelModel.findOne({name: this.channel.name});

                //If nowPlaying isn't null and isn't what we're about to throw on
                if(chanDB.media.nowPlaying != null && chanDB.media.nowPlaying.uuid.toString != mediaObj.uuid){
                    //Archive whats already in there since we're about to clobber the fuck out of it
                    chanDB.media.archived.push(chanDB.media.nowPlaying);
                }

                //Set the now playing queued media document
                chanDB.media.nowPlaying = mediaObj;

                //Filter media out of schedule by UUID
                chanDB.media.scheduled = chanDB.media.scheduled.filter((record) => {
                    return record.uuid != mediaObj.uuid;
                });

                //Save the channel
                await chanDB.save();
            }catch(err){
                loggerUtils.localExceptionHandler(err);
            }
        }

        //Send play signal out to the channel
        this.sendMedia();

        //Kick off the sync timer
        this.syncTimer = setTimeout(this.sync.bind(this), this.syncDelta);

        //Setup the next video
        this.refreshNextTimer();

        //return media object for use
        return mediaObj;
    }

    sync(){
        //Send sync signal out to the channel
        this.server.io.in(this.channel.name).emit("sync", {timestamp: this.timestamp});

        //If the media has over a second to go
        if((this.timestamp + 1) < this.nowPlaying.duration){
            //Increment the time stamp
            this.timestamp += (this.syncDelta / 1000);

            //Call the sync function in another second
            this.syncTimer = setTimeout(this.sync.bind(this), this.syncDelta);
        }else{
            //Get leftover video length in ms
            const leftover = (this.nowPlaying.duration - this.timestamp) * 1000;

            //Call the end function once the video is over
            this.syncTimer = setTimeout(this.end.bind(this), leftover);
        }
    }

    async end(quiet = false, noArchive = false, volatile = false, chanDB){
        try{
            //Call off any existing sync timer
            clearTimeout(this.syncTimer);

            //Clear out the sync timer
            this.syncTimer = null;


            //Keep a copy of whats playing for later when we need to clear the DB
            const wasPlaying = this.nowPlaying;

            //Clear now playing
            this.nowPlaying = null;

            //Clear timestamp
            this.timestamp = 0;

            //If we're not being quiet
            if(!quiet){
                //Tell everyone of the end-times
                this.server.io.in(this.channel.name).emit('end', {});
            }

            if(!volatile){
                //Now that everything is clean, we can take our time with the DB :P
                chanDB = await channelModel.findOne({name:this.channel.name});

                //If we couldn't find the channel
                if(chanDB == null){
                    //FUCK
                    throw new Error(`Unable to find channel document ${this.channel.name} while ending queue item!`);
                }

                //If we haven't changed 'nowPlaying' in the play list
                if(chanDB.media.nowPlaying.uuid == wasPlaying.uuid){
                    //Take it out
                    await chanDB.media.nowPlaying.deleteOne();
                }

                //Take it out of the active schedule
                this.schedule.delete(wasPlaying.startTime);

                if(!noArchive){
                    //Add the item to the channel archive
                    chanDB.media.archived.push(wasPlaying);
                }

                //broadcast queue using unsaved archive
                this.broadcastQueue(chanDB);

                //Save our changes to the DB
                await chanDB.save();
            }else{
                //broadcast queue using unsaved archive
                this.broadcastQueue(chanDB);
            }
        }catch(err){
            this.broadcastQueue();
            loggerUtils.localExceptionHandler(err);
        }
    }

    getItemsBetweenEpochs(start, end){
        //Create an empty array to hold found items
        const foundItems = [];

        //Loop through scheduled items
        for(let item of this.schedule){
            //If the item starts after our start date and before our end date
            if(item[0] >= start && item[0] <= end ){
                //Add the current item to the list
                foundItems.push(item[1]);
            }
        }

        //Return any found items
        return foundItems;
    }

    getItemAtEpoch(epoch = new Date().getTime()){
        //Loop through scheduled items
        for(let item of this.schedule){
            //If we're past or at the start time and at or before the end time
            if(item[0] <= epoch && item[1].getEndTime() >= epoch){
                //return the current item
                return item[1]
            }
        }

        //If we fell through the loop return null
        return null;
    }

    getLastItem(epoch = new Date().getTime()){
        //Create variable to hold the last item
        let last;

        //Loop through scheduled items
        for(let item of this.schedule){
            //If we've stumbled on to the next item
            if(item[0] >= epoch){
                //Break the loop
                break;
            //If we've stumbled upon an item that is currently playing
            }else if(item[1].getEndTime() >= epoch){
                //Break the loop
                break;
            //If we made it through this iteration without breaking the loop
            }

            //Set current item to last item
            last = item[1];
        }

        //If the loop has been broken or fallen through, return last.
        return last;
    }

    getNextItem(epoch = new Date().getTime()){
        //Iterate through the schedule
        for(let item of this.schedule){
            if(item[0] >= epoch){
                //Pull the scheduled media object from the map entry array
                return item[1];
            }
        }
    }

    getItemByUUID(uuid){
        //Iterate through the schedule
        for(let item of this.schedule){
            //If the uuid matches
            if(item[1].uuid == uuid){
                //return the found item
                return item[1];
            }
        }
    }

    sendMedia(socket){
        //Create data object
        const data = {
            media: this.nowPlaying,
            timestamp: this.timestamp
        }

        //If a socket is specified
        if(socket != null){
            //Send data out to specified socket
            socket.emit("start", data);
        //Otherwise
        }else{
            //Send that shit out to the entire channel
            this.server.io.in(this.channel.name).emit("start", data);
        }

    }

    async broadcastQueue(chanDB){
        this.server.io.in(this.channel.name).emit('queue',{queue: await this.prepQueue(chanDB)});
    }

    async prepQueue(chanDB){
        try{
            //If we didn't get handed a freebie
            if(chanDB == null){
                //Go out and get it done ourselves
                chanDB = await channelModel.findOne({name:this.channel.name});
            }

            //If we couldn't find the channel
            if(chanDB == null){
                //FUCK
                throw new Error(`Unable to find channel document ${this.channel.name} while rehydrating queue!`);
            }

            //Create an empty array to hold our schedule
            let schedule = [];

            //Get yestedays epoch
            const yesterday = new Date().setDate(new Date().getDate() - 1);

            //Iterate through the channel archive backwards to save time
            for(let mediaIndex = chanDB.media.archived.length - 1; mediaIndex >= 0; mediaIndex--){
                //Grab the current media record
                let media = chanDB.media.archived[mediaIndex].rehydrate();

                //If the media started within the last 24 hours
                if(media.startTime > yesterday){
                    //Add it to the schedule array as if it where part of the actual schedule map
                    schedule.push([media.startTime, media]);
                //Otherwise if it's older
                }else{
                    //Then we should be done as archived items are added as they are played/end.
                    //No newer items should be beyond this point!
                    break;
                }
            }

            //Concatonate the actual schedule to the items we pulled out of the archive return it
            return schedule.concat(Array.from(this.schedule));
        //If we can't get shit from the database
        }catch(err){
            //Complain
            loggerUtils.localExceptionHandler(err);
            //broadcast what we can from RAM
            return Array.from(this.schedule);
        }
    }

    async rehydrateQueue(chanDB){
        try{
            //If we didn't get handed a freebie
            if(chanDB == null){
                //Go out and get it done ourselves
                chanDB = await channelModel.findOne({name:this.channel.name});
            }

            //If we couldn't find the channel
            if(chanDB == null){
                //FUCK
                throw new Error(`Unable to find channel document ${this.channel.name} while rehydrating queue!`);
            }

            const now = new Date().getTime();

            //Next: Update this function to handle ended items

            //If something was playing
            if(chanDB.media.nowPlaying != null){
                //Rehydrate the currently playing item int oa queued media object
                const wasPlaying = chanDB.media.nowPlaying.rehydrate();

                //If the media hasn't ended yet
                if(wasPlaying.getEndTime() > now){
                    //Re-Schedule it in RAM
                    await this.scheduleMedia([wasPlaying], null, chanDB, true, true, true);
                //Otherwise, if it has
                }else{
                    //Null out nowPlaying
                    chanDB.media.nowPlaying = null;

                    //Archive the bitch
                    chanDB.media.archived.push(wasPlaying);
                }
            }

            //Create a new array to hold the new schedule so we only have to write to the DB once.
            let newSched = [];

            //For every saved scheduled item
            for(let record of chanDB.media.scheduled){
                //Rehydrate the current record into a queued media object
                const mediaObj = record.rehydrate();

                //If the item hasn't started
                if(mediaObj.startTime > now){
                    //Add record to new schedule
                    newSched.push(record);


                    //Re-Schedule it in RAM
                    await this.scheduleMedia([mediaObj], null, chanDB, true, true, false);
                }else{
                    //If the media should be playing now
                    if(mediaObj.getEndTime() > now){
                        //Save record to nowPlaying in the DB
                        chanDB.media.nowPlaying = record;

                        //Re-Schedule it in RAM
                        await this.scheduleMedia([mediaObj], null, chanDB, true, true, true);
                    //If it's been ended
                    }else{
                        //Archive ended media
                        chanDB.media.archived.push(record);
                    }
                }
            }

            //Update schedule to only contain what hasn't been played yet
            chanDB.media.scheduled = newSched;

            //Save the DB
            await chanDB.save();

        //if something fucked up
        }catch(err){
            //bitch about it in the server console
            loggerUtils.localExceptionHandler(err);
        }
    }
}