// v1.0
function debounce(func, wait) {
  let timer = undefined;
  return function () {
    if (timer) {
      clearTimeout(timer);
    }
    timer = setTimeout(func, wait);
  };
}
const fn = debounce(() => {
  console.log("1s 后执行");
}, 1000);

// v2.0
function debounce(func, wait) {
  let timer = undefined;
  return function () {
    const that = this,
      args = arguments;
    timer && clearTimeout(timer);
    timer = setTimeout(() => {
      func.apply(that, args);
    }, wait);
  };
}

//v2.1 改进一下, 增加立即执行判断
function debounce(func, wait, opt = { immediately: false }) {
  let timer = undefined;
  return function () {
    let that = this,
      args = arguments;
    if (timer === undefined && opt.immediately) {
      func.apply(that, args);
    }
    timer && clearTimeout(timer);
    timer = setTimeout(() => {
      func.apply(that, args);
    }, wait);
  };
}

const run = debounce(
  () => {
    console.log("OK");
  },
  1000,
  { immediately: true }
);

// debounce配置项如下
// const options = {
//   leading: boolean, leading表示在wait时间开始时 立即执行回调
//   maxWait: number, 表示func可以延迟执行的最大时间，若超过了maxWait，则必须要执行回调函数func。
//   trailing: boolean, trailing表示在wait时间结束后 立即执行回调
// };

var nullTag = "[object Null]",
  symbolTag = "[object Symbol]",
  undefinedTag = "[object Undefined]";

var reIsBinary = /^0b[01]+$/i;
var reIsOctal = /^0o[0-7]+$/i;
var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
var nativeMax = Math.max;

var freeParseInt = parseInt;

var freeGlobal =
  typeof global == "object" && global && global.Object === Object && global;

var freeSelf =
  typeof self == "object" && self && self.Object === Object && self;

var objectProto = Object.prototype;

var root = freeGlobal || freeSelf || Function("return this")();

var FUNC_ERROR_TEXT = "Expected a function";
var ctxNow = Date && Date.now !== root.Date.now && Date.now;
var nativeObjectToString = objectProto.toString;

var symToStringTag = Symbol ? Symbol.toStringTag : undefined;
var reTrim = /^\s+|\s+$/g;

var now =
  ctxNow ||
  function () {
    return root.Date.now();
  };

function objectToString(value) {
  return nativeObjectToString.call(value);
}

function getRawTag(value) {
  var isOwn = hasOwnProperty.call(value, symToStringTag),
    tag = value[symToStringTag];

  try {
    value[symToStringTag] = undefined;
    var unmasked = true;
  } catch (e) {}

  var result = nativeObjectToString.call(value);
  if (unmasked) {
    if (isOwn) {
      value[symToStringTag] = tag;
    } else {
      delete value[symToStringTag];
    }
  }
  return result;
}

function baseGetTag(value) {
  if (value == null) {
    return value === undefined ? undefinedTag : nullTag;
  }
  return symToStringTag && symToStringTag in Object(value)
    ? getRawTag(value)
    : objectToString(value);
}

function isSymbol(value) {
  return (
    typeof value == "symbol" ||
    (isObjectLike(value) && baseGetTag(value) == symbolTag)
  );
}

function toNumber(value) {
  if (typeof value == "number") {
    return value;
  }
  if (isSymbol(value)) {
    return NAN;
  }
  if (isObject(value)) {
    var other = typeof value.valueOf == "function" ? value.valueOf() : value;
    value = isObject(other) ? other + "" : other;
  }
  if (typeof value != "string") {
    return value === 0 ? value : +value;
  }
  value = value.replace(reTrim, "");
  var isBinary = reIsBinary.test(value);
  return isBinary || reIsOctal.test(value)
    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)
    : reIsBadHex.test(value)
    ? NAN
    : +value;
}

function isObjectLike(value) {
  return value != null && typeof value == "object";
}

function isObject(value) {
  var type = typeof value;
  return value != null && (type == "object" || type == "function");
}

