const config = require("../config/config.json"), crypto = require("crypto"), emoji = require("../misc/emoji_list.json"), fs = require("fs");

// Defines the function of this module
const MODULE_FUNCTION = "handle_requests",

	  // Base path for module folder creation and navigation
	  BASE_PATH = "/EUS",
	  API_CACHE_LIFESPAN = 3600000;

let node_modules = {};

let eusConfig = {},
	useUploadKey = true,
	cacheJSON = "",
	timeSinceLastCache = Date.now();

class Database {
	constructor(databaseAddress, databasePort = 3306, databaseUsername, databasePassword, databaseName) {
		this.connectionPool = node_modules["mysql2"].createPool({
			connectionLimit: 128,
			host: databaseAddress,
			port: databasePort,
			user: databaseUsername,
			password: databasePassword,
			database: databaseName
		});
	}

	dataReceived(resolveCallback, data, limited = false) {
		if (limited) resolveCallback(data[0]);
		else resolveCallback(data);
	}

	query(query = "", data) {
		const limited = query.includes("LIMIT 1");

		return new Promise((resolve, reject) => {
			this.connectionPool.getConnection((err, connection) => {
				if (err) {
					reject(err);
					try { connection.release();}
					catch (e) {
						console.error("Failed to release mysql connection", err);
					}
				} else {
					// Use old query
					if (data == null) {
						connection.query(query, (err, data) => {
							if (err) {
								reject(err);
								connection.release();
							} else {
								this.dataReceived(resolve, data, limited);
								connection.release();
							}
						});
					}
					// Use new prepared statements w/ placeholders
					else {
						connection.execute(query, data, (err, data) => {
							if (err) {
								reject(err);
								connection.release();
							} else {
								this.dataReceived(resolve, data, limited);
								connection.release();
							}
						});
					}
				}
			});
		});
	}
}

let dbConnection;
function init() {
	// Require node modules
	node_modules["chalk"] = require("chalk");
	node_modules["busboy"] = require("connect-busboy");
	node_modules["randomstring"] = require("randomstring");
	node_modules["streamMeter"] = require("stream-meter");
	node_modules["mysql2"] = require("mysql2");

	// Only ran on startup so using sync functions is fine

	// Makes the folder for files of the module
	if (!fs.existsSync(__dirname + BASE_PATH)) {
		fs.mkdirSync(__dirname + BASE_PATH);
		console.log(`[EUS] Made EUS module folder`);
	}
	// Makes the folder for frontend files
	if (!fs.existsSync(__dirname + BASE_PATH + "/files")) {
		fs.mkdirSync(__dirname + BASE_PATH + "/files");
		console.log(`[EUS] Made EUS web files folder`);
	}
	// Makes the folder for images
	if (!fs.existsSync(__dirname + BASE_PATH + "/i")) {
		fs.mkdirSync(__dirname + BASE_PATH + "/i");
		console.log(`[EUS] Made EUS images folder`);
	}

	if (!fs.existsSync("/tmp/EUS_UPLOADS")) {
		fs.mkdirSync("/tmp/EUS_UPLOADS");
		console.log("[EUS] Made EUS temp upload folder");
	}

	// Makes the config file
	if (!fs.existsSync(__dirname + BASE_PATH + "/config.json")) {
		// Config doesn't exist, make it.
		fs.writeFileSync(`${__dirname}${BASE_PATH}/config.json`, '{\n\t"baseURL":"http://example.com/",\n\t"acceptedTypes": [\n\t\t".png",\n\t\t".jpg",\n\t\t".jpeg",\n\t\t".gif"\n\t],\n\t"uploadKey": "",\n\t"database": {\n\t\t"databaseAddress": "127.0.0.1",\n\t\t"databasePort": 3306,\n\t\t"databaseUsername": "root",\n\t\t"databasePassword": "password",\n\t\t"databaseName": "EUS"\n\t}\n}');
		console.log("[EUS] Made EUS config File!");
		console.log("[EUS] Please edit the EUS Config file before restarting.");
		// Config has been made, close framework.
		process.exit(0);
	} else {
		eusConfig = require(`${__dirname}${BASE_PATH}/config.json`);
		if (validateConfig(eusConfig)) console.log("[EUS] EUS config passed all checks");
	}

	if (!eusConfig["noUpload"]) {
		dbConnection = new Database(eusConfig["database"]["databaseAddress"], eusConfig["database"]["databasePort"], eusConfig["database"]["databaseUsername"], eusConfig["database"]["databasePassword"], eusConfig["database"]["databaseName"]);
	}

	console.log("[EUS] Finished loading.");
}

