// fixtures/fonts.mjs — the font vocabulary, in one place.
//
// Three faces, one of which is the default. That last word is the whole
// reason this file exists, because the default is not a property of any
// face: it is a decision, held in four places that cannot see each
// other, and until it moved nothing had to state it.
//
//   - views/show.html's `[docs-text]` rule, which is what an unmarked
//     run is set in on screen;
//   - internal/export/pdf.go's styleFor, which is what an unmarked run
//     is set in on paper;
//   - internal/fonts' `Default`, which names the face those two must
//     agree on;
//   - and this module, which is what the toolbar SAYS an unmarked run
//     is set in.
//
// A toolbar disagreeing with the other three is the quiet failure. It
// does not throw and it does not lose anything: the font control simply
// reads "Serif" over text that is drawn in sans, and a person who wants
// serif selects it, watches the control already say Serif, and gets
// nothing. internal/docs's TestTheToolbarDefaultFontIsTheDefaultFace is
// what holds this file's DEFAULT_FONT to internal/fonts' Default, since
// Go and Node cannot import each other.
//
// The rule the whole vocabulary turns on: THE DEFAULT CARRIES NO MARK.
// Choosing it clears the group rather than setting anything, so a
// document only ever contains a font mark where somebody asked for a
// face other than the one they would have got anyway. That is what
// makes a document written before any of this existed render as today's
// default, and it is why moving the default is a one-line change here
// with real consequences rather than a cosmetic relabelling.

// The faces a person can choose, in the order the toolbar shows them —
// default first, because a <select> shows its first option until
// something sets a value, and with no JavaScript nothing ever does.
export const FONTS = ['sans', 'serif', 'mono']

// The face an unmarked run is in.
//
// One line, and moving it changes what most of the text in most
// documents is set in — on screen, on paper, and in what this control
// says. It is not a preference expressed here: internal/fonts' Default
// is the one that governs layout, and internal/docs's
// TestTheToolbarDefaultFontIsTheDefaultFace fails if this line and that
// constant name different faces.
export const DEFAULT_FONT = 'sans'

// Every font mark, including the default's. The default's mark is never
// written by the toolbar, but it is real, and the reason is the reverse
// of the obvious one: no document written before the default moved can
// contain font_serif, because serif WAS the absence of a mark then.
// What those documents contain is font_sans — the mark of the face that
// is now the default — written by everyone who chose sans while it was
// still a choice. That mark has to go on meaning sans and has to be
// cleared like any other. A paste can bring any of the three in, and
// POST /d/{sqid}/updates can carry anything at all. So the group this
// clears, and the group fontForMarks reads, is all three.
//
// The ORDER is mono, sans, serif, and it is not a listing preference:
// it is the order the other two renderers resolve a run carrying more
// than one font mark. core/src/fragment.rs pushes its spans in MARKS
// order (serif, sans, mono) and closes them reversed, so mono ends up
// innermost and the innermost family wins the cascade;
// internal/export/pdf.go's styleFor tests font_mono first and reaches
// the same answer. fontForMarks below returns its first hit, so this
// list has to run the same way round or the control names a face the
// text is not drawn in.
export const FONT_MARKS = ['font_mono', 'font_sans', 'font_serif']

// fontMark maps a chosen face to the mark to set: null for the default,
// which is spelled as the absence of one, and undefined for a value
// this module does not know.
//
// undefined and null are different answers on purpose. null means
// "clear the group", which is a real edit; undefined means "this is not
// one of ours", and a caller that treated it as null would clear a
// person's font because a stale page sent an option this build dropped.
export function fontMark(value) {
  if (!FONTS.includes(value)) return undefined
  if (value === DEFAULT_FONT) return null
  return 'font_' + value
}

// fontForMarks is the inverse, and it is what keeps the control honest:
// given the font marks active on the selection, which face is it in.
// No marks means the default — not "unknown", and not whichever face
// used to be the default when this line was written.
//
// FONT_MARKS order decides a run carrying two font marks, which the
// schema's own `excludes` makes impossible through the editor and
// POST /d/{sqid}/updates makes possible anyway. Not arbitrary: it is
// the order both renderers already resolve such a run in, so the answer
// here is the face actually drawn rather than merely a stable guess.
// See FONT_MARKS above for the mechanism on each side.
export function fontForMarks(names) {
  for (const mark of FONT_MARKS) {
    if (names.includes(mark)) return mark.slice('font_'.length)
  }
  return DEFAULT_FONT
}

// Every face has a mark, every mark has a face, the default is one of
// them, and it is the one the scriptless <select> shows.
//
// Runs at module load, like toolbar.mjs's alignmentsAreCovered and for
// the reason that one's comment gives at length: a guard that only runs
// when a browser mounts the editor is dead code in the gate, so a
// vocabulary that had drifted would pass CI and throw for every user.
// fonts.test.mjs imports this module, which is what makes this call
// execute on every gate run.
function fontsAreCovered() {
  const marked = FONT_MARKS.map((m) => m.slice('font_'.length))
  if ([...marked].sort().join() !== [...FONTS].sort().join()) {
    throw new Error(`fonts: marks [${marked}] do not match the faces [${FONTS}]`)
  }
  if (!FONTS.includes(DEFAULT_FONT)) {
    throw new Error(`fonts: the default ${JSON.stringify(DEFAULT_FONT)} is not one of [${FONTS}]`)
  }
  if (FONTS[0] !== DEFAULT_FONT) {
    throw new Error(
      `fonts: the toolbar lists ${JSON.stringify(FONTS[0])} first but the default is ` +
        `${JSON.stringify(DEFAULT_FONT)} — with no JavaScript the control would name a face the text is not in`,
    )
  }
  // There is deliberately no fourth check that fontMark(DEFAULT_FONT)
  // is null. One was written here and deleted: fontMark returns null
  // exactly when its argument is in FONTS and equals DEFAULT_FONT, and
  // the check above has already thrown if DEFAULT_FONT is not in FONTS
  // — so it compared a value to its own derivation and could not throw
  // for ANY value of DEFAULT_FONT. Verified rather than reasoned:
  // running fontMark over every face and over three non-faces makes the
  // condition false in all six cases.
  //
  // This is the eighth assertion found in this repo unable to fail
  // against the thing it names, and all eight have had one shape — a
  // value compared to itself, or to something derived from itself. "The
  // default is spelled as the absence of a mark" is a property of
  // fontMark's own definition, so the place to state it is that
  // function, and the place to TEST it is fonts.test.mjs, where the
  // expectation is a literal.
}

fontsAreCovered()