import async from "async";
import mongoose from "mongoose";
import config from "config";

import { hasPermission, useHasPermission } from "../hooks/hasPermission";
import isLoginRequired from "../hooks/loginRequired";

// eslint-disable-next-line
import moduleManager from "../../index";

const DBModule = moduleManager.modules.db;
const UtilsModule = moduleManager.modules.utils;
const WSModule = moduleManager.modules.ws;
const PlaylistsModule = moduleManager.modules.playlists;
const CacheModule = moduleManager.modules.cache;
const NotificationsModule = moduleManager.modules.notifications;
const StationsModule = moduleManager.modules.stations;
const ActivitiesModule = moduleManager.modules.activities;

CacheModule.runJob("SUB", {
	channel: "station.updateUsers",
	cb: ({ stationId, usersPerStation }) => {
		WSModule.runJob("EMIT_TO_ROOM", {
			room: `station.${stationId}`,
			args: ["event:station.users.updated", { data: { users: usersPerStation } }]
		});
	}
});

CacheModule.runJob("SUB", {
	channel: "station.updateUserCount",
	cb: ({ stationId, usersPerStationCount }) => {
		const count = usersPerStationCount || 0;

		WSModule.runJob("EMIT_TO_ROOM", {
			room: `station.${stationId}`,
			args: ["event:station.userCount.updated", { data: { userCount: count } }]
		});

		StationsModule.runJob("GET_STATION", { stationId }).then(async station => {
			if (station.privacy === "public")
				WSModule.runJob("EMIT_TO_ROOM", {
					room: "home",
					args: ["event:station.userCount.updated", { data: { stationId, userCount: count } }]
				});
			else {
				const sockets = await WSModule.runJob("GET_SOCKETS_FOR_ROOM", {
					room: "home"
				});

				sockets.forEach(async socketId => {
					const socket = await WSModule.runJob("SOCKET_FROM_SOCKET_ID", { socketId }, this);
					if (!socket) return;
					const { session } = socket;
					hasPermission("stations.view", session, stationId)
						.then(() => {
							socket.dispatch("event:station.userCount.updated", {
								data: { stationId, count }
							});
						})
						.catch(() => {});
				});
			}
		});
	}
});

CacheModule.runJob("SUB", {
	channel: "station.autofillPlaylist",
	cb: data => {
		const { stationId, playlistId } = data;

		PlaylistsModule.runJob("GET_PLAYLIST", { playlistId }).then(playlist =>
			WSModule.runJob("EMIT_TO_ROOMS", {
				rooms: [`station.${stationId}`, `manage-station.${stationId}`],
				args: ["event:station.autofillPlaylist", { data: { stationId, playlist } }]
			})
		);
	}
});

CacheModule.runJob("SUB", {
	channel: "station.blacklistedPlaylist",
	cb: data => {
		const { stationId, playlistId } = data;

		PlaylistsModule.runJob("GET_PLAYLIST", { playlistId }).then(playlist =>
			WSModule.runJob("EMIT_TO_ROOMS", {
				rooms: [`station.${stationId}`, `manage-station.${stationId}`],
				args: ["event:station.blacklistedPlaylist", { data: { stationId, playlist } }]
			})
		);
	}
});

CacheModule.runJob("SUB", {
	channel: "station.removedAutofillPlaylist",
	cb: data => {
		const { stationId, playlistId } = data;
		WSModule.runJob("EMIT_TO_ROOMS", {
			rooms: [`station.${stationId}`, `manage-station.${stationId}`],
			args: ["event:station.removedAutofillPlaylist", { data: { stationId, playlistId } }]
		});
	}
});

CacheModule.runJob("SUB", {
	channel: "station.removedBlacklistedPlaylist",
	cb: data => {
		const { stationId, playlistId } = data;
		WSModule.runJob("EMIT_TO_ROOMS", {
			rooms: [`station.${stationId}`, `manage-station.${stationId}`],
			args: ["event:station.removedBlacklistedPlaylist", { data: { stationId, playlistId } }]
		});
	}
});

CacheModule.runJob("SUB", {
	channel: "station.pause",
	cb: stationId => {
		StationsModule.runJob("GET_STATION", { stationId }).then(station => {
			WSModule.runJob("EMIT_TO_ROOM", {
				room: `station.${stationId}`,
				args: ["event:station.pause", { data: { pausedAt: station.pausedAt } }]
			});

			WSModule.runJob("EMIT_TO_ROOM", {
				room: `manage-station.${stationId}`,
				args: ["event:station.pause", { data: { stationId, pausedAt: station.pausedAt } }]
			});

			StationsModule.runJob("GET_SOCKETS_THAT_CAN_KNOW_ABOUT_STATION", {
				room: `home`,
				station
			}).then(response => {
				const { socketsThatCan } = response;
				socketsThatCan.forEach(socket => {
					socket.dispatch("event:station.pause", { data: { stationId } });
				});
			});
		});
	}
});

CacheModule.runJob("SUB", {
	channel: "station.resume",
	cb: stationId => {
		StationsModule.runJob("GET_STATION", { stationId }).then(station => {
			WSModule.runJob("EMIT_TO_ROOM", {
				room: `station.${stationId}`,
				args: ["event:station.resume", { data: { timePaused: station.timePaused } }]
			});

			WSModule.runJob("EMIT_TO_ROOM", {
				room: `manage-station.${stationId}`,
				args: ["event:station.resume", { data: { stationId, timePaused: station.timePaused } }]
			});

			StationsModule.runJob("GET_SOCKETS_THAT_CAN_KNOW_ABOUT_STATION", {
				room: `home`,
				station
			})
				.then(response => {
					const { socketsThatCan } = response;
					socketsThatCan.forEach(socket => {
						socket.dispatch("event:station.resume", { data: { stationId } });
					});
				})
				.catch(console.log);
		});
	}
});

CacheModule.runJob("SUB", {
	channel: "station.queueUpdate",
	cb: stationId => {
		StationsModule.runJob("GET_STATION", { stationId }).then(station => {
			if (!station.currentSong && station.queue.length > 0) {
				StationsModule.runJob("INITIALIZE_STATION", {
					stationId
				}).then();
			}

			WSModule.runJob("EMIT_TO_ROOM", {
				room: `station.${stationId}`,
				args: ["event:station.queue.updated", { data: { queue: station.queue } }]
			});

			WSModule.runJob("EMIT_TO_ROOM", {
				room: `manage-station.${stationId}`,
				args: ["event:manageStation.queue.updated", { data: { stationId, queue: station.queue } }]
			});
		});
	}
});

CacheModule.runJob("SUB", {
	channel: "station.changeQueueOrder",
	cb: res => {
		WSModule.runJob("EMIT_TO_ROOM", {
			room: `station.${res.stationId}`,
			args: ["event:station.queue.order.changed", { data: { queueOrder: res.queueOrder } }]
		});

		WSModule.runJob("EMIT_TO_ROOM", {
			room: `manage-station.${res.stationId}`,
			args: [
				"event:manageStation.queue.order.changed",
				{ data: { stationId: res.stationId, queueOrder: res.queueOrder } }
			]
		});
	}
});

CacheModule.runJob("SUB", {
	channel: "station.toggleSkipVote",
	cb: res => {
		const { stationId, voted, userId } = res;
		WSModule.runJob("EMIT_TO_ROOM", {
			room: `station.${stationId}`,
			args: ["event:station.toggleSkipVote", { data: { voted, userId } }]
		});
	}
});

CacheModule.runJob("SUB", {
	channel: "station.remove",
	cb: stationId => {
		WSModule.runJob("EMIT_TO_ROOM", {
			room: `station.${stationId}`,
			args: ["event:station.deleted"]
		});

		WSModule.runJob("EMIT_TO_ROOM", {
			room: `manage-station.${stationId}`,
			args: ["event:station.deleted"]
		});

		WSModule.runJob("EMIT_TO_ROOM", {
			room: `home`,
			args: ["event:station.deleted", { data: { stationId } }]
		});

		WSModule.runJob("EMIT_TO_ROOM", {
			room: "admin.stations",
			args: ["event:admin.station.deleted", { data: { stationId } }]
		});
	}
});

CacheModule.runJob("SUB", {
	channel: "station.create",
	cb: async stationId => {
		StationsModule.runJob("INITIALIZE_STATION", { stationId }).then(async res => {
			const { station } = res;
			station.userCount = StationsModule.usersPerStationCount[stationId] || 0;

			WSModule.runJob("EMIT_TO_ROOM", {
				room: "admin.stations",
				args: ["event:admin.station.created", { data: { station } }]
			});

			if (station.privacy === "public")
				WSModule.runJob("EMIT_TO_ROOM", {
					room: "home",
					args: ["event:station.created", { data: { station } }]
				});
			else {
				const sockets = await WSModule.runJob("GET_SOCKETS_FOR_ROOM", {
					room: "home"
				});

				sockets.forEach(async socketId => {
					const socket = await WSModule.runJob("SOCKET_FROM_SOCKET_ID", { socketId }, this);
					if (!socket) return;
					const { session } = socket;
					hasPermission("stations.view", session, stationId)
						.then(() => {
							socket.dispatch("event:station.created", { data: { station } });
						})
						.catch(() => {});
				});
			}
		});
	}
});

