const utils = require('./utils');
const Request = require('request');
const async = require('async');
const io = require('socket.io-client');
const Mumble = require('./mumble');
const currentPath = require('path').dirname(require.main.filename);
const fs = require('fs');
const lame = require('lame');
const Speaker = require('speaker');
const Resampler = require('libsamplerate.js');
const chunker = require('stream-chunker');
const Transform = require('stream').Transform;
const Throttle = require('stream-throttle').Throttle;
const chalk = require('chalk');
const OpusEncoder = require('node-opus').OpusEncoder;

const log = require('./utils').log

class Asset {

	constructor(id, configs, token) {

		this.id = id;
		this.token = token;
		this.configs = configs
		this._processConfigs();
		this.startTime = +new Date();
		this.pttEndSuccessfully = false;
		this.assetProps = {};

		utils.writeLog(`Creating asset ${id}`)

		// Do async work: Init asset.
		async.waterfall([
			this._getDataFromApi.bind(this),
			this._connectToHub.bind(this),
			this._connectToMurmur.bind(this),
			this._register.bind(this),
			this._moveToChannel.bind(this),
		],
		(err, result) => {
			utils.writeLog(`Asset ${this.id} was successfully initialized`)

			if (err) {
				utils.writeLog(`Asset ${this.id} was not successfully initialized`, err);
				return;
			}

			// Start simulating...
			this._start();
		});
	}

	_processConfigs() {
		let apiConfig = this.configs.api;

		this.apiEndpoint = apiConfig.use_secure ? 'https' : 'http';
		this.apiEndpoint += '://' +  apiConfig.host + (apiConfig.port ? (':' + apiConfig.port) : '');

		this.soundPath = currentPath;
		// this.soundPath += '/sounds/sound.mp3';
		this.soundPath += '/sounds/' + this.configs.sounds['sound'];
		// if (this.configs.sounds['custom' + this.id]) {

		// 	// Custom path sound.
		// 	this.soundPath += '/sounds/' + this.configs.sounds['custom' + this.id];
		// } else {

		// 	// Normal path sound.
		// 	this.soundPath += '/sounds/sample' + (this.id % this.configs.sounds.sounds_total_number) + '.mp3';
		// }
	}

	_getDataFromApi(callback) {
		utils.writeLog(`Get informations about asset ${this.id}`);
		Request.get(
			this.apiEndpoint + '/asset/' + this.id,
			{
				headers: {
					Authorization: `Bearer ${this.token}`
				}
			},
			(error, response, body) => {
				if (!error && (response.statusCode === 200 || response.statusCode === 201)) {
					let bodyObj = JSON.parse(body);

					// Here are the asset fields.
					this.assetProps = bodyObj.data;
					// console.log('!!!!!!!!!!!!!!!!!!!!!!!!!!!!', this.assetProps)
					return this._getGroupsFromApi(callback);
				} else {
					utils.writeLog(`ERROR getting informations about asset ${this.id}`, error);
					utils.writeErrorLog(`ERROR_API`);
					return callback(error);
				}
			}
		);
	}

	_getGroupsFromApi(callback) {

		Request.get(
			this.apiEndpoint + '/asset/ ' + this.id + '/groups',
			{
				headers: {
					Authorization: `Bearer ${this.token}`
				}
			},
			(error, response, body) => {
				if (!error && (response.statusCode === 200 || response.statusCode === 201)) {

					let bodyObj = JSON.parse(body);

					this.groups = bodyObj.data;

					// Find what group this asset is monitoring.
					this.groups.forEach((g) => {
						if (g.is_talk_group && g.monitoring.indexOf(this.id) != -1) {
							this.groupId = g.id;
							this.groupSipId = g.sip_id;
							this.groupName = g.name;
						}
					});

					if (!this.groupId) {
						return callback('No talk group assigned to ' + this.id);
					}
					utils.writeLog(`Informations about asset ${this.id} received`)
					return callback();
				} else {
					utils.writeLog(`Error getting informations about asset ${this.id}`, error);
					utils.writeErrorLog(`ERROR_API`);
					return callback(error);
				}
			}
		);
	}

