// ── The feed's sentences ──────────────────────────────────────────────────
//
// `lib/feed.js` is the one part of the client half with real branching in it, and
// it is pure on purpose so that a DOM-less runner can ask all of it. Everything
// here is a claim about what a reader sees for a given frame — which is exactly
// the kind of thing that rots silently, because a wrong killfeed line is still a
// killfeed line.
//
// The fixtures are the frames the bridge plugin actually emits (its
// `DescribeAttacker`, and PROTOCOL.md §8.4), not invented shapes.

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

import { describe, FEED_KINDS, FILTERS, kindsFor } from '../src/lib/feed.js'

const row = (kind, frame = {}) => ({ id: 1, kind, t: Date.now(), wipeId: 'w1', steamId: '7656', frame })

test('a player kill names the killer and the victim, in that order', () => {
  const line = describe(row('player.death', {
    name: 'Bob',
    attackerType: 'player',
    attackerName: 'Alice',
    weapon: 'rifle.ak',
    distance: 42.4,
    grid: 'H7',
  }))

  assert.equal(line.tone, 'kill')
  assert.equal(line.actor, 'Alice')
  assert.equal(line.verb, 'killed')
  assert.equal(line.subject, 'Bob')
  assert.match(line.detail, /rifle ak/)
  assert.match(line.detail, /42m/)
  assert.match(line.detail, /H7/)
})

test('the four attacker types are four different sentences', () => {
  // The plugin distinguishes them precisely so a reader does not have to guess
  // from an absent field, and collapsing any two loses something: a fall reported
  // as a kill by nobody is the failure this prevents.
  const victim = { name: 'Bob' }

  const npc = describe(row('player.death', { ...victim, attackerType: 'npc', attackerName: 'scientistnpc_full_any' }))
  // A family is named, not spelled out as a prefab (PLAN_FIXES F2, D185).
  assert.equal(npc.actor, 'Scientist')
  assert.equal(npc.subject, 'Bob')

  const self = describe(row('player.death', { ...victim, attackerType: 'self' }))
  assert.equal(self.actor, 'Bob')
  assert.equal(self.subject, null)
  assert.match(self.verb, /own hand/)

  const environment = describe(row('player.death', { ...victim, attackerType: 'environment' }))
  assert.equal(environment.actor, 'Bob')
  assert.equal(environment.verb, 'died')
  assert.equal(environment.subject, null)

  // `HitInfo` is legitimately null on the environment path, so a death frame with
  // NO attacker type at all is that case — not a missing field to render around.
  const bare = describe(row('player.death', victim))
  assert.equal(bare.verb, 'died')
  assert.equal(bare.subject, null)
})

test('a sleeping victim is said to have been sleeping', () => {
  const line = describe(row('player.death', { name: 'Bob', attackerType: 'player', attackerName: 'Alice', sleeping: true }))
  assert.match(line.detail, /while sleeping/)
})

test('a disconnect with no session length says nothing about one', () => {
  // The plugin OMITS `sessionSec` for a player who was already on when it loaded:
  // an unknown session is not a session of no length. A line reading "after 0s"
  // would be a lie this module invented.
  const unknown = describe(row('player.disconnected', { name: 'Bob', reason: 'Quit' }))
  assert.equal(unknown.detail, 'Quit')

  const known = describe(row('player.disconnected', { name: 'Bob', reason: 'Quit', sessionSec: 3720 }))
  assert.equal(known.detail, 'Quit · after 1h 2m')
})

test('a chat line carries the message as text, never as markup', () => {
  // The message is the one field on this wire whose bytes a player chooses. It
  // comes back as a STRING and is rendered as a React child, which escapes it;
  // this test is here so that a later "render the message with formatting" idea
  // has to delete an explicit assertion rather than quietly change behaviour.
  const line = describe(row('player.chat', { name: 'Bob', message: '<img src=x onerror=alert(1)>', channel: 'Global' }))
  assert.equal(line.verb, '<img src=x onerror=alert(1)>')
  assert.equal(typeof line.verb, 'string')
  // Global is the default channel and saying so on every line is noise; Team is
  // information.
  assert.equal(line.detail, '')
  assert.equal(describe(row('player.chat', { name: 'B', message: 'hi', channel: 'Team' })).detail, 'Team')

  // A chat row is the one line where the actor is a speaker rather than a
  // subject, and "Brannock see you in september" is not a sentence anybody
  // writes. The colon is presentation, so it lives here and not inside the text
  // the player typed.
  assert.equal(line.join, ': ')
  assert.equal(describe(row('player.connected', { name: 'B' })).join, undefined)
})

test('an unknown kind renders as itself rather than vanishing', () => {
  // A later protocol adds kinds, and a module may be older than the game host it
  // is reading. The server's allowlist has already decided the row may be seen;
  // dropping it here would make the page quietly say less than the truth.
  const line = describe(row('player.teleported', { name: 'Bob' }))
  assert.equal(line.verb, 'player.teleported')
  assert.equal(line.tone, 'other')
})

test('the feed never asks for the aggregate kind', () => {
  // `player.tally` is public and is flushed once a minute per active player
  // (§8.6). A feed that included it would be mostly wood counts; it is the
  // leaderboard's input, and that is where it shows up.
  assert.ok(!FEED_KINDS.includes('player.tally'))
  for (const filter of FILTERS) {
    for (const kind of filter.kinds) {
      assert.ok(FEED_KINDS.includes(kind), `filter "${filter.id}" asks for ${kind}, which the feed does not carry`)
    }
  }
})

