'use strict';

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

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

exports.waitForChooseExperiment = waitForChooseExperiment;
exports.waitForOptimize = waitForOptimize;

var _reduxSaga = require('redux-saga');

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

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

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

var _marked = /*#__PURE__*/_regenerator2.default.mark(waitForChooseExperiment);

function waitForChooseExperiment(internalAction, abTestName) {
  var payload;
  return _regenerator2.default.wrap(function waitForChooseExperiment$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          payload = void 0;
          // Busy waiting to take actually get the desired action
          // since there might be more than one action with the same type

        case 1:
          if (!true) {
            _context.next = 9;
            break;
          }

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

        case 4:
          payload = _context.sent.payload;

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

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

        case 7:
          _context.next = 1;
          break;

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

        case 11:
        case 'end':
          return _context.stop();
      }
    }
  }, _marked, this);
}

/**
 * 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_' + abTest;
  var internalAction = { type: internalActionType };
  return (/*#__PURE__*/_regenerator2.default.mark(function _callee(saga) {
      for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
        args[_key - 1] = arguments[_key];
      }

      return _regenerator2.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, _reduxSaga.delay)(timeout)
              });

            case 5:
              _context2.next = 7;
              return _effects.call.apply(undefined, [saga].concat(args));

            case 7:
              return _context2.abrupt('return', _context2.sent);

            case 8:
            case 'end':
              return _context2.stop();
          }
        }
      }, _callee, this);
    })
  );
}