// Cache for the file count and space usage, this takes a while to do so it's best to cache the result
let cacheIsReady = false;
function cacheFilesAndSpace() {
	timeSinceLastCache = Date.now();
	return new Promise(async (resolve, reject) => {
		const startCacheTime = Date.now();
		cacheIsReady = false;
		let cachedFilesAndSpace = {
			fileCounts: {},
		};

		const dbData = await dbConnection.query(`SELECT imageType, COUNT(imageType) AS "count" FROM images GROUP BY imageType`);
		let totalFiles = 0;
		dbData.forEach(fileType => {
			cachedFilesAndSpace["fileCounts"][fileType.imageType] = fileType.count;
			totalFiles += fileType.count;
		});
		cachedFilesAndSpace["filesTotal"] = totalFiles;

		cachedFilesAndSpace["size"] = {};

		const dbSize = (await dbConnection.query(`SELECT SUM(fileSize) FROM images LIMIT 1`))["SUM(fileSize)"];
		const totalSizeBytes = dbSize == null ? 0 : dbSize;
		const mbSize = totalSizeBytes / 1024 / 1024;
		cachedFilesAndSpace["size"]["mb"] = parseFloat(mbSize.toFixed(4));
		cachedFilesAndSpace["size"]["gb"] = parseFloat((mbSize / 1024).toFixed(4));
		cachedFilesAndSpace["size"]["string"] = await spaceToLowest(totalSizeBytes, true);

		resolve(cachedFilesAndSpace);
		global.modules.consoleHelper.printInfo(emoji.folder, `Stats api cache took ${Date.now() - startCacheTime}ms`);
	});
}

function validateConfig(json) {
	let performShutdownAfterValidation = false;
	// URL Tests
	if (!json["noUpload"]) {
		if (json["baseURL"] == null) {
			console.error("EUS baseURL property does not exist!");
			performShutdownAfterValidation = true;
		} else {
			if (json["baseURL"] == "") console.warn("EUS baseURL property is blank");
			const bURL = `${json["baseURL"]}`.split("");
			if (bURL.length > 1) { 
				if (bURL[bURL.length-1] != "/") console.warn("EUS baseURL property doesn't have a / at the end, this can lead to unpredictable results!");
			}
			else {
				if (json["baseURL"] != "http://" || json["baseURL"] != "https://") console.warn("EUS baseURL property is possibly invalid!");
			}
		}
	}
	// acceptedTypes checks
	if (!json["noUpload"]) {
		if (json["acceptedTypes"] == null) {
			console.error("EUS acceptedTypes list does not exist!");
			performShutdownAfterValidation = true;
		} else {
			if (json["acceptedTypes"].length < 1) console.warn("EUS acceptedTypes array has no extentions in it, users will not be able to upload images!");
		}
	}
	// uploadKey checks
	if (!json["noUpload"]) {
		if (json["uploadKey"] == null) {
			console.error("EUS uploadKey property does not exist!");
			performShutdownAfterValidation = true;
		} else {
			if (json["uploadKey"] == "") useUploadKey = false;
		}
	}
	// database checks
	if (!json["noUpload"]) {
		if (json["database"] == null) {
			console.error("EUS database properties do not exist!");
			performShutdownAfterValidation = true;
		} else {
			// databaseAddress
			if (json["database"]["databaseAddress"] == null) {
				console.error("EUS database.databaseAddress property does not exist!");
				performShutdownAfterValidation = true;
			}
			// databasePort
			if (json["database"]["databasePort"] == null) {
				console.error("EUS database.databasePort property does not exist!");
				performShutdownAfterValidation = true;
			}
			// databaseUsername
			if (json["database"]["databaseUsername"] == null) {
				console.error("EUS database.databaseUsername property does not exist!");
				performShutdownAfterValidation = true;
			}
			// databasePassword
			if (json["database"]["databasePassword"] == null) {
				console.error("EUS database.databasePassword property does not exist!");
				performShutdownAfterValidation = true;
			}
			// databaseName
			if (json["database"]["databaseName"] == null) {
				console.error("EUS database.databaseName property does not exist!");
				performShutdownAfterValidation = true;
			}
		}
	}

	// Check if server needs to be shutdown
	if (performShutdownAfterValidation) {
		console.error("EUS config properties are missing, refer to example config on GitHub (https://github.com/tgpholly/EUS)");
		process.exit(1);
	}
	else return true;
}

