import { getErrorMessage } from '@sim/utils/errors'

import { type PortOwnerInfo, portOpen, portOwner } from './detect.ts'

import { waitFor } from './probes.ts'

import * as p from './prompter.ts'

import { theme } from './theme.ts'

interface BusyPort {

port: number

owner: PortOwnerInfo | null

}

function describe(busy: BusyPort): string {

return busy.owner

? `:${busy.port} is held by ${busy.owner.command} (pid ${busy.owner.pid})`

: `:${busy.port} is in use`

}

/**

* Resolve any listeners on `ports` before Sim tries to bind them. Loops offering

* to kill non-docker owners (or pointing at docker ones) until every port is

* free. Returns true when all are free, false if the user left them alone — the

* caller decides whether that's fatal (compose can't start) or just skips an

* optional auto-start (dev).

*/

export async function ensurePortsFree(ports: number[]): Promise<boolean> {

for (;;) {

const busy: BusyPort[] = []

for (const port of ports) {

if (await portOpen(port)) busy.push({ port, owner: portOwner(port) })

}

if (busy.length === 0) return true

p.log.warn(`Sim needs ports ${ports.join(' and ')}, but ${busy.map(describe).join(' and ')}.`)

const dockerOwned = busy.filter((b) => b.owner?.isDocker)

if (dockerOwned.length > 0) {

p.log.info(

theme.muted(

'A docker-published port means a container holds it — find it with `docker ps` and stop it.'

)

)

}

const killable = busy.filter((b) => b.owner && !b.owner.isDocker)

const options: p.SelectOption<'recheck' | 'kill' | 'abort'>[] = [

{ value: 'recheck', label: "I've stopped it — check again" },

]

if (killable.length > 0) {

options.push({

value: 'kill',

label: 'Kill it for me',

hint: killable.map((b) => `${b.owner?.command} on :${b.port}`).join(', '),

})

}

options.push({ value: 'abort', label: 'Leave the ports alone' })

const choice = await p.select({ message: 'How do you want to handle it?', options })

if (choice === 'abort') return false

if (choice === 'kill') {

const killed: string[] = []

for (const b of killable) {

if (!b.owner) continue

const label = `${b.owner.command} (pid ${b.owner.pid})`

try {

process.kill(b.owner.pid, 'SIGKILL')

killed.push(label)

} catch (error) {

// The owner list came from an lsof snapshot, so the process may have

// exited in between — that is the outcome we wanted, not a failure.

// A signal we're not allowed to send is worth saying out loud, but

// never fatal: the loop re-probes and offers the choice again.

const code = (error as NodeJS.ErrnoException).code

if (code === 'ESRCH') killed.push(`${label} — already gone`)

else if (code === 'EPERM') {

p.log.warn(

`Not allowed to kill ${label} — stop it yourself, then choose "check again".`

)

} else {

p.log.warn(`Could not kill ${label}: ${getErrorMessage(error)}`)

}

}

}

if (killed.length > 0) p.log.step(`Killed ${killed.join(', ')}`)

// SIGKILL is async — the kernel releases the listening socket a beat after

// the process dies, so re-checking immediately would still see the port

// held. Wait for the killed ports to actually free before looping.

await waitFor(

async () => {

for (const b of killable) {

if (await portOpen(b.port)) return false

}

return true

},

5000,

250

)

}

}

}