'use strict';

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

var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
var _createClass = require('@babel/runtime/helpers/createClass');
var _classCallCheck = require('@babel/runtime/helpers/classCallCheck');
var cocos_network_request_cocosRequest = require('./request/cocos-request.js');

function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }

var _slicedToArray__default = /*#__PURE__*/_interopDefaultLegacy(_slicedToArray);
var _createClass__default = /*#__PURE__*/_interopDefaultLegacy(_createClass);
var _classCallCheck__default = /*#__PURE__*/_interopDefaultLegacy(_classCallCheck);

/**
 * 网络调度引擎
 *
 * 职责：把"请求拦截器 → doRequest → 响应拦截器 → decorator"串起来，
 * 对外暴露一个符合 `NetworkManager.setRequestImpl` 签名的函数。
 *
 * 调度链：
 *   1. 顺序跑 requestInterceptors（任一返回 abort=true 即中止）
 *   2. 调 doRequest（wx.request / fetch）
 *   3. 顺序跑 responseInterceptors（任一返回 abort=true 即走失败）
 *   4. 成功：resolve param.data（通常由 GetDataInterceptor 填好）
 *      失败：reject param.data（同上）
 *   5. decorator 包裹整个 Promise，做 r=100000 重试等横切逻辑
 */
var NetworkEngine = /*#__PURE__*/_createClass__default["default"](function NetworkEngine(options) {
  var _this = this;
  _classCallCheck__default["default"](this, NetworkEngine);
  /** 对外暴露的请求函数：一次完整的 request 调用 */
  this.request = function (cfg) {
    var decorator = _this.options.decorator;
    var runOnce = function runOnce() {
      return _this.runCore(cfg);
    };
    if (decorator) {
      return Promise.resolve(decorator(runOnce, cfg));
    }
    return runOnce();
  };
  /** 不含 decorator 的单次请求主链（供 decorator 重试时调用） */
  this.runCore = function (cfg) {
    var _this$options = _this.options,
      requestInterceptors = _this$options.requestInterceptors,
      responseInterceptors = _this$options.responseInterceptors;
    // 1) 请求拦截器链：用 reduce 串成 Promise 链
    var reqChain = requestInterceptors.reduce(function (prev, ic) {
      return prev.then(function (reqParam) {
        return Promise.resolve(ic.interceptor(reqParam)).then(function (_ref) {
          var _ref2 = _slicedToArray__default["default"](_ref, 2),
            abort = _ref2[0],
            next = _ref2[1];
          if (abort) {
            // 中止：把 next 当结果抛给上层
            return Promise.reject(next);
          }
          return next;
        });
      });
    }, Promise.resolve(cfg));
    return reqChain
    // 2) 底层发起；网络错误直接抛，不走响应拦截器
    .then(function (reqParam) {
      return cocos_network_request_cocosRequest.doRequest(reqParam).then(function (rawResp) {
        return {
          reqParam: reqParam,
          rawResp: rawResp
        };
      });
    }).then(function (_ref3) {
      var reqParam = _ref3.reqParam,
        rawResp = _ref3.rawResp;
      // 3) 响应拦截器链
      var initial = {
        request: reqParam,
        response: rawResp
      };
      var respChain = responseInterceptors.reduce(function (prev, ic) {
        return prev.then(function (respParam) {
          return Promise.resolve(ic.interceptor(respParam)).then(function (_ref4) {
            var _ref5 = _slicedToArray__default["default"](_ref4, 2),
              abort = _ref5[0],
              next = _ref5[1];
            var _a, _b;
            if (abort) {
              // 业务错误（r !== 0）：reject data 给上层（decorator / 业务）
              return Promise.reject((_a = next.data) !== null && _a !== void 0 ? _a : (_b = next.response) === null || _b === void 0 ? void 0 : _b.data);
            }
            return next;
          });
        });
      }, Promise.resolve(initial));
      // 4) 成功：GetDataInterceptor 已把 response.data 提出到 param.data
      return respChain.then(function (respParam) {
        var _a, _b;
        return (_a = respParam.data) !== null && _a !== void 0 ? _a : (_b = respParam.response) === null || _b === void 0 ? void 0 : _b.data;
      });
    });
  };
  this.options = options;
});

exports.NetworkEngine = NetworkEngine;