function debounce(func, wait, options) {
  var lastArgs,
    lastThis,
    maxWait,
    result,
    timerId,
    lastCallTime,
    lastInvokeTime = 0,
    leading = false,
    maxing = false,
    trailing = true;

  if (typeof func != "function") {
    throw new TypeError(FUNC_ERROR_TEXT);
  }

  wait = toNumber(wait) || 0;

  if (isObject(options)) {
    leading = !!options.leading;
    maxing = "maxWait" in options;
    maxWait = maxing
      ? nativeMax(toNumber(options.maxWait) || 0, wait)
      : maxWait;
    trailing = "trailing" in options ? !!options.trailing : trailing;
  }

  // 执行回调函数, 清理上次的 this 和 参数
  function invokeFunc(time) {
    var args = lastArgs,
      thisArg = lastThis;

    lastArgs = lastThis = undefined;
    lastInvokeTime = time;
    result = func.apply(thisArg, args);
    return result;
  }

  // leading 检查判断 同时开启定时器 ,记录上次执行时间 lastInvokeTime
  // 如果 leading = true, 立即执行, 否则 返回结果,这个时候  result 可能还是 undefined.

  function leadingEdge(time) {
    // Reset any `maxWait` timer.
    // 这里并 不一定会执行 回调函数(func), 但是也设置了一个值,
    // 就是为了判断 最大间隔 执行, lastInvokeTime 只会再真正调用 回调函数的时候设置
    // 但是 如果 防抖函数 一直触发的情况, 实际回调函数(func) 并不会执行, 所以 lastInvokeTime 一定是空的.
    // 如果设置maxWait, 没有上次执行时间, 就无法判断回调函数执行间隔时间,
    // 其实这里 就是针对首次的情况, 初始化第一次时间未当前时间

    // 如果 不设置 maxWait ,其实没有必要添加,

    lastInvokeTime = time;

    // Start the timer for the trailing edge.
    timerId = setTimeout(timerExpired, wait);
    // Invoke the leading edge.
    return leading ? invokeFunc(time) : result;
  }

  // 计算下一次执行的间隔时间(剩余时间)
  // 这里就是重启定时器时候，需要重新计算一下，
  // 针对与 wait maxWait 不同场景，执行下一次定时器需要的时间

  // wait     - （当前时间 -  debounced 上一次执行时间）
  // maxWait  - （当前时间 -  func 上一次执行时间）

  // 然后取最小

  function remainingWait(time) {
    var timeSinceLastCall = time - lastCallTime,
      timeSinceLastInvoke = time - lastInvokeTime,
      timeWaiting = wait - timeSinceLastCall;

    return maxing
      ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)
      : timeWaiting;
  }
  /**
   * 这里对与时间的判断 是否应该调用 回调函数
   * 这里的判断很巧妙
   */
  function shouldInvoke(time) {
    var timeSinceLastCall = time - lastCallTime,
      timeSinceLastInvoke = time - lastInvokeTime;

    // Either this is the first call, activity has stopped and we're at the
    // trailing edge, the system time has gone backwards and we're treating
    // it as the trailing edge, or we've hit the `maxWait` limit.

    // 1. 函数还未被调用过
    // 2. 函数(debounce)距离上次 调用 间隔时间 >= wait 间隔时间
    // 3. 函数(debounce)距离上次 调用 间隔时间 < 0 ??这个不知道为啥要这样判断, 按理来说, 当前时间 time 一定会大于上次执行时间
    // 4. 设置了最大间隔时间, 而且 回调函数间隔执行时间 大于 最大间隔时间
    return (
      lastCallTime === undefined ||
      timeSinceLastCall >= wait ||
      timeSinceLastCall < 0 ||
      (maxing && timeSinceLastInvoke >= maxWait)
    );
  }

  // 进入到这个函数（定时器的回调函数）只有两个场景
  // 1. 没有定时器
  // 2. 定时器被清了，那不是相当于还是没有定时器
  function timerExpired() {
    var time = now();
    // 再根据时间判断一下，能不能执行，
    if (shouldInvoke(time)) {
      return trailingEdge(time);
    }

    // 不能执行，重启定时器，不过时间需要重新计算一下
    // Restart the timer.
    timerId = setTimeout(timerExpired, remainingWait(time));
  }

  // trailing 的逻辑处理
  // 其实这里的英文注释系的很明白了, func 至少被节流过一次,才会触发, 也就是 wait之后,触发一次
  // 节流过的话, 会把 参数保存起来 lastArgs

  function trailingEdge(time) {
    timerId = undefined;

    // Only invoke if we have `lastArgs` which means `func` has been
    // debounced at least once.
    if (trailing && lastArgs) {
      return invokeFunc(time);
    }
    lastArgs = lastThis = undefined;
    return result;
  }

  function cancel() {
    if (timerId !== undefined) {
      clearTimeout(timerId);
    }
    lastInvokeTime = 0;
    lastArgs = lastCallTime = lastThis = timerId = undefined;
  }

  function flush() {
    return timerId === undefined ? result : trailingEdge(now());
  }
  /**
   * 最终返回的经过防抖动处理的函数
   *
   * debounced 函数的执行，无非是为了判断 func 是否能执行,因此按照这个分类,可能存在的场景:
   *
   * - func 可以执行
   *   1. 第一次执行 (leading = true)
   *   2. maxWait 存在 && 超过了 maxWait 时间
   *   3. 定时器到达了wait, debounced 并未触发
   *
   * - func 不可以执行
   *   1. 时间 wait 不满足
   *      1.1. 定时器不存在, 初始化一个即可
   *      1.2. 定时器已经存在 ,重置定时器, 延迟wait执行.
   *
   *   2. 不存在 wait 满足这种场景, 如果 wait 满足, func 必定执行
   */

  /**
   *  如果按照  debounced 的逻辑来判断
   *
   * - 满足 >wait || >maxWait || 第一次. 前两种立即执行, 第三种可能会立即执行,可能延迟执行,
   *
   *   1. 没有定时器
   *      无非两种情况 立即执行, 定时延期执行
   *
   *   2. 有定时器, (说明func 已经被加入到执行的 "队列里面", 并非第一次,)
   *
   *      2.1 如果设置了最大间隔 maxWait,这里结合上一层的条件(> wait , > maxWait). 立即执行,并添加一个定时器,
   *
   *      2.2 如果没有,无需处理,等定时器执行即可
   *
   * - 不满足, func 一定不会立即执行
   *   1. 有定时器, 已经触发了防抖, 无需处理,到了时间肯定会执行
   *   2. 没有定时器, 创建即可
   *
   *
   */
  function debounced() {
    var time = now(),
      isInvoking = shouldInvoke(time);

    lastArgs = arguments;
    lastThis = this;
    lastCallTime = time;

    if (isInvoking) {
      // 如果可执行,( 通过时间判断, 满足执行条件)

      // 如果没有 定时器， 则检查 leading,
      // 可能是第一次 (或者已经执行过 func, timerId 被 清理了 , 也可以认为是新的开始,第一次)
      if (timerId === undefined) {
        return leadingEdge(lastCallTime);
      }

      // 如果 有定时器 ( 说明已经触发过了 debounced )

      // 如果 设置了最大 间隔时间,
      if (maxing) {
        // Handle invocations in a tight loop.
        // 先把定时器 clear 掉, 再添加一个, 并立即执行 func
        clearTimeout(timerId);
        timerId = setTimeout(timerExpired, wait);
        return invokeFunc(lastCallTime);
      }
    }
    if (timerId === undefined) {
      timerId = setTimeout(timerExpired, wait);
    }
    return result;
  }
  debounced.cancel = cancel;
  debounced.flush = flush;
  return debounced;
}

