import * as assert from 'assert';
import * as asyn from 'async';
import * as bench from 'benchmark';
import * as waitless from 'waitless';

/** Just for the benefit of the *Benchmark.js* benchmarking package. */
type Deferred = { resolve(): void };

/** Creates a Promise that is resolved by Node's `setImmediate` function. */
function setImmediatePromise<T>(arg?: T): Promise<T> {
  return new Promise((resolve) => setImmediate((arg?: T) => resolve(arg), arg));
}

/**
 * $_JS_nested_callback_style
 *
 * Asynchronous pipe implemented in classic JavaScript nested callback function
 * style (aka "pyramid of doom" or "callback hell").
 *
 * @param {Deferred} deferred - needed by Benchmark.js to signal when the async
 *  test is complete
 */
function $_JS_nested_callback_style(deferred: Deferred) {
  setImmediate(
    (a) =>
      setImmediate(
        (b) =>
          setImmediate(
            (c) =>
              setImmediate(
                (d) =>
                  setImmediate(
                    (e) =>
                      setImmediate((f) => {
                        assert.equal(f, 32);
                        deferred.resolve();
                      }, e * 2),
                    d * 2
                  ),
                c * 2
              ),
            b * 2
          ),
        a * 2
      ),
    1
  );
}

/**
 * A_ES2015_promise_then_chain
 *
 * Asynchronous pipe implemented by way of an ES2015 promise.then chain.
 *
 * @param {Deferred} deferred - needed by Benchmark.js to signal when the async
 *  test is complete
 */
function A_ES2015_promise_then_chain(deferred: Deferred) {
  let prom = setImmediatePromise(1)
    .then((a) => setImmediatePromise(a * 2))
    .then((b) => setImmediatePromise(b * 2))
    .then((c) => setImmediatePromise(c * 2))
    .then((d) => setImmediatePromise(d * 2))
    .then((e) => setImmediatePromise(e * 2));

  prom.then((res) => {
    assert.equal(res, 32);
    deferred.resolve();
  });
}

/**
 * B_ES2017_async_with_inline_await
 *
 * Asynchronous pipe implemented as an ES2017 async function with inline await
 * statements.
 *
 * @param {Deferred} deferred - needed by Benchmark.js to signal when the async
 *  test is complete
 */
async function B_ES2017_async_with_inline_await(deferred: Deferred) {
  let a = await setImmediatePromise(1);
  let b = await setImmediatePromise(a * 2);
  let c = await setImmediatePromise(b * 2);
  let d = await setImmediatePromise(c * 2);
  let e = await setImmediatePromise(d * 2);
  let f = await setImmediatePromise(e * 2);
  assert.equal(f, 32);
  deferred.resolve();
}

/**
 * C_async_library_waterfall_function
 *
 * Asynchronous pipe implemented using the `waterfall` function from the *async*
 * npm package.
 *
 * @param {Deferred} deferred - needed by Benchmark.js to signal when the async
 *  test is complete
 */
function C_async_library_waterfall_function(deferred: Deferred) {
  asyn.waterfall(
    [
      (callback: any) => setImmediate(() => callback(null, 1)),
      (a: any, callback: any) => setImmediate(() => callback(null, a * 2)),
      (b: any, callback: any) => setImmediate(() => callback(null, b * 2)),
      (c: any, callback: any) => setImmediate(() => callback(null, c * 2)),
      (d: any, callback: any) => setImmediate(() => callback(null, d * 2)),
      (e: any, callback: any) => setImmediate(() => callback(null, e * 2))
    ],
    (err, f: any) => {
      assert.equal(f, 32);
      deferred.resolve();
    }
  );
}

/**
 * D_Async_pipe_by_functional_reduction
 *
 * Asynchronous pipe implemented using Eric Elliot's async pipe by functional
 * reduction/composition.
 *
 * @param {Deferred} deferred - needed by Benchmark.js to signal when the async
 *  test is complete
 *
 * @see https://twitter.com/_ericelliott/status/895791749334945792
 */
const EricElliot_async_pipe = (...fns: any[]) => (x: any) =>
  fns.reduce(async (y, f) => f(await y), x);

function D_Async_pipe_by_functional_reduction(deferred: Deferred) {
  let mypipe = EricElliot_async_pipe(
    (a: any) => setImmediatePromise(a * 2),
    (b: any) => setImmediatePromise(b * 2),
    (c: any) => setImmediatePromise(c * 2),
    (d: any) => setImmediatePromise(d * 2),
    (e: any) => setImmediatePromise(e * 2)
  );

  let prom = mypipe(1);

  prom.then((f: any) => {
    assert.equal(f, 32);
    deferred.resolve();
  });
}

/**
 * E_waitless_library_IOP_pipe
 *
 * Asynchronous pipe implemented using the `iop.pipe` function from the
 * *waitless* npm package.
 *
 * @param {Deferred} deferred - needed by Benchmark.js to signal when the async
 *  test is complete
 */
function E_waitless_library_IOP_pipe(deferred: Deferred) {
  let mypipe = waitless.iop.pipe(
    (a: number) => setImmediatePromise(a * 2),
    (b) => setImmediatePromise(b * 2),
    (c) => setImmediatePromise(c * 2),
    (d) => setImmediatePromise(d * 2),
    (e) => setImmediatePromise(e * 2)
  );

  let iop = mypipe(1);

  Promise.resolve(iop).then((f) => {
    assert.equal(f, 32);
    deferred.resolve();
  });
}

/**
 * F_waitless_library_CPS_pipe
 *
 * Asynchronous pipe implemented using the `cps.pipe` function from the
 * *waitless* npm package.
 *
 * @param {Deferred} deferred - needed by Benchmark.js to signal when the async
 *  test is complete
 */
function F_waitless_library_CPS_pipe(deferred: Deferred) {
  let mypipe = waitless.cps.pipe(
    (ret: Tv.Async.Retrn<number>, a: number) => setImmediate(ret, a * 2),
    (ret: Tv.Async.Retrn<number>, b) => setImmediate(ret, b * 2),
    (ret: Tv.Async.Retrn<number>, c) => setImmediate(ret, c * 2),
    (ret: Tv.Async.Retrn<number>, d) => setImmediate(ret, d * 2),
    (ret: Tv.Async.Retrn<number>, e) => setImmediate(ret, e * 2)
  );

  mypipe((f) => {
    assert.equal(f, 32);
    deferred.resolve();
  }, 1);
}