import * as core from './core.js';

let gHandlers = [];
let gSocketHandlers = [];
let gBadRequests = {};

const kRequestTimeout = 15000;
const kStallTimeout = 60000;

function logError(error) {
	print("ERROR " + error);
	if (error.stackTrace) {
		print(error.stackTrace);
	}
}

function addHandler(handler) {
	let added = false;
	for (let i in gHandlers) {
		if (gHandlers[i].path == handler.path) {
			gHandlers[i] = handler;
			added = true;
			break;
		}
	}
	if (!added) {
		gHandlers.push(handler);
		added = true;
	}
}

function all(prefix, handler) {
	addHandler({
		owner: this,
		path: prefix,
		invoke: handler,
	});
}

function registerSocketHandler(prefix, handler) {
	gSocketHandlers.push({
		owner: this,
		path: prefix,
		invoke: handler,
	});
}

function Request(method, uri, version, headers, body, client) {
	this.method = method;
	let index = uri.indexOf("?");
	if (index != -1) {
		this.uri = uri.slice(0, index);
		this.query = uri.slice(index + 1);
	} else {
		this.uri = uri;
		this.query = undefined;
	}
	this.version = version || '';
	this.headers = headers;
	this.client = {peerName: client.peerName, tls: client.tls};
	this.body = body;
	return this;
}

function findHandler(request) {
	let matchedHandler = null;
	for (let name in gHandlers) {
		let handler = gHandlers[name];
		if (request.uri == handler.path || request.uri.slice(0, handler.path.length + 1) == handler.path + '/') {
			matchedHandler = handler;
			break;
		}
	}
	return matchedHandler;
}

function findSocketHandler(request) {
	let matchedHandler = null;
	for (let name in gSocketHandlers) {
		let handler = gSocketHandlers[name];
		if (request.uri == handler.path || request.uri.slice(0, handler.path.length + 1) == handler.path + '/') {
			matchedHandler = handler;
			break;
		}
	}
	return matchedHandler;
}

function Response(request, client) {
	let kStatusText = {
		101: "Switching Protocols",
		200: 'OK',
		303: 'See other',
		304: 'Not Modified',
		400: 'Bad Request',
		401: 'Unauthorized',
		403: 'Forbidden',
		404: 'File not found',
		500: 'Internal server error',
	};
	let _started = false;
	let _finished = false;
	let _keepAlive = false;
	let _chunked = false;
	return {
		writeHead: function(status) {
			if (_started) {
				throw new Error("Response.writeHead called multiple times.");
			}
			let reason;
			let headers;
			if (arguments.length == 3) {
				reason = arguments[1];
				headers = arguments[2];
			} else {
				reason = kStatusText[status];
				headers = arguments[1];
			}
			let lowerHeaders = {};
			let requestVersion = request.version.split("/")[1].split(".");
			let responseVersion = (requestVersion[0] >= 1 && requestVersion[0] >= 1) ? "1.1" : "1.0";
			let headerString = "HTTP/" + responseVersion + " " + status + " " + reason + "\r\n";
			for (let i in headers) {
				headerString += i + ": " + headers[i] + "\r\n";
				lowerHeaders[i.toLowerCase()] = headers[i];
			}
			if ("connection" in lowerHeaders) {
				_keepAlive = lowerHeaders["connection"].toLowerCase() == "keep-alive";
			} else {
				_keepAlive = ((request.version == "HTTP/1.0" && ("connection" in lowerHeaders && lowerHeaders["connection"].toLowerCase() == "keep-alive")) ||
					(request.version == "HTTP/1.1" && (!("connection" in lowerHeaders) || lowerHeaders["connection"].toLowerCase() != "close")));
				headerString += "Connection: " + (_keepAlive ? "keep-alive" : "close") + "\r\n";
			}
			_chunked = _keepAlive && !("content-length" in lowerHeaders);
			if (_chunked) {
				headerString += "Transfer-Encoding: chunked\r\n";
			}
			headerString += "\r\n";
			_started = true;
			client.write(headerString).catch(function() {});
		},
		end: function(data) {
			if (_finished) {
				throw new Error("Response.end called multiple times.");
			}
			if (data) {
				if (_chunked) {
					client.write(data.length.toString(16) + "\r\n" + data + "\r\n" + "0\r\n\r\n").catch(function() {});
				} else {
					client.write(data).catch(function() {});
				}
			} else if (_chunked) {
				client.write("0\r\n\r\n").catch(function() {});
			}
			_finished = true;
			if (!_keepAlive) {
				client.shutdown().catch(function() {});
			}
		},
		reportError: function(error) {
			if (!_started) {
				client.write("HTTP/1.1 500 Internal Server Error\r\nContent-Type: text/plain; charset=utf-8\r\n\r\n").catch(function() {});
			}
			if (!_finished) {
				client.write("500 Internal Server Error\r\n\r\n" + error?.stackTrace).catch(function() {});
			}
			logError(client.peerName + " - - [" + new Date() + "] " + error);
		},
		isConnected: function() { return client.isConnected; },
	};
}

