'use strict';

const common = require('../common');
const tmpdir = require('../common/tmpdir');
const assert = require('assert');
const initHooks = require('./init-hooks');
const { checkInvocations } = require('./hook-checks');
const fs = require('fs');

const { isMainThread } = require('worker_threads');

if (!isMainThread) {
  common.skip('Worker bootstrapping works differently -> different async IDs');
}

tmpdir.refresh();

const file1 = tmpdir.resolve('file1');
const file2 = tmpdir.resolve('file2');

const onchangex = (x) => (curr, prev) => {
  console.log(`Watcher: ${x}`);
  console.log('current stat data:', curr);
  console.log('previous stat data:', prev);
};

const checkWatcherStart = common.mustCall((name, watcher) => {
  assert.strictEqual(watcher.type, 'STATWATCHER');
  assert.strictEqual(typeof watcher.uid, 'number');
  assert.strictEqual(watcher.triggerAsyncId, 1);
  checkInvocations(watcher, { init: 1 },
                   `${name}: when started to watch file`);
}, 2);

const hooks = initHooks();
hooks.enable();

// Install first file watcher.
const w1 = fs.watchFile(file1, { interval: 10 }, onchangex('w1'));
let as = hooks.activitiesOfTypes('STATWATCHER');
assert.strictEqual(as.length, 1);
// Count all change events to account for all of them in checkInvocations.
let w1HookCount = 0;
w1.on('change', () => w1HookCount++);

const statwatcher1 = as[0];
checkWatcherStart('watcher1', statwatcher1);

// Install second file watcher
const w2 = fs.watchFile(file2, { interval: 10 }, onchangex('w2'));
as = hooks.activitiesOfTypes('STATWATCHER');
assert.strictEqual(as.length, 2);
// Count all change events to account for all of them in checkInvocations.
let w2HookCount = 0;
w2.on('change', () => w2HookCount++);

const statwatcher2 = as[1];
checkInvocations(statwatcher1, { init: 1 },
                 'watcher1: when started to watch second file');
checkWatcherStart('watcher2', statwatcher2);

let w2Initialized = false;
let writeFile2AfterW1 = false;

const onW2Initialized = (curr, prev) => {
  if (curr.nlink !== 0 || prev.nlink !== 0)
    return;

  w2.removeListener('change', onW2Initialized);
  w2Initialized = true;
  if (writeFile2AfterW1) {
    setTimeout(() => fs.writeFileSync(file2, 'bar++'),
               common.platformTimeout(100));
  }
};
w2.on('change', onW2Initialized);

w1.on('change', common.mustCallAtLeast((curr, prev) => {
  console.log('w1 change to', curr, 'from', prev);
  // Wait for the initial ENOENT poll before creating the file. Otherwise the
  // first stat can race with the write and use the created file as the baseline.
  if (curr.nlink === 0 && prev.nlink === 0) {
    setTimeout(() => fs.writeFileSync(file1, 'foo++'),
               common.platformTimeout(100));
    return;
  }

  // Wait until we get the write above.
  if (prev.size !== 0 || curr.size !== 5)
    return;

  setImmediate(common.mustCall(() => {
    checkInvocations(statwatcher1,
                     { init: 1, before: w1HookCount, after: w1HookCount },
                     'watcher1: when unwatched first file');
    checkInvocations(statwatcher2, { init: 1 },
                     'watcher2: when unwatched first file');

    writeFile2AfterW1 = true;
    if (w2Initialized) {
      setTimeout(() => fs.writeFileSync(file2, 'bar++'),
                 common.platformTimeout(100));
    }
    w2.on('change', common.mustCallAtLeast((curr, prev) => {
      console.log('w2 change to', curr, 'from', prev);
      // Wait until we get the write above.
      if (prev.size !== 0 || curr.size !== 5)
        return;

      setImmediate(() => {
        checkInvocations(statwatcher1,
                         { init: 1, before: w1HookCount, after: w1HookCount },
                         'watcher1: when unwatched second file');
        checkInvocations(statwatcher2,
                         { init: 1, before: w2HookCount, after: w2HookCount },
                         'watcher2: when unwatched second file');
        fs.unwatchFile(file1);
        fs.unwatchFile(file2);
      });
    }));
  }));
}));

process.once('exit', () => {
  hooks.disable();
  hooks.sanityCheck('STATWATCHER');
  checkInvocations(statwatcher1,
                   { init: 1, before: w1HookCount, after: w1HookCount },
                   'watcher1: when process exits');
  checkInvocations(statwatcher2,
                   { init: 1, before: w2HookCount, after: w2HookCount },
                   'watcher2: when process exits');
});