/**
 * Returns the function for getting the string of a specific
 * item given the name of the item type in Redis.
 * @param  {string} itemString the name of the item
 * @return {Function}          the function used to get the key for a specific item from Redis
 */
exports.getItemStringFunction = function(itemString) {
  var functions = {
    "messages" : redisAction.getMessageString,
    "shapes" : redisAction.getShapeString,
    "currentshapes" : redisAction.getShapeString
  };
  return functions[itemString];
};

/**
 * Returns the function for getting the string of all the items
 * given the name of the items in Redis
 * @param  {string} itemString the name of the item
 * @return {Function}          the function used to get the key for the list of specific items in Redis
 */
exports.getItemsStringFunction = function(itemString) {
  var functions = {
    "messages" : redisAction.getMessagesString,
    "shapes" : redisAction.getCurrentShapesString,
    "currentshapes" : redisAction.getCurrentShapesString
  };
  return functions[itemString];
};

/**
 * Get the key for the list of meetings in Redis
 * @return {string} the key for the list of meetings in Redis
 */
exports.getMeetingsString = function() {
  return "meetings";
};

/**
 * Get the string representing the key for the meeting
 * given the meetingID in Redis
 * @param  {string} meetingID the ID of the meeting
 * @return {string}           the key for the meeting given the meetingID in Redis
 */
exports.getMeetingString = function(meetingID) {
  return "meeting-" + meetingID;
};

/**
 * Get the string representing the key for the hash of all
 * the users for a specified meetingID in Redis
 * @param  {string} meetingID the ID of the meeting
 * @return {string}           the key for the hash of all the users for a specified meetingID in Redis
 */
exports.getUsersString = function(meetingID) {
  return "meeting-" + meetingID + "-users";
};

/**
 * Get the string representing the key for a specific sessionID in Redis
 * @param  {string} meetingID the ID of the meeting
 * @param  {string} sessionID the sessionID (unique ID) of the user
 * @return {string}           the key for a specific sessionID in Redis
 */
exports.getUserString = function(meetingID, sessionID) {
  return "meeting-" + meetingID + "-user-" + sessionID;
};

/**
 * Get the string representing the key for the list of current users
 * in a specific meeting ID
 * @param  {string} meetingID the ID of the meeting
 * @return {string}           key for the list of current users in a specific meeting ID
 */
exports.getCurrentUsersString = function(meetingID) {
  return "meeting-" + meetingID + "-currentusers";
};

/**
 * Get the string representing the key for the hash of all
 * the messages for a specified meetingID in Redis
 * @param  {string} meetingID      the ID of the meeting
 * @param  {string} presentationID the unique ID of the presentation in the meeting
 * @param  {string} pageID         the unique ID of the page in the presentation
 * @return {string}                the key for the hash of all the messages for a specified meetingID in Redis
 */
exports.getMessagesString = function(meetingID, presentationID, pageID) {
  return "meeting-" + meetingID + "-messages";
};

/**
 * Get the string representing the key for a specific message in Redis
 * @param  {string} meetingID      the ID of the meeting
 * @param  {string} presentationID the unique ID of the presentation in the meeting
 * @param  {string} pageID         the unique ID of the page in the presentation
 * @param  {string} messageID      the unique ID of the message in the public chat
 * @return {string}                string representing the key for a specific message in Redis
 */
exports.getMessageString = function(meetingID, presentationID, pageID, messageID) {
  return "meeting-" + meetingID + "-message-" + messageID;
};

/**
 * Get the key for the list of presentations for a meeting ID
 * @param  {string} meetingID the ID of the meeting
 * @return {string}           key for the list of presentations for a meeting ID
 */
exports.getPresentationsString = function(meetingID) {
  return "meeting-" + meetingID + "-presentations";
};

/**
 * Get the key for a specific presentation in a meeting
 * @param  {string} meetingID      the ID of the meeting
 * @param  {string} presentationID the unique ID of the presentation in the meeting
 * @return {string}                key for a specific presentation in a meeting
 */
exports.getPresentationString = function(meetingID, presentationID) {
  return "meeting-" + meetingID + "-presentation-" + presentationID;
};

/**
 * Get the key for the pages in a specific presentation in a meeting
 * @param  {string} meetingID      the ID of the meeting
 * @param  {string} presentationID the unique ID of the presentation in the meeting
 * @return {string}                key for the pages in a specific presentation in a meeting
 */
exports.getPagesString = function(meetingID, presentationID) {
  return "meeting-" + meetingID + "-presentation-" + presentationID + "-pages";
};

/**
 * Get the key for the current presentation of the meeting
 * @param  {string} meetingID the ID of the meeting
 * @return {string}           key for the current presentation of the meeting
 */
exports.getCurrentPresentationString = function(meetingID) {
  return "meeting-" + meetingID + "-currentpresentation";
};

/**
 * Get the key for the current page in the presentation
 * @param  {string} meetingID      the ID of the meeting
 * @param  {string} presentationID the unique ID of the presentation in the meeting
 * @return {string}                key for the current page in the presentation
 */
