'use strict';

var md5 = require('../lib/md5');
var CryptoJS = require('../lib/crypto');
var xml2json = require('../lib/xml2json');
var json2xml = require('../lib/json2xml');
var base64 = require('../lib/base64');
var Tracker = require('./tracker');

function camSafeUrlEncode(str) {
  return encodeURIComponent(str)
    .replace(/!/g, '%21')
    .replace(/'/g, '%27')
    .replace(/\(/g, '%28')
    .replace(/\)/g, '%29')
    .replace(/\*/g, '%2A');
}

function getObjectKeys(obj, forKey) {
  var list = [];
  for (var key in obj) {
    if (obj.hasOwnProperty(key)) {
      list.push(forKey ? camSafeUrlEncode(key).toLowerCase() : key);
    }
  }
  return list.sort(function (a, b) {
    a = a.toLowerCase();
    b = b.toLowerCase();
    return a === b ? 0 : a > b ? 1 : -1;
  });
}

/**
 * obj杞负string
 * @param  {Object}  obj                闇€瑕佽浆鐨勫璞★紝蹇呴』
 * @param  {Boolean} lowerCaseKey       key鏄惁杞负灏忓啓锛岄粯璁alse锛岄潪蹇呴』
 * @return {String}  data               杩斿洖瀛楃涓�
 */
var obj2str = function (obj, lowerCaseKey) {
  var i, key, val;
  var list = [];
  var keyList = getObjectKeys(obj);
  for (i = 0; i < keyList.length; i++) {
    key = keyList[i];
    val = obj[key] === undefined || obj[key] === null ? '' : '' + obj[key];
    key = lowerCaseKey ? camSafeUrlEncode(key).toLowerCase() : camSafeUrlEncode(key);
    val = camSafeUrlEncode(val) || '';
    list.push(key + '=' + val);
  }
  return list.join('&');
};

// 鍙互绛惧叆绛惧悕鐨刪eaders
var signHeaders = [
  'cache-control',
  'content-disposition',
  'content-encoding',
  'content-length',
  'content-md5',
  'expect',
  'expires',
  'host',
  'if-match',
  'if-modified-since',
  'if-none-match',
  'if-unmodified-since',
  'origin',
  'range',
  'transfer-encoding',
  'pic-operations',
];

var getSignHeaderObj = function (headers) {
  var signHeaderObj = {};
  for (var i in headers) {
    var key = i.toLowerCase();
    if (key.indexOf('x-cos-') > -1 || signHeaders.indexOf(key) > -1) {
      signHeaderObj[i] = headers[i];
    }
  }
  return signHeaderObj;
};

//娴嬭瘯鐢ㄧ殑key鍚庨潰鍙互鍘绘帀
var getAuth = function (opt) {
  opt = opt || {};

  var SecretId = opt.SecretId;
  var SecretKey = opt.SecretKey;
  var KeyTime = opt.KeyTime;
  var method = (opt.method || opt.Method || 'get').toLowerCase();
  var queryParams = clone(opt.Query || opt.params || {});
  var headers = getSignHeaderObj(clone(opt.Headers || opt.headers || {}));

  var Key = opt.Key || '';
  var pathname;
  if (opt.UseRawKey) {
    pathname = opt.Pathname || opt.pathname || '/' + Key;
  } else {
    pathname = opt.Pathname || opt.pathname || Key;
    pathname.indexOf('/') !== 0 && (pathname = '/' + pathname);
  }

  // ForceSignHost鏄庣‘浼犲叆false鎵嶄笉鍔犲叆host绛惧悕
  var forceSignHost = opt.ForceSignHost === false ? false : true;

  // 濡傛灉鏈変紶鍏ュ瓨鍌ㄦ《涓旈渶瑕佸己鍒剁鍚嶏紝閭ｄ箞绛惧悕榛樿鍔� Host 鍙備笌璁＄畻锛岄伩鍏嶈法妗惰闂�
  if (!headers.Host && !headers.host && opt.Bucket && opt.Region && forceSignHost)
    headers.Host = opt.Bucket + '.cos.' + opt.Region + '.myqcloud.com';

  if (!SecretId) throw new Error('missing param SecretId');
  if (!SecretKey) throw new Error('missing param SecretKey');

  // 绛惧悕鏈夋晥璧锋鏃堕棿
  var now = Math.round(getSkewTime(opt.SystemClockOffset) / 1000) - 1;
  var exp = now;

  var Expires = opt.Expires || opt.expires;
  if (Expires === undefined) {
    exp += 900; // 绛惧悕杩囨湡鏃堕棿涓哄綋鍓� + 900s
  } else {
    exp += Expires * 1 || 0;
  }

  // 瑕佺敤鍒扮殑 Authorization 鍙傛暟鍒楄〃
  var qSignAlgorithm = 'sha1';
  var qAk = SecretId;
  var qSignTime = KeyTime || now + ';' + exp;
  var qKeyTime = KeyTime || now + ';' + exp;
  var qHeaderList = getObjectKeys(headers, true).join(';').toLowerCase();
  var qUrlParamList = getObjectKeys(queryParams, true).join(';').toLowerCase();

  // 绛惧悕绠楁硶璇存槑鏂囨。锛歨ttps://www.qcloud.com/document/product/436/7778
  // 姝ラ涓€锛氳绠� SignKey
  var signKey = CryptoJS.HmacSHA1(qKeyTime, SecretKey).toString();

  // 姝ラ浜岋細鏋勬垚 FormatString
  var formatString = [method, pathname, util.obj2str(queryParams, true), util.obj2str(headers, true), ''].join('\n');

  // 姝ラ涓夛細璁＄畻 StringToSign
  var stringToSign = ['sha1', qSignTime, CryptoJS.SHA1(formatString).toString(), ''].join('\n');

  // 姝ラ鍥涳細璁＄畻 Signature
  var qSignature = CryptoJS.HmacSHA1(stringToSign, signKey).toString();

  // 姝ラ浜旓細鏋勯€� Authorization
  var authorization = [
    'q-sign-algorithm=' + qSignAlgorithm,
    'q-ak=' + qAk,
    'q-sign-time=' + qSignTime,
    'q-key-time=' + qKeyTime,
    'q-header-list=' + qHeaderList,
    'q-url-param-list=' + qUrlParamList,
    'q-signature=' + qSignature,
  ].join('&');

  return authorization;
};

var readIntBE = function (chunk, size, offset) {
  var bytes = size / 8;
  var buf = chunk.slice(offset, offset + bytes);
  new Uint8Array(buf).reverse();
  return new { 8: Uint8Array, 16: Uint16Array, 32: Uint32Array }[size](buf)[0];
};
var buf2str = function (chunk, start, end, isUtf8) {
  var buf = chunk.slice(start, end);
  var str = '';
  new Uint8Array(buf).forEach(function (charCode) {
    str += String.fromCharCode(charCode);
  });
  if (isUtf8) str = decodeURIComponent(escape(str));
  return str;
};
var parseSelectPayload = function (chunk) {
  var header = {};
  var body = buf2str(chunk);
  var result = { records: [] };
  while (chunk.byteLength) {
    var totalLength = readIntBE(chunk, 32, 0);
    var headerLength = readIntBE(chunk, 32, 4);
    var payloadRestLength = totalLength - headerLength - 16;
    var offset = 0;
    var content;
    chunk = chunk.slice(12);
    // 鑾峰彇 Message 鐨� header 淇℃伅
    while (offset < headerLength) {
      var headerNameLength = readIntBE(chunk, 8, offset);
      var headerName = buf2str(chunk, offset + 1, offset + 1 + headerNameLength);
      var headerValueLength = readIntBE(chunk, 16, offset + headerNameLength + 2);
      var headerValue = buf2str(
        chunk,
        offset + headerNameLength + 4,
        offset + headerNameLength + 4 + headerValueLength
      );
      header[headerName] = headerValue;
      offset += headerNameLength + 4 + headerValueLength;
    }
    if (header[':event-type'] === 'Records') {
      content = buf2str(chunk, offset, offset + payloadRestLength, true);
      result.records.push(content);
    } else if (header[':event-type'] === 'Stats') {
      content = buf2str(chunk, offset, offset + payloadRestLength, true);
      result.stats = util.xml2json(content).Stats;
    } else if (header[':event-type'] === 'error') {
      var errCode = header[':error-code'];
      var errMessage = header[':error-message'];
      var err = new Error(errMessage);
      err.message = errMessage;
      err.name = err.code = errCode;
      result.error = err;
    } else if (['Progress', 'Continuation', 'End'].includes(header[':event-type'])) {
      // do nothing
    }
    chunk = chunk.slice(offset + payloadRestLength + 4);
  }
  return {
    payload: result.records.join(''),
    body: body,
  };
};

var getSourceParams = function (source) {
  var parser = this.options.CopySourceParser;
  if (parser) return parser(source);
  var m = source.match(
    /^([^.]+-\d+)\.cos(v6|-cdc|-cdz|-internal)?\.([^.]+)\.((myqcloud\.com)|(tencentcos\.cn))\/(.+)$/
  );
  if (!m) return null;
  return { Bucket: m[1], Region: m[3], Key: m[7] };
};

var noop = function () {};

// 娓呴櫎瀵硅薄閲屽€间负鐨� undefined 鎴� null 鐨勫睘鎬�
var clearKey = function (obj) {
  var retObj = {};
  for (var key in obj) {
    if (obj.hasOwnProperty(key) && obj[key] !== undefined && obj[key] !== null) {
      retObj[key] = obj[key];
    }
  }
  return retObj;
};

var readAsBinaryString = function (blob, callback) {
  var readFun;
  var fr = new FileReader();
  if (FileReader.prototype.readAsBinaryString) {
    readFun = FileReader.prototype.readAsBinaryString;
    fr.onload = function () {
      callback(this.result);
    };
  } else if (FileReader.prototype.readAsArrayBuffer) {
    // 鍦� ie11 娣诲姞 readAsBinaryString 鍏煎
    readFun = function (fileData) {
      var binary = '';
      var pt = this;
      var reader = new FileReader();
      reader.onload = function (e) {
        var bytes = new Uint8Array(reader.result);
        var length = bytes.byteLength;
        for (var i = 0; i < length; i++) {
          binary += String.fromCharCode(bytes[i]);
        }
        callback(binary);
      };
      reader.readAsArrayBuffer(fileData);
    };
  } else {
    console.error('FileReader not support readAsBinaryString');
  }
  readFun.call(fr, blob);
};

var fileSliceNeedCopy = (function () {
  var compareVersion = function (a, b) {
    a = a.split('.');
    b = b.split('.');
    for (var i = 0; i < b.length; i++) {
      if (a[i] !== b[i]) {
        return parseInt(a[i]) > parseInt(b[i]) ? 1 : -1;
      }
    }
    return 0;
  };
  var check = function (ua) {
    if (!ua) return false;
    var ChromeVersion = (ua.match(/Chrome\/([.\d]+)/) || [])[1];
    var QBCoreVersion = (ua.match(/QBCore\/([.\d]+)/) || [])[1];
    var QQBrowserVersion = (ua.match(/QQBrowser\/([.\d]+)/) || [])[1];
    var need =
      (ChromeVersion &&
        compareVersion(ChromeVersion, '53.0.2785.116') < 0 &&
        QBCoreVersion &&
        compareVersion(QBCoreVersion, '3.53.991.400') < 0 &&
        QQBrowserVersion &&
        compareVersion(QQBrowserVersion, '9.0.2524.400') <= 0) ||
      false;
    return need;
  };
  return check(typeof navigator !== 'undefined' && navigator.userAgent);
})();

// 鑾峰彇鏂囦欢鍒嗙墖
var fileSlice = function (file, start, end, isUseToUpload, callback) {
  var blob;
  if (file.slice) {
    blob = file.slice(start, end);
  } else if (file.mozSlice) {
    blob = file.mozSlice(start, end);
  } else if (file.webkitSlice) {
    blob = file.webkitSlice(start, end);
  }
  if (isUseToUpload && fileSliceNeedCopy) {
    var reader = new FileReader();
    reader.onload = function (e) {
      blob = null;
      callback(new Blob([reader.result]));
    };
    reader.readAsArrayBuffer(blob);
  } else {
    callback(blob);
  }
};

// 鑾峰彇鏂囦欢鍐呭鐨� MD5
var getBodyMd5 = function (UploadCheckContentMd5, Body, callback, onProgress) {
  callback = callback || noop;
  if (UploadCheckContentMd5) {
    if (typeof Body === 'string') {
      callback(util.md5(Body, true));
    } else if (Blob && Body instanceof Blob) {
      util.getFileMd5(
        Body,
        function (err, md5) {
          callback(md5);
        },
        onProgress
      );
    } else {
      callback();
    }
  } else {
    callback();
  }
};

// 鑾峰彇鏂囦欢 md5 鍊�
var md5ChunkSize = 1024 * 1024;
var getFileMd5 = function (blob, callback, onProgress) {
  var size = blob.size;
  var loaded = 0;
  var md5ctx = md5.getCtx();
  var next = function (start) {
    if (start >= size) {
      var hash = md5ctx.digest('hex');
      callback(null, hash);
      return;
    }
    var end = Math.min(size, start + md5ChunkSize);
    util.fileSlice(blob, start, end, false, function (chunk) {
      readAsBinaryString(chunk, function (content) {
        chunk = null;
        md5ctx = md5ctx.update(content, true);
        loaded += content.length;
        content = null;
        if (onProgress)
          onProgress({ loaded: loaded, total: size, percent: Math.round((loaded / size) * 10000) / 10000 });
        next(start + md5ChunkSize);
      });
    });
  };
  next(0);
};

function clone(obj) {
  return map(obj, function (v) {
    return typeof v === 'object' && v !== null ? clone(v) : v;
  });
}

function attr(obj, name, defaultValue) {
  return obj && name in obj ? obj[name] : defaultValue;
}

function extend(target, source) {
  each(source, function (val, key) {
    target[key] = source[key];
  });
  return target;
}

function isArray(arr) {
  return arr instanceof Array;
}

function isInArray(arr, item) {
  var flag = false;
  for (var i = 0; i < arr.length; i++) {
    if (item === arr[i]) {
      flag = true;
      break;
    }
  }
  return flag;
}

function makeArray(arr) {
  return isArray(arr) ? arr : [arr];
}

function each(obj, fn) {
  for (var i in obj) {
    if (obj.hasOwnProperty(i)) {
      fn(obj[i], i);
    }
  }
}

function map(obj, fn) {
  var o = isArray(obj) ? [] : {};
  for (var i in obj) {
    if (obj.hasOwnProperty(i)) {
      o[i] = fn(obj[i], i);
    }
  }
  return o;
}

function filter(obj, fn) {
  var iaArr = isArray(obj);
  var o = iaArr ? [] : {};
  for (var i in obj) {
    if (obj.hasOwnProperty(i)) {
      if (fn(obj[i], i)) {
        if (iaArr) {
          o.push(obj[i]);
        } else {
          o[i] = obj[i];
        }
      }
    }
  }
  return o;
}

var b64 = function (str) {
  var i,
    len,
    char,
    res = '';
  for (i = 0, len = str.length / 2; i < len; i++) {
    char = parseInt(str[i * 2] + str[i * 2 + 1], 16);
    res += String.fromCharCode(char);
  }
  return btoa(res);
};
var uuid = function () {
  var S4 = function () {
    return (((1 + Math.random()) * 0x10000) | 0).toString(16).substring(1);
  };
  return S4() + S4() + '-' + S4() + '-' + S4() + '-' + S4() + '-' + S4() + S4() + S4();
};

var hasMissingParams = function (apiName, params) {
  var Bucket = params.Bucket;
  var Region = params.Region;
  var Key = params.Key;
  var Domain = this.options.Domain;
  var checkBucket = !Domain || (typeof Domain === 'string' && Domain.indexOf('{Bucket}') > -1);
  var checkRegion = !Domain || (typeof Domain === 'string' && Domain.indexOf('{Region}') > -1);
  if (
    apiName.indexOf('Bucket') > -1 ||
    apiName === 'deleteMultipleObject' ||
    apiName === 'multipartList' ||
    apiName === 'listObjectVersions'
  ) {
    if (checkBucket && !Bucket) return 'Bucket';
    if (checkRegion && !Region) return 'Region';
  } else if (
    apiName.indexOf('Object') > -1 ||
    apiName.indexOf('multipart') > -1 ||
    apiName === 'sliceUploadFile' ||
    apiName === 'abortUploadTask'
  ) {
    if (checkBucket && !Bucket) return 'Bucket';
    if (checkRegion && !Region) return 'Region';
    if (!Key) return 'Key';
  }
  return false;
};

var formatParams = function (apiName, params) {
  // 澶嶅埗鍙傛暟瀵硅薄
  params = extend({}, params);

  // 缁熶竴澶勭悊 Headers
  if (apiName !== 'getAuth' && apiName !== 'getV4Auth' && apiName !== 'getObjectUrl') {
    var Headers = params.Headers || {};
    if (params && typeof params === 'object') {
      (function () {
        for (var key in params) {
          if (params.hasOwnProperty(key) && key.indexOf('x-cos-') > -1) {
            Headers[key] = params[key];
          }
        }
      })();

      var headerMap = {
        // params headers
        'x-cos-mfa': 'MFA',
        'Content-MD5': 'ContentMD5',
        'Content-Length': 'ContentLength',
        'Content-Type': 'ContentType',
        Expect: 'Expect',
        Expires: 'Expires',
        'Cache-Control': 'CacheControl',
        'Content-Disposition': 'ContentDisposition',
        'Content-Encoding': 'ContentEncoding',
        Range: 'Range',
        'If-Modified-Since': 'IfModifiedSince',
        'If-Unmodified-Since': 'IfUnmodifiedSince',
        'If-Match': 'IfMatch',
        'If-None-Match': 'IfNoneMatch',
        'x-cos-copy-source': 'CopySource',
        'x-cos-copy-source-Range': 'CopySourceRange',
        'x-cos-metadata-directive': 'MetadataDirective',
        'x-cos-copy-source-If-Modified-Since': 'CopySourceIfModifiedSince',
        'x-cos-copy-source-If-Unmodified-Since': 'CopySourceIfUnmodifiedSince',
        'x-cos-copy-source-If-Match': 'CopySourceIfMatch',
        'x-cos-copy-source-If-None-Match': 'CopySourceIfNoneMatch',
        'x-cos-acl': 'ACL',
        'x-cos-grant-read': 'GrantRead',
        'x-cos-grant-write': 'GrantWrite',
        'x-cos-grant-full-control': 'GrantFullControl',
        'x-cos-grant-read-acp': 'GrantReadAcp',
        'x-cos-grant-write-acp': 'GrantWriteAcp',
        'x-cos-storage-class': 'StorageClass',
        'x-cos-traffic-limit': 'TrafficLimit',
        'x-cos-mime-limit': 'MimeLimit',
        // SSE-C
        'x-cos-server-side-encryption-customer-algorithm': 'SSECustomerAlgorithm',
        'x-cos-server-side-encryption-customer-key': 'SSECustomerKey',
        'x-cos-server-side-encryption-customer-key-MD5': 'SSECustomerKeyMD5',
        // SSE-COS銆丼SE-KMS
        'x-cos-server-side-encryption': 'ServerSideEncryption',
        'x-cos-server-side-encryption-cos-kms-key-id': 'SSEKMSKeyId',
        'x-cos-server-side-encryption-context': 'SSEContext',
        // 涓婁紶鏃跺浘鐗囧鐞�
        'Pic-Operations': 'PicOperations',
      };
      util.each(headerMap, function (paramKey, headerKey) {
        if (params[paramKey] !== undefined) {
          Headers[headerKey] = params[paramKey];
        }
      });

      params.Headers = clearKey(Headers);
    }
  }

  return params;
};

var apiWrapper = function (apiName, apiFn) {
  return function (params, callback) {
    var self = this;

    // 澶勭悊鍙傛暟
    if (typeof params === 'function') {
      callback = params;
      params = {};
    }

    // 鏁寸悊鍙傛暟鏍煎紡
    params = formatParams(apiName, params);

    // tracker浼犻€�
    var tracker;
    if (self.options.EnableTracker) {
      if (params.calledBySdk === 'sliceUploadFile') {
        // 鍒嗗潡涓婁紶鍐呴儴鏂规硶浣跨敤sliceUploadFile鐨勫瓙閾捐矾
        tracker = params.tracker && params.tracker.generateSubTracker({ apiName });
      } else if (['uploadFile', 'uploadFiles'].includes(apiName)) {
        // uploadFile銆乽ploadFiles鏂规硶鍦ㄥ唴閮ㄥ鐞嗭紝姝ゅ涓嶅鐞�
        tracker = null;
      } else {
        var fileSize = -1;
        if (params.Body) {
          fileSize =
            typeof params.Body === 'string' ? params.Body.length : params.Body.size || params.Body.byteLength || -1;
        }
        tracker = new Tracker({
          bucket: params.Bucket,
          region: params.Region,
          apiName: apiName,
          fileKey: params.Key,
          fileSize: fileSize,
          deepTracker: self.options.DeepTracker,
          customId: self.options.CustomId,
          delay: self.options.TrackerDelay,
        });
      }
    }
    params.tracker = tracker;

    // 浠ｇ悊鍥炶皟鍑芥暟
    var formatResult = function (result) {
      if (result && result.headers) {
        result.headers['x-cos-request-id'] && (result.RequestId = result.headers['x-cos-request-id']);
        result.headers['x-ci-request-id'] && (result.RequestId = result.headers['x-ci-request-id']);
        result.headers['x-cos-version-id'] && (result.VersionId = result.headers['x-cos-version-id']);
        result.headers['x-cos-delete-marker'] && (result.DeleteMarker = result.headers['x-cos-delete-marker']);
      }
      return result;
    };
    var _callback = function (err, data) {
      // 鏍煎紡鍖栦笂鎶ュ弬鏁板苟涓婃姤
      tracker && tracker.formatResult(err, data);
      callback && callback(formatResult(err), formatResult(data));
    };

    var checkParams = function () {
      if (apiName !== 'getService' && apiName !== 'abortUploadTask') {
        // 鍒ゆ柇鍙傛暟鏄惁瀹屾暣
        var missingResult = hasMissingParams.call(self, apiName, params);
        if (missingResult) {
          return 'missing param ' + missingResult;
        }
        // 鍒ゆ柇 region 鏍煎紡
        if (params.Region) {
          if (self.options.CompatibilityMode) {
            if (!/^([a-z\d-.]+)$/.test(params.Region)) {
              return 'Region format error.';
            }
          } else {
            if (params.Region.indexOf('cos.') > -1) {
              return 'param Region should not be start with "cos."';
            } else if (!/^([a-z\d-]+)$/.test(params.Region)) {
              return 'Region format error.';
            }
          }
          // 鍒ゆ柇 region 鏍煎紡
          if (
            !self.options.CompatibilityMode &&
            params.Region.indexOf('-') === -1 &&
            params.Region !== 'yfb' &&
            params.Region !== 'default' &&
            params.Region !== 'accelerate'
          ) {
            console.warn(
              'warning: param Region format error, find help here: https://cloud.tencent.com/document/product/436/6224'
            );
          }
        }
        // 鍏煎涓嶅甫 AppId 鐨� Bucket
        if (params.Bucket) {
          if (!/^([a-z\d-]+)-(\d+)$/.test(params.Bucket)) {
            if (params.AppId) {
              params.Bucket = params.Bucket + '-' + params.AppId;
            } else if (self.options.AppId) {
              params.Bucket = params.Bucket + '-' + self.options.AppId;
            } else {
              return 'Bucket should format as "test-1250000000".';
            }
          }
          if (params.AppId) {
            console.warn(
              'warning: AppId has been deprecated, Please put it at the end of parameter Bucket(E.g Bucket:"test-1250000000" ).'
            );
            delete params.AppId;
          }
        }
        // 濡傛灉 Key 鏄� / 寮€澶达紝寮哄埗鍘绘帀绗竴涓� /
        if (!self.options.UseRawKey && params.Key && params.Key.substr(0, 1) === '/') {
          params.Key = params.Key.substr(1);
        }
      }
    };

    var errMsg = checkParams();
    var isSync = ['getAuth', 'getObjectUrl'].includes(apiName);
    if (typeof Promise === 'function' && !isSync && !callback) {
      return new Promise(function (resolve, reject) {
        callback = function (err, data) {
          err ? reject(err) : resolve(data);
        };
        if (errMsg) return _callback(util.error(new Error(errMsg)));
        apiFn.call(self, params, _callback);
      });
    } else {
      if (errMsg) return _callback(util.error(new Error(errMsg)));
      var res = apiFn.call(self, params, _callback);
      if (isSync) return res;
    }
  };
};

var throttleOnProgress = function (total, onProgress) {
  var self = this;
  var size0 = 0;
  var size1 = 0;
  var time0 = Date.now();
  var time1;
  var timer;

  function update() {
    timer = 0;
    if (onProgress && typeof onProgress === 'function') {
      time1 = Date.now();
      var speed = Math.max(0, Math.round(((size1 - size0) / ((time1 - time0) / 1000)) * 100) / 100) || 0;
      var percent;
      if (size1 === 0 && total === 0) {
        percent = 1;
      } else {
        percent = Math.floor((size1 / total) * 100) / 100 || 0;
      }
      time0 = time1;
      size0 = size1;
      try {
        onProgress({ loaded: size1, total: total, speed: speed, percent: percent });
      } catch (e) {}
    }
  }

  return function (info, immediately) {
    if (info) {
      size1 = info.loaded;
      total = info.total;
    }
    if (immediately) {
      clearTimeout(timer);
      update();
    } else {
      if (timer) return;
      timer = setTimeout(update, self.options.ProgressInterval);
    }
  };
};

var getFileSize = function (api, params, callback) {
  var size;
  if (typeof params.Body === 'string') {
    params.Body = new Blob([params.Body], { type: 'text/plain' });
  } else if (params.Body instanceof ArrayBuffer) {
    params.Body = new Blob([params.Body]);
  }
  if (
    params.Body &&
    (params.Body instanceof Blob ||
      params.Body.toString() === '[object File]' ||
      params.Body.toString() === '[object Blob]')
  ) {
    size = params.Body.size;
  } else {
    callback(util.error(new Error('params body format error, Only allow File|Blob|String.')));
    return;
  }
  params.ContentLength = size;
  callback(null, size);
};

// 鑾峰彇璋冩鐨勬椂闂存埑
var getSkewTime = function (offset) {
  return Date.now() + (offset || 0);
};

var error = function (err, opt) {
  var sourceErr = err;
  err.message = err.message || null;

  if (typeof opt === 'string') {
    err.error = opt;
    err.message = opt;
  } else if (typeof opt === 'object' && opt !== null) {
    extend(err, opt);
    if (opt.code || opt.name) err.code = opt.code || opt.name;
    if (opt.message) err.message = opt.message;
    if (opt.stack) err.stack = opt.stack;
  }

  if (typeof Object.defineProperty === 'function') {
    Object.defineProperty(err, 'name', { writable: true, enumerable: false });
    Object.defineProperty(err, 'message', { enumerable: true });
  }

  err.name = (opt && opt.name) || err.name || err.code || 'Error';
  if (!err.code) err.code = err.name;
  if (!err.error) err.error = clone(sourceErr); // 鍏煎鑰佺殑閿欒鏍煎紡

  return err;
};

var isWebWorker = function () {
  // 鏈夐檺鍒ゆ柇 worker 鐜鐨� constructor name 鍏舵鐢� worker 鐙湁鐨� FileReaderSync 鍏滃簳 璇︾粏鍙傝€� https://developer.mozilla.org/zh-CN/docs/Web/API/Web_Workers_API/Using_web_workers
  return (
    typeof globalThis === 'object' &&
    (globalThis.constructor.name === 'DedicatedWorkerGlobalScope' || globalThis.FileReaderSync)
  );
};

var isNode = function () {
  // 寰楀厹搴� web worker 鐜涓� webpack 鐢ㄤ簡 process 鎻掍欢涔嬬被鐨勬儏鍐�
  return typeof window !== 'object' && typeof process === 'object' && typeof require === 'function' && !isWebWorker();
};

var isCIHost = function (url) {
  return /^https?:\/\/([^/]+\.)?ci\.[^/]+/.test(url);
};

//鍒ゆ柇鏄惁鏄痠os
var isIOS = (function () {
  if (typeof navigator !== 'object') {
    return false;
  }
  var u = navigator.userAgent;
  var isIOS = !!u.match(/\(i[^;]+;( U;)? CPU.+Mac OS X/); //ios缁堢
  return isIOS;
})();

// 鍒ゆ柇鏄痲q鍐呯疆娴忚鍣�
var isQQ = (function () {
  if (typeof navigator !== 'object') {
    return false;
  }
  return /\sQQ/i.test(navigator.userAgent);
})();

var encodeBase64 = function (str, safe) {
  let base64Str = base64.encode(str);
  // 涓囪薄浣跨敤鐨勫畨鍏╞ase64鏍煎紡闇€瑕佺壒娈婂鐞�
  if (safe) {
    base64Str = base64Str.replaceAll('+', '-').replaceAll('/', '_').replaceAll('=', '');
  }
  return base64Str;
};

var util = {
  noop: noop,
  formatParams: formatParams,
  apiWrapper: apiWrapper,
  xml2json: xml2json,
  json2xml: json2xml,
  md5: md5,
  clearKey: clearKey,
  fileSlice: fileSlice,
  getBodyMd5: getBodyMd5,
  getFileMd5: getFileMd5,
  b64: b64,
  extend: extend,
  isArray: isArray,
  isInArray: isInArray,
  makeArray: makeArray,
  each: each,
  map: map,
  filter: filter,
  clone: clone,
  attr: attr,
  uuid: uuid,
  camSafeUrlEncode: camSafeUrlEncode,
  throttleOnProgress: throttleOnProgress,
  getFileSize: getFileSize,
  getSkewTime: getSkewTime,
  error: error,
  obj2str: obj2str,
  getAuth: getAuth,
  parseSelectPayload: parseSelectPayload,
  getSourceParams: getSourceParams,
  isBrowser: true,
  isNode: isNode,
  isCIHost: isCIHost,
  isIOS_QQ: isIOS && isQQ,
  encodeBase64: encodeBase64,
};

module.exports = util;