// 子应用只发意图，不碰宿主内部状态
function openSubappView(viewType, viewId) {
  emit('TAB_OPEN_REQUEST', { itemType: 'SUBAPP_VIEW', viewType, viewId });
}

// 宿主统一处理
function handleTabOpenRequest(raw) {
  const input = normalizeAndValidate(raw);

  if (raw.openInNewBrowserTab) {
    window.open(buildBusinessUrl(input));
    return;
  }

  // existing：目标业务对象已经有自己的 tab。
  // 例子：用户要打开 view A，而 view A 的独立 tab 已经在 tab list 里。
  const existing = findExistingTab(tabs, input);

  // absorbing：当前 focused tab 是一个可承载内部 view 的 carrier。
  // 例子：用户正在某个 SubApp root / SubApp view 里打开同属一个 app 的 sibling view；
  // 这时更像“在当前 app tab 内导航”，不是“打开一个全新工作上下文”。
  const absorbing = findFocusedTabThatCanAbsorb(input);

  // 这两个概念不是重叠的：
  // - existing 处理“目标是否已经有 tab”；
  // - absorbing 处理“当前 tab 是否可以直接承接这次导航”。
  //
  // 如果当前是 subapp root，并且目标已有精确 tab，优先跳已有 tab；
  // 否则会优先吸收到当前 carrier，避免在同一个子应用里频繁开重复 runtime。
  if (existing && absorbing?.kind === 'subapp-root') {
    focusTab(existing.id, savedUrlOrDefault(existing));
    return;
  }

  if (absorbing) {
    navigateInsideTab(absorbing.id, buildPath(input));
    return;
  }

  if (existing) {
    focusTab(existing.id, savedUrlOrDefault(existing));
    return;
  }

  addTabWithCapacityControl(input);
}

function onRouteChanged(location) {
  // 浏览器地址栏变化后，先把业务 URL 解析成“它是否属于某个 tab”。
  // appList 用来识别不同子应用的业务路由。
  const resolved = resolveTabFromUrl(location.pathname, appList);

  if (resolved.kind !== 'tab') {
    // Home、redirect、standalone fallback 这类页面不是工作 tab。
    // 它们走普通路由渲染，不创建 tab row，也不进入 hot runtime pool。
    renderSingleOutlet();
    return;
  }

  // 如果服务端 opened tabs 里已经有这个业务对象，只需要聚焦它。
  // 这里不能新增，否则刷新一次就可能多一个重复 tab。
  const matched = findOpenedTab(tabs, resolved.input);
  if (matched) {
    focusRuntime(matched.id);
    return;
  }

  // direct URL recovery:
  // 用户打开的是一个业务 URL，但 BFF 里还没有对应 tab。
  // 宿主要补开 tab，否则页面会变成“没有 tab 行归属”的孤儿页面。
  addTab(toAddWorkspaceTabRequest(resolved.input));
  focusRuntimeWhenReady(resolved.input);
}

function activateTab(tab) {
  // 每个 tab 都记住自己上一次停留的业务 URL。
  // 例如用户在 Workstream tab 内切到了某个 view，下次点回这个 tab 应该回到那个 view，
  // 而不是永远回到 Workstream 默认页。
  const path = loadSavedTabUrl(tab.id) ?? buildDefaultBusinessUrl(tab);

  // 从点击开始计时。后面会分别记录 frame visible、interactive、settled，
  // 防止“页面显示了但还不能点”的时间被旧指标漏掉。
  startTabSwitchMetric({ toId: tab.id, targetPath: path });

  // 告诉 Seto / iframe 的 history scope：
  // 接下来这次 URL 写入属于目标 tab，而不是某个 hidden runtime 的越界写入。
  prepareScopedNavigation({ targetTabId: tab.id, url: path });

  navigate(path, {
    // React Router 只看到一个全局 history。
    // 这里把目标 tab id 写进 history.state，后续 popstate / hashchange / Seto history
    // 才能判断这次导航应该投递给哪个 runtime。
    state: { workspaceTargetTabId: tab.id },

    // tab 激活是用户输入的直接结果，必须尽快让 focused frame 和 URL 对齐。
    flushSync: true,
  });
}