exports.getCurrentPageString = function(meetingID, presentationID) {
  return "meeting-" + meetingID + "-presentation-" + presentationID + "-currentpage";
};

/**
 * Get key of specific page.
 * @param  {string} meetingID      the ID of the meeting
 * @param  {string} presentationID the unique ID of the presentation in the meeting
 * @param  {string} pageID         the unique ID of the page in the presentation
 * @return {string}                key of specific page.
 */
exports.getPageString = function(meetingID, presentationID, pageID) {
  return "meeting-" + meetingID + "-presentation-" + presentationID + "-page-" + pageID;
};

/**
 * Get key of page image.
 * @param  {string} meetingID      the ID of the meeting
 * @param  {string} presentationID the unique ID of the presentation in the meeting
 * @param  {string} pageID         the unique ID of the page in the presentation
 * @return {string}                key of page image.
 */
exports.getPageImageString = function(meetingID, presentationID, pageID) {
  return "meeting-" + meetingID + "-presentation-" + presentationID + "-page-" + pageID + "-image";
};

/**
 * Get key for list of current shapes for the page
 * @param  {string} meetingID      the ID of the meeting
 * @param  {string} presentationID the unique ID of the presentation in the meeting
 * @param  {string} pageID         the unique ID of the page in the presentation
 * @return {string}                key for list of current shapes for the page
 */
exports.getCurrentShapesString = function(meetingID, presentationID, pageID) {
  return "meeting-" + meetingID + "-presentation-" + presentationID + "-page-" + pageID + "-currentshapes";
};

/**
 * Get key for specific shape on page
 * @param  {string} meetingID      the ID of the meeting
 * @param  {string} presentationID the unique ID of the presentation in the meeting
 * @param  {string} pageID         the unique ID of the page in the presentation
 * @param  {string} shapeID        the unique ID of the shape in the page
 * @return {string}                key for specific shape on page
 */
exports.getShapeString = function(meetingID, presentationID, pageID, shapeID) {
  return "meeting-" + meetingID + "-presentation-" + presentationID + "-page-" + pageID + "-shape-" + shapeID;
};

/**
 * Get the key for the current viewbox
 * @param  {string} meetingID the ID of the meeting
 * @return {string}           the key for the current viewbox
 */
exports.getCurrentViewBoxString = function(meetingID) {
  return "meeting-" + meetingID + "-viewbox";
};

/**
 * Get the key for the current tool
 * @param  {string} meetingID the ID of the meeting
 * @return {string}           the key for the current tool
 */
exports.getCurrentToolString = function(meetingID) {
  return "meeting-" + meetingID + "-currenttool";
};

/**
 * Get the key for the presenter
 * @param  {string} meetingID the ID of the meeting
 * @return {string}           the key for the presenter
 */
exports.getPresenterString = function(meetingID) {
  return "meeting-" + meetingID + "-presenter";
};

/**
 * Get the key for the public ID for a user
 * @param  {string} meetingID the ID of the meeting
 * @param  {string} publicID  the unique public ID of the user
 * @return {string}           the key for the public ID for a user
 */
exports.getPublicIDString = function (meetingID, publicID) {
  return 'meeting-' + meetingID + '-publicID-' + publicID;
};
/**
 * Get the key for session ID for a user
 * @param  {string} meetingID the ID of the meeting
 * @param  {string} sessionID the sessionID (unique ID) of the user
 * @return {string}           the key for session ID for a user
 */
exports.getSessionIDString = function (meetingID, sessionID) {
  return 'meeting-' + meetingID + '-sessionID-' + sessionID;
};

/**
 * Get the key for the width of a page image
 * @param  {string} meetingID      the ID of the meeting
 * @param  {string} presentationID the unique ID of the presentation in the meeting
 * @param  {string} pageID         the unique ID of the page in the presentation
 * @return {string}                the key for the width of a page image
 */
exports.getPageWidthString = function(meetingID, presentationID, pageID) {
  return 'meeting-' + meetingID + '-presentation-' + presentationID + '-page-' + pageID + '-width';
};

/**
 * Get the key for the height of a page image
 * @param  {string} meetingID      the ID of the meeting
 * @param  {string} presentationID the unique ID of the presentation in the meeting
 * @param  {string} pageID         the unique ID of the page in the presentation
 * @return {string}                the key for the height of a page image
 */
exports.getPageHeightString = function(meetingID, presentationID, pageID) {
  return 'meeting-' + meetingID + '-presentation-' + presentationID + '-page-' + pageID + '-height';
};

/**
 * Set the public and session ID to match one another
 * for lookup later
 * @param {string}   meetingID the ID of the meeting
 * @param {string}   sessionID the sessionID (unique ID) of the user
 * @param {string}   publicID  the unique public ID of the user
 * @param {Function} callback  callback function
 */
exports.setIDs = function(meetingID, sessionID, publicID, callback) {
  store.set(redisAction.getSessionIDString(meetingID, sessionID), publicID, function(err, reply) {
    store.set(redisAction.getPublicIDString(meetingID, publicID), sessionID, function(err, reply) {
      if(callback) callback();
    });
  });
};

