window.BunyanConfig = {"level":0};
/**
 * Bunyan.js
 *
 * Logging class for Javascript
 *
 * Copyright: (c) 2012 ÃÛÌÒTV.
 */

(function (window) {
	if (!window.console) {
		window.console = {
			log:function () {},
			debug:function () {},
			info:function () {},
			warn:function () {},
			error:function () {}
		};
	}

	if (window.Bunyan && window.Bunyan._isBunyanLogger) {
		window.Bunyan.configure(window.BunyanConfig || {});
		return;
	}

	var originalConsoleError = window.console && window.console.error;
	var levels = {
		off:0,
		error:1,
		warning:2,
		notice:3,
		info:4,
		debug:5
	};
	var defaults = {
		level:levels.off
	};

	var Bunyan = {
		_isBunyanLogger:true,
		_debug:false,
		_onerror:window.onerror,
		_config:defaults,
		_resourceErrorHandler:null,
		_unhandledRejectionHandler:null,
		_consoleMethods:{},
		_consoleHandlers:{},
		_logCount:0,
		_seenMessages:{},

		debug:function (bool) {
			Bunyan._debug = bool;
		},

		configure:function (config) {
			config = config || {};
			var level = typeof config.level === 'number' && config.level >= levels.off && config.level <= levels.debug
				? Math.floor(config.level)
				: defaults.level;
			Bunyan._config = {
				level:level
			};

			Bunyan.unload();
			if (Bunyan._config.level > levels.off) {
				Bunyan.load();
			}
		},

		logDebug:function (message, url, line) {
			Bunyan.logMessage(message, url, line, 'debug', null, 0, 'manual');
		},

		logError:function (message, url, line, column, error) {
			Bunyan.logMessage(message, url, line, 'error', error, column, 'uncaught_error');

			if (typeof Bunyan._onerror === 'function' && Bunyan._onerror !== Bunyan.logError) {
				return Bunyan._onerror.apply(window, arguments);
			}
		},

		logInfo:function (message, url, line) {
			Bunyan.logMessage(message, url, line, 'info', null, 0, 'manual');
		},

		logNotice:function (message, url, line) {
			Bunyan.logMessage(message, url, line, 'notice', null, 0, 'manual');
		},

		logWarning:function (message, url, line) {
			Bunyan.logMessage(message, url, line, 'warning', null, 0, 'manual');
		},

		autoload:function (doAutoload) {
			if (doAutoload) {
				Bunyan.load();
			} else {
				Bunyan.unload();
			}
		},

		logMessage:function (message, url, line, type, error, column, category) {
			if (!Bunyan.shouldLog(type) || !Bunyan.requiredCheck()) {
				return;
			}

			url = url && url !== 'undefined' ? url : window.location.href;
			line = line || 0;
			column = column || 0;
			type = type || 'info';
			category = category || 'manual';
			message = Bunyan.messageToString(message);

			var messageKey = [type, category, message, url, line, column].join('|');
			if (Bunyan._logCount >= 50 || Bunyan._seenMessages[messageKey]) {
				return;
			}
			Bunyan._logCount++;
			Bunyan._seenMessages[messageKey] = true;

			var stacktrace = error && error.stack ? error.stack : '';
			var data = Bunyan.encodeFormData({
				type:type,
				category:category,
				message:message,
				url:url,
				line:line,
				column:column,
				errorpage:window.location.href,
				stacktrace:stacktrace
			});
			try {
				var xhr = new window.XMLHttpRequest();
				xhr.open('POST', '/api/js-log.php', true);
				xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded; charset=UTF-8');
				xhr.setRequestHeader('X-Logger-Script', 'bunyan.js');
				xhr.setRequestHeader('X-Requested-With', 'XMLHttpRequest');

				var transactionId = Bunyan.transactionId();
				if (transactionId) {
					xhr.setRequestHeader('X-DC-TransactionId', transactionId);
				}

				if (Bunyan._debug) {
					xhr.onreadystatechange = function () {
						if (xhr.readyState !== 4) {
							return;
						}
						if (xhr.status >= 200 && xhr.status < 300) {
							Bunyan.consoleLog('Message logged successfully: ' + message);
						} else {
							Bunyan.consoleError('Could not log message to server. Status returned: ' + xhr.status);
						}
					}
				}

				xhr.send(data);
			} catch (transportError) {
				if (Bunyan._debug) {
					Bunyan.consoleError('Could not log message to server.');
				}
			}
		},

		load:function () {
			if (Bunyan.shouldLog('error')) {
				if (window.onerror !== Bunyan.logError) {
					Bunyan._onerror = window.onerror;
					window.onerror = Bunyan.logError;
				}
				Bunyan.loadResourceErrors();
				Bunyan.loadUnhandledRejections();
				Bunyan.loadConsoleMethod('error', 'error');
			}

			if (Bunyan.shouldLog('warning')) {
				Bunyan.loadConsoleMethod('warn', 'warning');
			}

			if (Bunyan.shouldLog('info')) {
				Bunyan.loadConsoleMethod('info', 'info');
			}

			if (Bunyan.shouldLog('debug')) {
				Bunyan.loadConsoleMethod('debug', 'debug');
			}
		},

		unload:function () {
			Bunyan.resetWindowError();

			if (window.removeEventListener && Bunyan._resourceErrorHandler) {
				window.removeEventListener('error', Bunyan._resourceErrorHandler, true);
			}
			if (window.removeEventListener && Bunyan._unhandledRejectionHandler) {
				window.removeEventListener('unhandledrejection', Bunyan._unhandledRejectionHandler, false);
			}
			for (var method in Bunyan._consoleHandlers) {
				if (
					Object.prototype.hasOwnProperty.call(Bunyan._consoleHandlers, method)
					&& window.console[method] === Bunyan._consoleHandlers[method]
				) {
					window.console[method] = Bunyan._consoleMethods[method];
				}
			}

			Bunyan._resourceErrorHandler = null;
			Bunyan._unhandledRejectionHandler = null;
			Bunyan._consoleMethods = {};
			Bunyan._consoleHandlers = {};
		},

		reload:function () {
			if (Bunyan._config.level === levels.off) {
				return;
			}
			Bunyan.load();
		},

		loadCustomError:function (customError) {
			window.onerror = customError;
		},

		resetWindowError:function () {
			if (window.onerror === Bunyan.logError) {
				window.onerror = Bunyan._onerror;
			}
		},

		loadResourceErrors:function () {
			if (!window.addEventListener || Bunyan._resourceErrorHandler) {
				return;
			}

			Bunyan._resourceErrorHandler = function (event) {
				if (event.error || event.target === window) {
					return;
				}
				var target = event.target || {};
				var source = target.src || target.href || window.location.href;
				var name = target.tagName ? target.tagName.toLowerCase() : 'resource';
				var type = Bunyan.resourceErrorType(name);
				Bunyan.logMessage('Failed to load ' + name + ': ' + source, source, 0, type, null, 0, 'resource_error');
			};
			window.addEventListener('error', Bunyan._resourceErrorHandler, true);
		},

		loadUnhandledRejections:function () {
			if (!window.addEventListener || Bunyan._unhandledRejectionHandler) {
				return;
			}

			Bunyan._unhandledRejectionHandler = function (event) {
				var reason = event.reason;
				var message = reason && reason.message ? reason.message : reason;
				Bunyan.logMessage(message || 'Unhandled promise rejection', window.location.href, 0, 'error', reason, 0, 'unhandled_rejection');
			};
			window.addEventListener('unhandledrejection', Bunyan._unhandledRejectionHandler, false);
		},

		loadConsoleMethod:function (method, type) {
			if (!window.console || typeof window.console[method] !== 'function' || Bunyan._consoleHandlers[method]) {
				return;
			}

			Bunyan._consoleMethods[method] = window.console[method];
			Bunyan._consoleHandlers[method] = function () {
				Bunyan._consoleMethods[method].apply(window.console, arguments);
				var args = Array.prototype.slice.call(arguments);
				var error = null;
				for (var i = 0; i < args.length; i++) {
					if (args[i] && args[i].stack) {
						error = args[i];
						break;
					}
				}
				Bunyan.logMessage(args, window.location.href, 0, type, error, 0, 'console_' + method);
			};
			window.console[method] = Bunyan._consoleHandlers[method];
		},

		shouldLog:function (type) {
			return Object.prototype.hasOwnProperty.call(levels, type) && Bunyan._config.level >= levels[type];
		},

		resourceErrorType:function (tagName) {
			if (tagName === 'script') {
				return 'error';
			}
			if (tagName === 'img' || tagName === 'audio' || tagName === 'video' || tagName === 'source' || tagName === 'track') {
				return 'notice';
			}
			return 'warning';
		},

		requiredCheck:function () {
			return typeof window.XMLHttpRequest === 'function' || typeof window.XMLHttpRequest === 'object';
		},

		encodeFormData:function (data) {
			var values = [];
			for (var name in data) {
				if (Object.prototype.hasOwnProperty.call(data, name)) {
					values.push(encodeURIComponent(name) + '=' + encodeURIComponent(data[name] == null ? '' : data[name]));
				}
			}
			return values.join('&').replace(/%20/g, '+');
		},

		messageToString:function (message) {
			if (Object.prototype.toString.call(message) === '[object Array]') {
				var values = [];
				for (var i = 0; i < message.length; i++) {
					values.push(Bunyan.messageToString(message[i]));
				}
				return values.join(' ');
			}
			if (message && typeof message === 'object') {
				if (typeof message.message === 'string') {
					return message.message;
				}

				try {
					return JSON.stringify(message);
				} catch (ignore) {
					return String(message);
				}
			}
			return String(message == null ? '' : message);
		},

		transactionId:function () {
			if (typeof window.g_transaction_id === 'string') {
				return window.g_transaction_id;
			}
			if (window.document && window.document.querySelector) {
				var element = window.document.querySelector('meta[name="ti:page_transaction_id"]');
				return element ? element.getAttribute('content') : '';
			}
			return '';
		},

		consoleLog:function (message) {
			if (window.console && typeof window.console.log === 'function') {
				window.console.log(message);
			}
		},

		consoleError:function (message) {
			if (typeof originalConsoleError === 'function') {
				originalConsoleError.call(window.console, message);
			}
		}
	};

	window.Bunyan = Bunyan;
	Bunyan.configure(window.BunyanConfig || {});
})(window);