const osu = require("osu-packet"),
	  fs = require("fs"),
	  consoleHelper = require("../consoleHelper.js"),
	  packetIDs = require("./packetIDs.js"),
	  loginHandler = require("./loginHandler.js"),
	  parseUserData = require("./util/parseUserData.js"),
	  User = require("./User.js"),
	  getUserFromToken = require("./util/getUserByToken.js"),
	  getUserById = require("./util/getUserById.js"),
	  bakedResponses = require("./bakedResponses.js"),
	  Streams = require("./Streams.js"),
	  DatabaseHelperClass = require("./DatabaseHelper.js"),
	  funkyArray = require("./util/funkyArray.js"),
	  config = require("../config.json");

// Users funkyArray for session storage
global.users = new funkyArray();

// Add the bot user
global.botUser = global.users.add("bot", new User(3, "SillyBot", "bot"));
// Set the bot's position on the map
global.botUser.location[0] = 50;
global.botUser.location[1] = -32;

global.DatabaseHelper = new DatabaseHelperClass(config.databaseAddress, config.databasePort, config.databaseUsername, config.databasePassword, config.databaseName);

async function subscribeToChannel(channelName = "", callback = function(message) {})  {
	// Dup and connect new client for channel subscription (required)
	const scoreSubmitUpdateClient = global.promClient.duplicate();
	await scoreSubmitUpdateClient.connect();
	// Subscribe to channel
	await scoreSubmitUpdateClient.subscribe(channelName, callback);
	consoleHelper.printBancho(`Subscribed to ${channelName} channel`);
}

// Do redis if it's enabled
if (config.redisEnabled) {
	(async () => {
		const { createClient } = require("redis");
		global.promClient = createClient({
			url: `redis://${config.redisPassword.replaceAll(" ", "") == "" ? "" : `${config.redisPassword}@`}${config.redisAddress}:${config.redisPort}/${config.redisDatabase}`
		});

		global.promClient.on('error', e => consoleHelper.printBancho(e));

		const connectionStartTime = Date.now();
		await global.promClient.connect();
		consoleHelper.printBancho(`Connected to redis server. Took ${Date.now() - connectionStartTime}ms`);

		// Score submit update channel
		subscribeToChannel("binato:update_user_stats", (message) => {
			// Update user info
			getUserById(parseInt(message)).updateUserInfo(true);
		});
	})();
} else consoleHelper.printWarn("Redis is disabled!");

// User timeout interval
setInterval(() => {
	for (let User of global.users.getIterableItems()) {
		if (User.id == 3) continue; // Ignore the bot
									// Bot: :(

		// Logout this user, they're clearly gone.
		if (Date.now() >= User.timeoutTime)
			Logout(User);
	}
}, 10000);

// An array containing the last 15 messages in chat
global.chatHistory = [];
global.addChatMessage = function(msg) {
	if (global.chatHistory.length == 15) {
		global.chatHistory.splice(0, 1);
		global.chatHistory.push(msg);
	} else {
		global.chatHistory.push(msg);
	}
}

global.StreamsHandler = new Streams();

// An array containing all chat channels
global.channels = [
	{ channelName:"#osu", channelTopic:"The main channel", channelUserCount: 0, locked: false },
	{ channelName:"#userlog", channelTopic:"Log about stuff doing go on yes very", channelUserCount: 0, locked: false },
	{ channelName:"#lobby", channelTopic:"Talk about multiplayer stuff", channelUserCount: 0, locked: false },
	{ channelName:"#english", channelTopic:"Talk in exclusively English", channelUserCount: 0, locked: false },
	{ channelName:"#japanese", channelTopic:"Talk in exclusively Japanese", channelUserCount: 0, locked: false },
];

// Create a stream for each chat channel
for (let i = 0; i < global.channels.length; i++) {
	global.StreamsHandler.addStream(global.channels[i].channelName, false);
}

// Add a stream for the multiplayer lobby
global.StreamsHandler.addStream("multiplayer_lobby", false);

if (!fs.existsSync("tHMM.ds")) fs.writeFileSync("tHMM.ds", "0");
global.totalHistoricalMultiplayerMatches = parseInt(fs.readFileSync("tHMM.ds").toString());
global.getAndAddToHistoricalMultiplayerMatches = function() {
	global.totalHistoricalMultiplayerMatches++;
	fs.writeFile("tHMM.ds", `${global.totalHistoricalMultiplayerMatches}`, () => {});
	return global.totalHistoricalMultiplayerMatches;
}

