const moment = require('moment');

// constants
const LOG_PREFIX_DEBUG = 'debug';
const LOG_PREFIX_INFO = 'info';
const LOG_PREFIX_WARNING = 'warning';
const LOG_PREFIX_ERROR = 'error';
const LOGLEVEL_DEBUG = 0;
const LOGLEVEL_INFO = 1;
const LOGLEVEL_WARNING = 2;
const LOGLEVEL_ERROR = 3;

let loglevel;
let timestamp;

initialize();

function initialize(loglevel, timestamp) {
    setLogLevel(loglevel || global.config?.log?.level);
    setTimestamp(timestamp || global.config?.log?.timestamp);
}

// set the loglevel
function setLogLevel(value) {
    switch (value) {
        case LOG_PREFIX_DEBUG:
        case LOGLEVEL_DEBUG:
            loglevel = LOGLEVEL_DEBUG;
            break;
        case LOG_PREFIX_INFO:
        case LOGLEVEL_INFO:
            loglevel = LOGLEVEL_INFO;
            break;
        case LOG_PREFIX_WARNING:
        case LOGLEVEL_WARNING:
            loglevel = LOGLEVEL_WARNING;
            break;
        case LOG_PREFIX_ERROR:
        case LOGLEVEL_ERROR:
            loglevel = LOGLEVEL_ERROR;
            break;
        default:
            loglevel = LOGLEVEL_INFO;
            break;
    }
}

// get the timestamp format
function setTimestamp(value) {
    timestamp = value || 'DD.MM.YYYY HH:mm:ss:SS';
}

// log a http request - response object
function http(object) {
    if (object === undefined) {
        return;
    }
    let message = '[' + object.request.method + ':' + object.code + '] url: \'' + object.request.url + '\'';
    let counter = 1;
    for (let param in object.request.body) {
        message += ', parameter ' + counter + ': \'' + param + '=' + object.request.body[param] + '\'';
        counter++;
    }
    if (object.request.timestamp) {
        message += ' > ' + (new Date().getTime() - object.request.timestamp) + 'ms';
    }
    if (object.data) {
        message += ' > data: ' + object.data;
    }
    if (object.code != 200) {
        error(message.trim());
        return;
    }
    debug(message.trim());
}

// prefix log with 'info'
function info(message) {
    if (loglevel > LOGLEVEL_INFO) {
        return;
    }
    trace(message);
}

// prefix log with 'info'
function warn(message) {
    if (loglevel > LOGLEVEL_WARNING) {
        return;
    }
    trace(message, 'warning');
}

// prefix log with 'debug'
function debug(message) {
    if (loglevel > LOGLEVEL_DEBUG) {
        return;
    }
    trace(message, 'debug');
}

// prefix log with 'error'
function error(message) {
    if (loglevel > LOGLEVEL_ERROR) {
        return;
    }
    if (message.stack) {
        trace(message.stack, 'error');
        return;
    }
    if (message.errors !== undefined) {
        for (let index = 0; index < message.errors.length; index++) {
            trace(message.errors[index], 'error');
        }
        return;
    }
    if (message.message) {
        trace(message.message, 'error');
        return;
    }
    trace(message, 'error');
}

// default logging function
function trace(message, prefix) {
    if (message === undefined || message === null || message.length === 0) {
        return;
    }
    if (prefix === undefined || prefix === null || prefix.length === 0) {
        prefix = 'info';
    }
    let print;
    switch (prefix) {
        case 'error':
            print = console.error;
            break;
        case 'debug':
            print = console.debug;
            break;
        case 'warning':
            print = console.warn;
            break;
        default:
            print = console.log;
    }
    message = moment().format(timestamp) + ' | ' + prefix + ' > ' + message;
    print(message);
}

// exports
module.exports = {
    initialize,
    info,
    warn,
    debug,
    error,
    http
}