/**
 * Stock `ctx.bareOsSyscall` op names (single source for `/proc` introspection).
 * Keep in sync with `BARE_OS_SYSCALL_OPS` in `packages/bare-os-coreutils/src/getconf.js`
 * and `docs/reference/posix-conformance-matrix.json`.
 */

/** @typedef {'stable' | 'experimental'} BareOsSyscallStability */
/** @typedef {'fs' | 'proc' | 'ipc' | 'signal' | 'vfs_meta'} BareOsSyscallCategory */

/**
 * Rich syscall table for `/proc/bare_os/syscalls.json` (schema v3+; v4 adds fd/signal models in index.js).
 * @type {ReadonlyArray<{ name: string, category: BareOsSyscallCategory, stability: BareOsSyscallStability }>}
 */
export const BARE_OS_SYSCALL_OPS_DETAIL = Object.freeze([
  { name: 'readFile', category: 'fs', stability: 'stable' },
  { name: 'writeFile', category: 'fs', stability: 'stable' },
  { name: 'readdir', category: 'fs', stability: 'stable' },
  { name: 'mkdir', category: 'fs', stability: 'stable' },
  { name: 'stat', category: 'fs', stability: 'stable' },
  { name: 'unlink', category: 'fs', stability: 'stable' },
  { name: 'chmod', category: 'fs', stability: 'stable' },
  { name: 'chdir', category: 'fs', stability: 'stable' },
  { name: 'getcwd', category: 'fs', stability: 'stable' },
  { name: 'readlink', category: 'fs', stability: 'stable' },
  { name: 'symlink', category: 'fs', stability: 'stable' },
  { name: 'exists', category: 'fs', stability: 'stable' },
  { name: 'lstat', category: 'fs', stability: 'stable' },
  { name: 'rmdir', category: 'fs', stability: 'stable' },
  { name: 'mount', category: 'vfs_meta', stability: 'experimental' },
  { name: 'umount', category: 'vfs_meta', stability: 'experimental' },
  { name: 'kill', category: 'signal', stability: 'stable' },
  { name: 'rename', category: 'fs', stability: 'stable' },
  { name: 'link', category: 'fs', stability: 'experimental' },
  { name: 'access', category: 'fs', stability: 'stable' },
  { name: 'utimes', category: 'fs', stability: 'stable' },
  { name: 'truncate', category: 'fs', stability: 'stable' },
  { name: 'ftruncate', category: 'fs', stability: 'experimental' },
  { name: 'fsync', category: 'fs', stability: 'experimental' },
  { name: 'fdatasync', category: 'fs', stability: 'experimental' },
  { name: 'posix_fadvise', category: 'fs', stability: 'experimental' },
  { name: 'pathconf', category: 'fs', stability: 'experimental' },
  { name: 'fcntl', category: 'fs', stability: 'stable' },
  { name: 'posixPoll', category: 'fs', stability: 'experimental' },
  { name: 'select', category: 'fs', stability: 'experimental' },
  { name: 'umask', category: 'fs', stability: 'stable' },
  {
    name: 'socket',
    category: 'ipc',
    stability: 'experimental',
    posixAlignment: 'ENOTSUP',
    mapsTo: ['ctx.bare bare-tcp / bare-dgram', 'Hyperswarm/Protomux P2P'],
    errnoHint: 'ENOSYS'
  },
  {
    name: 'bind',
    category: 'ipc',
    stability: 'experimental',
    posixAlignment: 'ENOTSUP',
    mapsTo: ['bare-tcp Server.listen', 'not AF_INET kernel sockets'],
    errnoHint: 'ENOSYS'
  },
  {
    name: 'listen',
    category: 'ipc',
    stability: 'experimental',
    posixAlignment: 'ENOTSUP',
    mapsTo: ['bare-tcp listen backlog analogs'],
    errnoHint: 'ENOSYS'
  },
  {
    name: 'accept',
    category: 'ipc',
    stability: 'experimental',
    posixAlignment: 'ENOTSUP',
    mapsTo: ['bare-tcp accept'],
    errnoHint: 'ENOSYS'
  },
  {
    name: 'connect',
    category: 'ipc',
    stability: 'experimental',
    posixAlignment: 'ENOTSUP',
    mapsTo: ['bare-tcp connect', 'UDX'],
    errnoHint: 'ENOSYS'
  },
  {
    name: 'send',
    category: 'ipc',
    stability: 'experimental',
    posixAlignment: 'ENOTSUP',
    mapsTo: ['stream.write'],
    errnoHint: 'ENOSYS'
  },
  {
    name: 'recv',
    category: 'ipc',
    stability: 'experimental',
    posixAlignment: 'ENOTSUP',
    mapsTo: ['stream.read'],
    errnoHint: 'ENOSYS'
  },
  {
    name: 'sendmsg',
    category: 'ipc',
    stability: 'experimental',
    posixAlignment: 'ENOTSUP',
    mapsTo: ['flattened iovec send on SOCK_DGRAM bridge'],
    errnoHint: 'ENOSYS'
  },
  {
    name: 'recvmsg',
    category: 'ipc',
    stability: 'experimental',
    posixAlignment: 'ENOTSUP',
    mapsTo: ['SOCK_DGRAM bridge datagram + msgHdr envelope'],
    errnoHint: 'ENOSYS'
  },
  {
    name: 'shutdown',
    category: 'ipc',
    stability: 'experimental',
    posixAlignment: 'ENOTSUP',
    mapsTo: ['stream.end / destroy'],
    errnoHint: 'ENOSYS'
  },
  {
    name: 'getsockopt',
    category: 'ipc',
    stability: 'experimental',
    posixAlignment: 'partial',
    mapsTo: [
      'ctx.bareOsSyscall("getsockopt")',
      'BARE_OS_POSIX_SOCKET_FD_BRIDGE: SOL_SOCKET/SO_KEEPALIVE and IPPROTO_TCP/TCP_NODELAY on bridge fds only; else ENOSYS'
    ],
    errnoHint: 'ENOSYS'
  },
  {
    name: 'setsockopt',
    category: 'ipc',
    stability: 'experimental',
    posixAlignment: 'partial',
    mapsTo: [
      'ctx.bareOsSyscall("setsockopt")',
      'bridge fds: same levels/optnames as getsockopt; logical slot state only'
    ],
    errnoHint: 'ENOSYS'
  },
  {
    name: 'readv',
    category: 'fs',
    stability: 'experimental',
    posixAlignment: 'partial',
    mapsTo: [
      'ctx.bareOsSyscall("readv")',
      'bounded sequential reads from posix-pipe read FD (BARE_OS_POSIX_FD_SIM)'
    ],
    errnoHint: 'EINVAL'
  },
  {
    name: 'writev',
    category: 'fs',
    stability: 'experimental',
    posixAlignment: 'partial',
    mapsTo: [
      'ctx.bareOsSyscall("writev")',
      'bounded concatenated write to posix-pipe write FD (BARE_OS_POSIX_FD_SIM)'
    ],
    errnoHint: 'EINVAL'
  },
  {
    name: 'mq_open',
    category: 'ipc',
    stability: 'experimental',
    posixAlignment: 'partial',
    mapsTo: ['ctx.bareOsSyscall("mq_open")', 'bareOsIpc.mqOpen'],
    errnoHint: 'EINVAL'
  },
  {
    name: 'mq_send',
    category: 'ipc',
    stability: 'experimental',
    posixAlignment: 'partial',
    mapsTo: ['ctx.bareOsSyscall("mq_send")', 'bareOsIpc.mqSend'],
    errnoHint: 'EAGAIN'
  },
  {
    name: 'mq_receive',
    category: 'ipc',
    stability: 'experimental',
    posixAlignment: 'partial',
    mapsTo: ['ctx.bareOsSyscall("mq_receive")', 'bareOsIpc.mqReceive'],
    errnoHint: 'EAGAIN'
  },
  {
    name: 'clock_gettime',
    category: 'fs',
    stability: 'experimental',
    posixAlignment: 'partial',
    mapsTo: [
      'ctx.bareOsSyscall("clock_gettime")',
      'CLOCK_REALTIME from Date; CLOCK_MONOTONIC from bare-hrtime.bigint() or performance.now() sketch'
    ],
    errnoHint: 'EINVAL'
  }
])