/**
 * Get the session ID from the public ID of a user
 * @param  {string}   meetingID the ID of the meeting
 * @param  {string}   publicID  the unique public ID of the user
 * @param  {Function} callback  callback function
 * @return {undefined}          callback is called with return value if applicable
 */
exports.getSessionIDFromPublicID = function(meetingID, publicID, callback) {
  store.get(redisAction.getPublicIDString(meetingID, publicID), function(err, sessionID) {
    callback(sessionID);
  });
};

/**
 * Get the public ID from the session ID of a user
 * @param  {string}   meetingID the ID of the meeting
 * @param  {string}   sessionID the sessionID (unique ID) of the user
 * @param  {Function} callback  callback function
 * @return {undefined}          callback is called with return value if applicable
 */
exports.getPublicIDFromSessionID = function(meetingID, sessionID, callback) {
  store.get(redisAction.getSessionIDString(meetingID, sessionID), function(err, publicID) {
    callback(publicID);
  });
};

/**
 * Set the presenter from the public ID only
 * @param {string}   meetingID the ID of the meeting
 * @param {string}   publicID  the unique public ID of the user
 * @param {Function} callback  callback function
 */
exports.setPresenterFromPublicID = function(meetingID, publicID, callback) {
  redisAction.getSessionIDFromPublicID(meetingID, publicID, function(sessionID) {
    redisAction.setPresenter(meetingID, sessionID, publicID, function(success) {
      if(success) {
        console.log('set presenter to ' + sessionID);
        if(callback) callback(true);
      }
      else {
        console.log('could not set presenter to ' + sessionID);
        if(callback) callback(false);
      }
    });
  });
};

exports.setCurrentTool = function(meetingID, tool, callback) {
  store.set(redisAction.getCurrentToolString(meetingID), tool, function(err, reply) {
    if(reply) {
      if(callback) callback(true);
    }
    else if(err) {
      console.log(err);
      if(callback) callback(null);
    }
  });
};

/**
 * Set the presenter
 * @param {string}   meetingID the ID of the meeting
 * @param {string}   sessionID the sessionID (unique ID) of the user
 * @param {string}   publicID  the unique public ID of the user
 * @param {Function} callback  callback function
 */
exports.setPresenter = function(meetingID, sessionID, publicID, callback) {
  store.hmset(redisAction.getPresenterString(meetingID), 'sessionID', sessionID, 'publicID', publicID, function(err, reply) {
    if(reply) {
      if(callback) callback(publicID);
    }
    else if(err) {
      console.log(err);
      if(callback) callback(false);
    }
  });
};

/**
 * Get the session ID (private) of the presenter
 * @param  {string}   meetingID the ID of the meeting
 * @param  {Function} callback  callback function
 * @return {undefined}          callback is called with return value if applicable
 */
exports.getPresenterSessionID = function(meetingID, callback) {
  store.hget(redisAction.getPresenterString(meetingID), 'sessionID', function(err, reply) {
    if(reply) {
      callback(reply);
    }
    else if(err) {
      console.log(err);
      callback(null);
    }
  });
};

/**
 * Get the public ID of the presenter
 * @param  {string}   meetingID the ID of the meeting
 * @param  {Function} callback  callback function
 * @return {undefined}          callback is called with return value if applicable
 */
exports.getPresenterPublicID = function(meetingID, callback) {
  store.hget(redisAction.getPresenterString(meetingID), 'publicID', function(err, reply) {
    if(reply) {
      callback(reply);
    }
    else if(err) {
      console.log(err);
      callback(null);
    }
  });
};

/**
 * Get the current tool of the meeting
 * @param  {string}   meetingID the ID of the meeting
 * @param  {Function} callback  callback function
 * @return {undefined}          callback is called with return value if applicable
 */
exports.getCurrentTool = function(meetingID, callback) {
  store.get(redisAction.getCurrentToolString(meetingID), function(err, reply) {
    if(reply) {
      callback(reply);
    }
    else if(err) {
      console.log(err);
      callback(null);
    }
  });
};

/**
 * Delete the item list
 * @param  {string}   meetingID      the ID of the meeting
 * @param  {string}   presentationID the unique ID of the presentation in the meeting
 * @param  {string}   pageID         the unique ID of the page in the presentation
 * @param  {string}   itemName       the name of the type of items being deleted
 * @param  {Function} callback       the callback function to be called when finished
 * @return {undefined}               callback is called with return value if applicable
 */
exports.deleteItemList = function(meetingID, presentationID, pageID, itemName, callback) {
  //delete the list which contains the item ids
  store.del(redisAction.getItemsStringFunction(itemName)(meetingID, presentationID, pageID), function(err, reply) {
    if(reply) {
      console.log("REDIS: Deleted the list of items: " + itemName);
    }
    if(err) console.log("REDIS ERROR: could not delete list of items: " + itemName);
  });
};

/**
 * Deletes the items by itemName and an array of itemIDs (use helper)
 * @param  {string} meetingID      the ID of the meeting
 * @param  {string} presentationID the unique ID of the presentation in the meeting
 * @param  {string} pageID         the unique ID of the page in the presentation
 * @param  {string} itemName       the name of the item
 * @param  {string} itemIDs        an array of itemIDs to delete
 * @return {undefined}             callback is called with return value if applicable
 */
