// fixtures/toolbar-roving.mjs — the formatting bar's keyboard
// navigation, split out of toolbar.mjs to keep both under spec §12's
// 300-line-per-module cap.
//
// It is a genuinely separate concern: toolbar.mjs decides what each
// control DOES to the document, and this decides which control the
// keyboard is on. Nothing here knows about ProseMirror.


// setupRoving makes the whole bar ONE tab stop, with the arrow keys
// moving between the controls inside it — the WAI-ARIA toolbar
// pattern, which `role="toolbar"` in views/show.html is a promise to
// implement.
//
// Without it the bar is fourteen tab stops between the shell bar and
// the first word of the document, on every page load, for someone who
// only wanted to type. It is also what a word processor does, so it is
// what people's hands already expect. (Raised by the caret-placement
// session, who was right that the fix is this and not reordering the
// DOM: the bar sits above the paper visually, so DOM order already
// matches reading order, and pulling focus order away from visual
// order to save a few tab presses would trade a small annoyance for a
// WCAG 2.4.3 Focus Order violation.)
//
// Left/Right rather than all four arrows, and preventDefault on the
// ones handled: a closed native <select> changes its own value on
// Left/Right, so the toolbar has to consume those; Up/Down are left
// alone, which is how the three selects stay operable from the
// keyboard without opening.
//
// Nothing here touches focus *visibility*. The controls keep
// rastrillo's own focus ring — a roving tabindex decides which control
// Tab reaches, not whether a person can see which one they are on, and
// show.html's ring removal is scoped to [docs-editor] alone precisely
// so this stays true.
export function setupRoving(root, controls) {
  if (!root || controls.length === 0) return { ensureReachable() {}, focusStop() { return false } }

  const reachable = () => controls.filter((c) => !c.disabled)

  function setStop(target) {
    for (const c of controls) c.tabIndex = c === target ? 0 : -1
  }

  // ensureReachable is called after every sync, because sync is what
  // enables and disables buttons: undo and redo start disabled, and a
  // disabled button cannot take focus at all — so a tab stop parked on
  // one makes the entire bar unreachable by keyboard rather than
  // merely awkward. That failure is invisible to every other check
  // here, which is why fixtures/browser-drive.mjs tabs in from outside
  // and asserts it can get through.
  function ensureReachable() {
    const list = reachable()
    if (list.length === 0) return
    if (list.some((c) => c.tabIndex === 0)) return
    setStop(list[0])
  }

  root.addEventListener('keydown', (event) => {
    const key = event.key
    if (key !== 'ArrowRight' && key !== 'ArrowLeft' && key !== 'Home' && key !== 'End') return
    const list = reachable()
    const at = list.indexOf(document.activeElement)
    if (at < 0 || list.length === 0) return

    let next
    if (key === 'Home') next = list[0]
    else if (key === 'End') next = list[list.length - 1]
    else if (key === 'ArrowRight') next = list[(at + 1) % list.length]
    else next = list[(at - 1 + list.length) % list.length]

    event.preventDefault()
    setStop(next)
    next.focus()
  })

  // A control reached by mouse becomes the tab stop, so Tab leaves
  // from where the person last was rather than from wherever the
  // keyboard happened to leave it.
  root.addEventListener('focusin', (event) => {
    if (controls.includes(event.target)) setStop(event.target)
  })

  ensureReachable()
  // focusStop moves focus onto the bar's current tab stop, and reports
  // whether it managed to.
  //
  // It exists for Escape inside the editable surface. Tab is
  // repurposed in there — it indents rather than moving focus — and
  // although Shift+Tab still escapes backwards, there is no forward
  // exit below indent 8. WCAG 2.1.2 permits a modified key provided
  // the person is told, but "you can only leave backwards" is a poor
  // thing to have to tell them, so Escape leaves forwards onto the
  // nearest chrome instead.
  function focusStop() {
    const list = reachable()
    if (list.length === 0) return false
    const target = list.find((c) => c.tabIndex === 0) || list[0]
    setStop(target)
    target.focus()
    return true
  }

  return { ensureReachable, focusStop }
}