/**
 * POSIX.1 XSH-style names mapped to guest behavior (not separate `ctx.bareOsSyscall` ops).
 * Merged into `/proc/bare_os/syscalls.json` **`opsDetail`** for Issue 7 traceability.
 * @type {ReadonlyArray<{
 *   name: string,
 *   category: BareOsSyscallCategory,
 *   stability: BareOsSyscallStability,
 *   posixAlignment: 'simulated' | 'partial' | 'ENOTSUP',
 *   mapsTo: string[],
 *   errnoHint?: string
 * }>}
 */
export const BARE_OS_POSIX_XSH_OPS_DETAIL = Object.freeze([
  {
    name: 'open',
    category: 'fs',
    stability: 'stable',
    posixAlignment: 'simulated',
    mapsTo: ['vfs.readFile', 'vfs.writeFile', 'vfs.exists', 'vfs.lstat'],
    errnoHint: 'ENOENT'
  },
  {
    name: 'close',
    category: 'fs',
    stability: 'stable',
    posixAlignment: 'partial',
    mapsTo: ['logical fd table eviction', 'IPC channel teardown'],
    errnoHint: 'EBADF'
  },
  {
    name: 'read',
    category: 'fs',
    stability: 'stable',
    posixAlignment: 'partial',
    mapsTo: ['vfs.readFile', 'ctx.bareOsBinReadStdin', 'IPC fifo consumer'],
    errnoHint: 'EAGAIN'
  },
  {
    name: 'write',
    category: 'fs',
    stability: 'stable',
    posixAlignment: 'partial',
    mapsTo: ['vfs.writeFile', 'ctx.bareOsBinWrite', 'IPC fifo producer'],
    errnoHint: 'EIO'
  },
  {
    name: 'readv',
    category: 'fs',
    stability: 'experimental',
    posixAlignment: 'partial',
    mapsTo: ['ctx.bareOsSyscall("readv")', 'posix-pipe read FD', 'bounded iovec count'],
    errnoHint: 'EINVAL'
  },
  {
    name: 'writev',
    category: 'fs',
    stability: 'experimental',
    posixAlignment: 'partial',
    mapsTo: ['ctx.bareOsSyscall("writev")', 'posix-pipe write FD', 'bounded total bytes'],
    errnoHint: 'EINVAL'
  },
  {
    name: 'getsockopt',
    category: 'ipc',
    stability: 'experimental',
    posixAlignment: 'partial',
    mapsTo: [
      'ctx.bareOsSyscall("getsockopt")',
      'BARE_OS_POSIX_SOCKET_FD_BRIDGE: SOL_SOCKET/SO_KEEPALIVE and IPPROTO_TCP/TCP_NODELAY on bridge fds only; else ENOSYS'
    ],
    errnoHint: 'ENOSYS'
  },
  {
    name: 'setsockopt',
    category: 'ipc',
    stability: 'experimental',
    posixAlignment: 'partial',
    mapsTo: [
      'ctx.bareOsSyscall("setsockopt")',
      'bridge fds: same levels/optnames as getsockopt; logical slot state only'
    ],
    errnoHint: 'ENOSYS'
  },
  {
    name: 'lseek',
    category: 'fs',
    stability: 'stable',
    posixAlignment: 'ENOTSUP',
    mapsTo: ['no byte-offset FD cursor in guest'],
    errnoHint: 'ESPIPE'
  },
  {
    name: 'nanosleep',
    category: 'fs',
    stability: 'experimental',
    posixAlignment: 'partial',
    mapsTo: ['ctx.bareOsSyscall("nanosleep")', 'Issue 7-style delay; capped wall sleep'],
    errnoHint: 'EINVAL'
  },
  {
    name: 'clock_gettime',
    category: 'fs',
    stability: 'experimental',
    posixAlignment: 'partial',
    mapsTo: [
      'ctx.bareOsSyscall("clock_gettime")',
      'args.clockId CLOCK_REALTIME vs CLOCK_MONOTONIC; tv_sec/tv_nsec partial POSIX shape'
    ],
    errnoHint: 'EINVAL'
  },
  {
    name: 'posix_fadvise',
    category: 'fs',
    stability: 'experimental',
    posixAlignment: 'simulated',
    mapsTo: [
      'ctx.bareOsSyscall("posix_fadvise")',
      'logical no-op; documents POSIX.1 posix_fadvise intent for Hyperdrive-backed paths'
    ],
    errnoHint: 'EINVAL'
  },
  {
    name: 'pipe',
    category: 'ipc',
    stability: 'stable',
    posixAlignment: 'simulated',
    mapsTo: ['mkfifo', '/run/bare-os/ipc/*', 'BARE_OS_POSIX_FD_SIM optional channel pairs'],
    errnoHint: 'EMFILE'
  },
  {
    name: 'dup',
    category: 'fs',
    stability: 'stable',
    posixAlignment: 'partial',
    mapsTo: ['ctx.bareOsRegisterLogicalFd'],
    errnoHint: 'EBADF'
  },
  {
    name: 'dup2',
    category: 'fs',
    stability: 'stable',
    posixAlignment: 'partial',
    mapsTo: ['shell redirect table', '2>&1 merge'],
    errnoHint: 'EBADF'
  },
  {
    name: 'fcntl',
    category: 'fs',
    stability: 'stable',
    posixAlignment: 'partial',
    mapsTo: [
      'ctx.bareOsSyscall("fcntl")',
      'F_GETFL',
      'F_SETFL',
      'F_GETLK',
      'F_SETLK',
      'F_SETLKW',
      'cooperative session-scoped advisory locks (path or fd→path); F_SETLKW is EAGAIN when busy unless BARE_OS_POSIX_FCNTL_BLOCKING_WAIT (bounded wait via BARE_OS_FCNTL_LOCK_WAIT_MS_MAX)',
      'O_APPEND',
      'O_NONBLOCK',
      'bareOsLogicalFdFlags'
    ],
    errnoHint: 'EBADF'
  },
  {
    name: 'poll',
    category: 'fs',
    stability: 'experimental',
    posixAlignment: 'partial',
    mapsTo: ['ctx.bareOsPosixPoll', 'ctx.bareOsSyscall("posixPoll")'],
    errnoHint: 'EINVAL'
  },
  {
    name: 'select',
    category: 'fs',
    stability: 'experimental',
    posixAlignment: 'partial',
    mapsTo: ['ctx.bareOsSyscall("select")', 'bareOsPosixPollProbe subset'],
    errnoHint: 'EBADF'
  },
  {
    name: 'umask',
    category: 'fs',
    stability: 'stable',
    posixAlignment: 'partial',
    mapsTo: ['vfs.env.UMASK octal', 'umask shell builtin'],
    errnoHint: 'EINVAL'
  },
  {
    name: 'fsync',
    category: 'fs',
    stability: 'experimental',
    posixAlignment: 'partial',
    mapsTo: [
      'ctx.bareOsSyscall("fsync")',
      'cooperative no-op; Hyperdrive persistence is host-managed'
    ],
    errnoHint: 'EINVAL'
  },
  {
    name: 'fdatasync',
    category: 'fs',
    stability: 'experimental',
    posixAlignment: 'partial',
    mapsTo: [
      'ctx.bareOsSyscall("fdatasync")',
      'cooperative no-op; same sketch as fsync on guest'
    ],
    errnoHint: 'EINVAL'
  },
  {
    name: 'socket',
    category: 'ipc',
    stability: 'experimental',
    posixAlignment: 'ENOTSUP',
    mapsTo: ['ctx.bareOsSyscall("socket")', 'ENOSYS-shaped probe'],
    errnoHint: 'ENOSYS'
  },
  {
    name: 'bind',
    category: 'ipc',
    stability: 'experimental',
    posixAlignment: 'partial',
    mapsTo: [
      'ctx.bareOsSyscall("bind")',
      'SOCK_STREAM bridge: port+host before listen; SOCK_DGRAM passive bind via bareDgram.Socket.bind (BARE_OS_POSIX_SOCKET_FD_BRIDGE)'
    ],
    errnoHint: 'EINVAL'
  },
  {
    name: 'listen',
    category: 'ipc',
    stability: 'experimental',
    posixAlignment: 'partial',
    mapsTo: [
      'ctx.bareOsSyscall("listen")',
      'bareTcp.Server.listen when BARE_OS_POSIX_SOCKET_FD_BRIDGE'
    ],
    errnoHint: 'EADDRINUSE'
  },
  {
    name: 'accept',
    category: 'ipc',
    stability: 'experimental',
    posixAlignment: 'partial',
    mapsTo: [
      'ctx.bareOsSyscall("accept")',
      'dequeue accepted TCP socket to new logical fd; EAGAIN when empty + O_NONBLOCK'
    ],
    errnoHint: 'EAGAIN'
  },
  {
    name: 'connect',
    category: 'ipc',
    stability: 'experimental',
    posixAlignment: 'ENOTSUP',
    mapsTo: [
      'ctx.bareOsSyscall("connect")',
      'SOCK_STREAM/SOCK_DGRAM bridge when BARE_OS_POSIX_SOCKET_FD_BRIDGE (DGRAM may follow bind on same fd)'
    ],
    errnoHint: 'ENOSYS'
  },
  {
    name: 'send',
    category: 'ipc',
    stability: 'experimental',
    posixAlignment: 'partial',
    mapsTo: [
      'ctx.bareOsSyscall("send")',
      'SOCK_DGRAM connected or bound (bound requires port+host args) + SOCK_STREAM (accepted) bridge write'
    ],
    errnoHint: 'ENOSYS'
  },
  {
    name: 'recv',
    category: 'ipc',
    stability: 'experimental',
    posixAlignment: 'partial',
    mapsTo: [
      'ctx.bareOsSyscall("recv")',
      'SOCK_DGRAM bridge dequeue; SOCK_STREAM accepted fd tcpRecvQueue (BARE_OS_POSIX_SOCKET_FD_BRIDGE)'
    ],
    errnoHint: 'ENOSYS'
  },
  {
    name: 'recvfrom',
    category: 'ipc',
    stability: 'experimental',
    posixAlignment: 'partial',
    mapsTo: [
      'ctx.bareOsSyscall("recvfrom")',
      'SOCK_DGRAM bridge + peer address; SOCK_STREAM accepted + remoteAddress/remotePort'
    ],
    errnoHint: 'ENOSYS'
  },
  {
    name: 'sendmsg',
    category: 'ipc',
    stability: 'experimental',
    posixAlignment: 'partial',
    mapsTo: [
      'ctx.bareOsSyscall("sendmsg")',
      'SOCK_DGRAM + SOCK_STREAM bridge flattened iovs (BARE_OS_POSIX_SOCKET_FD_BRIDGE); ancillary CMSGS ENOTSUP'
    ],
    errnoHint: 'ENOSYS'
  },
  {
    name: 'recvmsg',
    category: 'ipc',
    stability: 'experimental',
    posixAlignment: 'partial',
    mapsTo: [
      'ctx.bareOsSyscall("recvmsg")',
      'SOCK_DGRAM bridge + msgHdr.name from rinfo; SOCK_STREAM accepted + remote addr; scatter iov / SCM_RIGHTS ENOTSUP'
    ],
    errnoHint: 'ENOSYS'
  },
  {
    name: 'shutdown',
    category: 'ipc',
    stability: 'experimental',
    posixAlignment: 'partial',
    mapsTo: [
      'ctx.bareOsSyscall("shutdown")',
      'TCP bridge: destroy socket or close listening Server'
    ],
    errnoHint: 'EINVAL'
  }
])