exports.deleteItems = function(meetingID, presentationID, pageID, itemName, itemIDs) {
  //delete each item
  for (var j = itemIDs.length - 1; j >= 0; j--) {
    store.del(redisAction.getItemStringFunction(itemName)(meetingID, presentationID, pageID, itemIDs[j]), function(err, reply) {
      if(reply) console.log("REDIS: Deleted item: " + itemName);
      if(err) console.log("REDIS ERROR: could not delete item: " + itemName);
    });
  };
};

/**
 * Delete a meeting
 * @param  {string}   meetingID the ID of the meeting
 * @param  {Function} callback  callback function
 * @return {undefined}          callback is called with return value if applicable
 */
exports.deleteMeeting = function(meetingID, callback) {
  store.srem(redisAction.getMeetingsString(), meetingID, function(err, reply) {
    if(reply) {
      console.log("Deleted meeting " + meetingID + " from list of meetings.");
      if(callback) callback(true);
    }
    else if(err) {
      console.log("Meeting was not in the list of meetings.");
      if(callback) callback(false);
    }
  });
};

/**
 * Process of the meeting once all the users have left
 * For now, this simply deletes everything associated with the meeting from redis
 * @param  {string}              meetingID the ID of the meeting
 * @return {undefined}           callback is called with return value if applicable
 */
exports.processMeeting = function(meetingID) {
  store.del(redisAction.getPresenterString(meetingID), function(err, reply) {
    console.log('deleted presenter');
  });
  store.del(redisAction.getCurrentViewBoxString(meetingID), function(err, reply) {
    console.log('deleted viewbox');
  });
  store.del(redisAction.getCurrentToolString(meetingID), function(err, reply) {
    console.log('deleted current tool');
  });
  redisAction.deleteMeeting(meetingID);
  redisAction.getPresentationIDs(meetingID, function(presIDs) {
    for(var k = presIDs.length - 1; k >=0; k--) {
      redisAction.getPageIDs(meetingID, presIDs[k], function(presID, pageIDs) {
        for(var m = pageIDs.length - 1; m >= 0; m--) {
          items = ['messages', 'shapes'];
          var j = 0;
          for (var j = items.length - 1; j >= 0; j--) {
            //must iterate through all presentations and all pages
            redisAction.getItemIDs(meetingID, presID, pageIDs[m], items[j], function(meetingID, presentationID, pageID, itemIDs, itemName) {
              redisAction.deleteItems(meetingID, presentationID, pageID, itemName, itemIDs);
            });
          }
          lists = ['currentshapes', 'messages'];
          for (var n = lists.length - 1; n >= 0; n--) {
            redisAction.deleteItemList(meetingID, presID, pageIDs[m], lists[n]);
          }
        }
      });
      redisAction.deletePages(meetingID, presIDs[k]); //delete all the pages for the associated presentation
    }
  });
  redisAction.deletePresentations(meetingID); //delete all the presentations
};

/**
 * Get the item IDs from the item name
 * @param  {string}   meetingID      the ID of the meeting
 * @param  {string}   presentationID the unique ID of the presentation in the meeting
 * @param  {string}   pageID         the unique ID of the page in the presentation
 * @param  {string}   itemName       the name of the type of items getting the IDs of
 * @param  {Function} callback       the callback function to be called when finished
 * @return {undefined}               callback is called with return value if applicable
 */
exports.getItemIDs = function(meetingID, presentationID, pageID, itemName, callback) {
  store.lrange(redisAction.getItemsStringFunction(itemName)(meetingID, presentationID, pageID), 0, -1, function(err, itemIDs) {
    callback(meetingID, presentationID, pageID, itemIDs, itemName);
  });
};

/**
 * Get a list of the current users of the meeting
 * @param  {string}   meetingID the ID of the meeting
 * @param  {Function} callback  callback function
 * @return {undefined}             callback is called with return value if applicable
 */
exports.getCurrentUsers = function(meetingID, callback) {
  store.smembers(redisAction.getCurrentUsersString(meetingID), function(err, reply) {
    if(reply) {
      callback(reply);
    }
    else if(err) {
    }
  });
};

/**
 * Set the image size to a image in a page
 * @param {string}   meetingID      the ID of the meeting
 * @param {string}   presentationID the unique ID of the presentation in the meeting
 * @param {string}   pageID         the unique ID of the page in the presentation
 * @param {string|number}   width   the value of the width of the image (in pixels)
 * @param {string|number}   height  the value of the height of the image (in pixels)
 * @param {Function} callback       the callback function to be called when finished
 */
exports.setImageSize = function(meetingID, presentationID, pageID, width, height, callback) {
  store.set(redisAction.getPageWidthString(meetingID, presentationID, pageID), width, function(err, reply) {
    store.set(redisAction.getPageHeightString(meetingID, presentationID, pageID), height, function(err, reply) {
      console.log('set size');
      if(callback) callback(true);
    });
  });
};