function handleRequest(request, response) {
	let handler = findHandler(request);

	print(request.client.peerName + " - - [" + new Date() + "] " + request.method + " " + request.uri + " " + request.version + " \"" + request.headers["user-agent"] + "\"");

	if (handler) {
		try {
			Promise.resolve(handler.invoke(request, response)).catch(function(error) {
				response.reportError(error);
				request.client.close();
			});
		} catch (error) {
			response.reportError(error);
			request.client.close();
		}
	} else {
		response.writeHead(200, {"Content-Type": "text/plain; charset=utf-8"});
		response.end("No handler found for request: " + request.uri);
	}
}

function handleWebSocketRequest(request, response, client) {
	let buffer = new Uint8Array(0);
	let frame;
	let frameOpCode = 0x0;

	let handler = findSocketHandler(request);
	if (!handler) {
		client.close();
		return;
	}

	response.send = function(message, opCode) {
		if (opCode === undefined) {
			opCode = 0x2;
		}
		if (opCode == 0x1 && (typeof message == "string" || message instanceof String)) {
			message = utf8Encode(message);
		}
		let fin = true;
		let packet = [(fin ? (1 << 7) : 0) | (opCode & 0xf)];
		let mask = false;
		if (message.length < 126) {
			packet.push((mask ? (1 << 7) : 0) | message.length);
		} else if (message.length < (1 << 16)) {
			packet.push((mask ? (1 << 7) : 0) | 126);
			packet.push((message.length >> 8) & 0xff);
			packet.push(message.length & 0xff);
		} else {
			let high = 0; //(message.length / (1 ** 32)) & 0xffffffff;
			let low = message.length & 0xffffffff;
			packet.push((mask ? (1 << 7) : 0) | 127);
			packet.push((high >> 24) & 0xff);
			packet.push((high >> 16) & 0xff);
			packet.push((high >> 8) & 0xff);
			packet.push((high >> 0) & 0xff);
			packet.push((low >> 24) & 0xff);
			packet.push((low >> 16) & 0xff);
			packet.push((low >> 8) & 0xff);
			packet.push(low & 0xff);
		}

		let array = new Uint8Array(packet.length + message.length);
		array.set(packet, 0);
		array.set(message, packet.length);
		try {
			return client.write(array);
		} catch (error) {
			client.close();
			throw error;
		}
	}
	response.onMessage = null;

	let extra_headers = handler.invoke(request, response);

	client.read(function(data) {
		if (data) {
			let newBuffer = new Uint8Array(buffer.length + data.length);
			newBuffer.set(buffer, 0);
			newBuffer.set(data, buffer.length);
			buffer = newBuffer;

			while (buffer.length >= 2) {
				let bits0 = buffer[0];
				let bits1 = buffer[1];
				if (bits1 & (1 << 7) == 0) {
					// Unmasked message.
					client.close();
				}
				let opCode = bits0 & 0xf;
				let fin = bits0 & (1 << 7);
				let payloadLength = bits1 & 0x7f;
				let maskStart = 2;

				if (payloadLength == 126) {
					payloadLength = 0;
					for (let i = 0; i < 2; i++) {
						payloadLength <<= 8;
						payloadLength |= buffer[2 + i];
					}
					maskStart = 4;
				} else if (payloadLength == 127) {
					payloadLength = 0;
					for (let i = 0; i < 8; i++) {
						payloadLength <<= 8;
						payloadLength |= buffer[2 + i];
					}
					maskStart = 10;
				}
				let havePayload = buffer.length >= payloadLength + 2 + 4;
				if (havePayload) {
					let mask =
						buffer[maskStart + 0] |
						buffer[maskStart + 1] << 8 |
						buffer[maskStart + 2] << 16 |
						buffer[maskStart + 3] << 24;
					let dataStart = maskStart + 4;
					let payload = buffer.slice(dataStart, dataStart + payloadLength);
					let decoded = maskBytes(payload, mask);
					buffer = buffer.slice(dataStart + payloadLength);

					if (frame) {
						let newBuffer = new Uint8Array(frame.length + decoded.length);
						newBuffer.set(frame, 0);
						newBuffer.set(decoded, frame.length);
						frame = newBuffer;
					} else {
						frame = decoded;
					}

					if (opCode) {
						frameOpCode = opCode;
					}

					if (fin) {
						if (response.onMessage) {
							response.onMessage({
								data: frameOpCode == 0x1 ? utf8Decode(frame) : frame,
								opCode: frameOpCode,
							});
						}
						frame = undefined;
					}
				} else {
					break;
				}
			}
		} else {
			response.onClose();
			client.close();
		}
	});
	client.onError(function(error) {
		logError(client.peerName + " - - [" + new Date() + "] " + error);
		response.onError(error);
	});

	let headers = {
		"Upgrade": "websocket",
		"Connection": "Upgrade",
		"Sec-WebSocket-Accept": webSocketAcceptResponse(request.headers["sec-websocket-key"]),
	};
	if (request.headers["sec-websocket-version"] != "13") {
		headers["Sec-WebSocket-Version"] = "13";
	}
	response.writeHead(101, Object.assign({}, headers, extra_headers));
}