CacheModule.runJob("SUB", {
	channel: "station.updated",
	cb: async data => {
		const stationModel = await DBModule.runJob("GET_MODEL", {
			modelName: "station"
		});

		const { stationId } = data;

		stationModel.findOne(
			{ _id: stationId },
			[
				"_id",
				"name",
				"displayName",
				"description",
				"type",
				"privacy",
				"owner",
				"requests",
				"autofill",
				"theme",
				"skipVoteThreshold"
			],
			(err, station) => {
				WSModule.runJob("EMIT_TO_ROOMS", {
					rooms: [`station.${stationId}`, `manage-station.${stationId}`, "admin.stations"],
					args: ["event:station.updated", { data: { station } }]
				});

				StationsModule.runJob("GET_SOCKETS_THAT_CAN_KNOW_ABOUT_STATION", {
					room: `home`,
					station
				}).then(response => {
					const { socketsThatCan } = response;
					socketsThatCan.forEach(socket => {
						socket.dispatch("event:station.updated", { data: { station } });
					});
				});

				if (data.previousStation && data.previousStation.privacy !== station.privacy) {
					if (station.privacy === "public") {
						// Station became public

						WSModule.runJob("EMIT_TO_ROOM", {
							room: "home",
							args: ["event:station.created", { data: { station } }]
						});
					} else if (data.previousStation.privacy === "public") {
						// Station became hidden

						StationsModule.runJob("GET_SOCKETS_THAT_CAN_KNOW_ABOUT_STATION", {
							room: `home`,
							station
						}).then(response => {
							const { socketsThatCannot } = response;
							socketsThatCannot.forEach(socket => {
								socket.dispatch("event:station.deleted", { data: { stationId } });
							});
						});
					}
				}
			}
		);
	}
});

