'use strict';

const locks = require('locks');
const logger = require('komodo-sdk/logger');

const mutexWaitForOK = locks.createMutex();
const mutexCommand = locks.createMutex();

const mutexSubCommand = locks.createMutex();

function setLockWaitForOK() {
    logger.verbose('Entering MUTEX OK');
    return new Promise((resolve) => {
        mutexWaitForOK.lock(() => {
            logger.verbose('MUTEX OK entered');
            resolve(true);
        });
    });
}

function releaseLockWaitForOK() {
    try {
        logger.verbose('Leaving MUTEX OK');
        mutexWaitForOK.unlock();
    } catch (e) {
        //
    }
}

function setLockWaitForCommand() {
    logger.verbose('Entering MUTEX Command');
    return new Promise((resolve) => {
        mutexCommand.lock(() => {
            logger.verbose('MUTEX Command entered');
            resolve(true);
        });
    });
}

function tryLockWaitForCommand() {
    return mutexCommand.tryLock();
}


function releaseLockWaitForCommand() {
    try {
        logger.verbose('Leaving MUTEX Command');
        mutexCommand.unlock();
    } catch (e) {
        //
    }
}

function setLockWaitForSubCommand() {
    logger.verbose('Entering MUTEX SUBCOMMAND');
    return new Promise((resolve) => {
        mutexSubCommand.lock(() => {
            logger.verbose('MUTEX SUBCOMMAND entered');
            resolve(true);
        });
    });
}

function releaseLockWaitForSubCommand() {
    try {
        logger.verbose('Leaving MUTEX SUBCOMMAND');
        mutexSubCommand.unlock();
    } catch (e) {
        //
    }
}

exports.setLockWaitForOK = setLockWaitForOK;
exports.releaseLockWaitForOK = releaseLockWaitForOK;

exports.setLockWaitForCommand = setLockWaitForCommand;
exports.releaseLockWaitForCommand = releaseLockWaitForCommand;
exports.tryLockWaitForCommand = tryLockWaitForCommand;

exports.setLockWaitForSubCommand = setLockWaitForSubCommand;
exports.releaseLockWaitForSubCommand = releaseLockWaitForSubCommand;