	_connectToHub(callback) {

		let hubAddress = this.configs.hub.address;
		let options = {rejectUnauthorized: false, secure: true};
		let hub = io(hubAddress, options);
		this.hub = hub;

		// Disconnect event
		hub.on('disconnect', () => {
			utils.writeLog(`Asset ${this.id} disconnected from HUB`);
		});

		hub.on('connect_timeout', () => {
			utils.writeLog(`Asset ${this.id} connect_timeout from HUB`);
			utils.writeErrorLog(`ERROR_HUB`);
		});

		hub.on('connect_error', () => {
			utils.writeLog(`Asset ${this.id} connect_error from HUB`);
			utils.writeErrorLog(`ERROR_HUB`);
		});

		hub.once('connect', () => {
			return callback();
		});
		hub.on('connect', () => {
			utils.writeLog(`Asset ${this.id} connected to HUB`);
			this._sendArs();
		});

		hub.on('ptt-press', data => {
			// this._log('ptt-press received');
		});

		hub.on('ptt-release', data => {
			// this._log('ptt-release received');
		});

		hub.on('reload', data => {
			// this._log('reload received');
		});
	}

	_sendArs() {
		let hub = this.hub;
		if (hub && hub.connected) {
			utils.writeLog(`Asset ${this.id} sending ARS`)
			hub.emit('ars', JSON.stringify({
				ars: true,
				userAgent: 'android',
				asset_id: this.id,
				account_id: this.assetProps.account_id,
				asset_sip_id : this.assetProps.sip_id,
				fake: false
			}));
		}
	}

	_connectToMurmur(callback) {

		this.mumble = new Mumble(this.id, this.configs, (err) => {
			if (err) {
				utils.writeLog(`Asset ${this.id} Murmur connection error`, err);
				utils.writeErrorLog(`ERROR_MURMUR`);
				return callback(err);
			} else {
				// return callback();
				setTimeout(()=> {
					return callback();
				}, 1000);
			}
		});
	}

	_register(callback) {
		Request.post(
			this.apiEndpoint + '/audio/register/' + this.id,
			{
				headers: {
					Authorization: `Bearer ${this.token}`
				}
			},
			(error, response, body) => {
				if (!error && (response.statusCode === 200 || response.statusCode === 201)) {
					utils.writeLog(`Asset ${this.id} audio registered`);
					return callback();
				} else {
					console.log('_register--------------------')
					console.log('error---', error)
					console.log('response---', response)
					console.log('body---', body)
					// utils.writeLog(`Asset ${this.id} audio registered error`, error);
					// utils.writeErrorLog(`ERROR_API`);
					// return callback(error);
				}
			}
		);
	}

	_moveToChannel(callback) {
		Request.post(
			this.apiEndpoint + '/audio/enter-group/' + this.id + '/' + this.groupId,
			{
				headers: {
					Authorization: `Bearer ${this.token}`
				}
			},
			(error, response, body) => {
				if (!error && (response.statusCode === 200 || response.statusCode === 201)) {
					let hub = this.hub;
					if (hub && hub.connected) {

						hub.emit('group-monitoring', JSON.stringify(
							{
								asset_id: this.id,
								asset_sip_id : this.assetProps.sip_id,
								asset_alias : this.assetProps.name,
								request_ptt_groups_status: false,
								group_sip_id: this.groupSipId,
								group_id: this.groupId,
								group_name: this.groupName,
								scan_group_ids: null
							}
						));
						utils.writeLog(`Asset ${this.id} mmonitoring group ${this.groupId}`)
						return callback();
					} else {
						return callback('Cannot send group-monitoring: Hub not connected');
					}
				} else {
					console.log('_moveToChannel--------------------')
					console.log('error---', error)
					console.log('response---', response)
					console.log('body---', body)
					// utils.writeLog(`Asset ${this.id} audio enter group error`, error);
					// utils.writeErrorLog(`ERROR_API`);
					// return callback(error);
				}
			}
		);
	}

	_start() {
		if(this.configs.settings.send_voice) {
			this._makePtt(() => {
				if(this.pttEndSuccessfully) {
					this._verifyRecorder();
				}
			});
		}

		if(this.configs.settings.send_gps) {
			this._sendGPS();
		}
	}

	_verifyRecorder(callback) {
		console.log(chalk.green(`Check to see if a record was created for the unit id: ${this.id} | name: ${this.assetProps.name}`));
		let startDate = parseInt(this.startTime) - 5000;
		let stopDate = parseInt(+new Date() + 30 * 1000);
		setTimeout(() => { this._getRecord(startDate, stopDate, this.configs); }, 3000);
	}

