/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

!function() {

	var CHUNK_SIZE = 100;			// break large objects into chunks of this size
	var ARGUMENT_COUNT_INDEX = 3;	// index of Argument count field in FrameDetails
	var LOCAL_COUNT_INDEX = 4;		// index of Local count field in FrameDetails

	// try to load 'vm' even if 'require' isn't available in the current context
	var vm = process.mainModule ? process.mainModule.require('vm') : require('vm');

	// the following objects should be available in all versions of node.js
	var LookupMirror = vm.runInDebugContext('LookupMirror');
	var DebugCommandProcessor = vm.runInDebugContext('DebugCommandProcessor');

	/*
	 * Retrieving index and named properties of an object requires some work in recent versions of node
	 * because 'propertyNames' no longer takes a filter argument.
	 */
	var indexedPropertyCount;
	var namedProperties;
	try {
		var PropertyKind = vm.runInDebugContext('PropertyKind');
		indexedPropertyCount = function(mirror) {
			return mirror.propertyNames(PropertyKind.Indexed).length;
		};
		namedProperties = function(mirror) {
			return mirror.propertyNames(PropertyKind.Named);
		};
	} catch (error) {
		indexedPropertyCount = function(mirror) {
			var n = 0;
			const names = mirror.propertyNames();
			for (var i = 0; i < names.length; i++) {
				var name = names[i];
				if (name.length > 0 && name[0] >= '0' && name[0] <= '9') {
					n++;
				}
			}
			return n;
		};
		namedProperties = function(mirror) {
			var named = [];
			const names = mirror.propertyNames();
			for (var i = 0; i < names.length; i++) {
				var name = names[i];
				if (name.length === 0 || name[0] < '0' || name[0] > '9') {
					named.push(name);
				}
			}
			return named;
		};
	}

	/**
	 * In old versions of node it was possible to monkey patch the JSON response serializer.
	 * This made it possible to drop large objects from the 'refs' array (that is part of every protocol response).
	 */
	try {
		var JSONProtocolSerializer = vm.runInDebugContext('JSONProtocolSerializer');

		JSONProtocolSerializer.prototype.serializeReferencedObjects = function () {
			var content = [];
			for (var i = 0; i < this.mirrors_.length; i++) {
				var m = this.mirrors_[i];

				if (m.isArray()) continue;

				if (m.isObject()) {
					if (m.handle() < 0) {
						// we cannot drop transient objects from 'refs' because they cannot be looked up later
					} else {
						if (m.propertyNames(PropertyKind.Indexed | PropertyKind.Named, CHUNK_SIZE).length >= CHUNK_SIZE) continue;
					}
				}

				content.push(this.serialize_(m, false, false));
			}
			return content;
		};
	} catch (error) {
		// since overriding 'serializeReferencedObjects' is optional, we can silently ignore the error.
	}

	/**
	 * The original backtrace request returns unsolicited arguments and local variables for all stack frames.
	 * If these arguments or local variables are large, they blow up the backtrace response which slows down
	 * stepping speed.
	 * This override clears the argument and local variable count in the FrameDetails structure
	 * which prevents arguments and local variables from being included in the backtrace response.
	 */
	DebugCommandProcessor.prototype.dispatch_['vscode_backtrace'] = function(request, response) {
		var result = this.backtraceRequest_(request, response);
		if (!result && response.body.frames) {
			var frames = response.body.frames;
			for (var i = 0; i < frames.length; i++) {
				const d = frames[i].details_.details_;
				if (d) {
					d[ARGUMENT_COUNT_INDEX]= 0;		// don't include any Arguments in stack frame
					d[LOCAL_COUNT_INDEX]= 0;		// don't include any Locals in stack frame
				}
			}
		}
		return result;
	}

	/**
	 * This new protocol request makes it possible to retrieve a range of values from a
	 * large object.
	 * If 'start' is specified, 'count' indexed properties are returned.
	 * If 'start' is omitted, the first 'count' named properties are returned.
 	 */
	DebugCommandProcessor.prototype.dispatch_['vscode_slice'] = function(request, response) {
		var handle = request.arguments.handle;
		var start = request.arguments.start;
		var count = request.arguments.count;
		var mirror = LookupMirror(handle);
		if (!mirror) {
			return response.failed('Object #' + handle + '# not found');
		}
		var result = [];
		if (typeof start === 'number') {
			if (mirror.isArray()) {
				var a = mirror.indexedPropertiesFromRange(start, start+count-1);
				for (var i = 0; i < a.length; i++) {
					result.push({ name: (start+i).toString(), value: a[i].value() });
				}
			} else if (mirror.isObject()) {
				for (var i = 0, j = start; i < count; i++, j++) {
					var p = mirror.property(j.toString());
					result.push({ name: j.toString(), value: p.value() });
				}
			}
		} else {
			if (mirror.isArray() || mirror.isObject()) {
				var names = namedProperties(mirror);
				for (var i = 0; i < names.length; i++) {
					var name = names[i];
					var p = mirror.property(name);
					result.push({ name: name, value: p.value() });
				}
			}
		}
		response.body = {
			result: result
		};
	};

	/**
	 * If the passed mirror object is a large array or object this function
	 * returns the mirror without its properties but with a size attribute ('vscode_size') instead.
 	 */
	var dehydrate = function(mirror) {
		var size = -1;

		if (mirror.isArray()) {
			size = mirror.length();
		} else if (mirror.isObject()) {
			switch (mirror.className()) {
			case 'ArrayBuffer':
			case 'Int8Array':
			case 'Uint8Array':
			case 'Uint8ClampedArray':
			case 'Int16Array':
			case 'Uint16Array':
			case 'Int32Array':
			case 'Uint32Array':
			case 'Float32Array':
			case 'Float64Array':
				size = indexedPropertyCount(mirror);
				break;
			default:
				break;
			}
		}

		if (size > CHUNK_SIZE) {
			return {
				handle: mirror.handle(),
				type: 'object',
				className: mirror.className(),
				vscode_size: size
				//value: mirror.className()
			};
		}
		return mirror;
	};

	/**
	 * This override removes the properties of large data structures from the lookup response
	 * and returns the size of the data structure instead.
 	 */
	DebugCommandProcessor.prototype.dispatch_['vscode_lookup'] = function(request, response) {
		var result = this.lookupRequest_(request, response);
		if (!result && response.body) {
			var handles = request.arguments.handles;
			for (var i = 0; i < handles.length; i++) {
				var handle = handles[i];
				response.body[handle] = dehydrate(response.body[handle]);
			}
		}
		return result;
	};

	/**
	 * This override removes the properties of large data structures from the lookup response
	 * and returns the size of the data structure instead.
 	 */
	DebugCommandProcessor.prototype.dispatch_['vscode_evaluate'] = function(request, response) {
		var result = this.evaluateRequest_(request, response);
		if (!result) {
			response.body = dehydrate(response.body);
		}
		return result;
	};

	/**
	 * This override trims the maximum number of local variables to 'maxLocals'.
	 */
	DebugCommandProcessor.prototype.dispatch_['vscode_scopes'] = function(request, response) {
		var result = this.scopesRequest_(request, response);
		if (!result) {
			var maxLocals = request.arguments.maxLocals;
			var scopes = response.body.scopes;
			for (var i = 0; i < scopes.length-1; i++) {
				const details = scopes[i].details_.details_;
				if (details && details[0] === 1) {	// locals
					const locals = details[1];
					const names = Object.keys(locals);
					if (names.length > maxLocals) {
						var locals2 = {};
						for (var j = 0; j < maxLocals; j++) {
							var name = names[j];
							locals2[name] = locals[name];
						}
						details[1] = locals2;
						response.body.vscode_locals = names.length;	// remember original number of locals
					}
				}
			}
		}
		return result;
	};
}()