export type Fiber = {
  tag: WorkTag,
  key: null | string,
  ...
  // 链表结构信息
  return: Fiber | null,
  child: Fiber | null,
  sibling: Fiber | null,
  ...
}

const channel = new MessageChannel()

channel.port1.onmessage = function(msgEvent) {
  console.log('recieve message!')
}

channel.port2.postMessage(null)

// output: recieve message!

let schedulePerformWorkUntilDeadline; // 调度器
if (typeof localSetImmediate === 'function') {
  // Node.js 与 旧版本IE环境.
  ...
} else if (typeof MessageChannel !== 'undefined') {
  // DOM 与 Web Worker 环境.
  const channel = new MessageChannel();
  const port = channel.port2;
  channel.port1.onmessage = performWorkUntilDeadline; // 执行器
  schedulePerformWorkUntilDeadline = () => {
    port.postMessage(null);
  };
} else {
  // 非浏览器环境的兜底方案.
  ...
}

function requestHostCallback(callback) {
  scheduledHostCallback = callback; 
   // 开启任务循环
  if (!isMessageLoopRunning) {
    isMessageLoopRunning = true;
    // 调度器开始运作，即 port1 端口将收到消息，执行 performWorkUntilDeadline 
    schedulePerformWorkUntilDeadline();
  }
}

const performWorkUntilDeadline = () => {
  //当前是否有处理中的任务
  if (scheduledHostCallback !== null) {
    // 计算此次任务的 deadline
    const currentTime = getCurrentTime();
    deadline = currentTime + yieldInterval;
    const hasTimeRemaining = true;
    let hasMoreWork = true;
    
    try {
      // 是否还有更多任务
      hasMoreWork = scheduledHostCallback(hasTimeRemaining, currentTime);
    } finally {
      if (hasMoreWork) {
        // 有：继续进行任务调度
        schedulePerformWorkUntilDeadline();
      } else {
        isMessageLoopRunning = false;
        scheduledHostCallback = null;
      }
    }
  } else {
    isMessageLoopRunning = false;
  }
};

const localPerformance = performance;
// 获取当前时间
getCurrentTime = () => localPerformance.now();

// 让出线程周期, 默认是5ms
let yieldInterval = 5;

let deadline = 0;
const maxYieldInterval = 300;
let needsPaint = false;
const scheduling = navigator.scheduling;
// 是否让出主线程
shouldYieldToHost = function() {
  const currentTime = getCurrentTime();
  if (currentTime >= deadline) {
    if (needsPaint || scheduling.isInputPending()) { // 判断是否有输入事件
      return true;
    }
    return currentTime >= maxYieldInterval; // 在持续运行的react应用中, currentTime肯定大于300ms, 这个判断只在初始化过程中才有可能返回false
  } else {
    // 当前帧还有时间
    return false;
  }
};

// Tasks are stored on a min heap
// 任务被存储在一个小根堆中
var taskQueue = []; // 任务队列

// 代码有所简化
function unstable_scheduleCallback(priorityLevel, callback, options) {
  // 【1. 计算任务过期时间】
  var startTime = getCurrentTime();
  var timeout;
  switch (priorityLevel) {
   ...
   timeout = SOME_PRIORITY_TIMEOUT
  }
  var expirationTime = startTime + timeout; // 优先级越高；过期时间越小
  //【2. 创建新任务】
  var newTask = {
    id: taskIdCounter++, // 唯一ID
    callback, // 传入的回调函数
    priorityLevel, // 优先级
    startTime, // 创建 task 的时间
    expirationTime, // 过期时间, 
  };
  newTask.sortIndex = expirationTime;
  // 【3. 加入任务队列】
  push(taskQueue, newTask);
  // 【4. 请求调度】
  if (!isHostCallbackScheduled && !isPerformingWork) {
    isHostCallbackScheduled = true;
    requestHostCallback(flushWork);
  }
  return newTask;
}

// 代码有所简化
function workLoop(hasTimeRemaining, initialTime) {
  let currentTime = initialTime; // 保存当前时间, 用于判断任务是否过期
  currentTask = peek(taskQueue); // 获取队列中的第一个任务
  while (currentTask !== null) {
    // 是否需要让出线程的判断
    if (
      currentTask.expirationTime > currentTime &&
      (!hasTimeRemaining || shouldYieldToHost())
    ) {
      // 任务虽然没有超时，但本帧时间不够了。挂起
      break;
    }
    const callback = currentTask.callback;
    if (typeof callback === 'function') {
      currentTask.callback = null;
      currentPriorityLevel = currentTask.priorityLevel;
      const didUserCallbackTimeout = currentTask.expirationTime <= currentTime;
      // 执行回调
      const continuationCallback = callback(didUserCallbackTimeout);
      currentTime = getCurrentTime();
      // 回调完成, 判断是否还有连续回调
      if (typeof continuationCallback === 'function') {
        currentTask.callback = continuationCallback;
      } else {
        // 把currentTask移出队列
        if (currentTask === peek(taskQueue)) {
          pop(taskQueue);
        }
      }
    } else {
      // 如果任务被取消(这时currentTask.callback = null), 将其移出队列
      pop(taskQueue);
    }
    // 更新 currentTask
    currentTask = peek(taskQueue);
  }
  if (currentTask !== null) {
    return true; // 如果task队列没有清空, 返回ture. 等待调度中心下一次回调
  } else {
    return false; // task队列已经清空, 返回false.
  }
}