/**
 * Get a image size from the image on the page
 * @param  {string}   meetingID      the ID of the meeting
 * @param  {string}   presentationID the unique ID of the presentation in the meeting
 * @param  {string}   pageID         the unique ID of the page in the presentation
 * @param  {Function} callback       the callback function to be called when finished
 * @return {undefined}               callback is called with return value if applicable
 */
exports.getImageSize = function(meetingID, presentationID, pageID, callback) {
  store.get(redisAction.getPageWidthString(meetingID, presentationID, pageID), function(err, width) {
    store.get(redisAction.getPageHeightString(meetingID, presentationID, pageID), function(err, height) {
      callback(width, height);
    });
  });
};

/**
 * Get presentation IDs for a meeting
 * @param  {string}   meetingID the ID of the meeting
 * @param  {Function} callback  callback function
 * @return {undefined}          callback is called with return value if applicable
 */
exports.getPresentationIDs = function(meetingID, callback) {
  store.smembers(redisAction.getPresentationsString(meetingID), function(err, presIDs) {
    callback(presIDs);
  });
};

/**
 * Get the page IDs for a presentation
 * @param  {string}   meetingID      the ID of the meeting
 * @param  {string}   presentationID the unique ID of the presentation in the meeting
 * @param  {Function} callback       the callback function to be called when finished
 * @return {undefined}               callback is called with return value if applicable
 */
exports.getPageIDs = function(meetingID, presentationID, callback) {
  store.lrange(redisAction.getPagesString(meetingID, presentationID), 0, -1, function(err, pageIDs) {
    callback(presentationID, pageIDs);
  });
};

/**
 * Checks the Redis datastore whether the session is valid
 * @param  {string}   meetingID the ID of the meeting
 * @param  {string}   sessionID the sessionID (unique ID) of the user
 * @param  {Function} callback  callback function returns true if valid session
 * @return {undefined}          callback is used to return value
 */
exports.isValidSession = function(meetingID, sessionID, callback) {
  store.sismember(redisAction.getUsersString(meetingID), sessionID, function(err, isValid) {
    callback(isValid);
  });
};

/**
 * Calls a callback returning whether the 
 * meeting is running or not (true => running)
 * @param  {string}   meetingID the ID of the meeting
 * @param  {Function} callback  callback function returns true if meeting is running
 * @return {undefined}          callback is used to return value
 */
exports.isMeetingRunning = function(meetingID, callback) {
  store.sismember(redisAction.getMeetingsString(), meetingID, function(err, reply) {
    if(reply == 1) {
      callback(true);
    }
    else if(reply == 0) {
      callback(false);
    }
  });
};

/**
 * Delete all page references from a presentation.
 * @param  {string}   meetingID      the ID of the meeting
 * @param  {string}   presentationID the unique ID of the presentation in the meeting
 * @param  {Function} callback       the callback function to be called when finished
 * @return {undefined}               callback is called with return value if applicable
 */
exports.deletePages = function(meetingID, presentationID, callback) {
  //delete each page image
  redisAction.getPageIDs(meetingID, presentationID, function(presentationID, pageIDs) {
    for (var i = pageIDs.length - 1; i >= 0; i--) {
      redisAction.deletePageImage(meetingID, presentationID, pageIDs[i]);
    };
    //delete list of pages
    store.del(redisAction.getPagesString(meetingID, presentationID), function(err, reply) {
      if(reply) console.log("REDIS: Deleted all pages");
      if(err) console.log("REDIS ERROR: Couldn't delete all pages");
      //delete currentpage
      store.del(redisAction.getCurrentPageString(meetingID, presentationID), function(err, reply) {
        if(reply) console.log("REDIS: Deleted current page");
        if(err) console.log("REDIS ERROR: Couldn't delete current page");
        if(callback) callback();
      });
    });
  });
};

/**
 * Delete the reference to the image from a
 * particular presentation page in a meeting
 * @param  {string}   meetingID      the ID of the meeting
 * @param  {string}   presentationID the unique ID of the presentation in the meeting
 * @param  {string}   pageID         the unique ID of the page in the presentation
 * @param  {Function} callback       the callback function to be called when finished
 * @return {undefined}               callback is called with return value if applicable
 */
exports.deletePageImage = function(meetingID, presentationID, pageID, callback) {
  store.del(redisAction.getPageImageString(meetingID, presentationID, pageID), function(err, reply) {
    if(reply) console.log("REDIS: Deleted page image");
    if(err) console.log("REDIS ERROR: Could not delete page image");
    if(callback) callback();
  });
};

/**
 * Delete all presentation references from the meeting
 * @param  {string}   meetingID the ID of the meeting
 * @param  {Function} callback  callback function
 * @return {undefined}          callback is called with return value if applicable
 */
exports.deletePresentations = function(meetingID, callback) {
  store.del(redisAction.getPresentationsString(meetingID), function(err, reply) {
    if(reply) console.log("REDIS: Deleted all presentations");
    else console.log("REDIS ERROR: Couldn't delete all presentations");
    store.del(redisAction.getCurrentPresentationString(meetingID), function(err, reply) {
      if(reply) console.log("REDIS: Deleted current presentation");
      if(err) console.log("REDIS ERROR: Couldn't delete current presentation");
      if(callback) callback();
    });
  });
};