/** Full `opsDetail` for proc JSON (ctx ops + POSIX XSH surface). */
export const BARE_OS_SYSCALL_OPS_DETAIL_FULL = Object.freeze([
  ...BARE_OS_SYSCALL_OPS_DETAIL,
  ...BARE_OS_POSIX_XSH_OPS_DETAIL
])

/**
 * Stable Open Group Issue 7 index tokens for audit dashboards (not a conformance claim).
 * @type {Readonly<Record<string, readonly string[]>>}
 */
export const BARE_OS_SYSCALL_OPS_SUSV4_REFS = Object.freeze({
  open: Object.freeze(['XSH/open']),
  close: Object.freeze(['XSH/close']),
  read: Object.freeze(['XSH/read']),
  write: Object.freeze(['XSH/write']),
  readv: Object.freeze(['XSH/readv']),
  writev: Object.freeze(['XSH/writev']),
  pipe: Object.freeze(['XSH/pipe']),
  dup: Object.freeze(['XSH/dup']),
  dup2: Object.freeze(['XSH/dup2']),
  fcntl: Object.freeze(['XSH/fcntl']),
  poll: Object.freeze(['XSH/poll']),
  select: Object.freeze(['XSH/select']),
  umask: Object.freeze(['XSH/umask']),
  lseek: Object.freeze(['XSH/lseek']),
  nanosleep: Object.freeze(['XSH/nanosleep']),
  clock_gettime: Object.freeze(['XSH/clock_gettime']),
  posix_fadvise: Object.freeze(['XSH/posix_fadvise']),
  fsync: Object.freeze(['XSH/fsync']),
  fdatasync: Object.freeze(['XSH/fdatasync']),
  pathconf: Object.freeze(['XSH/pathconf']),
  mq_open: Object.freeze(['XSH/mq_open']),
  mq_send: Object.freeze(['XSH/mq_send']),
  mq_receive: Object.freeze(['XSH/mq_receive']),
  socket: Object.freeze(['XSH/socket']),
  bind: Object.freeze(['XSH/bind']),
  listen: Object.freeze(['XSH/listen']),
  accept: Object.freeze(['XSH/accept']),
  connect: Object.freeze(['XSH/connect']),
  send: Object.freeze(['XSH/send']),
  recv: Object.freeze(['XSH/recv']),
  recvfrom: Object.freeze(['XSH/recvfrom']),
  sendmsg: Object.freeze(['XSH/sendmsg']),
  recvmsg: Object.freeze(['XSH/recvmsg']),
  shutdown: Object.freeze(['XSH/shutdown']),
  getsockopt: Object.freeze(['XSH/getsockopt']),
  setsockopt: Object.freeze(['XSH/setsockopt'])
})

export const BARE_OS_STOCK_SYSCALL_OPS = Object.freeze(
  BARE_OS_SYSCALL_OPS_DETAIL.map((o) => o.name)
)

export function bareOsStockSyscallOpsCsv() {
  return BARE_OS_STOCK_SYSCALL_OPS.join(',')
}

export function bareOsPosixXshOpsCsv() {
  return BARE_OS_POSIX_XSH_OPS_DETAIL.map((o) => o.name).join(',')
}