// client-id.mjs: a tab keeps its presence id across a reload, two tabs
// do not share one, and a duplicated tab (which copies its original's
// sessionStorage) gives the copied id up.
import test from 'node:test'
import assert from 'node:assert/strict'
import { tabClientId, claimClientId, clientIdKey } from './client-id.mjs'
import { createPresence } from './presence.mjs'

function memoryStorage () {
  const m = new Map()
  return {
    getItem: k => (m.has(k) ? m.get(k) : null),
    setItem: (k, v) => { m.set(k, String(v)) },
    copy () { const c = memoryStorage(); for (const [k, v] of m) c.setItem(k, v); return c }
  }
}

let n = 0
const make = () => (++n).toString(16).padStart(16, '0')

test('a reload reuses the id this tab stored for the deck', () => {
  const tab = memoryStorage()
  const first = tabClientId({ storage: tab, deck: 'd1', make })
  const reloaded = tabClientId({ storage: tab, deck: 'd1', make })
  assert.equal(reloaded, first)
  assert.equal(tab.getItem(clientIdKey('d1')), first)
})

test('two tabs, and two decks in one tab, get different ids', () => {
  const a = tabClientId({ storage: memoryStorage(), deck: 'd1', make })
  const b = tabClientId({ storage: memoryStorage(), deck: 'd1', make })
  assert.notEqual(a, b)
  const tab = memoryStorage()
  assert.notEqual(tabClientId({ storage: tab, deck: 'd1', make }), tabClientId({ storage: tab, deck: 'd2', make }))
})

test('a stored value that is not an id, or storage that throws, gives a fresh id', () => {
  const tab = memoryStorage()
  tab.setItem(clientIdKey('d1'), '<script>')
  const id = tabClientId({ storage: tab, deck: 'd1', make })
  assert.match(id, /^[0-9a-f]{16}$/)
  const throwing = { getItem () { throw new Error('blocked') }, setItem () { throw new Error('blocked') } }
  assert.match(tabClientId({ storage: throwing, deck: 'd1', make }), /^[0-9a-f]{16}$/)
  assert.match(tabClientId({ storage: null, deck: 'd1', make }), /^[0-9a-f]{16}$/)
})

// A pair of in-memory BroadcastChannels: a message posted on one is
// delivered to the other, never to itself (as the real one does).
function channelPair () {
  const a = { onmessage: null, postMessage: m => queueMicrotask(() => b.onmessage && b.onmessage({ data: m })), close () {} }
  const b = { onmessage: null, postMessage: m => queueMicrotask(() => a.onmessage && a.onmessage({ data: m })), close () {} }
  return [a, b]
}

test('a duplicated tab gives up the copied id; the original keeps it', async () => {
  const original = memoryStorage()
  const id = tabClientId({ storage: original, deck: 'd1', make })
  const duplicate = original.copy()
  let dupId = tabClientId({ storage: duplicate, deck: 'd1', make })
  assert.equal(dupId, id, 'the duplicate starts with the copy — the case being guarded')

  const [chA, chB] = channelPair()
  let originalTaken = false
  claimClientId({ channel: chA, getId: () => id, onTaken: () => { originalTaken = true } })
  const guard = claimClientId({
    channel: chB,
    getId: () => dupId,
    onTaken: () => {
      duplicate.setItem(clientIdKey('d1'), '')
      dupId = tabClientId({ storage: duplicate, deck: 'd1', make })
    }
  })
  guard.claim()
  await new Promise(r => setTimeout(r, 0))
  assert.notEqual(dupId, id)
  assert.equal(originalTaken, false)
  assert.equal(original.getItem(clientIdKey('d1')), id)
  assert.equal(duplicate.getItem(clientIdKey('d1')), dupId)
})

test('a reload finds no rival and keeps its id', async () => {
  const tab = memoryStorage()
  const id = tabClientId({ storage: tab, deck: 'd1', make })
  const [ch] = channelPair() // nobody on the other end: the old page is gone
  let taken = false
  claimClientId({ channel: ch, getId: () => id, onTaken: () => { taken = true } }).claim()
  await new Promise(r => setTimeout(r, 0))
  assert.equal(taken, false)
  assert.equal(tabClientId({ storage: tab, deck: 'd1', make }), id)
})

test('presence switches id: beats carry the new one and the old one is somebody else', () => {
  const posts = []
  const p = createPresence({
    clientId: 'aaaaaaaaaaaaaaaa',
    post: b => { posts.push(b); return Promise.resolve() },
    getState: () => ({ slide: 's', block: '' }),
    setTimeoutFn: () => 1,
    clearTimeoutFn: () => {}
  })
  p.start()
  p.setClientId('bbbbbbbbbbbbbbbb')
  assert.equal(p.clientId, 'bbbbbbbbbbbbbbbb')
  assert.equal(posts.at(-1).client, 'bbbbbbbbbbbbbbbb')
  const d = p.applySet([{ client: 'aaaaaaaaaaaaaaaa', name: 'x' }, { client: 'bbbbbbbbbbbbbbbb', name: 'me' }])
  assert.deepEqual(d.people.map(x => x.client), ['aaaaaaaaaaaaaaaa'])
})