/**
 * Delete the user from Redis
 * @param  {string}   meetingID the ID of the meeting
 * @param  {string}   sessionID the sessionID (unique ID) of the user
 * @param  {Function} callback  callback function
 * @return {undefined}          callback is called with return value if applicable
 */
exports.deleteUser = function(meetingID, sessionID, callback) {
  store.srem(redisAction.getUsersString(meetingID), sessionID, function(err, num_deleted) {
    store.del(redisAction.getUserString(meetingID, sessionID), function(err, reply) {
		  callback(true);
    });
  });
};

/**
 * Remove the current user from the list of current user
 * @param  {string}   meetingID the ID of the meeting
 * @param  {string}   sessionID the sessionID (unique ID) of the user
 * @param  {Function} callback  callback function
 * @return {undefined}          callback is called with return value if applicable
 */
exports.deleteCurrentUser = function(meetingID, sessionID, callback) {
  store.srem(redisAction.getCurrentUsersString(meetingID), sessionID, function(err, num_deleted) {
    callback(true);
  });
};

/**
 * Gets all the properties associated with a specific user (sessionID)
 * @param  {string}   meetingID the ID of the meeting
 * @param  {string}   sessionID the sessionID (unique ID) of the user
 * @param  {Function} callback  callback function
 * @return {undefined}             callback is called with return value if applicable
 */
exports.getUserProperties = function(meetingID, sessionID, callback) {
  store.hgetall(redisAction.getUserString(meetingID, sessionID), function(err, properties) {
    callback(properties);
  });
};

/**
 * Gets a single property from a specific user
 * @param  {string}   meetingID the ID of the meeting
 * @param  {string}   sessionID the sessionID (unique ID) of the user
 * @param  {string}   property  the name of the property from the users list of properties to get
 * @param  {Function} callback  callback function
 * @return {undefined}          callback is called with return value if applicable
 */
exports.getUserProperty = function(meetingID, sessionID, property, callback) {
  store.hget(redisAction.getUserString(meetingID, sessionID), property, function(err, prop) {
    if(prop) callback(prop);
    if(err) {
      console.log(err);
      callback(null);
    }
  });
};

/**
 * Get all users and their data in an array
 * (users are in a set, not a list, because they need to be accessed with O(1))
 * @param  {string}   meetingID the ID of the meeting
 * @param  {Function} callback  callback function
 * @return {undefined}          callback is called with return value if applicable
 */
exports.getUsers =  function (meetingID, callback) {
  users = [];
  usercount = 0;
  usersdone = 0;

  store.smembers(redisAction.getUsersString(meetingID), function (err, userids) {
    usercount = userids.length;
    for (var i = usercount - 1; i >= 0; i--){
      store.hgetall(redisAction.getUserString(meetingID, userids[i]), function (err, props) {
        users.push(props);
        usersdone++;
        if (usercount == usersdone) {
          callback(users);
        }
      });
    };
  });
};

/**
 * Get the page image filename 
 * @param  {string}   meetingID      the ID of the meeting
 * @param  {string}   presentationID the unique ID of the presentation in the meeting
 * @param  {string}   pageID         the unique ID of the page in the presentation
 * @param  {Function} callback       the callback function to be called when finished
 * @return {undefined}               callback is called with return value if applicable
 */
exports.getPageImage = function(meetingID, presentationID, pageID, callback) {
  store.get(redisAction.getPageImageString(meetingID, presentationID, pageID), function(err, filename) {
    if(filename) {
      console.log(filename);
      callback(pageID, filename);
    }
    else console.log("REDIS ERROR: Couldn't get page image");
  });
};

/**
 * Get array of items by item name and meeting id
 * @param  {string}   meetingID      the ID of the meeting
 * @param  {string}   presentationID the unique ID of the presentation in the meeting
 * @param  {string}   pageID         the unique ID of the page in the presentation
 * @param  {string}   item           the name of the type of item
 * @param  {Function} callback       the callback function to be called when finished
 * @return {undefined}               callback is called with return value if applicable
 */
exports.getItems = function(meetingID, presentationID, pageID, item, callback) {
  var items = [];
  var itemCount = 0;
  var itemsDone = 0;
  var itemsGetFunction;
  var itemGetFunction;
 
  itemGetFunction = redisAction.getItemStringFunction(item);
  itemsGetFunction = redisAction.getItemsStringFunction(item);
 
  store.lrange(itemsGetFunction(meetingID, presentationID, pageID), 0, -1, function (err, itemIDs) {
    itemCount = itemIDs.length;
    if(itemCount == 0) callback([]);
    for (var i = itemCount - 1; i >= 0; i--) {
      store.hgetall(itemGetFunction(meetingID, presentationID, pageID, itemIDs[i]), function(err, itemHash) {
        items.push(itemHash);
        itemsDone++;
        if (itemCount == itemsDone) {
          callback(items);
        }
      });
    };
  });
};