	_getRecord(startDate, stopDate, configs) {


		console.log(`${this.apiEndpoint}/asset-history/${this.id}/call-history/${startDate}/${stopDate}/10`);

		// console.log(this.apiEndpoint + `/history-pagination/1/300/${this.id}/${startDate}/${stopDate}/0/0/0/1/null`)
		Request.get(
			`${this.apiEndpoint}/asset-history/${this.id}/call-history/${startDate}/${stopDate}/10`,
			// this.apiEndpoint + `/history-pagination/1/300/${this.id}/${startDate}/${stopDate}/0/0/0/1/null`,
			{
				headers: {
					Authorization: `Bearer ${this.token}`
				}
			},
			(error, response, body) => {
				if(!error && (response.statusCode === 200 || response.statusCode === 201)) {
					let bodyObj = JSON.parse(body);
					// console.log('bodyObj', bodyObj)
					if(bodyObj.data.length > 0) {

						// Get the latest record
						let latest = { id: 0 }
						bodyObj.data.forEach(e => {
							if(e.id > latest.id) {
								latest = e;
							}
						})
						console.log(chalk.green(`[RECORDER] Record found(${latest.id}) for asset ${this.id} ✓`));
						utils.writeLog(`[RECORDER] Record found(${latest.id}) for asset ${this.id}`)
					} else {
						console.log(chalk.yellow(`[RECORDER] for asset ${this.id} not found`));
					}
				} else {
					utils.writeLog(`Error getting record for asset ${this.id} | ${error}`);
					utils.writeErrorLog(`ERROR_RECORDER`);
				}
				let assetIds = configs.assets.ids;

				// console.log('id', this.id, 'total', assetIds)
				// console.log('assetIds[0]', assetIds[0])
				// console.log('max', Math.max(...assetIds))
				if(Math.max(...assetIds) == this.id) {
					setTimeout(() => {
						utils.writeLog('STOP')
						.then(() => {
							process.exit(0);
						});
					}, 7000);
				}
				// const settings = configs.settings;
				// let testing_period = 1000;
				// if(settings.hasOwnProperty('testing_period')) { testing_period = parseInt(settings.testing_period, 10); }
				// const exit_time = 13000 + testing_period;
				// setTimeout(() => {
				// 	utils.writeLog('STOP')
				// 	.then(() => {
				// 		process.exit(0);
				// 	});
				// }, exit_time);

			}
		);
	}

	_makePtt(callback) {

		// Send ptt-press, transmit all the sound then send ptt-release.

		// Check hub.
		let hub = this.hub;
		if (!hub || !hub.connected) {
			return callback();
		}

		// Send ptt-press and wait for it to be accepted.
		this._sendPttPress((isAccepted) => {

			if (!isAccepted) {
				return callback();
			}

			// Ptt accepted. We can send voice.

			// Mp3 read stream.
			var mp3 = fs.createReadStream(this.soundPath);
			mp3.on('error', (e) => {
				utils.writeErrorLog(`Error _makePtt asset ${this.id}`, e);
			});
			
			mp3.on('data', (data) => {

			});

			// Decoded mp3.
			var lameDecoder = mp3
			.pipe(new lame.Decoder)
			.on('data', (data) => {

			})

			// On format we continue pipeing in. We need the mp3 format to know what to do next. Eg: To resample the mp3 we need to know the current sample rate.
			.on('format', (format) => {

				// Create resampler.
				var resampler = new Resampler({
					unsafe: false,
					type: Resampler.Type.ZERO_ORDER_HOLD,
					ratio: 48000 / format.sampleRate,
					channels: format.channels
				})

				// Create mumble voice stream.
				var voiceStream = this.mumble.client.createVoiceStream(0, format.channels);

				// Send ptt-release on voice end.
				voiceStream.on('end', () => {
					this.pttEndSuccessfully = true;
					setTimeout(() => {
						this._sendPttRelease();
						callback();
					}, 1500); // Hangtime
				});

				// @TODO: Ugly hack for the voice to work with mp3 (The fix is to remove float32ToInt16 conversion). It is the _transform function from OpusEncoderStream class (mumble-client-codecs-node project).
				voiceStream._readableState.pipes._transform = function(chunk, encoding, callback) {
					if (!this._opus) {
						this._opus = new OpusEncoder(48000, chunk.numberOfChannels);
					}

					callback(null, {
						target: chunk.target,
						codec: 'Opus',
						frame: this._opus.encode(chunk.pcm),
						position: chunk.position
					});
				}

				// This is used to slow down the mp3 transmision. Murmur will drop packages that are too early. This will make the mp3 transmision real time, just like it is a microphone stream.
				var throtler = new Transform({
					transform (data, _, callback) {
						setTimeout(() => {
							callback(null, data)
						}, 16 / format.channels)
					},
					readableObjectMode: true
				});

				// Used for converting buffer to float32. Needed for Murmur.
				const buffer2Float32Array = new Transform({
					transform (data, _, callback) {
					  callback(null, new Float32Array(data.buffer, data.byteOffset, data.byteLength / 4))
					},
					readableObjectMode: true
				});

				// Pipe on.
				lameDecoder

					// Make 4096 chunks to be like the microphone stream.
					.pipe(chunker(4096, {flush: true, align: true}))

					// Resample to 48000 hz.
					.pipe(resampler)

					// Make 4 * 480 chunks for Murmur purposes.
					.pipe(chunker(4 * 480, {flush: true, align: true}))

					// Slow down the stream.
					.pipe(throtler)

					// Convert to float 32.
					.pipe(buffer2Float32Array)

					// Used for testing in nodejs speaker.
					// .pipe(new Speaker)

					// Mumble voice stream.
					.pipe(voiceStream);
			});
		})
	}