function webSocketAcceptResponse(key) {
	let kMagic = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
	let kAlphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
	return base64Encode(sha1Digest(key + kMagic));
}

function badRequest(client, reason) {
	let now = new Date();
	let count = 0;
	let old = gBadRequests[client.peerName];
	if (!old) {
		gBadRequests[client.peerName] = {
			expire: new Date(now.getTime() + 1 * 60 * 1000),
			count: 1,
			reason: reason,
		};
		count = 1;
	} else {
		old.count++;
		old.reason = reason;
		count = old.count;
	}
	new Response({version: '1.0'}, client).reportError(reason + ': ' + count);
	client.close();
}

function allowRequest(client) {
	let old = gBadRequests[client.peerName];
	if (old) {
		let now = new Date();
		if (old.expire < now) {
			delete gBadRequests[client.peerName];
			return true;
		} else {
			return old.count < 3;
		}
	} else {
		return true;
	}
}

function handleConnection(client) {
	if (!allowRequest(client)) {
		print('Rejecting client for too many bad requests: ', client.peerName, gBadRequests[client.peerName].reason);
		client.info = 'rejected';
		client.close();
		return;
	}

	client.info = 'accepted';
	let inputBuffer = new Uint8Array(0);
	let request;
	let headers = {};
	let parsing_header = true;
	let bodyToRead = -1;
	let body;
	let requestCount = -1;
	let readCount = 0;
	let isWebsocket = false;

	function resetTimeout(requestIndex) {
		if (isWebsocket) {
			return;
		}
		if (bodyToRead == -1) {
			setTimeout(function() {
				if (requestCount == requestIndex) {
					client.info = 'timed out';
					if (requestCount == 0) {
						badRequest(client, 'Timed out waiting for request.');
					} else {
						client.close();
					}
				}
			}, kRequestTimeout);
		} else {
			let lastReadCount = readCount;
			setTimeout(function() {
				if (readCount == lastReadCount) {
					client.info = 'stalled';
					if (requestCount == 0) {
						badRequest(client, 'Request stalled.');
					} else {
						client.close();
					}
				}
			}, kStallTimeout);
		}
	}

	resetTimeout(++requestCount);

	function reset() {
		request = undefined;
		headers = {};
		parsing_header = true;
		bodyToRead = -1;
		body = undefined;
		client.info = 'reset';
		resetTimeout(++requestCount);
	}

	function finish() {
		client.info = 'finishing';
		let requestObject = new Request(request[0], request[1], request[2], headers, body, client);
		let response = new Response(requestObject, client);
		try {
			handleRequest(requestObject, response)
			if (client.isConnected) {
				reset();
			}
		} catch (error) {
			response.reportError(error);
			client.close();
		}
	}

	client.onError(function(error) {
		logError(client.peerName + " - - [" + new Date() + "] " + error);
	});

	client.read(function(data) {
		readCount++;
		if (data) {
			if (bodyToRead != -1 && !isWebsocket) {
				resetTimeout(requestCount);
			}
			let newBuffer = new Uint8Array(inputBuffer.length + data.length);
			newBuffer.set(inputBuffer, 0);
			newBuffer.set(data, inputBuffer.length);
			inputBuffer = newBuffer;

			if (parsing_header)
			{
				let result = parseHttp(inputBuffer, inputBuffer.length - data.length);
				if (result) {
					if (typeof result === 'number') {
						if (result == -2) {
							/* More. */
						} else {
							badRequest(client, 'Bad request.');
							return;
						}
					} else if (typeof result === 'object')  {
						request = [
							result.method,
							result.path,
							`HTTP/1.${result.minor_version}`,
						];

						headers = Object.fromEntries(Object.entries(result.headers).map(x => [x[0].toLowerCase(), x[1]]));
						parsing_header = false;
						inputBuffer = inputBuffer.slice(result.bytes_parsed);

						if (!client.tls && tildefriends.https_port && core.globalSettings.http_redirect && !result.path.startsWith('/.well-known/')) {
							let requestObject = new Request(request[0], request[1], request[2], headers, body, client);
							let response = new Response(requestObject, client);
							response.writeHead(303, {"Location": `${core.globalSettings.http_redirect}${result.path}`, "Content-Length": "0"});
							response.end();
							return;
						}

						if (headers["content-length"] != undefined) {
							bodyToRead = parseInt(headers["content-length"]);
							if (bodyToRead > 16 * 1024 * 1024) {
								badRequest(client, 'Request too large: ' + bodyToRead + '.');
								return;
							}
							body = new Uint8Array(bodyToRead);
							client.info = 'waiting for body';
							resetTimeout(requestCount);
						} else if (headers["connection"]
							&& headers["connection"].toLowerCase().split(",").map(x => x.trim()).indexOf("upgrade") != -1
							&& headers["upgrade"]
							&& headers["upgrade"].toLowerCase() == "websocket") {
							isWebsocket = true;
							client.info = 'websocket';
							let requestObject = new Request(request[0], request[1], request[2], headers, body, client);
							let response = new Response(requestObject, client);
							handleWebSocketRequest(requestObject, response, client);
							/* Prevent the timeout from disconnecting us. */
							requestCount++;
						} else {
							finish();
						}
					}
				}
			}

			if (!parsing_header && inputBuffer.length)
			{
				let offset = body.length - bodyToRead;
				let length = Math.min(inputBuffer.length, body.length - offset);
				if (inputBuffer.length > body.length - offset) {
					body.set(inputBuffer.slice(0, length), offset);
					inputBuffer = inputBuffer.slice(length);
				} else {
					body.set(inputBuffer, offset);
					inputBuffer = inputBuffer.slice(inputBuffer.length);
				}
				bodyToRead -= length;
				if (bodyToRead <= 0) {
					finish();
				}
			}
		} else {
			client.info = 'EOF';
			client.close();
		}
	});
}