export default {
	/**
	 * Get a list of all the stations
	 * @param {object} session - user session
	 * @param {boolean} adminFilter - whether to filter out stations admins do not own
	 * @param {Function} cb - callback
	 */
	async index(session, adminFilter, cb) {
		const userModel = await DBModule.runJob("GET_MODEL", { modelName: "user" });

		async.waterfall(
			[
				// get array of the ids of the user's favorite stations
				next => {
					if (session.userId)
						return userModel.findById(session.userId).select({ favoriteStations: -1 }).exec(next);
					return next(null, { favoriteStations: [] });
				},

				(user, next) => {
					const favoriteStations = user ? user.favoriteStations : [];
					CacheModule.runJob("HGETALL", { table: "stations" }, this).then(stations =>
						next(null, stations, favoriteStations)
					);
				},

				(stations, favorited, next) => {
					const filteredStations = [];

					async.eachLimit(
						stations,
						1,
						(station, nextStation) => {
							async.waterfall(
								[
									callback => {
										// only relevant if user logged in
										if (session.userId) {
											if (favorited.indexOf(station._id) !== -1) station.isFavorited = true;
											return callback();
										}

										return callback();
									},

									callback => {
										StationsModule.runJob(
											"CAN_USER_VIEW_STATION",
											{
												station,
												userId: session.userId
											},
											this
										)
											.then(exists => callback(null, exists))
											.catch(callback);
									},

									(exists, callback) => {
										if (!exists) callback(null, false, false);
										else if (station.privacy === "public") callback(null, true, true);
										else
											hasPermission("stations.index", session.userId, station._id)
												.then(() => callback(null, true, true))
												.catch(() => callback(null, true, false));
									},

									(exists, canIndex, callback) => {
										if (!exists) callback(null, false);
										else if (!canIndex && !adminFilter)
											hasPermission("stations.index.other", session.userId)
												.then(() => callback(null, true))
												.catch(() => callback(null, false));
										else callback(null, canIndex);
									}
								],
								(err, exists) => {
									if (err) return this.log("ERROR", "STATIONS_INDEX", err);

									station.userCount = StationsModule.usersPerStationCount[station._id] || 0;

									if (exists) filteredStations.push(station);
									return nextStation();
								}
							);
						},
						() => next(null, filteredStations, favorited)
					);
				}
			],
			async (err, stations, favorited) => {
				if (err) {
					err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
					this.log("ERROR", "STATIONS_INDEX", `Indexing stations failed. "${err}"`);
					return cb({ status: "error", message: err });
				}

				this.log("SUCCESS", "STATIONS_INDEX", `Indexing stations successful.`, false);

				return cb({ status: "success", data: { stations, favorited } });
			}
		);
	},

	/**
	 * Gets stations, used in the admin stations page by the AdvancedTable component
	 * @param {object} session - the session object automatically added by the websocket
	 * @param page - the page
	 * @param pageSize - the size per page
	 * @param properties - the properties to return for each station
	 * @param sort - the sort object
	 * @param queries - the queries array
	 * @param operator - the operator for queries
	 * @param {Function} cb - gets called with the result
	 */
	getData: useHasPermission(
		"admin.view.stations",
		async function getSet(session, page, pageSize, properties, sort, queries, operator, cb) {
			async.waterfall(
				[
					next => {
						DBModule.runJob(
							"GET_DATA",
							{
								page,
								pageSize,
								properties,
								sort,
								queries,
								operator,
								modelName: "station",
								blacklistedProperties: [],
								specialProperties: {
									owner: [
										{
											$addFields: {
												ownerOID: {
													$convert: {
														input: "$owner",
														to: "objectId",
														onError: "unknown",
														onNull: "unknown"
													}
												}
											}
										},
										{
											$lookup: {
												from: "users",
												localField: "ownerOID",
												foreignField: "_id",
												as: "ownerUser"
											}
										},
										{
											$unwind: {
												path: "$ownerUser",
												preserveNullAndEmptyArrays: true
											}
										},
										{
											$addFields: {
												ownerUsername: {
													$cond: [
														{ $eq: [{ $type: "$owner" }, "string"] },
														{ $ifNull: ["$ownerUser.username", "unknown"] },
														"none"
													]
												}
											}
										},
										{
											$project: {
												ownerOID: 0,
												ownerUser: 0
											}
										}
									]
								},
								specialQueries: {
									owner: newQuery => ({ $or: [newQuery, { ownerUsername: newQuery.owner }] })
								}
							},
							this
						)
							.then(response => {
								next(null, response);
							})
							.catch(err => {
								next(err);
							});
					}
				],
				async (err, response) => {
					if (err) {
						err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
						this.log("ERROR", "STATIONS_GET_DATA", `Failed to get data from stations. "${err}"`);
						return cb({ status: "error", message: err });
					}
					this.log("SUCCESS", "STATIONS_GET_DATA", `Got data from stations successfully.`);
					return cb({ status: "success", message: "Successfully got data from stations.", data: response });
				}
			);
		}
	),

	/**
	 * Obtains basic metadata of a station in order to format an activity
	 * @param {object} session - user session
	 * @param {string} stationId - the station id
	 * @param {Function} cb - callback
	 */
	getStationForActivity(session, stationId, cb) {
		async.waterfall(
			[
				next => {
					StationsModule.runJob("GET_STATION", { stationId }, this)
						.then(station => {
							next(null, station);
						})
						.catch(next);
				}
			],
			async (err, station) => {
				if (err) {
					err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
					this.log(
						"ERROR",
						"STATIONS_GET_STATION_FOR_ACTIVITY",
						`Failed to obtain metadata of station ${stationId} for activity formatting. "${err}"`
					);
					return cb({ status: "error", message: err });
				}
				this.log(
					"SUCCESS",
					"STATIONS_GET_STATION_FOR_ACTIVITY",
					`Obtained metadata of station ${stationId} for activity formatting successfully.`
				);
				return cb({
					status: "success",
					data: {
						title: station.displayName,
						thumbnail: station.currentSong ? station.currentSong.thumbnail : ""
					}
				});
			}
		);
	},

	/**
	 * Verifies that a station exists from its name
	 * @param {object} session - user session
	 * @param {string} stationName - the station name
	 * @param {Function} cb - callback
	 */
	existsByName(session, stationName, cb) {
		async.waterfall(
			[
				next => {
					StationsModule.runJob("GET_STATION_BY_NAME", { stationName }, this)
						.then(station => next(null, station))
						.catch(next);
				},

				(station, next) => {
					if (!station) return next(null, false);
					return StationsModule.runJob("CAN_USER_VIEW_STATION", { station, userId: session.userId }, this)
						.then(exists => next(null, exists))
						.catch(next);
				}
			],
			async (err, exists) => {
				if (err) {
					err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
					this.log(
						"ERROR",
						"STATION_EXISTS_BY_NAME",
						`Checking if station "${stationName}" exists failed. "${err}"`
					);
					return cb({ status: "error", message: err });
				}

				this.log(
					"SUCCESS",
					"STATION_EXISTS_BY_NAME",
					`Station "${stationName}" exists successfully.` /* , false */
				);

				return cb({ status: "success", data: { exists } });
			}
		);
	},

	/**
	 * Verifies that a station exists from its id
	 * @param {object} session - user session
	 * @param {string} stationId - the station id
	 * @param {Function} cb - callback
	 */
	existsById(session, stationId, cb) {
		async.waterfall(
			[
				next => {
					StationsModule.runJob("GET_STATION", { stationId }, this)
						.then(station => next(null, station))
						.catch(next);
				},

				(station, next) => {
					if (!station) return next(null, false);
					return StationsModule.runJob("CAN_USER_VIEW_STATION", { station, userId: session.userId }, this)
						.then(exists => next(null, exists))
						.catch(next);
				}
			],
			async (err, exists) => {
				if (err) {
					err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
					this.log(
						"ERROR",
						"STATION_EXISTS_BY_ID",
						`Checking if station "${stationId}" exists failed. "${err}"`
					);
					return cb({ status: "error", message: err });
				}

				this.log(
					"SUCCESS",
					"STATION_EXISTS_BY_ID",
					`Station "${stationId}" exists successfully.` /* , false */
				);

				return cb({ status: "success", data: { exists } });
			}
		);
	},

	/**
	 * Gets the official playlist for a station
	 * @param {object} session - user session
	 * @param {string} stationId - the station id
	 * @param {Function} cb - callback
	 */
	getPlaylist(session, stationId, cb) {
		async.waterfall(
			[
				next => {
					StationsModule.runJob("GET_STATION", { stationId }, this)
						.then(station => {
							next(null, station);
						})
						.catch(next);
				},

				(station, next) => {
					StationsModule.runJob(
						"CAN_USER_VIEW_STATION",
						{
							station,
							userId: session.userId
						},
						this
					)
						.then(canView => {
							if (canView) return next(null, station);
							return next("Insufficient permissions.");
						})
						.catch(err => next(err));
				},

				(station, next) => {
					if (!station) return next("Station not found.");
					if (station.type !== "official") return next("This is not an official station.");
					return next();
				},

				next => {
					CacheModule.runJob(
						"HGET",
						{
							table: "officialPlaylists",
							key: stationId
						},
						this
					)
						.then(playlist => {
							next(null, playlist);
						})
						.catch(next);
				},

				(playlist, next) => {
					if (!playlist) return next("Playlist not found.");
					return next(null, playlist);
				}
			],
			async (err, playlist) => {
				if (err) {
					err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
					this.log(
						"ERROR",
						"STATIONS_GET_PLAYLIST",
						`Getting playlist for station "${stationId}" failed. "${err}"`
					);
					return cb({ status: "error", message: err });
				}

				this.log(
					"SUCCESS",
					"STATIONS_GET_PLAYLIST",
					`Got playlist for station "${stationId}" successfully.`,
					false
				);

				return cb({ status: "success", data: { songs: playlist.songs } });
			}
		);
	},

	/**
	 * Joins the station by its name
	 * @param {object} session - user session
	 * @param {string} stationIdentifier - the station name or station id
	 * @param {Function} cb - callback
	 */
	async join(session, stationIdentifier, cb) {
		const userModel = await DBModule.runJob("GET_MODEL", { modelName: "user" });
		async.waterfall(
			[
				next => {
					StationsModule.runJob("GET_STATION_BY_NAME", { stationName: stationIdentifier }, this)
						.then(station => next(null, station))
						.catch(() =>
							// station identifier may be using stationid instead
							StationsModule.runJob("GET_STATION", { stationId: stationIdentifier }, this)
								.then(station => next(null, station))
								.catch(next)
						);
				},

				(station, next) => {
					if (!station) return next("Station not found.");
					return StationsModule.runJob("CAN_USER_VIEW_STATION", { station, userId: session.userId }, this)
						.then(canView => {
							if (!canView) next("Not allowed to join station.");
							else next(null, station);
						})
						.catch(err => next(err));
				},

				(station, next) => {
					WSModule.runJob("SOCKET_JOIN_ROOM", {
						socketId: session.socketId,
						room: `station.${station._id}`
					});

					const data = {
						_id: station._id,
						type: station.type,
						currentSong: station.currentSong,
						startedAt: station.startedAt,
						paused: station.paused,
						timePaused: station.timePaused,
						pausedAt: station.pausedAt,
						description: station.description,
						displayName: station.displayName,
						name: station.name,
						privacy: station.privacy,
						requests: station.requests,
						autofill: station.autofill,
						owner: station.owner,
						blacklist: station.blacklist,
						theme: station.theme,
						djs: station.djs,
						skipVoteThreshold: station.skipVoteThreshold
					};

					StationsModule.userList[session.socketId] = station._id;

					next(null, data);
				},

				(data, next) => {
					userModel.find({ _id: { $in: data.djs } }, (err, users) => {
						if (err) next(err);
						else {
							data.djs = users.map(user => {
								const { _id, name, username, avatar } = user._doc;
								return { _id, name, username, avatar };
							});
							next(null, data);
						}
					});
				},

				(data, next) => {
					data = JSON.parse(JSON.stringify(data));

					data.userCount = StationsModule.usersPerStationCount[data._id] || 0;
					data.users = StationsModule.usersPerStation[data._id] || [];

					if (!data.currentSong || !data.currentSong.title) return next(null, data);

					WSModule.runJob("SOCKET_JOIN_SONG_ROOM", {
						socketId: session.socketId,
						room: `song.${data.currentSong.mediaSource}`
					});

					data.currentSong.skipVotes = data.currentSong.skipVotes.length;

					return next(null, data);
				},

				(data, next) => {
					// only relevant if user logged in
					if (session.userId) {
						return StationsModule.runJob(
							"HAS_USER_FAVORITED_STATION",
							{
								userId: session.userId,
								stationId: data._id
							},
							this
						)
							.then(isStationFavorited => {
								data.isFavorited = isStationFavorited;
								return next(null, data);
							})
							.catch(err => next(err));
					}

					return next(null, data);
				}
			],
			async (err, data) => {
				if (err) {
					err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
					this.log("ERROR", "STATIONS_JOIN", `Joining station "${stationIdentifier}" failed. "${err}"`);
					return cb({ status: "error", message: err });
				}

				this.log("SUCCESS", "STATIONS_JOIN", `Joined station "${data._id}" successfully.`);
				return cb({ status: "success", data });
			}
		);
	},

	/**
	 * Gets a station by id
	 * @param {object} session - user session
	 * @param {string} stationId - the station id
	 * @param {Function} cb - callback
	 */
	getStationById(session, stationId, cb) {
		async.waterfall(
			[
				next => {
					StationsModule.runJob("GET_STATION", { stationId }, this)
						.then(station => {
							next(null, station);
						})
						.catch(next);
				},

				(station, next) => {
					if (!station) return next("Station not found.");
					return StationsModule.runJob(
						"CAN_USER_VIEW_STATION",
						{
							station,
							userId: session.userId
						},
						this
					)
						.then(canView => {
							if (!canView) next("Not allowed to get station.");
							else next(null, station);
						})
						.catch(err => next(err));
				},

				(station, next) => {
					// only relevant if user logged in
					if (session.userId) {
						return StationsModule.runJob(
							"HAS_USER_FAVORITED_STATION",
							{
								userId: session.userId,
								stationId
							},
							this
						)
							.then(isStationFavorited => {
								station.isFavorited = isStationFavorited;
								return next(null, station);
							})
							.catch(err => next(err));
					}

					return next(null, station);
				},

				(station, next) => {
					const data = {
						_id: station._id,
						type: station.type,
						description: station.description,
						displayName: station.displayName,
						name: station.name,
						privacy: station.privacy,
						requests: station.requests,
						autofill: station.autofill,
						owner: station.owner,
						theme: station.theme,
						paused: station.paused,
						currentSong: station.currentSong,
						isFavorited: station.isFavorited,
						djs: station.djs,
						skipVoteThreshold: station.skipVoteThreshold
					};

					next(null, data);
				}
			],
			async (err, data) => {
				if (err) {
					err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
					this.log("ERROR", "GET_STATION_BY_ID", `Getting station "${stationId}" failed. "${err}"`);
					return cb({ status: "error", message: err });
				}
				this.log("SUCCESS", "GET_STATION_BY_ID", `Got station "${stationId}" successfully.`);
				return cb({ status: "success", data: { station: data } });
			}
		);
	},

	/**
	 * Gets station history
	 * @param {object} session - user session
	 * @param {string} stationId - the station id
	 * @param {Function} cb - callback
	 */
	getHistory(session, stationId, cb) {
		async.waterfall(
			[
				next => {
					if (!config.get("experimental.station_history")) return next("Station history is not enabled");
					return next();
				},

				next => {
					StationsModule.runJob("GET_STATION", { stationId }, this)
						.then(station => {
							next(null, station);
						})
						.catch(next);
				},

				(station, next) => {
					if (!station) return next("Station not found.");
					return StationsModule.runJob(
						"CAN_USER_VIEW_STATION",
						{
							station,
							userId: session.userId
						},
						this
					)
						.then(canView => {
							if (!canView) next("Not allowed to access station history.");
							else next();
						})
						.catch(err => next(err));
				},

				next => {
					StationsModule.stationHistoryModel
						.find({ stationId }, { documentVersion: 0, __v: 0 })
						.sort({ "payload.skippedAt": -1 })
						.limit(250)
						.then(response => next(null, response))
						.catch(next);
				}
			],
			async (err, history) => {
				if (err) {
					err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
					this.log(
						"ERROR",
						"GET_STATION_HISTORY",
						`Getting station history for station "${stationId}" failed. "${err}"`
					);
					return cb({ status: "error", message: err });
				}
				this.log(
					"SUCCESS",
					"GET_STATION_HISTORY",
					`Got station history for station "${stationId}" successfully.`
				);
				return cb({ status: "success", data: { history } });
			}
		);
	},

	getStationAutofillPlaylistsById(session, stationId, cb) {
		async.waterfall(
			[
				next => {
					StationsModule.runJob("GET_STATION", { stationId }, this)
						.then(station => {
							next(null, station);
						})
						.catch(next);
				},

				(station, next) => {
					if (!station) return next("Station not found.");
					return StationsModule.runJob(
						"CAN_USER_VIEW_STATION",
						{
							station,
							userId: session.userId
						},
						this
					)
						.then(canView => {
							if (!canView) next("Not allowed to get station.");
							else next(null, station);
						})
						.catch(err => next(err));
				},

				(station, next) => {
					const playlists = [];

					async.eachLimit(
						station.autofill.playlists,
						1,
						(playlistId, next) => {
							PlaylistsModule.runJob("GET_PLAYLIST", { playlistId }, this)
								.then(playlist => {
									playlists.push(playlist);
									next();
								})
								.catch(() => {
									playlists.push(null);
									next();
								});
						},
						err => {
							next(err, playlists);
						}
					);
				}
			],
			async (err, playlists) => {
				if (err) {
					err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
					this.log(
						"ERROR",
						"GET_STATION_AUTOFILL_PLAYLISTS_BY_ID",
						`Getting station "${stationId}"'s autofilling playlists failed. "${err}"`
					);
					return cb({ status: "error", message: err });
				}
				this.log(
					"SUCCESS",
					"GET_STATION_AUTOFILL_PLAYLISTS_BY_ID",
					`Got station "${stationId}"'s autofilling playlists successfully.`
				);
				return cb({ status: "success", data: { playlists } });
			}
		);
	},

	getStationBlacklistById(session, stationId, cb) {
		async.waterfall(
			[
				next => {
					StationsModule.runJob("GET_STATION", { stationId }, this)
						.then(station => {
							next(null, station);
						})
						.catch(next);
				},

				(station, next) => {
					if (!station) return next("Station not found.");
					return StationsModule.runJob(
						"CAN_USER_VIEW_STATION",
						{
							station,
							userId: session.userId
						},
						this
					)
						.then(canView => {
							if (!canView) next("Not allowed to get station.");
							else next(null, station);
						})
						.catch(err => next(err));
				},

				(station, next) => {
					const playlists = [];

					async.eachLimit(
						station.blacklist,
						1,
						(playlistId, next) => {
							PlaylistsModule.runJob("GET_PLAYLIST", { playlistId }, this)
								.then(playlist => {
									playlists.push(playlist);
									next();
								})
								.catch(() => {
									playlists.push(null);
									next();
								});
						},
						err => {
							next(err, playlists);
						}
					);
				}
			],
			async (err, playlists) => {
				if (err) {
					err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
					this.log(
						"ERROR",
						"GET_STATION_BLACKLIST_BY_ID",
						`Getting station "${stationId}"'s blacklist failed. "${err}"`
					);
					return cb({ status: "error", message: err });
				}
				this.log(
					"SUCCESS",
					"GET_STATION_BLACKLIST_BY_ID",
					`Got station "${stationId}"'s blacklist successfully.`
				);
				return cb({ status: "success", data: { playlists } });
			}
		);
	},

	/**
	 * Toggle votes to skip a station
	 * @param {object} session - the session object automatically added by the websocket
	 * @param stationId - the station id
	 *  @param {Function} cb - gets called with the result
	 */
	toggleSkipVote: isLoginRequired(async function toggleSkipVote(session, stationId, cb) {
		const stationModel = await DBModule.runJob("GET_MODEL", { modelName: "station" }, this);

		async.waterfall(
			[
				next => {
					StationsModule.runJob("GET_STATION", { stationId }, this)
						.then(station => next(null, station))
						.catch(next);
				},

				(station, next) => {
					if (!station) return next("Station not found.");
					return StationsModule.runJob("CAN_USER_VIEW_STATION", { station, userId: session.userId }, this)
						.then(canView => {
							if (canView) return next(null, station);
							return next("Insufficient permissions.");
						})
						.catch(err => next(err));
				},

				(station, next) => {
					if (!station.currentSong) return next("There is currently no song to skip.");
					const query = {};
					const voted = station.currentSong.skipVotes.indexOf(session.userId) !== -1;
					if (!voted) query.$push = { "currentSong.skipVotes": session.userId };
					else query.$pull = { "currentSong.skipVotes": session.userId };
					return stationModel.updateOne({ _id: stationId }, query, err => {
						if (err) next(err);
						else next(null, !voted);
					});
				},

				(voted, next) => {
					StationsModule.runJob("UPDATE_STATION", { stationId }, this)
						.then(station => {
							next(null, station, voted);
						})
						.catch(next);
				},

				(station, voted, next) => {
					if (!station) return next("Station not found.");

					return StationsModule.runJob("PROCESS_SKIP_VOTES", { stationId }, this)
						.then(() => next(null, voted))
						.catch(next);
				}
			],
			async (err, voted) => {
				if (err) {
					err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
					this.log(
						"ERROR",
						"STATIONS_TOGGLE_SKIP_VOTE",
						`Toggling skip vote on "${stationId}" failed. "${err}"`
					);
					return cb({ status: "error", message: err });
				}
				this.log("SUCCESS", "STATIONS_TOGGLE_SKIP_VOTE", `Toggling skip vote on "${stationId}" successful.`);

				CacheModule.runJob("PUB", {
					channel: "station.toggleSkipVote",
					value: { stationId, voted, userId: session.userId }
				});

				return cb({
					status: "success",
					message: voted
						? "Successfully voted to skip the song."
						: "Successfully removed vote to skip the song.",
					data: { voted }
				});
			}
		);
	}),

	/**
	 * Force skips a station
	 * @param {object} session - user session
	 * @param {string} stationId - the station id
	 * @param {Function} cb - callback
	 */
	forceSkip(session, stationId, cb) {
		async.waterfall(
			[
				next => {
					hasPermission("stations.skip", session, stationId)
						.then(() => next())
						.catch(next);
				},

				next => {
					StationsModule.runJob("GET_STATION", { stationId }, this)
						.then(station => {
							next(null, station);
						})
						.catch(next);
				},

				(station, next) => {
					if (!station) return next("Station not found.");
					return next();
				}
			],
			async err => {
				if (err) {
					err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
					this.log("ERROR", "STATIONS_FORCE_SKIP", `Force skipping station "${stationId}" failed. "${err}"`);
					return cb({ status: "error", message: err });
				}
				StationsModule.runJob("SKIP_STATION", { stationId, natural: false, skipReason: "force_skip" });
				this.log("SUCCESS", "STATIONS_FORCE_SKIP", `Force skipped station "${stationId}" successfully.`);
				return cb({
					status: "success",
					message: "Successfully skipped station."
				});
			}
		);
	},

	/**
	 * Leaves the user's current station
	 * @param {object} session - user session
	 * @param {string} stationId - id of station to leave
	 * @param {Function} cb - callback
	 */
	leave(session, stationId, cb) {
		async.waterfall(
			[
				next => {
					StationsModule.runJob("GET_STATION", { stationId }, this)
						.then(station => next(null, station))
						.catch(next);
				},

				(station, next) => {
					if (!station) return next("Station not found.");
					return next();
				}
			],
			async (err, userCount) => {
				if (err) {
					err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
					this.log("ERROR", "STATIONS_LEAVE", `Leaving station "${stationId}" failed. "${err}"`);
					return cb({ status: "error", message: err });
				}

				this.log("SUCCESS", "STATIONS_LEAVE", `Left station "${stationId}" successfully.`);

				WSModule.runJob("SOCKET_LEAVE_ROOM", { socketId: session.socketId, room: `station.${stationId}` });
				WSModule.runJob("SOCKETS_LEAVE_SONG_ROOMS", { sockets: [session.socketId] });

				delete StationsModule.userList[session.socketId];

				return cb({
					status: "success",
					message: "Successfully left station.",
					data: { userCount }
				});
			}
		);
	},

	/**
	 * Updates a station's settings
	 * @param {object} session - user session
	 * @param {string} stationId - the station id
	 * @param {object} newStation - updated station object
	 * @param {Function} cb - callback
	 */
	async update(session, stationId, newStation, cb) {
		const stationModel = await DBModule.runJob("GET_MODEL", { modelName: "station" }, this);
		const playlistModel = await DBModule.runJob("GET_MODEL", { modelName: "playlist" }, this);

		async.waterfall(
			[
				next => {
					hasPermission("stations.update", session, stationId)
						.then(() => next())
						.catch(next);
				},

				next => {
					if (newStation.requests.autorequestLimit > newStation.requests.limit)
						next("The autorequest limit cannot be higher than the request limit.");
					else next();
				},

				next => {
					stationModel.findOne({ _id: stationId }, next);
				},

				(previousStation, next) => {
					const { name, displayName, description, privacy, requests, autofill, theme, skipVoteThreshold } =
						newStation;
					const { enabled, limit, mode } = autofill;
					// This object makes sure only certain properties can be changed by a user
					const setObject = {
						name,
						displayName,
						description,
						privacy,
						requests,
						"autofill.enabled": enabled,
						"autofill.limit": limit,
						"autofill.mode": mode,
						theme,
						skipVoteThreshold
					};

					stationModel.updateOne({ _id: stationId }, { $set: setObject }, { runValidators: true }, err => {
						next(err, previousStation);
					});
				},

				(previousStation, next) => {
					StationsModule.runJob("UPDATE_STATION", { stationId }, this)
						.then(station => next(null, station, previousStation))
						.catch(next);
				},

				(station, previousStation, next) => {
					if (
						newStation.autofill.enabled &&
						JSON.stringify(newStation.autofill) !== JSON.stringify(previousStation.autofill)
					)
						StationsModule.runJob("AUTOFILL_STATION", { stationId }, this)
							.then(() => {
								CacheModule.runJob("PUB", {
									channel: "station.queueUpdate",
									value: stationId
								})
									.then(() => next(null, station, previousStation))
									.catch(next);
							})
							.catch(err => {
								if (err === "Autofill is disabled in this station" || err === "Autofill limit reached")
									next(null, station, previousStation);
								else next(err);
							});
					else next(null, station, previousStation);
				},

				(station, previousStation, next) => {
					playlistModel.updateOne(
						{ _id: station.playlist },
						{ $set: { displayName: `Station - ${station.displayName}` } },
						err => {
							next(err, station, previousStation);
						}
					);
				}
			],
			async (err, station, previousStation) => {
				if (err) {
					err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);

					this.log("ERROR", "STATIONS_UPDATE", `Updating station "${stationId}" failed. "${err}"`);

					return cb({ status: "error", message: err });
				}

				this.log("SUCCESS", "STATIONS_UPDATE", `Updated station "${stationId}" successfully.`);

				CacheModule.runJob("PUB", {
					channel: "station.updated",
					value: { stationId, previousStation }
				});

				return cb({
					status: "success",
					message: "Successfully updated the station."
				});
			}
		);
	},

	/**
	 * Pauses a station
	 * @param {object} session - user session
	 * @param {string} stationId - the station id
	 * @param {Function} cb - callback
	 */
	async pause(session, stationId, cb) {
		const stationModel = await DBModule.runJob(
			"GET_MODEL",
			{
				modelName: "station"
			},
			this
		);
		async.waterfall(
			[
				next => {
					hasPermission("stations.playback.toggle", session, stationId)
						.then(() => next())
						.catch(next);
				},

				next => {
					StationsModule.runJob("GET_STATION", { stationId }, this)
						.then(station => {
							next(null, station);
						})
						.catch(next);
				},

				(station, next) => {
					if (!station) return next("Station not found.");
					if (station.paused) return next("That station was already paused.");
					return stationModel.updateOne(
						{ _id: stationId },
						{ $set: { paused: true, pausedAt: Date.now() } },
						next
					);
				},

				(res, next) => {
					StationsModule.runJob("UPDATE_STATION", { stationId }, this)
						.then(() => next())
						.catch(next);
				}
			],
			async err => {
				if (err) {
					err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
					this.log("ERROR", "STATIONS_PAUSE", `Pausing station "${stationId}" failed. "${err}"`);
					return cb({ status: "error", message: err });
				}
				this.log("SUCCESS", "STATIONS_PAUSE", `Paused station "${stationId}" successfully.`);
				CacheModule.runJob("PUB", {
					channel: "station.pause",
					value: stationId
				});
				NotificationsModule.runJob("UNSCHEDULE", {
					name: `stations.nextSong?id=${stationId}`
				});
				return cb({
					status: "success",
					message: "Successfully paused."
				});
			}
		);
	},

	/**
	 * Resumes a station
	 * @param {object} session - user session
	 * @param {string} stationId - the station id
	 * @param {Function} cb - callback
	 */
	async resume(session, stationId, cb) {
		const stationModel = await DBModule.runJob(
			"GET_MODEL",
			{
				modelName: "station"
			},
			this
		);
		async.waterfall(
			[
				next => {
					hasPermission("stations.playback.toggle", session, stationId)
						.then(() => next())
						.catch(next);
				},

				next => {
					StationsModule.runJob("GET_STATION", { stationId }, this)
						.then(station => {
							next(null, station);
						})
						.catch(next);
				},

				(station, next) => {
					if (!station) return next("Station not found.");
					if (!station.paused) return next("That station is not paused.");
					station.timePaused += Date.now() - station.pausedAt;
					return stationModel.updateOne(
						{ _id: stationId },
						{
							$set: { paused: false },
							$inc: { timePaused: Date.now() - station.pausedAt }
						},
						next
					);
				},

				(res, next) => {
					StationsModule.runJob("UPDATE_STATION", { stationId }, this)
						.then(() => next())
						.catch(next);
				},

				next => {
					StationsModule.runJob("PROCESS_SKIP_VOTES", { stationId }, this)
						.then(() => next())
						.catch(next);
				}
			],
			async err => {
				if (err) {
					err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
					this.log("ERROR", "STATIONS_RESUME", `Resuming station "${stationId}" failed. "${err}"`);
					return cb({ status: "error", message: err });
				}
				this.log("SUCCESS", "STATIONS_RESUME", `Resuming station "${stationId}" successfully.`);
				CacheModule.runJob("PUB", {
					channel: "station.resume",
					value: stationId
				});
				return cb({
					status: "success",
					message: "Successfully resumed."
				});
			}
		);
	},

	/**
	 * Removes a station
	 * @param {object} session - user session
	 * @param {string} stationId - the station id
	 * @param {Function} cb - callback
	 */
	async remove(session, stationId, cb) {
		const stationModel = await DBModule.runJob("GET_MODEL", { modelName: "station" }, this);
		const userModel = await DBModule.runJob("GET_MODEL", { modelName: "user" }, this);

		async.waterfall(
			[
				next => {
					hasPermission("stations.remove", session, stationId)
						.then(() => next())
						.catch(next);
				},

				next => {
					stationModel.findById(stationId, (err, station) => {
						if (err) return next(err);
						return next(null, station);
					});
				},

				(station, next) => {
					stationModel.deleteOne({ _id: stationId }, err => next(err, station));
				},

				(station, next) => {
					CacheModule.runJob("HDEL", { table: "stations", key: stationId }, this)
						.then(() => next(null, station))
						.catch(next);
				},

				// remove the playlist for the station
				(station, next) => {
					if (station.playlist)
						PlaylistsModule.runJob("DELETE_PLAYLIST", { playlistId: station.playlist })
							.then(() => {})
							.catch(next);
					next(null, station);
				},

				// remove reference to the station id in any array of a user's favorite stations
				(station, next) => {
					userModel.updateMany(
						{ favoriteStations: stationId },
						{ $pull: { favoriteStations: stationId } },
						err => next(err, station)
					);
				}
			],
			async (err, station) => {
				if (err) {
					err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
					this.log("ERROR", "STATIONS_REMOVE", `Removing station "${stationId}" failed. "${err}"`);
					return cb({ status: "error", message: err });
				}

				this.log("SUCCESS", "STATIONS_REMOVE", `Removing station "${stationId}" successfully.`);

				CacheModule.runJob("PUB", {
					channel: "station.remove",
					value: stationId
				});

				ActivitiesModule.runJob("ADD_ACTIVITY", {
					userId: session.userId,
					type: "station__remove",
					payload: { message: `Removed a station named ${station.displayName}` }
				});

				ActivitiesModule.runJob("REMOVE_ACTIVITY_REFERENCES", { type: "stationId", stationId });

				return cb({
					status: "success",
					message: "Successfully removed."
				});
			}
		);
	},

	/**
	 * Create a station
	 * @param {object} session - the session object automatically added by the websocket
	 * @param data - the station data
	 *  @param {Function} cb - gets called with the result
	 */
	create: isLoginRequired(async function create(session, data, cb) {
		const stationModel = await DBModule.runJob("GET_MODEL", { modelName: "station" }, this);
		const playlistModel = await DBModule.runJob("GET_MODEL", { modelName: "playlist" }, this);

		data.name = data.name.toLowerCase();

		let blacklist = [
			"about",
			"support",
			"staff",
			"help",
			"news",
			"terms",
			"privacy",
			"profile",
			"c",
			"community",
			"tos",
			"login",
			"register",
			"p",
			"official",
			"o",
			"faq",
			"team",
			"donate",
			"buy",
			"shop",
			"forums",
			"explore",
			"settings",
			"admin",
			"auth",
			"reset_password",
			"backend",
			"api",
			"songs",
			"playlists",
			"playlist",
			"albums",
			"artists",
			"artist",
			"station"
		];

		if (data.type === "community") blacklist = [...blacklist, ...config.get("blacklistedCommunityStationNames")];

		async.waterfall(
			[
				next => {
					if (!data) return next("Invalid data.");
					return next();
				},

				next => {
					stationModel.findOne(
						{
							$or: [{ name: data.name }, { displayName: new RegExp(`^${data.displayName}$`, "i") }]
						},
						next
					);
				},

				(station, next) => {
					this.log(station);

					if (station) return next("A station with that name or display name already exists.");

					if (blacklist.indexOf(data.name) !== -1)
						return next("That name is blacklisted. Please use a different name.");

					if (data.type === "official")
						return hasPermission("stations.create.official", session)
							.then(() => next())
							.catch(() => next("Insufficient permissions."));
					return next();
				},

				next => {
					const stationId = mongoose.Types.ObjectId();
					playlistModel.create(
						{
							displayName: `Station - ${data.name}`,
							songs: [],
							createdBy: data.type === "official" ? "Musare" : session.userId,
							createdFor: `${stationId}`,
							createdAt: Date.now(),
							type: "station"
						},
						(err, playlist) => {
							next(err, playlist, stationId);
						}
					);
				},

				(playlist, stationId, next) => {
					const { name, displayName, description, type } = data;
					if (type === "official") {
						stationModel.create(
							{
								_id: stationId,
								name,
								displayName,
								description,
								playlist: playlist._id,
								type,
								privacy: "private",
								queue: [],
								currentSong: null
							},
							next
						);
					} else {
						stationModel.create(
							{
								_id: stationId,
								name,
								displayName,
								description,
								playlist: playlist._id,
								type,
								privacy: "private",
								owner: session.userId,
								queue: [],
								currentSong: null
							},
							next
						);
					}
				},

				// This extra step is needed because Mongoose decides to create an object with empty arrays for currentSong for some reason
				(station, next) => {
					stationModel.updateOne(
						{ _id: station._id },
						{
							$set: {
								currentSong: null
							}
						},
						err => {
							next(err, station);
						}
					);
				}
			],
			async (err, station) => {
				if (err) {
					err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
					this.log("ERROR", "STATIONS_CREATE", `Creating station failed. "${err}"`);
					cb({ status: "error", message: err });
				} else {
					this.log("SUCCESS", "STATIONS_CREATE", `Created station "${station._id}" successfully.`);

					CacheModule.runJob("PUB", {
						channel: "station.create",
						value: station._id
					});

					ActivitiesModule.runJob("ADD_ACTIVITY", {
						userId: session.userId,
						type: "station__create",
						payload: {
							message: `Created a station named <stationId>${station.displayName}</stationId>`,
							stationId: station._id
						}
					});

					cb({
						status: "success",
						message: "Successfully created station."
					});
				}
			}
		);
	}),

	/**
	 * Adds song to station queue
	 * @param {object} session - the session object automatically added by the websocket
	 * @param stationId - the station id
	 * @param mediaSource - the song id
	 * @param requestType - whether the song was autorequested or requested normally
	 *  @param {Function} cb - gets called with the result
	 */
	addToQueue: isLoginRequired(async function addToQueue(session, stationId, mediaSource, requestType, cb) {
		async.waterfall(
			[
				next => {
					StationsModule.runJob("GET_STATION", { stationId }, this)
						.then(station => {
							next(null, station);
						})
						.catch(next);
				},

				(station, next) => {
					if (!station) return next("Station not found.");
					if (!station.requests.enabled) return next("Requests are disabled in this station.");

					if (
						station.requests.access === "owner" ||
						(station.requests.access === "user" && station.privacy === "private")
					) {
						return hasPermission("stations.request", session, stationId)
							.then(() => next(null, station))
							.catch(() => next("You do not have permission to add songs to queue."));
					}

					return next(null, station);
				},

				(station, next) =>
					StationsModule.runJob(
						"CAN_USER_VIEW_STATION",
						{
							station,
							userId: session.userId
						},
						this
					)
						.then(canView => {
							if (canView) return next();
							return next("Insufficient permissions.");
						})
						.catch(err => next(err)),

				next =>
					StationsModule.runJob(
						"ADD_TO_QUEUE",
						{
							stationId,
							mediaSource,
							requestUser: session.userId,
							requestType
						},
						this
					)
						.then(() => next())
						.catch(next)
			],
			async err => {
				if (err) {
					err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
					this.log(
						"ERROR",
						"STATIONS_ADD_SONG_TO_QUEUE",
						`Adding song "${mediaSource}" to station "${stationId}" queue failed. "${err}"`
					);
					return cb({ status: "error", message: err });
				}

				this.log(
					"SUCCESS",
					"STATIONS_ADD_SONG_TO_QUEUE",
					`Added song "${mediaSource}" to station "${stationId}" successfully.`
				);

				return cb({
					status: "success",
					message: "Successfully added song to queue."
				});
			}
		);
	}),

	/**
	 * Removes song from station queue
	 * @param {object} session - user session
	 * @param {string} stationId - the station id
	 * @param {string} mediaSource - the media source
	 * @param {Function} cb - callback
	 */
	async removeFromQueue(session, stationId, mediaSource, cb) {
		async.waterfall(
			[
				next => {
					hasPermission("stations.queue.remove", session, stationId)
						.then(() => next())
						.catch(next);
				},

				next => {
					if (!mediaSource) return next("Invalid media source.");
					return StationsModule.runJob("REMOVE_FROM_QUEUE", { stationId, mediaSource }, this)
						.then(() => next())
						.catch(next);
				}
			],
			async err => {
				if (err) {
					err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
					this.log(
						"ERROR",
						"STATIONS_REMOVE_SONG_TO_QUEUE",
						`Removing song "${mediaSource}" from station "${stationId}" queue failed. "${err}"`
					);
					return cb({ status: "error", message: err });
				}

				this.log(
					"SUCCESS",
					"STATIONS_REMOVE_SONG_TO_QUEUE",
					`Removed song "${mediaSource}" from station "${stationId}" successfully.`
				);

				return cb({
					status: "success",
					message: "Successfully removed song from queue."
				});
			}
		);
	},

	/**
	 * Gets the queue from a station
	 * @param {object} session - user session
	 * @param {string} stationId - the station id
	 * @param {Function} cb - callback
	 */
	getQueue(session, stationId, cb) {
		async.waterfall(
			[
				next => {
					StationsModule.runJob("GET_STATION", { stationId }, this)
						.then(station => next(null, station))
						.catch(next);
				},

				(station, next) => {
					if (!station) return next("Station not found.");
					return next(null, station);
				},

				(station, next) => {
					StationsModule.runJob("CAN_USER_VIEW_STATION", { station, userId: session.userId }, this)
						.then(canView => {
							if (canView) return next(null, station);
							return next("Insufficient permissions.");
						})
						.catch(err => next(err));
				},

				(station, next) => next(null, station.queue)
			],
			async (err, queue) => {
				if (err) {
					err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
					this.log(
						"ERROR",
						"STATIONS_GET_QUEUE",
						`Getting queue for station "${stationId}" failed. "${err}"`
					);
					return cb({ status: "error", message: err });
				}

				this.log("SUCCESS", "STATIONS_GET_QUEUE", `Got queue for station "${stationId}" successfully.`);

				return cb({
					status: "success",
					message: "Successfully got queue.",
					data: { queue }
				});
			}
		);
	},

	/**
	 * Reposition a song in station queue
	 * @param {object} session - user session
	 * @param {string} stationId - the station id
	 * @param {object} song - contains details about the song that is to be repositioned
	 * @param {string} song.mediaSource - the media source of the song
	 * @param {number} song.newIndex - the new position for the song in the queue
	 * @param {number} song.oldIndex - the old position of the song in the queue
	 * @param {Function} cb - callback
	 */
	async repositionSongInQueue(session, stationId, song, cb) {
		const stationModel = await DBModule.runJob("GET_MODEL", { modelName: "station" }, this);

		async.waterfall(
			[
				next => {
					hasPermission("stations.queue.reposition", session, stationId)
						.then(() => next())
						.catch(next);
				},

				next => {
					if (!song || !song.mediaSource) return next("You must provide a song to reposition.");
					return next();
				},

				// remove song from queue
				next => {
					stationModel.updateOne(
						{ _id: stationId },
						{ $pull: { queue: { mediaSource: song.mediaSource } } },
						next
					);
				},

				// add song back to queue (in new position)
				(res, next) => {
					stationModel.updateOne(
						{ _id: stationId },
						{ $push: { queue: { $each: [song], $position: song.newIndex } } },
						err => next(err)
					);
				},

				// update the cache representation of the station
				next => {
					StationsModule.runJob("UPDATE_STATION", { stationId }, this)
						.then(station => next(null, station))
						.catch(next);
				}
			],
			async (err, station) => {
				if (err) {
					err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
					this.log(
						"ERROR",
						"STATIONS_REPOSITION_SONG_IN_QUEUE",
						`Repositioning song ${song.mediaSource} in queue of station "${stationId}" failed. "${err}"`
					);
					return cb({ status: "error", message: err });
				}

				this.log(
					"SUCCESS",
					"STATIONS_REPOSITION_SONG_IN_QUEUE",
					`Repositioned song ${song.mediaSource} in queue of station "${stationId}" successfully.`
				);

				const queueOrder = station.queue.map(song => song.mediaSource);

				CacheModule.runJob("PUB", {
					channel: "station.changeQueueOrder",
					value: {
						queueOrder,
						stationId
					}
				});

				return cb({
					status: "success",
					message: "Successfully repositioned song in queue."
				});
			}
		);
	},

	/**
	 * Autofill a playlist in a station
	 * @param {object} session - user session
	 * @param {string} stationId - the station id
	 * @param {string} playlistId - the playlist id
	 * @param {Function} cb - callback
	 */
	async autofillPlaylist(session, stationId, playlistId, cb) {
		async.waterfall(
			[
				next => {
					hasPermission("stations.autofill", session, stationId)
						.then(() => next())
						.catch(next);
				},

				next => {
					StationsModule.runJob("GET_STATION", { stationId }, this)
						.then(station => next(null, station))
						.catch(next);
				},

				(station, next) => {
					PlaylistsModule.runJob("GET_PLAYLIST", { playlistId }, this)
						.then(playlist => next(null, station, playlist))
						.catch(next);
				},

				(station, playlist, next) => {
					if (!playlist) return next("Playlist not found");
					if (playlist.privacy !== "public" && playlist.createdBy !== session.userId)
						return hasPermission("playlists.get", session)
							.then(() => next(null, station, playlist))
							.catch(() => next("User unauthorised to view playlist."));
					return next(null, station, playlist);
				},

				(station, playlist, next) => {
					if (!station) return next("Station not found.");
					if (station.type === "official" && ["genre", "admin"].indexOf(playlist.type) === -1)
						return next("Official statuibs are only allowed to autofill genre and admin playlists.");
					if (
						station.type === "community" &&
						["user", "user-liked", "user-disliked", "genre", "admin"].indexOf(playlist.type) === -1
					)
						return next("Community stations are only allowed to autofill user, genre and admin playlists.");
					if (station.autofill.playlists.indexOf(playlistId) !== -1)
						return next("That playlist is already autofilling.");
					if (station.autofill.mode === "sequential" && station.autofill.playlists.length > 0)
						return next("Error: Only 1 playlist can be autofilling in sequential mode.");
					return next();
				},

				next => {
					StationsModule.runJob("AUTOFILL_PLAYLIST", { stationId, playlistId }, this)
						.then(() => {
							next();
						})
						.catch(next);
				}
			],
			async err => {
				if (err) {
					err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
					this.log(
						"ERROR",
						"STATIONS_AUTOFILL_PLAYLIST",
						`Including playlist "${playlistId}" for station "${stationId}" failed. "${err}"`
					);
					return cb({ status: "error", message: err });
				}

				this.log(
					"SUCCESS",
					"STATIONS_AUTOFILL_PLAYLIST",
					`Including playlist "${playlistId}" for station "${stationId}" successfully.`
				);

				PlaylistsModule.runJob("AUTOFILL_STATION_PLAYLIST", { stationId }).then().catch();

				CacheModule.runJob("PUB", {
					channel: "station.autofillPlaylist",
					value: {
						playlistId,
						stationId
					}
				});

				return cb({
					status: "success",
					message: "Successfully added autofill playlist."
				});
			}
		);
	},

	/**
	 * Remove autofilled playlist from a station
	 * @param {object} session - user session
	 * @param {string} stationId - the station id
	 * @param {string} playlistId - the playlist id
	 * @param {Function} cb - callback
	 */
	async removeAutofillPlaylist(session, stationId, playlistId, cb) {
		async.waterfall(
			[
				next => {
					hasPermission("stations.autofill", session, stationId)
						.then(() => next())
						.catch(next);
				},

				next => {
					StationsModule.runJob("GET_STATION", { stationId }, this)
						.then(station => next(null, station))
						.catch(next);
				},

				(station, next) => {
					if (!station) return next("Station not found.");
					if (station.autofill.playlists.indexOf(playlistId) === -1)
						return next("That playlist is not autofilling.");
					return next();
				},

				next => {
					StationsModule.runJob("REMOVE_AUTOFILL_PLAYLIST", { stationId, playlistId }, this)
						.then(() => {
							next();
						})
						.catch(next);
				}
			],
			async err => {
				if (err) {
					err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
					this.log(
						"ERROR",
						"STATIONS_REMOVE_AUTOFILL_PLAYLIST",
						`Removing autofill playlist "${playlistId}" for station "${stationId}" failed. "${err}"`
					);
					return cb({ status: "error", message: err });
				}

				this.log(
					"SUCCESS",
					"STATIONS_REMOVE_AUTOFILL_PLAYLIST",
					`Removing autofill playlist "${playlistId}" for station "${stationId}" successfully.`
				);

				PlaylistsModule.runJob("AUTOFILL_STATION_PLAYLIST", { stationId }).then().catch();

				CacheModule.runJob("PUB", {
					channel: "station.removedAutofillPlaylist",
					value: {
						playlistId,
						stationId
					}
				});

				return cb({
					status: "success",
					message: "Successfully removed autofill playlist."
				});
			}
		);
	},

	/**
	 * Blacklist a playlist in a station
	 * @param {object} session - user session
	 * @param {string} stationId - the station id
	 * @param {string} playlistId - the playlist id
	 * @param {Function} cb - callback
	 */
	async blacklistPlaylist(session, stationId, playlistId, cb) {
		async.waterfall(
			[
				next => {
					hasPermission("stations.blacklist", session, stationId)
						.then(() => next())
						.catch(next);
				},

				next => {
					StationsModule.runJob("GET_STATION", { stationId }, this)
						.then(station => next(null, station))
						.catch(next);
				},

				(station, next) => {
					if (!station) return next("Station not found.");
					if (station.blacklist.indexOf(playlistId) !== -1)
						return next("That playlist is already blacklisted.");
					return next();
				},

				next => {
					StationsModule.runJob("BLACKLIST_PLAYLIST", { stationId, playlistId }, this)
						.then(() => {
							next();
						})
						.catch(next);
				}
			],
			async err => {
				if (err) {
					err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
					this.log(
						"ERROR",
						"STATIONS_BLACKLIST_PLAYLIST",
						`Blacklisting playlist "${playlistId}" for station "${stationId}" failed. "${err}"`
					);
					return cb({ status: "error", message: err });
				}

				this.log(
					"SUCCESS",
					"STATIONS_BLACKLIST_PLAYLIST",
					`Blacklisting playlist "${playlistId}" for station "${stationId}" successfully.`
				);

				PlaylistsModule.runJob("AUTOFILL_STATION_PLAYLIST", { stationId }).then().catch();

				CacheModule.runJob("PUB", {
					channel: "station.blacklistedPlaylist",
					value: {
						playlistId,
						stationId
					}
				});

				return cb({
					status: "success",
					message: "Successfully blacklisted playlist."
				});
			}
		);
	},

	/**
	 * Remove blacklisted a playlist from a station
	 * @param {object} session - user session
	 * @param {string} stationId - the station id
	 * @param {string} playlistId - the playlist id
	 * @param {Function} cb - callback
	 */
	async removeBlacklistedPlaylist(session, stationId, playlistId, cb) {
		async.waterfall(
			[
				next => {
					hasPermission("stations.blacklist", session, stationId)
						.then(() => next())
						.catch(next);
				},

				next => {
					StationsModule.runJob("GET_STATION", { stationId }, this)
						.then(station => next(null, station))
						.catch(next);
				},

				(station, next) => {
					if (!station) return next("Station not found.");
					if (station.blacklist.indexOf(playlistId) === -1) return next("That playlist is not blacklisted.");
					return next();
				},

				next => {
					StationsModule.runJob("REMOVE_BLACKLISTED_PLAYLIST", { stationId, playlistId }, this)
						.then(() => {
							next();
						})
						.catch(next);
				}
			],
			async err => {
				if (err) {
					err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
					this.log(
						"ERROR",
						"STATIONS_REMOVE_BLACKLISTED_PLAYLIST",
						`Removing blacklisted playlist "${playlistId}" for station "${stationId}" failed. "${err}"`
					);
					return cb({ status: "error", message: err });
				}

				this.log(
					"SUCCESS",
					"STATIONS_REMOVE_BLACKLISTED_PLAYLIST",
					`Removing blacklisted playlist "${playlistId}" for station "${stationId}" successfully.`
				);

				PlaylistsModule.runJob("AUTOFILL_STATION_PLAYLIST", { stationId }).then().catch();

				CacheModule.runJob("PUB", {
					channel: "station.removedBlacklistedPlaylist",
					value: {
						playlistId,
						stationId
					}
				});

				return cb({
					status: "success",
					message: "Successfully removed blacklisted playlist."
				});
			}
		);
	},

	/**
	 * Favorites a station
	 * @param {object} session - the session object automatically added by the websocket
	 * @param {string} stationId - the station to favorite
	 * @param {Function} cb - gets called with the result
	 */
	favoriteStation: isLoginRequired(async function favoriteStation(session, stationId, cb) {
		const userModel = await DBModule.runJob("GET_MODEL", { modelName: "user" }, this);
		async.waterfall(
			[
				next => {
					StationsModule.runJob("GET_STATION", { stationId }, this)
						.then(station => next(null, station))
						.catch(next);
				},

				(station, next) => {
					if (!station) return next("Station not found.");
					return StationsModule.runJob("CAN_USER_VIEW_STATION", { station, userId: session.userId }, this)
						.then(canView => {
							if (canView) return next(null, station);
							return next("Insufficient permissions.");
						})
						.catch(err => next(err));
				},

				(station, next) => {
					userModel.updateOne(
						{ _id: session.userId },
						{ $addToSet: { favoriteStations: stationId } },
						(err, res) => next(err, station, res)
					);
				},

				(station, res, next) => {
					if (res.nModified === 0) return next("The station was already favorited.");
					return next(null, station);
				}
			],
			async (err, station) => {
				if (err) {
					err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
					this.log("ERROR", "FAVORITE_STATION", `Favoriting station "${stationId}" failed. "${err}"`);
					return cb({ status: "error", message: err });
				}

				this.log("SUCCESS", "FAVORITE_STATION", `Favorited station "${stationId}" successfully.`);

				CacheModule.runJob("PUB", {
					channel: "user.favoritedStation",
					value: {
						userId: session.userId,
						stationId
					}
				});

				ActivitiesModule.runJob("ADD_ACTIVITY", {
					userId: session.userId,
					type: "station__favorite",
					payload: {
						message: `Favorited station <stationId>${station.displayName}</stationId>`,
						stationId
					}
				});

				return cb({
					status: "success",
					message: "Succesfully favorited station."
				});
			}
		);
	}),

	/**
	 * Unfavorites a station
	 * @param {object} session - the session object automatically added by the websocket
	 * @param {string} stationId - the station to unfavorite
	 * @param {Function} cb - gets called with the result
	 */
	unfavoriteStation: isLoginRequired(async function unfavoriteStation(session, stationId, cb) {
		const userModel = await DBModule.runJob("GET_MODEL", { modelName: "user" }, this);

		async.waterfall(
			[
				next => {
					userModel.updateOne({ _id: session.userId }, { $pull: { favoriteStations: stationId } }, next);
				},

				(res, next) => {
					if (res.nModified === 0) return next("The station wasn't favorited.");
					return next();
				},

				next => {
					StationsModule.runJob("GET_STATION", { stationId }, this)
						.then(station => next(null, station))
						.catch(next);
				}
			],
			async (err, station) => {
				if (err) {
					err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
					this.log("ERROR", "UNFAVORITE_STATION", `Unfavoriting station "${stationId}" failed. "${err}"`);
					return cb({ status: "error", message: err });
				}

				this.log("SUCCESS", "UNFAVORITE_STATION", `Unfavorited station "${stationId}" successfully.`);

				CacheModule.runJob("PUB", {
					channel: "user.unfavoritedStation",
					value: {
						userId: session.userId,
						stationId
					}
				});

				ActivitiesModule.runJob("ADD_ACTIVITY", {
					userId: session.userId,
					type: "station__unfavorite",
					payload: {
						message: `Unfavorited station <stationId>${station.displayName}</stationId>`,
						stationId
					}
				});

				return cb({
					status: "success",
					message: "Succesfully unfavorited station."
				});
			}
		);
	}),

	/**
	 * Clears every station queue
	 * @param {object} session - the session object automatically added by the websocket
	 * @param {Function} cb - gets called with the result
	 */
	clearEveryStationQueue: useHasPermission(
		"stations.clearEveryStationQueue",
		async function clearEveryStationQueue(session, cb) {
			this.keepLongJob();
			this.publishProgress({
				status: "started",
				title: "Clear every station queue",
				message: "Clearing every station queue.",
				id: this.toString()
			});
			await CacheModule.runJob("RPUSH", { key: `longJobs.${session.userId}`, value: this.toString() }, this);
			await CacheModule.runJob(
				"PUB",
				{
					channel: "longJob.added",
					value: { jobId: this.toString(), userId: session.userId }
				},
				this
			);

			async.waterfall(
				[
					next => {
						StationsModule.runJob("CLEAR_EVERY_STATION_QUEUE", {}, this)
							.then(() => next())
							.catch(next);
					}
				],
				async err => {
					if (err) {
						err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
						this.log("ERROR", "CLEAR_EVERY_STATION_QUEUE", `Clearing every station queue failed. "${err}"`);
						this.publishProgress({
							status: "error",
							message: err
						});
						return cb({ status: "error", message: err });
					}
					this.log("SUCCESS", "CLEAR_EVERY_STATION_QUEUE", "Clearing every station queue was successful.");
					this.publishProgress({
						status: "success",
						message: "Successfully cleared every station queue."
					});
					return cb({ status: "success", message: "Successfully cleared every station queue." });
				}
			);
		}
	),

	/**
	 * Reset a station queue
	 * @param {object} session - the session object automatically added by the websocket
	 * @param {string} stationId - the station id
	 * @param {Function} cb - gets called with the result
	 */
	async resetQueue(session, stationId, cb) {
		async.waterfall(
			[
				next => {
					hasPermission("stations.queue.reset", session, stationId)
						.then(() => next())
						.catch(next);
				},

				next => {
					StationsModule.runJob("RESET_QUEUE", { stationId }, this)
						.then(() => next())
						.catch(next);
				}
			],
			async err => {
				if (err) {
					err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
					this.log("ERROR", "RESET_QUEUE", `Resetting station queue failed. "${err}"`);
					return cb({ status: "error", message: err });
				}
				this.log("SUCCESS", "RESET_QUEUE", "Resetting station queue was successful.");
				return cb({ status: "success", message: "Successfully reset station queue." });
			}
		);
	},

	/**
	 * Gets skip votes for a station
	 * @param {object} session - the session object automatically added by the websocket
	 * @param {string} stationId - the station id
	 * @param {string} songId - the song id to get skipvotes for
	 * @param {Function} cb - gets called with the result
	 */

	getSkipVotes: isLoginRequired(async function getSkipVotes(session, stationId, songId, cb) {
		async.waterfall(
			[
				next => {
					StationsModule.runJob("GET_STATION", { stationId }, this)
						.then(res => next(null, res.currentSong))
						.catch(console.log);
				},

				(currentSong, next) => {
					if (currentSong && currentSong._id === songId)
						next(null, {
							skipVotes: currentSong.skipVotes.length,
							skipVotesCurrent: true,
							voted: currentSong.skipVotes.indexOf(session.userId) !== -1
						});
					else
						next(null, {
							skipVotes: 0,
							skipVotesCurrent: false,
							voted: false
						});
				}
			],
			async (err, data) => {
				if (err) {
					err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
					this.log(
						"ERROR",
						"STATIONS_GET_SKIP_VOTES",
						`User "${session.userId}" failed to get skip votes for ${stationId}. "${err}"`
					);
					return cb({ status: "error", message: err });
				}

				return cb({
					status: "success",
					data
				});
			}
		);
	}),

	/**
	 * Add DJ to station
	 * @param {object} session - the session object automatically added by the websocket
	 * @param {string} stationId - the station id
	 * @param {string} userId - the dj user id
	 * @param {Function} cb - gets called with the result
	 */
	async addDj(session, stationId, userId, cb) {
		async.waterfall(
			[
				next => {
					hasPermission("stations.djs.add", session, stationId)
						.then(() => next())
						.catch(next);
				},

				next => {
					StationsModule.runJob("ADD_DJ", { stationId, userId }, this)
						.then(() => next())
						.catch(next);
				}
			],
			async err => {
				if (err) {
					err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
					this.log("ERROR", "ADD_DJ", `Adding DJ failed. "${err}"`);
					return cb({ status: "error", message: err });
				}
				this.log("SUCCESS", "ADD_DJ", "Adding DJ was successful.");
				return cb({ status: "success", message: "Successfully added DJ." });
			}
		);
	},

	/**
	 * Remove DJ from station
	 * @param {object} session - the session object automatically added by the websocket
	 * @param {string} stationId - the station id
	 * @param {string} userId - the dj user id
	 * @param {Function} cb - gets called with the result
	 */
	async removeDj(session, stationId, userId, cb) {
		async.waterfall(
			[
				next => {
					hasPermission("stations.djs.remove", session, stationId)
						.then(() => next())
						.catch(next);
				},

				next => {
					StationsModule.runJob("REMOVE_DJ", { stationId, userId }, this)
						.then(() => next())
						.catch(next);
				}
			],
			async err => {
				if (err) {
					err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
					this.log("ERROR", "REMOVE_DJ", `Removing DJ failed. "${err}"`);
					return cb({ status: "error", message: err });
				}
				this.log("SUCCESS", "REMOVE_DJ", "Removing DJ was successful.");
				return cb({ status: "success", message: "Successfully removed DJ." });
			}
		);
	},

	/**
	 * Sets the state of the current user session
	 * @param {object} session - the session object automatically added by the websocket
	 * @param {string} newStationState - the new state
	 * @param {Function} cb - gets called with the result
	 */
	setStationState(session, newStationState, cb) {
		session.stationState = newStationState;

		cb({ status: "success" });
	}
};