import { afterEach, describe, expect, it } from 'vitest'
import type { KVChangeEvent } from '../../src/kv-storage/base-kv-storage.js'
import { StorageUnavailableError } from '../../src/utils/errors.js'
import { TestNetwork } from './sync-helpers.js'

let network: TestNetwork
afterEach(() => network?.close())

describe('KVStorageHttp.subscribe (SSE)', () => {
  it('relays every change under the path as remote change events, its own writes included', async () => {
    network = new TestNetwork()
    const watcher = network.client()
    await watcher.child('users').subscribe()
    const received: KVChangeEvent[] = []
    watcher.on('change', (e) => e.origin === 'remote' && received.push(e))
    const other = watcher.waitFor('change', (e) => e.origin === 'remote')
    await network.client().child('users').set('1', { name: 'Ada', n: 1n })
    await other
    const own = watcher.waitFor('change', (e) => e.origin === 'remote')
    await network.client().set('elsewhere', 1) // not subscribed
    await watcher.child('users').delete('1')
    await own
    expect(received.map((e) => e.changes)).toEqual([[{ key: 'users/1', value: { name: 'Ada', n: 1n } }], [{ key: 'users/1' }]])
  })

  it('emits resync when a dropped stream reconnects', async () => {
    network = new TestNetwork()
    const watcher = network.client()
    await watcher.subscribe('')
    const resync = watcher.waitFor('resync', () => true)
    network.dropStreams()
    await resync
    const after = watcher.waitFor('change', () => true)
    await network.client().set('a', 1)
    expect((await after).changes).toEqual([{ key: 'a', value: 1 }])
  })

  it('stops relaying after unsubscribe', async () => {
    network = new TestNetwork()
    const watcher = network.client()
    await watcher.subscribe('a')
    await watcher.subscribe('b')
    await watcher.unsubscribe('a')
    const received: KVChangeEvent[] = []
    watcher.on('change', (e) => received.push(e))
    const arrived = watcher.waitFor('change', () => true)
    await network.client().set('a', 1)
    await network.client().set('b', 2)
    await arrived
    expect(received.flatMap((e) => e.changes)).toEqual([{ key: 'b', value: 2 }])
  })

  it('reports an unreachable server as StorageUnavailableError', async () => {
    network = new TestNetwork()
    const client = network.client()
    network.online = false
    await expect(client.readMany(['x'])).rejects.toBeInstanceOf(StorageUnavailableError)
  })
})