'use strict';

const locks = require('locks');

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

const mutexSubCommand = locks.createMutex();

function setLockWaitForOK() {
    return new Promise((resolve) => {
        mutexWaitForOK.lock(() => {
            resolve(true);
        });
    });
}

function releaseLockWaitForOK() {
    try {
        mutexWaitForOK.unlock();
    } catch (e) {
        //
    }
}

function setLockWaitForCommand() {
    return new Promise((resolve) => {
        mutexCommand.lock(() => {
            resolve(true);
        });
    });
}

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


function releaseLockWaitForCommand() {
    try {
        mutexCommand.unlock();
    } catch (e) {
        //
    }
}

function setLockWaitForSubCommand() {
    return new Promise((resolve) => {
        mutexSubCommand.lock(() => {
            resolve(true);
        });
    });
}

function releaseLockWaitForSubCommand() {
    // mutexSubCommand.unlock();

    try {
        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;