import type { ExecOptions, ExecResult, ExecStream } from '@interfaces/index'

import { Readable } from 'node:stream'

import {

createDataHandlers,

createKillFunction,

createProcessPromiseWrapper,

createProcessState,

setupDataHandlers,

type DataHandlers,

type ProcessState

} from '@utils/index'

/**

* Creates a buffered process that collects all output before resolving.

* @param command - Command string to execute

* @param options - Execution options including timeout, cwd, and env

* @returns Object with promise and kill function

*/

export function createBufferedProcess(command: string, options: ExecOptions): ExecResult {

const state: ProcessState = createProcessState(command, options)

const kill: (signal?: string | number) => void = createKillFunction(state)

const promise: Promise<ExecResult> = createProcessPromiseWrapper(state, options, kill)

return {

stdout: '',

stderr: '',

exitCode: 0,

kill,

then: promise.then.bind(promise),

catch: promise.catch.bind(promise),

finally: promise.finally.bind(promise)

} as ExecResult & Promise<ExecResult>

}

/**

* Creates a streaming process that provides real-time output.

* @param command - Command string to execute

* @param options - Execution options including timeout, cwd, and env

* @returns Stream object with output iterable, promise, and kill function

*/

export function createStreamProcess(command: string, options: ExecOptions): ExecStream {

const state: ProcessState = createProcessState(command, options)

const outputStream: Readable = new Readable({

read(): void {

// This will be controlled by the data events

}

})

const handlers: DataHandlers = createDataHandlers('stream', outputStream)

setupDataHandlers(state.child, handlers)

state.child.on('close', (): void => {

outputStream.push(null)

})

const outputIterable: AsyncIterable<Buffer> = {

async *[Symbol.asyncIterator](): AsyncGenerator<Buffer> {

for await (const chunk of outputStream) {

yield chunk

}

}

}

const kill: (signal?: string | number) => void = createKillFunction(state)

const promise: Promise<ExecResult> = createProcessPromiseWrapper(state, options, kill)

return {

output: outputIterable,

promise,

kill

}

}