// fixtures/sizes.test.mjs — the font-size vocabulary, under plain Node.
//
// fonts.test.mjs's counterpart. Importing this module is also what makes
// sizes.mjs's own module-load guard run in the gate — the same
// arrangement align.test.mjs and fonts.test.mjs have, and for the reason
// their comments give at length: a guard that only executes when a
// browser mounts the editor is dead code in CI, so a drifted vocabulary
// would pass the whole gate and then throw for every user.

import { test } from 'node:test'
import assert from 'node:assert/strict'

import {
  SIZES,
  DEFAULT_SIZE,
  SIZE_MARKS,
  LEGACY_SIZES,
  sizeMark,
  sizeForMarks,
} from './sizes.mjs'

test('the default is offered, is first, and carries no mark', () => {
  assert.ok(SIZES.includes(DEFAULT_SIZE))
  assert.equal(SIZES[0], DEFAULT_SIZE)
  // The literal null is the assertion, not a derivation of sizeMark's
  // own definition. fonts.mjs's guard has a long comment about an
  // assertion that compared a value to itself and could not fail for
  // any input; this is where that expectation belongs — in a test,
  // against a literal.
  assert.equal(sizeMark(DEFAULT_SIZE), null)
  assert.equal(sizeMark(12), null)
})

test('every other size maps to its own mark', () => {
  assert.equal(sizeMark(8), 'size_8')
  assert.equal(sizeMark(14), 'size_14')
  assert.equal(sizeMark(72), 'size_72')
})

test('a size string works, because that is what a <select> gives you', () => {
  assert.equal(sizeMark('14'), 'size_14')
  assert.equal(sizeMark('12'), null)
})

test('a size this build does not offer is undefined, never null', () => {
  // undefined and null are different answers: null clears the group,
  // which is a real edit. A stale page sending 13 must not silently
  // reset a person's text to 12.
  assert.equal(sizeMark(13), undefined)
  assert.equal(sizeMark(0), undefined)
  assert.equal(sizeMark('enormous'), undefined)
  assert.equal(sizeMark(''), undefined)
})

test('no marks means the default size', () => {
  assert.equal(sizeForMarks([]), DEFAULT_SIZE)
  assert.equal(sizeForMarks(['strong', 'em']), DEFAULT_SIZE)
})

test('a mark reports its own size', () => {
  assert.equal(sizeForMarks(['size_18']), 18)
  assert.equal(sizeForMarks(['strong', 'size_9', 'em']), 9)
})

// The legacy marks are the reason this module has a mapping at all, and
// the reason the control could not simply slice the prefix off a mark
// name the way it used to.
test('the four-step scale still reports a size on the ladder', () => {
  assert.equal(sizeForMarks(['size_sm']), 10)
  assert.equal(sizeForMarks(['size_lg']), 14)
  assert.equal(sizeForMarks(['size_xl']), 18)
  for (const pt of Object.values(LEGACY_SIZES)) {
    assert.ok(SIZES.includes(pt), `${pt}pt is not on the ladder, so the control could not show it`)
  }
})

test('the legacy marks are in the group the toolbar clears', () => {
  // If they were not, choosing a size on a run carrying an old mark
  // would leave it in place and the run would be at two sizes at once —
  // which the schema forbids and POST /d/{sqid}/updates does not.
  for (const mark of Object.keys(LEGACY_SIZES)) {
    assert.ok(SIZE_MARKS.includes(mark), `${mark} is not cleared when a size is chosen`)
  }
})

test('the ladder wins over a legacy mark on the same run', () => {
  // Impossible through the editor (the schema's excludes), reachable
  // through POST /d/{sqid}/updates. The answer has to be stable rather
  // than whichever was found first, and internal/export/pdf.go's
  // sizeOrder makes the same choice so the screen and the PDF agree.
  assert.equal(sizeForMarks(['size_lg', 'size_24']), 24)
  assert.equal(sizeForMarks(['size_24', 'size_lg']), 24)
})