'use strict';

(() => {
  // Create a ReadableStream that will pass the tests in
  // testTransferredReadableStream(), below.
  function createOriginalReadableStream() {
    return new ReadableStream({
      start(controller) {
        controller.enqueue('a');
        controller.close();
      }
    });
  }

  // Common tests to roughly determine that |rs| is a correctly transferred
  // version of a stream created by createOriginalReadableStream().
  function testTransferredReadableStream(rs) {
    assert_equals(rs.constructor, ReadableStream,
                  'rs should be a ReadableStream in this realm');
    assert_true(rs instanceof ReadableStream,
                'instanceof check should pass');

    // Perform a brand-check on |rs| in the process of calling getReader().
    const reader = ReadableStream.prototype.getReader.call(rs);

    return reader.read().then(({value, done}) => {
      assert_false(done, 'done should be false');
      assert_equals(value, 'a', 'value should be "a"');
      return reader.read();
    }).then(({done}) => {
      assert_true(done, 'done should be true');
    });
  }

  function testMessage(msg) {
    assert_array_equals(msg.ports, [], 'there should be no ports in the event');
    return testTransferredReadableStream(msg.data);
  }

  function testMessageEvent(target) {
    return new Promise((resolve, reject) => {
      target.addEventListener('message', ev => {
        try {
          resolve(testMessage(ev));
        } catch (e) {
          reject(e);
        }
      }, {once: true});
    });
  }

  function testMessageEventOrErrorMessage(target) {
    return new Promise((resolve, reject) => {
      target.addEventListener('message', ev => {
        if (typeof ev.data === 'string') {
          // Assume it's an error message and reject with it.
          reject(ev.data);
          return;
        }

        try {
          resolve(testMessage(ev));
        } catch (e) {
          reject(e);
        }
      }, {once: true});
    });
  }

  function checkTestResults(target) {
    return new Promise((resolve, reject) => {
      target.onmessage = msg => {
        // testharness.js sends us objects which we need to ignore.
        if (typeof msg.data !== 'string')
        return;

        if (msg.data === 'OK') {
          resolve();
        } else {
          reject(msg.data);
        }
      };
    });
  }

  // These tests assume that a transferred ReadableStream will behave the same
  // regardless of how it was transferred. This enables us to simply transfer the
  // stream to ourselves.
  function createTransferredReadableStream(underlyingSource) {
    const original = new ReadableStream(underlyingSource);
    const promise = new Promise((resolve, reject) => {
      addEventListener('message', msg => {
        const rs = msg.data;
        if (rs instanceof ReadableStream) {
          resolve(rs);
        } else {
          reject(new Error(`what is this thing: "${rs}"?`));
        }
      }, {once: true});
    });
    postMessage(original, '*', [original]);
    return promise;
  }

  function recordingTransferredReadableStream(underlyingSource, strategy) {
    const original = recordingReadableStream(underlyingSource, strategy);
    const promise = new Promise((resolve, reject) => {
      addEventListener('message', msg => {
        const rs = msg.data;
        if (rs instanceof ReadableStream) {
          rs.events = original.events;
          rs.eventsWithoutPulls = original.eventsWithoutPulls;
          rs.controller = original.controller;
          resolve(rs);
        } else {
          reject(new Error(`what is this thing: "${rs}"?`));
        }
      }, {once: true});
    });
    postMessage(original, '*', [original]);
    return promise;
  }

  self.createOriginalReadableStream = createOriginalReadableStream;
  self.testMessage = testMessage;
  self.testMessageEvent = testMessageEvent;
  self.testMessageEventOrErrorMessage = testMessageEventOrErrorMessage;
  self.checkTestResults = checkTestResults;
  self.createTransferredReadableStream = createTransferredReadableStream;
  self.recordingTransferredReadableStream = recordingTransferredReadableStream;

})();