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

import * as EE from 'events';

export class NodeV8Message {
	seq: number;
	type: string;

	public constructor(type: string) {
		this.seq = 0;
		this.type = type;
	}
}

export class NodeV8Response extends NodeV8Message {
	request_seq: number;
	success: boolean;
	running:  boolean;
	command: string;
	message: string;
	body: any;
	refs: any;

	public constructor(request: NodeV8Response, message?: string) {
		super('response');
		this.request_seq = request.seq;
		this.command = request.command;
		if (message) {
			this.success = false;
			this.message = message;
		} else {
			this.success = true;
		}
	}
}

export class NodeV8Event extends NodeV8Message {
	event: string;
	body: any;

	public constructor(event: string, body?: any) {
		super('event');
		this.event = event;
		if (body) {
			this.body = body;
		}
	}
}

export class NodeV8Protocol extends EE.EventEmitter {

	private static TIMEOUT = 3000;

	private _state: string;
	private _contentLength: number;
	private _bodyStartByteIndex: number;
	private _res: any;
	private _sequence: number;
	private _writableStream: NodeJS.WritableStream;
	private _pendingRequests = new Map<number, NodeV8Response>();
	private _unresponsiveMode: boolean;

	public embeddedHostVersion: number = -1;


	public startDispatch(inStream: NodeJS.ReadableStream, outStream: NodeJS.WritableStream): void {
		this._sequence = 1;
		this._writableStream = outStream;
		this._newRes(null);

		inStream.setEncoding('utf8');

		inStream.on('data', (data) => this.execute(data));
		inStream.on('close', () => {
			this.emitEvent(new NodeV8Event('close'));
		});
		inStream.on('error', (error) => {
			this.emitEvent(new NodeV8Event('error'));
		});

		outStream.on('error', (error) => {
			this.emitEvent(new NodeV8Event('error'));
		});

		inStream.resume();
	}

	public stop(): void {
		if (this._writableStream) {
			this._writableStream.end();
		}
	}

	public command(command: string, args?: any, cb?: (response: NodeV8Response) => void): void {

		const timeout = NodeV8Protocol.TIMEOUT;

		const request: any = {
			command: command
		};
		if (args && Object.keys(args).length > 0) {
			request.arguments = args;
		}

		if (this._unresponsiveMode) {
			if (cb) {
				cb(new NodeV8Response(request, 'cancelled because node is unresponsive'));
			}
			return;
		}

		this.send('request', request);

		if (cb) {
			this._pendingRequests[request.seq] = cb;

			const timer = setTimeout(() => {
				clearTimeout(timer);
				const clb = this._pendingRequests[request.seq];
				if (clb) {
					delete this._pendingRequests[request.seq];
					clb(new NodeV8Response(request, 'timeout after ' + timeout + 'ms'));

					this._unresponsiveMode = true;
					this.emitEvent(new NodeV8Event('diagnostic', { reason: 'unresponsive ' + command }));
				}
			}, timeout);
		}
	}

	public command2(command: string, args: any, timeout: number = NodeV8Protocol.TIMEOUT): Promise<NodeV8Response> {
		return new Promise((completeDispatch, errorDispatch) => {
			this.command(command, args, (result: NodeV8Response) => {
				if (result.success) {
					completeDispatch(result);
				} else {
					errorDispatch(result);
				}
			});
		});
	}

	public sendEvent(event: NodeV8Event): void {
		this.send('event', event);
	}

	public sendResponse(response: NodeV8Response): void {
		if (response.seq > 0) {
			console.error('attempt to send more than one response for command {0}', response.command);
		} else {
			this.send('response', response);
		}
	}

	// ---- private ------------------------------------------------------------

	private emitEvent(event: NodeV8Event) {
		this.emit(event.event, event);
	}

	private send(typ: string, message: NodeV8Message): void {
		message.type = typ;
		message.seq = this._sequence++;
		const json = JSON.stringify(message);
		const data = 'Content-Length: ' + Buffer.byteLength(json, 'utf8') + '\r\n\r\n' + json;
		if (this._writableStream) {
			this._writableStream.write(data);
		}
	}

	private _newRes(raw: string): void {
		this._res = {
			raw: raw || '',
			headers: {}
		};
		this._state = 'headers';
		this.execute('');
	}

	private internalDispatch(message: NodeV8Message): void {
		switch (message.type) {
		case 'event':
			const e = <NodeV8Event> message;
			this.emitEvent(e);
			break;
		case 'response':
			if (this._unresponsiveMode) {
				this._unresponsiveMode = false;
				this.emitEvent(new NodeV8Event('diagnostic', { reason: 'responsive' }));
			}
			const response = <NodeV8Response> message;
			const clb = this._pendingRequests[response.request_seq];
			if (clb) {
				delete this._pendingRequests[response.request_seq];
				clb(response);
			}
			break;
		default:
			break;
		}
	}

	private execute(d): void {
		const res = this._res;
		res.raw += d;

		switch (this._state) {
			case 'headers':
				const endHeaderIndex = res.raw.indexOf('\r\n\r\n');
				if (endHeaderIndex < 0)
					break;

				const rawHeader = res.raw.slice(0, endHeaderIndex);
				const endHeaderByteIndex = Buffer.byteLength(rawHeader, 'utf8');
				const lines = rawHeader.split('\r\n');
				for (let i = 0; i < lines.length; i++) {
					const kv = lines[i].split(/: +/);
					res.headers[kv[0]] = kv[1];
					if (kv[0] === 'Embedding-Host') {
						const match = kv[1].match(/node\sv(\d+)\.\d+\.\d+/)
						if (match && match.length === 2) {
							this.embeddedHostVersion = parseInt(match[1]);
						} else if (kv[1] === 'Electron') {
							this.embeddedHostVersion = 4;
						}
					}
				}

				this._contentLength = +res.headers['Content-Length'];
				this._bodyStartByteIndex = endHeaderByteIndex + 4;

				this._state = 'body';

				const len = Buffer.byteLength(res.raw, 'utf8');
				if (len - this._bodyStartByteIndex < this._contentLength) {
					break;
				}
			// pass thru

			case 'body':
				const resRawByteLength = Buffer.byteLength(res.raw, 'utf8');
				if (resRawByteLength - this._bodyStartByteIndex >= this._contentLength) {
					const buf = new Buffer(resRawByteLength);
					buf.write(res.raw, 0, resRawByteLength, 'utf8');
					res.body = buf.slice(this._bodyStartByteIndex, this._bodyStartByteIndex + this._contentLength).toString('utf8');
					res.body = res.body.length ? JSON.parse(res.body) : {};
					this.internalDispatch(res.body);
					this._newRes(buf.slice(this._bodyStartByteIndex + this._contentLength).toString('utf8'));
				}
				break;

			default:
				throw new Error('Unknown state');
				break;
		}
	}
}