/**

* This is the common logic for both the Node.js and web browser
* implementations of `debug()`.
*/

function setup(env) {
createDebug.debug = createDebug;
createDebug.default = createDebug;
createDebug.coerce = coerce;
createDebug.disable = disable;
createDebug.enable = enable;
createDebug.enabled = enabled;
createDebug.humanize = require('ms');
createDebug.destroy = destroy;

Object.keys(env).forEach(key => {
createDebug[key] = env[key];
});

/**
* The currently active debug mode names, and names to skip.
*/

createDebug.names = [];
createDebug.skips = [];

/**
* Map of special "%n" handling functions, for the debug "format" argument.
*
* Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
*/
createDebug.formatters = {};

/**
* Selects a color for a debug namespace
* @param {String} namespace The namespace string for the debug instance to be
colored
* @return {Number|String} An ANSI color code for the given namespace
* @api private
*/
function selectColor(namespace) {
let hash = 0;

for (let i = 0; i < namespace.length; i++) {

hash = ((hash << 5) - hash) + namespace.charCodeAt(i);
hash |= 0; // Convert to 32bit integer
}

return createDebug.colors[Math.abs(hash) % createDebug.colors.length];

}
createDebug.selectColor = selectColor;

/**
* Create a debugger with the given `namespace`.
*
* @param {String} namespace
* @return {Function}
* @api public
 */
function createDebug(namespace) {
let prevTime;
let enableOverride = null;
let namespacesCache;
let enabledCache;

function debug(...args) {
// Disabled?
if (!debug.enabled) {
return;
}

const self = debug;

// Set `diff` timestamp

const curr = Number(new Date());
const ms = curr - (prevTime || curr);
self.diff = ms;
self.prev = prevTime;
self.curr = curr;
prevTime = curr;

args[0] = createDebug.coerce(args[0]);

if (typeof args[0] !== 'string') {

// Anything else let's inspect with %O
args.unshift('%O');
}

// Apply any `formatters` transformations

let index = 0;
args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
// If we encounter an escaped % then don't increase the
array index
if (match === '%%') {
return '%';
}
index++;
const formatter = createDebug.formatters[format];
if (typeof formatter === 'function') {
const val = args[index];
match = formatter.call(self, val);

// Now we need to remove `args[index]` since it's

inlined in the `format`
args.splice(index, 1);
index--;
}
return match;
});

// Apply env-specific formatting (colors, etc.)

createDebug.formatArgs.call(self, args);

const logFn = self.log || createDebug.log;

logFn.apply(self, args);
}
 debug.namespace = namespace;
debug.useColors = createDebug.useColors();
debug.color = createDebug.selectColor(namespace);
debug.extend = extend;
debug.destroy = createDebug.destroy; // XXX Temporary. Will be removed
in the next major release.

Object.defineProperty(debug, 'enabled', {
enumerable: true,
configurable: false,
get: () => {
if (enableOverride !== null) {
return enableOverride;
}
if (namespacesCache !== createDebug.namespaces) {
namespacesCache = createDebug.namespaces;
enabledCache = createDebug.enabled(namespace);
}

return enabledCache;
},
set: v => {
enableOverride = v;
}
});

// Env-specific initialization logic for debug instances

if (typeof createDebug.init === 'function') {
createDebug.init(debug);
}

return debug;
}

function extend(namespace, delimiter) {

const newDebug = createDebug(this.namespace + (typeof delimiter ===
'undefined' ? ':' : delimiter) + namespace);
newDebug.log = this.log;
return newDebug;
}

/**
* Enables a debug mode by namespaces. This can include modes
* separated by a colon and wildcards.
*
* @param {String} namespaces
* @api public
*/
function enable(namespaces) {
createDebug.save(namespaces);
createDebug.namespaces = namespaces;

createDebug.names = [];
createDebug.skips = [];

let i;
const split = (typeof namespaces === 'string' ? namespaces :
'').split(/[\s,]+/);
const len = split.length;
 for (i = 0; i < len; i++) {
if (!split[i]) {
// ignore empty strings
continue;
}

namespaces = split[i].replace(/\*/g, '.*?');

if (namespaces[0] === '-') {

createDebug.skips.push(new RegExp('^' + namespaces.slice(1)
+ '$'));
} else {
createDebug.names.push(new RegExp('^' + namespaces + '$'));
}
}
}

/**
* Disable debug output.
*
* @return {String} namespaces
* @api public
*/
function disable() {
const namespaces = [
...createDebug.names.map(toNamespace),
...createDebug.skips.map(toNamespace).map(namespace => '-' +
namespace)
].join(',');
createDebug.enable('');
return namespaces;
}

/**
* Returns true if the given mode name is enabled, false otherwise.
*
* @param {String} name
* @return {Boolean}
* @api public
*/
function enabled(name) {
if (name[name.length - 1] === '*') {
return true;
}

let i;
let len;

for (i = 0, len = createDebug.skips.length; i < len; i++) {

if (createDebug.skips[i].test(name)) {
return false;
}
}

for (i = 0, len = createDebug.names.length; i < len; i++) {

if (createDebug.names[i].test(name)) {
return true;
}
 }

return false;
}

/**
* Convert regexp to namespace
*
* @param {RegExp} regxep
* @return {String} namespace
* @api private
*/
function toNamespace(regexp) {
return regexp.toString()
.substring(2, regexp.toString().length - 2)
.replace(/\.\*\?$/, '*');
}

/**
* Coerce `val`.
*
* @param {Mixed} val
* @return {Mixed}
* @api private
*/
function coerce(val) {
if (val instanceof Error) {
return val.stack || val.message;
}
return val;
}

/**
* XXX DO NOT USE. This is a temporary stub function.
* XXX It WILL be removed in the next major release.
*/
function destroy() {
console.warn('Instance method `debug.destroy()` is deprecated and no
longer does anything. It will be removed in the next major version of `debug`.');
}

createDebug.enable(createDebug.load());

return createDebug;
}

module.exports = setup;