"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.waitForChooseExperiment = waitForChooseExperiment;
exports.waitForOptimize = waitForOptimize;

var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));

var _effects = require("redux-saga/effects");

var _abActions = require("../actions/abActions");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

var _marked = /*#__PURE__*/_regenerator["default"].mark(waitForChooseExperiment);

function waitForChooseExperiment(internalAction, abTestName) {
  var _yield$take, payload;

  return _regenerator["default"].wrap(function waitForChooseExperiment$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          if (!true) {
            _context.next = 9;
            break;
          }

          _context.next = 3;
          return (0, _effects.take)(_abActions.ActionTypes.CHOOSE_EXPERIMENT);

        case 3:
          _yield$take = _context.sent;
          payload = _yield$take.payload;

          if (!(payload.name === abTestName)) {
            _context.next = 7;
            break;
          }

          return _context.abrupt("break", 9);

        case 7:
          _context.next = 0;
          break;

        case 9:
          _context.next = 11;
          return (0, _effects.put)(internalAction);

        case 11:
        case "end":
          return _context.stop();
      }
    }
  }, _marked);
}
/**
 * Returns a generator which calls a saga if the sepecific experiment is loaded or the timeout runs out.
 *
 * @param {string} abTest - The name of the A/B test, the saga should wait for
 * @param {number} timeout - Maximal timeout, default is 1000ms
 */


function waitForOptimize(abTest) {
  var timeout = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1000;
  // Create an action which then can be used internally
  var internalActionType = "@doodle/ab/internal/DEPEND_ON_".concat(abTest);
  var internalAction = {
    type: internalActionType
  };
  return /*#__PURE__*/_regenerator["default"].mark(function _callee(saga) {
    var _len,
        args,
        _key,
        _args2 = arguments;

    return _regenerator["default"].wrap(function _callee$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            if (!abTest) {
              _context2.next = 5;
              break;
            }

            _context2.next = 3;
            return (0, _effects.spawn)(waitForChooseExperiment, internalAction, abTest);

          case 3:
            _context2.next = 5;
            return (0, _effects.race)({
              action: (0, _effects.take)(internalActionType),
              timeout: (0, _effects.delay)(timeout)
            });

          case 5:
            for (_len = _args2.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
              args[_key - 1] = _args2[_key];
            }

            _context2.next = 8;
            return _effects.call.apply(void 0, [saga].concat(args));

          case 8:
            return _context2.abrupt("return", _context2.sent);

          case 9:
          case "end":
            return _context2.stop();
        }
      }
    }, _callee);
  });
}