test('every kind the feed asks for is one the public route will serve', () => {
  // Held against the module's own allowlist rather than against a copy of it: a
  // kind this file asked for and `server/catalogue.js` refuses is a filter that
  // silently returns nothing, which reads as a quiet server.
  //
  // A CommonJS file from the server half, read by an ESM test through
  // `createRequire`. Crossing the two halves is fine HERE and nowhere else:
  // `test/` is not shipped, and `scripts/checkImports.js` governs what is.
  const catalogue = createRequire(import.meta.url)('../../server/catalogue.js')
  for (const kind of FEED_KINDS) {
    assert.ok(catalogue.PUBLIC_KINDS.includes(kind), `the feed asks for ${kind}, which is not public`)
  }
})

test('a boss appearing and falling read as sentences, with its name as typed (runicnpc stage 6)', () => {
  const up = describe(row('npc.boss.spawned', { profile: 'juggernaut', name: 'The Juggernaut' }))
  assert.deepEqual({ actor: up.actor, verb: up.verb, detail: up.detail }, { actor: 'The Juggernaut', verb: 'has appeared', detail: 'a boss' })

  const killed = describe(row('npc.boss.died', { profile: 'juggernaut', name: 'The Juggernaut', killerName: 'Marisol', damagers: 5 }))
  assert.deepEqual({ tone: killed.tone, actor: killed.actor, verb: killed.verb, subject: killed.subject, detail: killed.detail },
    { tone: 'kill', actor: 'Marisol', verb: 'killed', subject: 'The Juggernaut', detail: '5 players fought it' })

  // No player landed the blow (a turret, or another NPC): it still fell.
  const fell = describe(row('npc.boss.died', { profile: 'juggernaut', name: 'The Juggernaut', damagers: 1 }))
  assert.deepEqual({ actor: fell.actor, verb: fell.verb, detail: fell.detail }, { actor: 'The Juggernaut', verb: 'was killed', detail: '' })

  assert.deepEqual(kindsFor('bosses'), ['npc.boss.spawned', 'npc.boss.died'])
})

test('an unknown filter falls back to everything rather than to nothing', () => {
  assert.deepEqual(kindsFor('nonsense'), FEED_KINDS)
  assert.deepEqual(kindsFor(undefined), FEED_KINDS)
})

// ── Rust's own world events (protocol 14, PLAN_REDESIGNS §14.3.1) ─────────
//
// The frames here are what the SERVER sends a viewer (`worldEvents.shapeFor`),
// not what the plugin emitted: a grid instead of a position, names only for the
// presence audience, `credited` by the server's rule.

const world = (frame) => row('world.event', { kind: 'world.event', ...frame })

test('a downed helicopter names whom the rule credits, and only them', () => {
  const one = describe(world({ event: 'heli.downed', grid: 'G7', creditRule: 'blow', creditedCount: 1, credited: [{ name: 'Alice' }] }))
  assert.deepEqual([one.tone, one.verb, one.subject, one.detail], ['kill', 'Patrol helicopter downed by', 'Alice', 'G7'])

  const many = describe(world({ event: 'heli.downed', grid: 'G7', creditRule: 'all', creditedCount: 4, credited: [{ name: 'Alice' }, { name: 'Bob' }, { name: 'Cleo' }, { name: 'Dov' }] }))
  assert.equal(many.subject, 'Alice, Bob and 2 others')
})

test('below the presence audience the same line names nobody (D376)', () => {
  const line = describe(world({ event: 'heli.downed', grid: 'G8', creditRule: 'blow', creditedCount: 1 }))
  assert.deepEqual([line.verb, line.subject, line.detail], ['Patrol helicopter downed', null, 'G8'])

  const hack = describe(world({ event: 'crate.hack.started', where: 'oilrig_large', grid: 'C3' }))
  assert.equal(hack.actor, null)
  assert.equal(hack.verb, 'A locked crate is being hacked on Large Oil Rig')
})

test('a named line reads as the plan writes it', () => {
  const hack = describe(world({ event: 'crate.hack.started', where: 'oilrig_large', name: 'Bob' }))
  assert.equal(`${hack.actor} ${hack.verb}`, 'Bob started hacking the locked crate on Large Oil Rig')

  const road = describe(world({ event: 'bradley.spawned', where: 'road', count: 12 }))
  assert.equal(road.verb, '12 road Bradleys are out')

  assert.equal(describe(world({ event: 'deepsea.opened' })).verb, 'The Deep Sea is open')
  assert.equal(describe(world({ event: 'cargo.docked', harbourName: 'Harbor', grid: 'Q9' })).verb, 'The cargo ship has docked at Harbor')
  assert.equal(describe(world({ event: 'chinook.dropped', monumentName: 'Water Treatment Plant' })).verb, 'A Chinook dropped a locked crate at Water Treatment Plant')
})

test('every type the server knows has its own words, and an unknown one says its name', () => {
  const { TYPE_IDS } = createRequire(import.meta.url)('../../server/worldEvents.js')
  for (const event of TYPE_IDS) {
    const line = describe(world({ event }))
    assert.notEqual(line.tone, 'other', `${event} has no words of its own`)
    assert.ok(line.verb && line.verb !== event, event)
  }
  assert.equal(describe(world({ event: 'meteor.landed' })).verb, 'meteor.landed')
})

test('the world filter asks for world events, which the server serves publicly', () => {
  assert.deepEqual(kindsFor('world'), ['world.event'])
  assert.ok(FEED_KINDS.includes('world.event'))
})