/**
 * Load a text resource
 */
function loadText(path: string): Task<any> {
	return request(path).then(response => {
		if (!response.ok) {
			throw new Error('Request failed: ' + response.status);
		}
		return response.text();
	});
}

export function loadJson(path: string, basePath?: string): Task<any> {
	if (path[0] !== '/') {
		basePath = basePath == null ? '/' : basePath;
		path = `${basePath}${path}`;
	}
	return request(path).then(response => {
		return response.text().then(text => {
			return parseJSON(text);
		});
	});
}

	/**
	 * Some testing services have problems handling large message POSTs, so
	 * limit the maximum size of each POST body to maxPostSize bytes. Always
	 * send at least one message, even if it's more than maxPostSize bytes.
	 */
	protected _sendMessages(): Task<any> | undefined {
		const messages = this._messageBuffer;
		if (messages.length === 0) {
			return;
		}

		const block = [messages.shift()!];

		let size = block[0].message.length;
		while (
			messages.length > 0 &&
			size + messages[0].message.length < this._maxPostSize
		) {
			size += messages[0].message.length;
			block.push(messages.shift()!);
		}

		this._activeRequest = request(this.url, {
			method: 'POST',
			headers: { 'Content-Type': 'application/json' },
			body: JSON.stringify(block.map(entry => entry.message))
		})
			.then(response => {
				if (response.status === 200) {
					return response.json<any[]>();
				} else if (response.status === 204) {
					return [];
				} else {
					throw new Error(response.statusText);
				}
			})
			.then((results: any[]) => {
				block.forEach((entry, index) => {
					entry.resolve(results[index]);
				});
			})
			.catch(error => {
				block.forEach(entry => {
					entry.reject(error);
				});
			})
			.finally(() => {
				this._activeRequest = undefined;
				if (messages.length > 0) {
					return this._sendMessages();
				}
			});

		return this._activeRequest;
	}

		const sendNextBlock = (): Task<any> => {
			const block = [ messages.shift() ];
			let size = block[0].length;
			while (messages.length > 0 && size + messages[0].length < exports.maxPostSize) {
				size += messages[0].length;
				block.push(messages.shift());
			}

			return request(this.url, {
				method: 'POST',
				headers: { 'Content-Type': 'application/json' },
				body: JSON.stringify(block)
			}).then(() => {
				if (messages.length > 0) {
					return sendNextBlock();
				}
			});
		};

	/**
	 * Some testing services have problems handling large message POSTs, so
	 * limit the maximum size of each POST body to maxPostSize bytes. Always
	 * send at least one message, even if it's more than maxPostSize bytes.
	 */
	protected _sendMessages(): Task<void> {
		const messages = this._messageBuffer;
		const block = [messages.shift()!];

		let size = block[0].length;
		while (
			messages.length > 0 &&
			size + messages[0].length < this._maxPostSize
		) {
			size += messages[0].length;
			block.push(messages.shift()!);
		}

		return request(this.url, {
			method: 'POST',
			headers: { 'Content-Type': 'application/json' },
			body: JSON.stringify(block)
		}).then(() => {
			if (messages.length > 0) {
				return this._sendMessages();
			}
		});
	}