import {Latus} from '@latus/core';
import {expect} from 'chai';

import {
  buildCondition,
  buildExpression,
  buildExpressions,
  buildInvoke,
  buildValue,
} from '../src/builders';
import Context from '../src/context';
import compile from '../src/compilers/compile';

const {name} = require('../package.json');

describe(name, () => {
  let latus;
  let context;
  beforeEach(async () => {
    latus = Latus.mock([
      ['@avocado/behavior', `${__dirname}/../src`],
    ]);
    await Promise.all(latus.invokeFlat('@latus/core/starting'));
    context = new Context({}, latus);
  });
  describe('Flow', () => {
    it('does conditional', async () => {
      const test = {foo: 69};
      context.add('test', test);
      expect(compile(buildExpression(['test', 'foo']), latus)(context)).to.equal(69);
      const tickingPromise = compile(buildInvoke(
        ['Flow', 'conditional'],
        [
          compile(buildCondition('and', [
            buildValue(true),
            buildValue(false),
          ]), latus),
          compile(buildExpressions([
            buildExpression(['test', 'foo'], 420),
          ]), latus),
        ],
      ), latus)(context);
      tickingPromise && tickingPromise.tick();
      expect(compile(buildExpression(['test', 'foo']), latus)(context)).to.equal(69);
      const tickingPromise2 = compile(buildInvoke(
        ['Flow', 'conditional'],
        [
          compile(buildCondition('and', [
            buildValue(true),
            buildValue(true),
          ]), latus),
          compile(buildExpressions([
            buildExpression(['test', 'foo'], 420),
          ]), latus),
        ],
      ), latus)(context);
      tickingPromise2 && tickingPromise2.tick();
      expect(compile(buildExpression(['test', 'foo']), latus)(context)).to.equal(420);
    });
    it('does nop', async () => {
      compile(buildInvoke(['Flow', 'nop']), latus)(context);
    });
    it('does parallel actions', async () => {
      const tickingPromise = compile(buildInvoke(
        ['Flow', 'parallel'],
        [
          buildExpressions([
            buildInvoke(['Timing', 'wait'], [100]),
            buildInvoke(['Timing', 'wait'], [200]),
          ]),
        ],
      ), latus)(context);
      tickingPromise.tick(200);
      return tickingPromise;
    });
    it('does serial actions', async () => {
      const DELAY = 30;
      const tickingPromise = compile(buildInvoke(
        ['Flow', 'serial'],
        [
          buildExpressions([
            buildInvoke(['Timing', 'wait'], [100]),
            buildInvoke(['Timing', 'wait'], [200]),
          ]),
        ],
      ), latus)(context);
      tickingPromise.tick(200);
      let start = Date.now();
      await Promise.race([
        new Promise((resolve) => setTimeout(resolve, DELAY)),
        tickingPromise,
      ])
      expect(Date.now() - start).to.be.at.least(DELAY * 0.9);
    });
  });
});