let kBacklog = 8;
let kHost = "0.0.0.0"

let socket = new Socket();
socket.bind(kHost, tildefriends.http_port).then(function(port) {
	print("bound to", port);
	print("checking", tildefriends.args.out_http_port_file);
	if (tildefriends.args.out_http_port_file) {
		print("going to write the file");
		File.writeFile(tildefriends.args.out_http_port_file, port.toString() + '\n').then(function(r) {
			print("wrote port file", tildefriends.args.out_http_port_file, r);
		}).catch(function() {
			print("failed to write port file");
		});
	}
	let listenResult = socket.listen(kBacklog, async function() {
		try {
			let client = await socket.accept();
			client.noDelay = true;
			handleConnection(client);
		} catch (error) {
			logError("[" + new Date() + "] accept error " + error);
		}
	});
}).catch(function(error) {
	logError("[" + new Date() + "] bind error " + error);
});

if (tildefriends.https_port) {
	let tls = {};
	let secureSocket = new Socket();
	secureSocket.bind(kHost, tildefriends.https_port).then(function() {
		return secureSocket.listen(kBacklog, async function() {
			try {
				let client = await secureSocket.accept();
				client.noDelay = true;
				client.tls = true;
				const kCertificatePath = "data/httpd/certificate.pem";
				const kPrivateKeyPath = "data/httpd/privatekey.pem";

				let stat = await Promise.all([
					await File.stat(kCertificatePath),
					await File.stat(kPrivateKeyPath),
				]);
				if (!tls.context ||
					tls.certStat.mtime != stat[0].mtime ||
					tls.certStat.size != stat[0].size ||
					tls.keyStat.mtime != stat[1].mtime ||
					tls.keyStat.size != stat[1].size) {
					print("Reloading " + kCertificatePath + " and " + kPrivateKeyPath);
					let privateKey = utf8Decode(await File.readFile(kPrivateKeyPath));
					let certificate = utf8Decode(await File.readFile(kCertificatePath));

					tls.context = new TlsContext();
					tls.context.setPrivateKey(privateKey);
					tls.context.setCertificate(certificate);
					tls.certStat = stat[0];
					tls.keyStat = stat[1];
				}

				let result = client.startTls(tls.context);
				handleConnection(client);
				return result;
			} catch (error) {
				logError("[" + new Date() + "] [" + client.peerName + "] " + error);
			}
		});
	}).catch(function(error) {
		logError("[" + new Date() + "] bind error " + error);
	});
}

export { all, registerSocketHandler };