'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;