/**
 * Get the current presentation ID for the meeting
 * @param  {string}   meetingID the ID of the meeting
 * @param  {Function} callback  callback function
 * @return {undefined}          callback is called with return value if applicable
 */
exports.getCurrentPresentationID = function(meetingID, callback) {
  store.get(redisAction.getCurrentPresentationString(meetingID), function(err, currPresID) {
    if(currPresID) {
      callback(currPresID);
    }
    else console.log("REDIS ERROR: Couldn't get current presentationID");
  });
};

/**
 * Change to the next page in the presentation
 * @param  {string}   meetingID      the ID of the meeting
 * @param  {string}   presentationID the unique ID of the presentation in the meeting
 * @param  {Function} callback       the callback function to be called when finished
 * @return {undefined}               callback is called with return value if applicable
 */
exports.changeToNextPage = function(meetingID, presentationID, callback) {
  var pages = redisAction.getPagesString(meetingID, presentationID);
  store.lpop(pages, function(err, reply) {
    store.rpush(pages, reply, function(err, reply) {
      store.lindex(pages, 0, function(err, currPage){
        if(currPage) {
          callback(currPage);
        }
        else console.log("REDIS ERROR: Couldn't get current pageID");
      });
    });
  });
};

/**
 * Change to the previous page in the presentation
 * @param  {string}   meetingID      the ID of the meeting
 * @param  {string}   presentationID the unique ID of the presentation in the meeting
 * @param  {Function} callback       the callback function to be called when finished
 * @return {undefined}               callback is called with return value if applicable
 */
exports.changeToPrevPage = function(meetingID, presentationID, callback) {
  var pages = redisAction.getPagesString(meetingID, presentationID);
  //removes the last element and then returns it, only after appending it back
  //to the beginning of the same list
  store.rpoplpush(pages, pages, function(err, currPage) {
    if(currPage) {
      callback(currPage);
    }
    else console.log("REDIS ERROR: Couldn't get current pageID");
  });
};

/**
 * Get the current page of the presentation
 * @param  {string}   meetingID      the ID of the meeting
 * @param  {string}   presentationID the unique ID of the presentation in the meeting
 * @param  {Function} callback       the callback function to be called when finished
 * @return {undefined}               callback is called with return value if applicable
 */
exports.getCurrentPageID = function(meetingID, presentationID, callback) {
  //The first element in the pages is always the current page
  store.lindex(redisAction.getPagesString(meetingID, presentationID), 0, function(err, currPgID) {
    if(currPgID) {
      callback(currPgID);
    }
    else console.log("REDIS ERROR: Couldn't get current pageID");
  });
};

/**
 * Create a new presentation for a meeting,
 * and possibly set it as the current meeting
 * @param  {string}   meetingID  the ID of the meeting
 * @param  {boolean}  setCurrent set current presentation after creation (true or false)
 * @param  {Function} callback   the callback function to be called when finished
 * @return {undefined}           callback is called with return value if applicable
 */
exports.createPresentation = function(meetingID, setCurrent, callback) {
  var presentationID = rack(); //create a new unique presentationID
  store.sadd(redisAction.getPresentationsString(meetingID), presentationID, function(err, reply) {
    if(reply) {
      console.log("REDIS: Added presentationID " + presentationID + " to set of presentations.");
      if(setCurrent) {
        redisAction.setCurrentPresentation(meetingID, presentationID, function() {
          callback(presentationID);
        });
      }
      else callback(presentationID);
    }
    else if(err) {
      console.log("REDIS ERROR: Couldn't add presentationID " + presentationID + "to set of presentations");
      callback(null);
    }
  });
};

/**
 * Set the current page of the presentation
 * @param {string}   meetingID      the ID of the meeting
 * @param {string}   presentationID the unique ID of the presentation in the meeting
 * @param {string}   pageID         the unique ID of the page in the presentation
 * @param {Function} callback       the callback function to be called when finished
 */
exports.setCurrentPage = function(meetingID, presentationID, pageID, callback) {
  store.set(redisAction.getCurrentPageString(meetingID, presentationID), pageID, function(err, reply) {
      if(reply) console.log("REDIS: Set current pageID to " + pageID);
      if(err) console.log("REDIS ERROR: Couldn't set current pageID to " + pageID);
      if(callback) callback();
    });
};

/**
 * Create a page for a presentation in a meeting
 * @param  {string}   meetingID      the ID of the meeting
 * @param  {string}   presentationID the unique ID of the presentation in the meeting
 * @param  {string}   imageName      the file name of the image
 * @param  {boolean}  setCurrent     set as current page after creating the page (true or false)
 * @param  {Function} callback       the callback function to be called when finished
 * @return {undefined}               callback is called with return value if applicable
 */
