import { Actor } from '../../classes/display/actor.js';
import { Box } from '../../classes/display/box.js';
import { Scene } from '../../classes/display/scene.js';
import { VM } from '../../classes/supporting/vm.js';

const contractIds = ['contract-id-1', 'contract-id-2'];

class Greeter extends Actor {
  constructor(vm, value, scene) {
    super('Greeter', scene);
    this.vm = vm;
    this.value = value;
  }

  hello(sender, message) {
    return `${sender.name} ${this.value}: ${message}`;
  }
}

class Repeater extends Actor {
  constructor(vm, greeter, scene) {
    super('Repeater', scene);
    this.vmHandle = vm.getHandle(this);
    this.greeter = greeter;
  }

  forward(__sender, method, message) {
    return this.vmHandle.callContract(this.greeter, method, message);
  }
}

describe('VM', () => {
  let vm;
  let sender;
  let vmHandle;
  let scene;

  before(() => {
    const rootElement = document.getElementById('scene');
    const rootBox = new Box('rootBox', rootElement).flex();
    scene = new Scene('VM test', rootBox).withSequenceDiagram();
    vm = new VM(scene);
    sender = new Actor('Sender', scene);
    vm.addContract(contractIds[0], Greeter, 'world', scene);
    vm.addContract(contractIds[1], Repeater, contractIds[0], scene);
    vmHandle = vm.getHandle(sender);
  });

  beforeEach(async () => {
    await scene.sequence.startSection();
  });

  afterEach(async () => {
    await scene.sequence.endSection();
  });

  it('Should exist', () => {
    should.exist(vm);
  });

  it('Call a contract method', async () => {
    (await Promise.resolve(vmHandle.callContract(contractIds[0], 'hello', 'good morning')))
      .should.equal('Sender world: good morning');
  });

  it('Call a contract method which calls another contract method', async () => {
    (await Promise.resolve(vmHandle.callContract(contractIds[1], 'forward', 'hello', 'good day')))
      .should.equal('Repeater world: good day');
  });
});