let existanceCache = {};

function fileExists(file) {
	return new Promise((resolve) => {
		fs.access(file, (error) => {
			resolve(!error);
		});
	});
}

function sendFile(req, res, path, startTime) {
	// File does exist, send it back to the client.
	res.sendFile(path);
	global.modules.consoleHelper.printInfo(emoji.heavy_check, `${req.method}: ${node_modules.chalk.green("[200]")} ${req.url} ${Date.now() - startTime}ms`);
}

async function regularFile(req, res, urs = "", startTime) {
	if (req.url === "/") { urs = "/index.html" } else if (!req.url.includes(".") && !req.url.endsWith("/")) { urs = `${req.url}/index.html` } else { urs = req.url }

	if (await fileExists(`${__dirname}${BASE_PATH}/files${urs}`)) {
		sendFile(req, res, `${__dirname}${BASE_PATH}/files${decodeURIComponent(urs)}`, startTime);
	} else {
		let isSuccess = false;
		if (!urs.endsWith(".html")) {
			if (await fileExists(`${__dirname}${BASE_PATH}/files${decodeURIComponent(urs)}.html`)) {
				isSuccess = true;
				sendFile(req, res, `${__dirname}${BASE_PATH}/files${decodeURIComponent(urs)}.html`, startTime);
			}
		} else if (urs.endsWith("/index.html")) {
			const path = `${__dirname}${BASE_PATH}/files${decodeURIComponent(req.url)}.html`;
			if (await fileExists(path)) {
				isSuccess = true;
				sendFile(req, res, path, startTime);
			}
		}

		if (!isSuccess) {
			// Doesn't exist, send a 404 to the client.
			await error404Page(res);
			global.modules.consoleHelper.printInfo(emoji.cross, `${req.method}: ${node_modules.chalk.red("[404]")} ${req.url} ${Date.now() - startTime}ms`);
		}
	}
}

function imageFile(req, res, file, startTime = 0) {
	res.sendFile(`${__dirname}${BASE_PATH}/i/${file}`);
	global.modules.consoleHelper.printInfo(emoji.heavy_check, `${req.method}: ${node_modules.chalk.green("[200]")} (ImageReq) ${req.url} ${Date.now() - startTime}ms`);
}

async function doImageLookup(req, res, urs, startTime) {
	// Check if we even need to query the DB
	const dbAble = (!/[^0-9A-Za-z]/.test(urs)) && urs != "" && urs != "index" && (req.url.split("/").length == 2);

	if (dbAble) {
		if (urs in existanceCache) {
			const cachedFile = existanceCache[urs];
			imageFile(req, res, `${cachedFile.fileHash}.${cachedFile.fileType}`, startTime);
		} else {
			// Try to get what we think is an image's details from the DB
			const dbEntry = await dbConnection.query(`SELECT hash, imageType FROM images WHERE imageId = ? LIMIT 1`, [urs]);

			// There's an entry in the DB for this, send the file back.
			if (dbEntry != null) {
				existanceCache[urs] = {
					fileHash: dbEntry.hash,
					fileType: dbEntry.imageType
				};
				imageFile(req, res, `${dbEntry.hash}.${dbEntry.imageType}`, startTime);
			}
			// There's no entry, so treat this as a regular file.
			else regularFile(req, res, urs, startTime);
		}
	}
	// We can still serve files if they are not dbable
	// since we don't need to check the db
	else regularFile(req, res, urs, startTime);
}

const PATH_404 = `${__dirname}${BASE_PATH}/files/404.html`;
async function error404Page(res) {
	if (await fileExists(PATH_404)) {
		res.status(404).sendFile(PATH_404);
	} else {
		res.status(404).send("404!<hr>EUS");
	}
}

let getHandler = (req, res, urs, startTime) => res.send("EUS is starting up, please try again in a few seconds.");

