export interface SchedulerJob extends Function {
  id?: number //唯一ID
  pre?: boolean //是否是预处理
  active?: boolean //是否激活
  computed?: boolean //是否是计算任务
    /**
    * 表示是否允许该效果自行递归触发
    * 当由调度程序管理时。
    *
    * 默认情况下，作业无法自行触发，因为某些内置方法调用，
    * 例如 Array.prototype.push 实际上也执行读取（#1740）
    * 可能导致令人困惑的无限循环。
    * 允许的情况是组件更新函数和监视回调。
    * 组件更新函数可能会更新子组件 props，进而更新子组件 props
    * 触发刷新：“预”监视回调，该回调会改变父级的状态
    * 依赖于（#1801）。 监视回调不会跟踪其依赖项，因此如果
    * 再次触发自身，这可能是故意的，并且是用户的
    * 负责执行递归状态突变，最终
    * 稳定（#1727）。
    */
  allowRecurse?: boolean
  /**
    * 设置组件渲染效果时由renderer.ts附加
    * 用于在报告最大递归更新时获取组件信息。
    * 仅限开发人员。
    */
  ownerInstance?: ComponentInternalInstance
}

export function queueJob(job: SchedulerJob) {
  // 重复数据删除搜索使用 Array.includes() 的 startIndex 参数
  // 默认情况下，搜索索引包括当前正在运行的作业
  // 所以它不能再次递归地触发自身。
  // 如果作业是 watch() 回调，则搜索将从 +1 索引开始
  // 允许它递归地触发自身 - 用户有责任
  // 确保它不会陷入无限循环。
  if (
    !queue.length ||
    !queue.includes(
      job,
      isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex
    )
  ) {
    if (job.id == null) {
      queue.push(job)
    } else {
      queue.splice(findInsertionIndex(job.id), 0, job)
    }
    queueFlush()
  }
}

function queueFlush() {
  if (!isFlushing && !isFlushPending) {
    isFlushPending = true
    currentFlushPromise = resolvedPromise.then(flushJobs)
  }
}

let isFlushing = false //是否有更新循环正在执行
let isFlushPending = false //是否有等待中的更新循环

for(let i=0;i<1000;i++) {
    count.value++
}

const resolvedPromise = /*#__PURE__*/ Promise.resolve() as Promise<any>
resolvedPromise.then(flushJobs)

isFlushPending = true
currentFlushPromise = resolvedPromise.then(flushJobs)

function flushJobs(seen?: CountMap) {
  isFlushPending = false
  isFlushing = true
  if (__DEV__) {
    seen = seen || new Map()
  }

   // 在刷新之前对队列进行排序。
   // 这确保了：
   // 1. 组件从父级更新到子级。 （因为父母总是
   // 在子进程之前创建，因此它的渲染效果会更小
   // 优先级编号）
   // 2. 如果在父组件更新期间卸载了组件，
   // 可以跳过它的更新。
  queue.sort(comparator)

   // checkRecursiveUpdate 的条件使用必须由以下确定
   // try ... catch 块，因为 Rollup 默认情况下会取消对 treeshaking 的优化
   // 在 try-catch 中。 这可以使所有警告代码保持不变。 虽然
   // 他们最终会被像 terser 这样的缩小器动摇，一些缩小器
   // 将无法做到这一点（例如 https://github.com/evanw/esbuild/issues/1610）
  const check = __DEV__
    ? (job: SchedulerJob) => checkRecursiveUpdates(seen!, job)
    : NOOP

  try {
    for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
      const job = queue[flushIndex]
      if (job && job.active !== false) {
        if (__DEV__ && check(job)) {
          continue
        }
        // console.log(`running:`, job.id)
        callWithErrorHandling(job, null, ErrorCodes.SCHEDULER)
      }
    }
  } finally {
    flushIndex = 0
    queue.length = 0

    flushPostFlushCbs(seen)

    isFlushing = false
    currentFlushPromise = null
    // 一些 postFlushCb 排队作业！
    // 继续冲洗直到排空。
    if (queue.length || pendingPostFlushCbs.length) {
      flushJobs(seen)
    }
  }
}

export function flushPostFlushCbs(seen?: CountMap) {
  if (pendingPostFlushCbs.length) {
    const deduped = [...new Set(pendingPostFlushCbs)]
    pendingPostFlushCbs.length = 0

    // #1947 already has active queue, nested flushPostFlushCbs call
    if (activePostFlushCbs) {
      activePostFlushCbs.push(...deduped)
      return
    }

    activePostFlushCbs = deduped
    if (__DEV__) {
      seen = seen || new Map()
    }

    activePostFlushCbs.sort((a, b) => getId(a) - getId(b))

    for (
      postFlushIndex = 0;
      postFlushIndex < activePostFlushCbs.length;
      postFlushIndex++
    ) {
      if (
        __DEV__ &&
        checkRecursiveUpdates(seen!, activePostFlushCbs[postFlushIndex])
      ) {
        continue
      }
      activePostFlushCbs[postFlushIndex]()
    }
    activePostFlushCbs = null
    postFlushIndex = 0
  }
}