function onTabMutationSuccess() {
  // 本窗口的缓存先失效。
  queryClient.invalidateQueries(WORKSPACE_TABS_KEY);

  // 其它窗口没有共享 React state，只能收到一个“事实变了”的通知后自己重拉。
  broadcastChannel.postMessage({ type: 'TABS_INVALIDATED' });
}

function onOtherWindowInvalidated() {
  queryClient.invalidateQueries(WORKSPACE_TABS_KEY);
}

function addWorkspaceTab(input) {
  queryClient.setQueryData(WORKSPACE_TABS_KEY, tabs => [
    ...tabs,
    makeTempLockedTab(input),
  ]);

  post('/workspace/api/tab/add', input)
    .then(serverTab => replaceTempTab(serverTab))
    .finally(() => broadcastTabsInvalidated());
}

class WarmPool {
  promote(tabId, location, runtimeKind) {
    // 用户聚焦或预热命中时，把这个 tab 放进 hot set。
    hot.set(tabId, { tabId, location, runtimeKind, lastFocusedAt: now() });

    // Seto sandbox 更重，所以有单独上限；全局 hot frame 也有总上限。
    // 淘汰只会卸载 runtime，不会删除 opened tab。
    evictOldestSetoIfOverCap();
    evictOldestHotFrameIfOverGlobalCap();

    notifySubscribers();
  }
}

afterFirstScreenReady(() => {
  // 首屏完成后才允许后台准备，不能抢 FMP。
  queue(nativeTabCandidates, { delay: 1000 });

  // Seto sandbox 更重，延后且只做必要 lifecycle prime。
  queue(setoTabCandidates, { delay: 3000, primeLifecycle: true });
});

if (tabSwitchIsSettling() || foregroundTabHasLease()) {
  // 用户正在切 tab，后台预热必须让路。
  pauseOrRetryBackgroundPrewarm();
}

function scopedPushState(state, unused, url) {
  const targetTabId =
    preparedNavigation?.url === url
      ? preparedNavigation.targetTabId
      : readTabIdFromHistoryState(state) ?? resolveTabIdFromUrl(url);

  if (targetTabId !== currentFrame.tabId) {
    reportScopeDrop('history_drop');
    return;
  }

  rawHistory.pushState(state, unused, url);

  if (focusedRuntimeTabId === currentFrame.tabId) {
    hostHistory.pushState(addTabIdToState(state, currentFrame.tabId), unused, url);
  }
}

parentProxy.get('history')  -> scopedHistory
parentProxy.get('document') -> iframeWin.document
parentProxy.get('location') -> iframeWin.location
parentProxy.get('__workspaceMFEventBus__') -> scopedEventBus

function addEventListener(type, listener) {
  if (type !== 'popstate' && type !== 'hashchange') {
    return rawAddEventListener(type, listener);
  }

  rawAddEventListener(type, event => {
    if (resolveTargetTabForEvent(event) === currentFrame.tabId) {
      listener(event);
    } else {
      reportScopeDrop('event_drop');
    }
  });
}

scopedEventBus.listen(listener) {
  if (!listener.listensTo('TAB_FOCUSED', 'TAB_BLURRED')) {
    return hostBus.listen(listener);
  }

  return hostBus.listen(payload => {
    if (payload.data.tabId === currentFrame.tabId) {
      listener(payload);
    }
  });
}

function appendToRuntimeBody(node) {
  if (isAppShell(node)) {
    scopedRoot.appendChild(node);
    return;
  }

  if (isContentOverlay(node)) {
    contentOverlayRoot.appendChild(node);
    return;
  }

  if (isFloatingOverlay(node)) {
    floatingOverlayRoot.appendChild(node);
    return;
  }

  scopedRoot.appendChild(node);
}

// 运行时 owner：history / parent / popstate 应该属于哪个 Seto frame。
setFocusedSetoRuntimeTab(focusedTabId);

// 弹层 owner：只有当前 tab 的 overlay root 可见。
setFocusedWorkspaceOverlayTab(focusedTabId);

// 事件 owner：只把 TAB_FOCUSED 发给目标 tab，避免后台 runtime 误启动。
emitTabFocusedToTargetOnly(focusedTabId);