module.exports = {
	init: init,
	extras:async function() {
		if (!eusConfig["noUpload"]) {
			// Setup express to use busboy
			global.app.use(node_modules.busboy());
			getHandler = doImageLookup;
			cacheJSON = JSON.stringify(await cacheFilesAndSpace());
			cacheIsReady = true;
		} else {
			getHandler = regularFile;
		}
	},
	get:async function(req, res) {
		/*
			req - Request from client
			res - Response from server
		*/
		
		// Set some headers
		res.set("Strict-Transport-Security", "max-age=31536000; includeSubDomains");
		res.set("X-XSS-Protection", "1; mode=block");
		res.set("Permissions-Policy", "microphone=(), geolocation=(), magnetometer=(), camera=(), payment=(), usb=(), accelerometer=(), gyroscope=()");
		res.set("Referrer-Policy", "strict-origin-when-cross-origin");
		res.set("Content-Security-Policy", "block-all-mixed-content;frame-ancestors 'self'");
		res.set("X-Frame-Options", "SAMEORIGIN");
		res.set("X-Content-Type-Options", "nosniff");

		req.url = decodeURIComponent(req.url.split("?")[0]);

		// Auto 404 any attempted php / wp access and log it.
		// TODO: IP ban based on mass access. Very clearly a scan.
		if (req.url.includes(".php") || req.url.includes("/wp-")) {
			global.modules.consoleHelper.printWarn(emoji.globe_europe, `${req.method}: SUSSY ${req.headers["cf-connecting-ip"]} ${req.url}`);
			return await error404Page(res);
		}

		if (req.url.includes("/api/")) {
			return handleAPI(req, res);
		}

		const startTime = Date.now();

		const urs = req.url.split("/")[1];
		getHandler(req, res, urs, startTime);
	},
	post:async function(req, res) {
		/*
			req - Request from client
			res - Response from server
		*/

		if (eusConfig["noUpload"]) return res.end("");
		if (req.url != "/upload") return res.end("");

		res.header("Access-Control-Allow-Origin", "*");

		if (useUploadKey && eusConfig["uploadKey"] != req.header("key")) return res.end("Incorrect key provided for upload");

		const startTime = Date.now();
		req.pipe(req.busboy);
		req.busboy.on('file', function (fieldname, file, info) {
			fileOutName = node_modules.randomstring.generate(14);
			global.modules.consoleHelper.printInfo(emoji.fast_up, `${req.method}: Upload of ${fileOutName} started.`);
			// Check the file is within the accepted file types
			let fileType = info.filename.split(".").slice(-1);
			if (info.filename === "blob") {
				fileType = info.mimeType.split("/")[1];
			}
			var thefe = "";
			if (eusConfig.acceptedTypes.includes(`.${fileType}`)) {
				// File is accepted, set the extention of the file in thefe for later use.
				thefe = fileType;
			} else {
				// File isn't accepted, send response back to client stating so.
				res.status(403).end("This file type isn't accepted.");
				return;
			}
			// Create a write stream for the file
			let fstream = fs.createWriteStream("/tmp/EUS_UPLOADS/" + fileOutName);
			file.pipe(fstream);

			// Get all file data for the file MD5
			let fileData = [];
			file.on("data", (chunk) => {
				fileData.push(chunk);
			});

			fstream.on('close', async () => {
				let md5Buffer = Buffer.concat(fileData);
				// bye
				fileData = null;

				// Create MD5 hash of file
				const hash = crypto.createHash("md5");
				hash.setEncoding("hex");
				hash.write(md5Buffer);
				hash.end();

				const fileHash = hash.read();
				const dataOnHash = await dbConnection.query("SELECT imageId FROM images WHERE hash = ? LIMIT 1", [fileHash]);
				if (dataOnHash !== undefined)
				{
					fs.unlink(`/tmp/EUS_UPLOADS/${fileOutName}`, () => {});
					res.end(`${eusConfig.baseURL}${dataOnHash.imageId}`);
					global.modules.consoleHelper.printInfo(emoji.heavy_check, `${req.method}: Hash matched! Sending ${dataOnHash.imageId} instead. Took ${Date.now() - startTime}ms`);
					return;
				} else {
					fs.rename(`/tmp/EUS_UPLOADS/${fileOutName}`, `${__dirname}${BASE_PATH}/i/${fileHash}.${thefe[0]}`, async () => {
						// Add to the existance cache
						existanceCache[fileOutName] = {
							fileHash: fileHash,
							fileType: thefe[0]
						};
	
						// Store image data in db
						await dbConnection.query(`INSERT INTO images (id, imageId, imageType, hash, fileSize) VALUES (NULL, ?, ?, ?, ?)`, [fileOutName, thefe[0], fileHash, md5Buffer.length]);
					
						// Send URL of the uploaded image to the client           
						res.end(eusConfig.baseURL + fileOutName);
						global.modules.consoleHelper.printInfo(emoji.heavy_check, `${req.method}: Upload of ${fileOutName} finished. Took ${Date.now() - startTime}ms`);
	
						// Update cached files & space
						if ((Date.now() - timeSinceLastCache) >= API_CACHE_LIFESPAN) {
							cacheJSON = JSON.stringify(await cacheFilesAndSpace());
						} else {
							const tempJson = JSON.parse(cacheJSON);
							tempJson.fileCounts[thefe[0]]++;
							cacheJSON = JSON.stringify(tempJson);
							global.modules.consoleHelper.printInfo(emoji.folder, `Skiped api cache`);
						}
						cacheIsReady = true;
					});
				}
			});
		});
	}
}

