import EmbeddedPostgres from 'embedded-postgres'
import { build, stop } from 'esbuild'
import { mkdtemp, rm, readFile } from 'node:fs/promises'
import { tmpdir } from 'node:os'
import { join, resolve, dirname } from 'node:path'
import { createServer } from 'node:net'
import { randomBytes } from 'node:crypto'
import { spawn } from 'node:child_process'
import assert from 'node:assert/strict'
import { pathToFileURL } from 'node:url'

if (process.argv.length !== 2) throw Error('Read HTTP acceptance requires its own disposable cluster and no arguments')
const repo = resolve(import.meta.dirname, '../..')
const directory = await mkdtemp(join(tmpdir(), 'mm-flow-http-owned-'))
const bundleDirectory = await mkdtemp(join(repo, 'tmp', 'mm-flow-http-owned-bundle-'))
const listener = createServer()
await new Promise(resolve => listener.listen(0, '127.0.0.1', resolve))
const port = listener.address().port
await new Promise(resolve => listener.close(resolve))
const password = randomBytes(24).toString('hex')
const postgres = new EmbeddedPostgres({
  databaseDir: join(directory, 'pg'), port, user: 'mcp_test', password,
  persistent: true, createPostgresUser: false, initdbFlags: ['--encoding=UTF8'],
  postgresFlags: ['-h', '127.0.0.1', '-c', 'work_mem=4MB'],
  onLog: () => {}, onError: () => {},
})
let started = false
let outcome = 1
try {
  const file = join(bundleDirectory, 'read-http-owned.mjs')
  // Current application sources only: no candidate overlays or generated mocks.
  await build({
    entryPoints: [join(repo, 'backend/src/services/traffic-flow-read-http.owned.test.ts')],
    outfile: file, platform: 'node', format: 'esm', bundle: true,
    packages: 'external', sourcemap: 'inline',
    banner: { js: "import {createRequire as __ownedCreateRequire} from 'node:module';const require=__ownedCreateRequire(import.meta.url);" },
    plugins: [{ name: 'contracts-source', setup(builder) {
      builder.onResolve({ filter: /^@mmapp\/contracts(?:\/.*)?$/ }, args => ({
        path: resolve(repo, 'packages/contracts/src', args.path.replace(/^@mmapp\/contracts\/?/, '') || 'index') + '.ts',
      }))
      builder.onLoad({ filter: /\.ts$/ }, async args => ({
        contents: (await readFile(args.path, 'utf8')).replaceAll('import.meta.url', JSON.stringify(pathToFileURL(args.path).href)),
        loader: 'ts',
      }))
    } }],
  })
  await postgres.initialise()
  await postgres.start()
  started = true
  const exit = await new Promise((resolve, reject) => {
    const child = spawn(process.execPath, [file], {
      cwd: directory, windowsHide: true, stdio: 'inherit',
      env: { ...process.env,
        DATABASE_URL: `postgresql://mcp_test:${password}@127.0.0.1:${port}/postgres`,
        DATABASE_PATH: join(directory, 'unused.sqlite'), MCP_STATE_DIR: join(directory, 'state'),
        AUTH_REQUIRED: 'true', AUTH_ISSUER: 'https://auth.test.local',
        AUTH_JWT_SECRET: 'owned-flow-http-only-secret', MCP_PUBLIC_URL: 'http://localhost:8000/mcp', NODE_ENV: 'test',
        NODE_PATH: join(repo, 'node_modules'),
      },
    })
    child.once('error', reject)
    child.once('exit', resolve)
  })
  outcome = exit ?? 1
} finally {
  if (started) await postgres.stop()
  assert.equal(dirname(resolve(directory)), resolve(tmpdir()))
  assert.match(directory, /mm-flow-http-owned-/)
  await rm(directory, { recursive: true, force: true, maxRetries: 20, retryDelay: 100 })
  assert.equal(dirname(resolve(bundleDirectory)), resolve(repo, 'tmp'))
  assert.match(bundleDirectory, /mm-flow-http-owned-bundle-/)
  await rm(bundleDirectory, { recursive: true, force: true, maxRetries: 20, retryDelay: 100 })
  stop()
  console.log('Owned read HTTP cluster stopped and temporary resources removed')
}
process.exitCode = outcome