import { constants } from 'fs'
import { access } from 'fs/promises'
import { delimiter, join } from 'path'

export const PERSISTENT_CLI_REQUIRED_MESSAGE =
  'CodeBurn needs a persistent codeburn command. Install CodeBurn globally first: npm install -g codeburn'

const DEFAULT_CLI_LOOKUP_PATHS = process.platform === 'win32'
  ? []
  : ['/opt/homebrew/bin', '/usr/local/bin', '/usr/bin', '/bin']

export function buildPersistentCodeburnLookupPath(existingPath = process.env.PATH ?? ''): string {
  const parts = existingPath.split(delimiter).filter(Boolean)
  for (const fallback of DEFAULT_CLI_LOOKUP_PATHS) {
    if (!parts.includes(fallback)) parts.push(fallback)
  }
  return parts.join(delimiter)
}

export function isTransientNpxPath(path: string): boolean {
  return path.includes('/_npx/') || path.includes('/.npm/_npx/') || path.includes('\\_npx\\')
}

function codeburnExecutableNames(): string[] {
  if (process.platform !== 'win32') return ['codeburn']
  return ['codeburn.cmd', 'codeburn.exe', 'codeburn.bat', 'codeburn']
}

async function executableExists(path: string): Promise<boolean> {
  try {
    await access(path, process.platform === 'win32' ? constants.F_OK : constants.F_OK | constants.X_OK)
    return true
  } catch {
    return false
  }
}

export async function resolvePersistentCodeburnPathFromPath(
  lookupPath: string,
  message: string = PERSISTENT_CLI_REQUIRED_MESSAGE,
): Promise<string> {
  const seen = new Set<string>()
  for (const dir of lookupPath.split(delimiter).filter(Boolean)) {
    for (const executable of codeburnExecutableNames()) {
      const candidate = join(dir, executable)
      if (seen.has(candidate)) continue
      seen.add(candidate)
      if (isTransientNpxPath(candidate)) continue
      if (await executableExists(candidate)) return candidate
    }
  }
  throw new Error(message)
}

export function resolvePersistentCodeburnPathFromWhichOutput(
  output: string,
  message: string = PERSISTENT_CLI_REQUIRED_MESSAGE,
): string {
  const paths = output
    .split(/\r?\n/)
    .map(path => path.trim())
    .filter(Boolean)
  const persistentPath = paths.find(path => path.startsWith('/') && !isTransientNpxPath(path))
  if (persistentPath) return persistentPath
  throw new Error(message)
}