// Include packets
const ChangeAction = require("./Packets/ChangeAction.js"),
	  SendPublicMessage = require("./Packets/SendPublicMessage.js"),
	  Logout = require("./Packets/Logout.js"),
	  Spectator = require("./Spectator.js"),
	  SendPrivateMessage = require("./Packets/SendPrivateMessage.js"),
	  MultiplayerManager = require("./MultiplayerManager.js"),
	  SetAwayMessage = require("./Packets/SetAwayMessage.js"),
	  ChannelJoin = require("./Packets/ChannelJoin.js"),
	  ChannelPart = require("./Packets/ChannelPart.js"),
	  AddFriend = require("./Packets/AddFriend.js"),
	  RemoveFriend = require("./Packets/RemoveFriend.js"),
	  UserPresenceBundle = require("./Packets/UserPresenceBundle.js"),
	  UserPresence = require("./Packets/UserPresence.js"),
	  UserStatsRequest = require("./Packets/UserStatsRequest.js"),
	  MultiplayerInvite = require("./Packets/MultiplayerInvite.js"),
	  TourneyMatchSpecialInfo = require("./Packets/TourneyMatchSpecialInfo.js"),
	  TourneyMatchJoinChannel = require("./Packets/TourneyMatchSpecialInfo.js"),
	  TourneyMatchLeaveChannel = require("./Packets/TourneyLeaveMatchChannel.js");

// A class for managing everything multiplayer
global.MultiplayerManager = new MultiplayerManager();