exports.createPage = function(meetingID, presentationID, imageName, setCurrent, callback) {
  var pageID = rack(); //create a new unique pageID
  var afterPush = function(err, reply) {
    if(reply) {
      console.log("REDIS: Created page with ID " + pageID);
      redisAction.setPageImage(meetingID, presentationID, pageID, imageName, function() {
        callback(pageID, imageName);
      });
    }
    else if(err) {
      console.log("REDIS ERROR: Couldn't create page with ID " + pageID);
      callback(null);
    }
  };
 
  console.log("Making page with id " + pageID);
  if(setCurrent) {
    store.lpush(redisAction.getPagesString(meetingID, presentationID), pageID, afterPush);
  }
  else {
    store.rpush(redisAction.getPagesString(meetingID, presentationID), pageID, afterPush);
  }
};

/**
 * Set the image for a particular page ID
 * @param {string}   meetingID      the ID of the meeting
 * @param {string}   presentationID the unique ID of the presentation in the meeting
 * @param {string}   pageID         the unique ID of the page in the presentation
 * @param {string}   imageName      the file name of the image
 * @param {Function} callback       the callback function to be called when finished
 */
exports.setPageImage = function(meetingID, presentationID, pageID, imageName, callback) {
  store.set(redisAction.getPageImageString(meetingID, presentationID, pageID), imageName, function (err, reply) {
    if(reply) console.log("REDIS: Set page " + pageID +" image to " + imageName);
    else if(err) console.log("REDIS ERROR: Couldn't set page " + pageID +" image to " + imageName);
    if(callback) callback();
  });
};

/**
 * Set the current presentation
 * @param {string}   meetingID      the ID of the meeting
 * @param {string}   presentationID the unique ID of the presentation in the meeting
 * @param {Function} callback       the callback function to be called when finished
 */
exports.setCurrentPresentation = function(meetingID, presentationID, callback) {
  store.set(redisAction.getCurrentPresentationString(meetingID), presentationID, function(err, reply) {
    if(reply) console.log("REDIS: Set current presentationID to " + presentationID);
    else if(err) console.log("REDIS ERROR: Couldn't set current presentationID"); //impossible because set never fails
    if(callback) callback();
  });
};

/**
 * Set the value of the current viewbox for the meeting
 * @param {string}   meetingID the ID of the meeting
 * @param {string}   viewbox   the string representing the viewbox value
 * @param {Function} callback  callback function
 */
exports.setViewBox = function(meetingID, viewbox, callback) {
  store.set(redisAction.getCurrentViewBoxString(meetingID), viewbox, function(err, reply){
    if(reply) {
      if(callback) callback(true);
    }
    else if(err) {
      console.log(err);
      if(callback) callback(false);
    }
  });
};

/**
 * Get the current viewbox of the meeting
 * @param  {string}   meetingID the ID of the meeting
 * @param  {Function} callback  callback function
 * @return {undefined}          callback is called with return value if applicable
 */
exports.getViewBox = function(meetingID, callback) {
  store.get(redisAction.getCurrentViewBoxString(meetingID), function(err, reply) {
    if(reply) {
      if(callback) callback(reply);
    }
    else if(err) {
      console.log(err);
      if(callback) callback(null);
    }
  });
};

/**
 * Create a reference to a meeting
 * @param  {string}   meetingID the ID of the meeting
 * @param  {Function} callback  callback function
 * @return {undefined}          callback is called with return value if applicable
 */
exports.createMeeting = function(meetingID, callback) {
  store.sadd(redisAction.getMeetingsString(), meetingID); //create the meeting if not already created.
  if(callback) callback();
};

/**
 * Create a reference to a user
 * @param  {string}   meetingID the ID of the meeting
 * @param  {string}   userID    the unique session ID of the user
 * @param  {Function} callback  callback function
 * @return {undefined}          callback is called with return value if applicable
 */
exports.createUser = function(meetingID, userID, callback) {
  store.sadd(redisAction.getUsersString(meetingID), userID); //meeting-123-users.push(sessionID)
  if(callback) callback();
};

/**
 * Update user properties
 * @param  {string}   meetingID  the ID of the meeting
 * @param  {string}   userID     the unique session ID of the user
 * @param  {Object}   properties a hash of properties to set as the users properties
 * @param  {Function} callback   the callback function to be called when finished
 * @return {undefined}           callback is called with return value if applicable
 */
exports.updateUserProperties = function(meetingID, userID, properties, callback) {
  properties.unshift(redisAction.getUserString(meetingID, userID));
  properties.push(function(err, reply) {
    if(reply) {
      if(callback) callback(true);
    }
    else if(err) {
      console.log(err);
      if(callback) callback(false);
    }
  });
  store.hmset.apply(store, properties);
};

exports.getMeetings = function(callback){
  store.smembers("meetings",function (err,meetingids){
    if(meetingids){
      var index = 0;
      var resp = [];
      var f = function (err,properties){
        if(index == meetingids.length)
          callback(resp);
        else{
          var r = {};
          r.meetingID = meetingids[index];
          r.externalID = properties["externalID"];
          r.meetingName = properties["name"];
          resp.push(r);
          index += 1;
          store.hgetall("meeting-" + meetingids[index], f);
        }

      }

      store.hgetall("meeting-" + meetingids[index],f);  
      
    }else{
      console.log(err);
      callback([]);
    }
  });
};