function throttle(func, wait, options) {
  var leading = true,
    trailing = true;

  if (typeof func != "function") {
    throw new TypeError(FUNC_ERROR_TEXT);
  }
  if (isObject(options)) {
    leading = "leading" in options ? !!options.leading : leading;
    trailing = "trailing" in options ? !!options.trailing : trailing;
  }
  return debounce(func, wait, {
    leading: leading,
    maxWait: wait,
    trailing: trailing,
  });
}

const cryptoName = "SHA-1";
const bit = 22;
const baseSize = 1 << bit; // 4MB 每个块大小

// 计算sha1,
function sha1(data, hex) {
  return new Promise((reslove, reject) => {
    crypto.subtle
      .digest(cryptoName, data)
      .then((buf) => reslove(hex ? arrayBufferToHex(buf) : buf))
      .catch(reject);
  });
}

function countBlock(fileSize) {
  return (fileSize + (baseSize - 1)) >> bit;
}

// 计算文件hash
async function fileHash(file) {
  const fileSize = file.size;
  const chunkCount = countBlock(fileSize);

  let allBuff;
  let prefix;
  // 大于 4MB 的文件
  if (chunkCount > 1) {
    // const sha1ListBuff
    prefix = new Uint8Array([0x96]).buffer;
    let start = 0;
    const sah1BuffList = [];
    while (start < fileSize) {
      const bf = file.slice(start, start + baseSize);
      const currSha1Buff = await sha1(await bf.arrayBuffer());
      start += baseSize;
      sah1BuffList.push(currSha1Buff);
    }
    allBuff = await sha1(mergeToU8Arr(...sah1BuffList));
  } else {
    prefix = new Uint8Array([0x16]).buffer;
    allBuff = await sha1(await file.arrayBuffer());
  }

  allBuff = mergeToU8Arr(prefix, allBuff);
  // base64
  console.log(base64URLEncode(allBuff));
  // hex
  console.log(arrayBufferToHex(allBuff));
}

function mergeToU8Arr(...buf) {
  const l = buf.length;
  if (l === 1) {
    return buf;
  }
  let totalLen = 0;
  for (let i = 0; i < l; i++) {
    totalLen += buf[i].byteLength;
  }
  const tmpBuf = new ArrayBuffer(totalLen);
  const u8Buf = new Uint8Array(tmpBuf);
  let offset = 0;
  for (const bf of buf) {
    const curBuf = new Uint8Array(bf);
    u8Buf.set(curBuf, offset);
    offset += curBuf.length;
  }
  return u8Buf;
}

function base64URLEncode(input) {
  // 使用 btoa 进行 Base64 编码
  let base64Encoded = btoa(
    String.fromCharCode.apply(null, new Uint8Array(input))
  );
  // 替换标准 Base64 字符集中的一些字符，以获得 URL 安全的编码
  return base64Encoded
    .replace(/\+/g, "-")
    .replace(/\//g, "_")
    .replace(/=+$/, "");
}
// 将 ArrayBuffer 转换为十六进制字符串
function arrayBufferToHex(buffer) {
  const hashArray = Array.from(new Uint8Array(buffer));
  return hashArray.map((byte) => byte.toString(16).padStart(2, "0")).join("");
}