async function handleAPI(req, res) {
	const startTime = Date.now();
	let jsonaa = {}, filesaa = 0, spaceaa = 0;
	switch (req.url.split("?")[0]) {
		// Status check to see the online status of EUS
		// Used by ESL to make sure EUS is online
		case "/api/get-server-status":
			global.modules.consoleHelper.printInfo(emoji.heavy_check, `${req.method}: ${node_modules.chalk.green("[200]")} (APIReq) ${req.url} ${Date.now() - startTime}ms`);
			return res.end('{"status":1,"version":"'+global.internals.version+'"}');
		
		/*  Stats api endpoint
			Query inputs
			  f : Values [0,1]
			  s : Values [0,1]
		*/
		case "/api/get-stats":
			filesaa = req.query["f"];
			spaceaa = req.query["s"];
			if (!cacheIsReady) return res.end("Cache is not ready");
			jsonaa = JSON.parse(cacheJSON);
			// If total files is asked for
			if (filesaa == 1) {
				// If getting the space used on the server isn't required send the json
				if (spaceaa != 1) {
					global.modules.consoleHelper.printInfo(emoji.heavy_check, `${req.method}: ${node_modules.chalk.green("[200]")} (APIReq) ${req.url} ${Date.now() - startTime}ms`);
					delete jsonaa["space"];
					return res.end(JSON.stringify(jsonaa));
				}
			}
			// Getting space is required
			if (spaceaa == 1) {
				global.modules.consoleHelper.printInfo(emoji.heavy_check, `${req.method}: ${node_modules.chalk.green("[200]")} (APIReq) ${req.url} ${Date.now() - startTime}ms`);
				if (filesaa != 1) delete jsonaa["files"];
				return res.end(JSON.stringify(jsonaa));
			}

			if (filesaa != 1 && spaceaa != 1) {
				global.modules.consoleHelper.printInfo(emoji.heavy_check, `${req.method}: ${node_modules.chalk.green("[200]")} (APIReq) ${req.url} ${Date.now() - startTime}ms`);
				return res.end("Please add f and or s to your queries to get the files and space");
			}
		break;

		// Information API
		case "/api/get-info":
			global.modules.consoleHelper.printInfo(emoji.heavy_check, `${req.method}: ${node_modules.chalk.green("[200]")} (APIReq) ${req.url} ${Date.now() - startTime}ms`);
			return res.end(JSON.stringify({
				version: global.internals.version,
				instance: config["server"]["instance_type"]
			}));

		default:
			global.modules.consoleHelper.printInfo(emoji.heavy_check, `${req.method}: ${node_modules.chalk.green("[200]")} (APIReq) ${req.url} ${Date.now() - startTime}ms`);
			return res.send(`
				<h2>All currently avaliable api endpoints</h2>
				<a href="/api/get-server-status">/api/get-server-status</a>
				<a href="/api/get-stats">/api/get-stats</a>
				<a href="/api/get-info">/api/get-info</a>
			`);
	}
}

const spaceValues = ["B", "KB", "MB", "GB", "TB", "PB", "EB"]; // Futureproofing™

async function spaceToLowest(spaceValue, includeStringValue) {
	return new Promise((resolve, reject) => {
		// Converts space values to lower values e.g MB, GB, TB etc depending on the size of the number
		let i1 = 1;
		// Loop through until value is at it's lowest
		while (spaceValue >= 1024) {
			spaceValue = spaceValue / 1024;
			if (spaceValue >= 1024) i1++;
		}

		if (includeStringValue) resolve(`${spaceValue.toFixed(2)} ${spaceValues[i1]}`);
		else resolve(spaceValue);
	});
}

module.exports.MOD_FUNC = MODULE_FUNCTION;

module.exports.REQUIRED_NODE_MODULES = [
	"chalk", "connect-busboy", "randomstring",
	"stream-meter", "mysql2"
];