import {colors} from "./_color_client";
import {IDebugger} from "./create-logger";
import {LOG_LEVEL} from "./levels";
import {currentLevel, loggers} from "./vars";

function isError(level: LOG_LEVEL) {
	return LOG_LEVEL.EMERG === level ||
	       LOG_LEVEL.ERROR === level;
}

function isInfo(level: LOG_LEVEL) {
	return LOG_LEVEL.NOTICE === level;
}

const noop = () => {
};

/** @internal */
export function createLoggerClient(level: LOG_LEVEL = LOG_LEVEL.INFO, title: string): IDebugger {
	if (!LOG_LEVEL.hasOwnProperty(level)) {
		throw new Error(`unknown log level: ${level}`);
	}
	let levelName = LOG_LEVEL[level];
	const levelId = levelName;
	let myLevel = level, currentLogFn;
	
	const id = (title || 'default') + '-' + levelId;
	if (loggers[id]) {
		return loggers[id];
	}
	
	while (levelName.length < 6) {
		levelName += ' ';
	}
	
	let logFn = isError(level)
		? console.warn.bind(console)
		: isInfo(level)
			? console.info.bind(console)
			: console.log.bind(console);
	
	function switchFn() {
		if (log_func.enabled) {
			currentLogFn = logFn;
		} else {
			currentLogFn = noop;
		}
	}
	
	const log_func: any = (...args) => {
		const arg0 = args.shift();
		let hints: string[];
		if (typeof arg0 === 'object' || typeof arg0 === 'function') {
			hints = ['%c[%s]%c %O', colors[levelId], levelName, colors.reset, arg0];
		} else if (typeof arg0 === 'string') {
			hints = ['%c[%s]%c ' + arg0, colors[levelId], levelName, colors.reset];
		} else {
			hints = ['%c[%s]%c %s', colors[levelId], levelName, colors.reset, arg0];
		}
		hints[0] = hints[0].replace(/%j/, '%O');
		currentLogFn(...hints, ...args)
	};
	
	Object.defineProperty(log_func, 'level', {
		get() {
			return myLevel;
		},
		set(level) {
			const before = log_func.enabled;
			myLevel = level;
			const after = log_func.enabled;
			if (before !== after) {
				switchFn();
			}
		},
	});
	Object.defineProperty(log_func, 'enabled', {
		get() {
			return level <= myLevel;
		},
	});
	Object.defineProperty(log_func, 'fn', {
		get() {
			return logFn;
		},
		set(v: (...args: any[]) => void) {
			if (typeof v !== 'function') {
				throw new TypeError('log function must be a function type.');
			}
			logFn = v;
			switchFn();
		},
	});
	
	switchFn();
	if (currentLevel) {
		log_func.level = currentLevel;
	}
	
	loggers[id] = log_func;
	return log_func;
}