module.exports = async function(req, res) {
	// Get the client's token string and request data
	const requestTokenString = req.header("osu-token"),
		  requestData = req.packet;
	
	// Server's response
	let responseData;

	// Check if the user is logged in
	if (requestTokenString == null) {
		// Client doesn't have a token yet, let's auth them!
		const userData = parseUserData(requestData);
		consoleHelper.printBancho(`New client connection. [User: ${userData.username}]`);
		await loginHandler(req, res, userData);
	} else {
		// Client has a token, let's see what they want.
		try {
			// Get the current user
			const PacketUser = getUserFromToken(requestTokenString);

			// Make sure the client's token isn't invalid
			if (PacketUser != null) {
				// Update the session timeout time
				PacketUser.timeoutTime = Date.now() + 60000;

				// Create a new osu! packet reader
				const osuPacketReader = new osu.Client.Reader(requestData);
				// Parse current bancho packet
				const PacketData = osuPacketReader.Parse();

				// Go through each packet sent by the client
				PacketData.forEach(CurrentPacket => {
					switch (CurrentPacket.id) {
						case packetIDs.client_changeAction:
							ChangeAction(PacketUser, CurrentPacket.data);
						break;

						case packetIDs.client_sendPublicMessage:
							SendPublicMessage(PacketUser, CurrentPacket.data);
						break;

						case packetIDs.client_logout:
							Logout(PacketUser);
						break;

						case packetIDs.client_requestStatusUpdate:
							UserPresenceBundle(PacketUser);
						break;

						case packetIDs.client_pong: // Pretty sure this is just a client ping
													// so we probably don't do anything here
						break;                      // It's probably just the client wanting to pull data down. (That's exactly what it is)

						case packetIDs.client_startSpectating:
							Spectator.startSpectatingUser(PacketUser, CurrentPacket.data);
						break;

						case packetIDs.client_spectateFrames:
							Spectator.sendSpectatorFrames(PacketUser, CurrentPacket.data);
						break;

						case packetIDs.client_stopSpectating:
							Spectator.stopSpectatingUser(PacketUser);
						break;

						case packetIDs.client_sendPrivateMessage:
							SendPrivateMessage(PacketUser, CurrentPacket.data);
						break;

						case packetIDs.client_joinLobby:
							global.MultiplayerManager.userEnterLobby(PacketUser);
						break;

						case packetIDs.client_partLobby:
							global.MultiplayerManager.userLeaveLobby(PacketUser);
						break;

						case packetIDs.client_createMatch:
							global.MultiplayerManager.createMultiplayerMatch(PacketUser, CurrentPacket.data);
						break;

						case packetIDs.client_joinMatch:
							global.MultiplayerManager.joinMultiplayerMatch(PacketUser, CurrentPacket.data);
						break;

						case packetIDs.client_matchChangeSlot:
							PacketUser.currentMatch.moveToSlot(PacketUser, CurrentPacket.data);
						break;

						case packetIDs.client_matchReady:
							PacketUser.currentMatch.setStateReady(PacketUser);
						break;

						case packetIDs.client_matchChangeSettings:
							PacketUser.currentMatch.updateMatch(PacketUser, CurrentPacket.data);
						break;

						case packetIDs.client_matchNotReady:
							PacketUser.currentMatch.setStateNotReady(PacketUser);
						break;

						case packetIDs.client_partMatch:
							global.MultiplayerManager.leaveMultiplayerMatch(PacketUser);
						break;

						// Also handles user kick if the slot has a user
						case packetIDs.client_matchLock:
							PacketUser.currentMatch.lockMatchSlot(PacketUser, CurrentPacket.data);
						break;

						case packetIDs.client_matchNoBeatmap:
							PacketUser.currentMatch.missingBeatmap(PacketUser);
						break;

						case packetIDs.client_matchSkipRequest:
							PacketUser.currentMatch.matchSkip(PacketUser);
						break;
						
						case packetIDs.client_matchHasBeatmap:
							PacketUser.currentMatch.notMissingBeatmap(PacketUser);
						break;

						case packetIDs.client_matchTransferHost:
							PacketUser.currentMatch.transferHost(PacketUser, CurrentPacket.data);
						break;

						case packetIDs.client_matchChangeMods:
							PacketUser.currentMatch.updateMods(PacketUser, CurrentPacket.data);
						break;

						case packetIDs.client_matchStart:
							PacketUser.currentMatch.startMatch();
						break;

						case packetIDs.client_matchLoadComplete:
							PacketUser.currentMatch.matchPlayerLoaded(PacketUser);
						break;

						case packetIDs.client_matchComplete:
							PacketUser.currentMatch.onPlayerFinishMatch(PacketUser);
						break;

						case packetIDs.client_matchScoreUpdate:
							PacketUser.currentMatch.updatePlayerScore(PacketUser, CurrentPacket.data);
						break;

						case packetIDs.client_matchFailed:
							PacketUser.currentMatch.matchFailed(PacketUser);
						break;

						case packetIDs.client_matchChangeTeam:
							PacketUser.currentMatch.changeTeam(PacketUser);
						break;

						case packetIDs.client_channelJoin:
							ChannelJoin(PacketUser, CurrentPacket.data);
						break;

						case packetIDs.client_channelPart:
							ChannelPart(PacketUser, CurrentPacket.data);
						break;

						case packetIDs.client_setAwayMessage:
							SetAwayMessage(PacketUser, CurrentPacket.data);
						break;

						case packetIDs.client_friendAdd:
							AddFriend(PacketUser, CurrentPacket.data);
						break;

						case packetIDs.client_friendRemove:
							RemoveFriend(PacketUser, CurrentPacket.data);
						break;

						case packetIDs.client_userStatsRequest:
							UserStatsRequest(PacketUser, CurrentPacket.data);
						break;

						case packetIDs.client_specialMatchInfoRequest:
							TourneyMatchSpecialInfo(PacketUser, CurrentPacket.data);
						break;

						case packetIDs.client_specialJoinMatchChannel:
							TourneyMatchJoinChannel(PacketUser, CurrentPacket.data);
						break;

						case packetIDs.client_specialLeaveMatchChannel:
							TourneyMatchLeaveChannel(PacketUser, CurrentPacket.data);
						break;

						case packetIDs.client_invite:
							MultiplayerInvite(PacketUser, CurrentPacket.data);
						break;

						case packetIDs.client_userPresenceRequest:
							UserPresence(PacketUser, PacketUser.id); // Can't really think of a way to generalize this?
						break;

						default:
							// Ignore client_beatmapInfoRequest and client_receiveUpdates
							if (CurrentPacket.id == 68 || CurrentPacket.id == 79) break;
							// Print out unimplemented packet
							console.dir(CurrentPacket);
						break;
					}
				});

				responseData = PacketUser.queue
				PacketUser.clearQueue();
			} else {
				// User's token is invlid, force a reconnect
				consoleHelper.printBancho(`Forced client re-login (Token is invalid)`);
				responseData = bakedResponses("reconnect");
			}
		} catch (e) {
			console.error(e);
		} finally {
			// Only send the headers that we absolutely have to
			res.removeHeader('X-Powered-By');
			res.removeHeader('Date');
			res.writeHead(200, {
				"Connection": "keep-alive",
				"Keep-Alive": "timeout=5, max=100",
			});
			// Send the prepared packet(s) to the client
			res.end(responseData);
		}
	}
};