const Worker = require('@thinkmill/node-worker');

const myWorker = new Worker(
  'test-worker',
  ({ label, ordinal, timeoutMs }) => {
    return new Promise((resolve, reject) => {
      const takeMs = 4000 + (Math.random() * 1500);
      console.log(`Run #${ordinal} ..
        will take ${takeMs} ms`);
      setTimeout(() => {
        console.log(`Run #${ordinal} ..
          resolving`);
        resolve(true);
      }, takeMs);
    });
  }, {
    sleepMs: 5000,
    timeoutMs: 5 * 1000,
  }
);

myWorker.start();

const Worker = require('@thinkmill/node-worker');
const debug = require('debug')('workers:dequeue-things');
const Model = require('../models/queuedThings');

// Manage the dequeuing of things
const payload = async ({ label, ordinal, timeoutMs }) => {
  const runForMs = timeoutMs - 1000;
  const runUntil = new Date(Date.now() + runForMs);

  debug(`Running for ${runForMs} ms (until ${runUntil.toISOString()})`);

  return new Promise(async (resolve, reject) => {
    let processedCount = 0;
    let queueEmptied = false;
    let nextThing;

    try {
      do {
        await knex.transaction(async (trx) => {

          // Get the next thing from the queue
          nextThing = await Model.query(trx).findOne('isReady', true).whereNull('processedAt').orderBy('queuedAt');

          // The queue is empty; exit early
          if (!nextThing) {
            queueEmptied = true;
            return;
          }

          // Do whatever it is that things do
          // ..

          // Record that we've processed this thing
          await Model.query(trx).update({ processedAt: new Date() }).where({ id: nextThing.id });

          // Inc. our count
          processedCount++;
        });
      }
      while (new Date() < runUntil);
    }
    catch (err) {
      return reject(err);
    }

    // Output some debug info
    const summaryMsg = `DONE: ${processedCount} things processed, leaving the queue ${queueEmptied ? 'EMPTY' : 'NOT EMPTY'}`;
    debug(summaryMsg);

    // Resolve with a boolean indicating whether the payload should be re-invoked soon or after the normal sleep
    return resolve(queueEmptied);
  });
};

// Create the worker instance and start it
const worker = new Worker('dequeue-things', payload, { sleepMs: 60 * 1000 });
worker.start();