	_sendGPS(callback) {
		let hub = this.hub;
		if (hub && hub.connected) {

			let lat = this.configs.settings.gps_lat_start_point;
			let lng = this.configs.settings.gps_lng_start_point;

			setInterval(() => {
				var new_lat = this._randomCoordinates(lat);
				var new_lng = this._randomCoordinates(lng);

				hub.emit('gps', JSON.stringify(
					{
						unix_time: 1467126677000,
						asset_id: this.assetProps.id,
						asset_sip_id: this.assetProps.sip_id,
						speed_kmh: 16,
						lat: new_lat,
						lng: new_lng,
						accuracy: 20.3,
						activity_type: "driving",
						activity_confidence: 90
					}
				));
				lat = new_lat;
				lng = new_lng;

			}, this.configs.settings.gps_report_interval);
		}
	}

	_randomCoordinates(coordinate) {
		if(Math.round(Math.random()) === 0) {
			return parseFloat(parseFloat(coordinate) - parseFloat((Math.random() * (0.01 - 0.005) + 0.005).toFixed(4))).toFixed(6);
		} else {
			return parseFloat(parseFloat(coordinate) + parseFloat((Math.random() * (0.01 - 0.005) + 0.005).toFixed(4))).toFixed(6);
		}
	}

	_sendPttPress(callback) {
		let hub = this.hub;
		if (hub && hub.connected) {

			var pttAcceptHandler = (data) => {
				data = JSON.parse(data);
				if (data.asset_id != this.id) {
					return;
				}
				utils.writeLog(`Asset ${this.id} sending PTT-PRESS to group ${this.groupId}`)
				hub.removeListener('ptt-deny', pttDenyHandler);
				callback(true);
			};
			hub.once('ptt-accept', pttAcceptHandler);

			var pttDenyHandler = (data) => {
				data = JSON.parse(data);
				if (data.asset_id != this.id) {
					return;
				}
				utils.writeLog(`Asset ${this.id} received PTT-DENY`);
				hub.removeListener('ptt-accept', pttAcceptHandler);
				callback(false);
			};
			hub.once('ptt-deny', pttDenyHandler);

			hub.emit('ptt-press', JSON.stringify(
				{
					destination_group_id: this.groupId,
					destination_group_sip_id: this.groupSipId,
					destination_asset_id: 0,
					destination_asset_sip_id: 0,
					asset_id: this.id,
					asset_sip_id: this.assetProps.sip_id,
					asset_alias : this.assetProps.name,
					priority : this.assetProps.priority,
					portable_asset_id: 0,
					portable_alias: null,
				}
			));
		}
	}

	_sendPttRelease() {
		let hub = this.hub;
		if (hub && hub.connected) {

			utils.writeLog(`Asset ${this.id} sending PTT-RELEASE to group ${this.groupId}`);
			hub.emit('ptt-release', JSON.stringify(
				{
					destination_group_id: this.groupId,
					destination_group_sip_id: this.groupSipId,
					destination_asset_id: 0,
					destination_asset_sip_id: 0,
					asset_id: this.id,
					asset_sip_id: this.assetProps.sip_id,
					asset_alias : this.assetProps.name,
					priority : this.assetProps.priority,
					portable_asset_id: 0,
					portable_alias: null,
				}
			));
		}
	}

}

module.exports = Asset;