"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 _ref, 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:
          _ref = _context.sent;
          payload = _ref.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);
    })
  );
}