cache-meter

  on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
    const below = await next(e)
    if (e.props && e.props.hasSurvey) return below
    const s = await session($)
    if (!s.lastActivity && !s.keepWarm) return below
    if (!isLanguagePicked) await pickLanguage($)
    now = await $.clock.now()
    const { Box, Text, Button } = $.ui.resolve(e)
    const st = cacheState(s)
    const big = isBig(s)
    const parts = []
    if (st.kind === 'kept') {
      const until = clock(s.keepWarmUntil)
      parts.push(Text({ color: 'cyan', children: [s.pings ? L.kept(until, pings(s.pings), amount(s, s.pingTokens, s.pingUsd)) : L.keptNoPings(until)] }))
    }
    // All is well, so only the dot is green and the words stay dim
    else if (st.kind === 'warm') parts.push(Text({ children: [Text({ color: 'green', children: ['●'] }), Text({ dimColor: true, children: [L.warm(minutes(st.left))] })] }))
    else if (st.kind === 'cooling') parts.push(Text({ color: 'yellow', bold: true, children: [L.cooling(minutes(st.left))] }))
    else if (st.kind === 'cold') parts.push(Text(big ? { color: 'red', bold: true, children: [L.cold(minutes(-st.left))] } : { dimColor: true, children: [L.cold(minutes(-st.left))] }))
    const r = rewrite(s)
    const cost = amount(s, r.tokens, r.usd)
    parts.push(st.kind === 'cold' && big
      ? Text({ color: 'red', children: [L.nextRewrites(cost)] })
      : Text({ dimColor: true, children: [L.rewriteWouldCost(cost)] }))
    if (s.coldRestarts.length) {
      const re = restarts(s)
      parts.push(Text({ dimColor: true, children: [L.rewritten(re.times, amount(s, re.tokens, re.usd))] }))
    }
    // Plan limits only when one is close to running out
    const high = limitsFrom(s, 80)
    if (high.length) parts.push(Text(limitTone(high, { children: [L.limits(limitsText(high))] })))
    // Keep warm is on offer whenever there is a warm cache to keep: quiet while there is time,
    // loud once a big cache is about to cool. A real button like Handoff's; the letter only on the
    // terminal, since a desktop draws a hotkey as a chip in front of the label
    const key = e.surface === 'terminal' ? { hotkey: 'k' } : {}
    const redraw = async (fn) => {
      now = await $.clock.now()
      await fn()
      await publish($)
      $.ui.invalidate('ui.render')
    }
    if (st.kind === 'warm' || st.kind === 'cooling') {
      const isUrgent = st.kind === 'cooling' && big
      parts.push(Button({ key: 'keepwarm', label: L.keepWarm, ...key, ...(isUrgent ? {} : { dimColor: true }), onPress: () => redraw(() => startKeepWarm($, settings.keepWarmHours)) }))
    } else if (st.kind === 'kept') {
      parts.push(Button({ key: 'keepwarm', label: L.stopKeeping, ...key, onPress: () => redraw(() => stopKeepWarm($, L.whyOff)) }))
    }
    // Every part, the button too, is set off from the next by the same dim bar
    const row = parts.flatMap((p, i) => i ? [Text({ key: `bar${i}`, dimColor: true, children: ['│'] }), p] : [p])
    const mine = Box({ key: 'cache-meter', flexDirection: 'row', columnGap: 1, children: row })
    // Its own place in the band the mods of this repo share, whatever order they loaded in
    return joinBand(Box, 'cache-meter', mine, below)
  })

export function joinBand(Box, name, mine, below) {
  const rows = rowsOf(Box, below)
  rows.push(Box({ key: `${ROW}${PLACE[name]}:${name}`, flexDirection: 'column', children: [mine] }))
  rows.sort((a, b) => placeOf(a) - placeOf(b))
  return Box({ key: BAND, flexDirection: 'column', rowGap: 0.5, children: rows })
}

function rowsOf(Box, below) {
  if (below === null || below === undefined || below === false) return []
  if (typeof below === 'object' && below.type === 'Box' && below.props && below.props.key === BAND) {
    return [...(below.children ?? [])]
  }
  return [Box({ key: `${ROW}${FOREIGN}:other`, flexDirection: 'column', children: [below] })]
}