#!/usr/bin/env bun
/**
 * Fails if `@/triggers` can statically reach `@/blocks`.
 *
 * Block configs spread `getTrigger('…').subBlocks` while their module body runs, so
 * `blocks/*` legitimately depends on `triggers/*`. The reverse edge closes the loop, and
 * then whichever barrel an entry point reaches first decides whether the process starts:
 * enter through `@/triggers` and a block config calls `getTrigger()` before
 * `TRIGGER_REGISTRY` is initialized, throwing
 * `ReferenceError: Cannot access 'TRIGGER_REGISTRY' before initialization`.
 *
 * This regressed silently once already. `deploy.ts` imported a value from `@/blocks`,
 * which biome sorts above `@/triggers`, so the safe barrel always evaluated first. #6272
 * deleted that import as unused cleanup and took all eleven deployment routes with it —
 * a one-line deletion, forty lines from the import it was protecting, in a file whose
 * tests mock both barrels and therefore could not fail.
 *
 * Only STATIC edges are walked. A dynamic `import()` resolves when it is called rather
 * than during module evaluation, so it carries no initialization-order obligation — that
 * is precisely how `triggers/editor-state.ts` reads the editor's Zustand stores.
 *
 * Usage:
 *   bun run scripts/check-trigger-block-cycle.ts
 *   bun run scripts/check-trigger-block-cycle.ts --verbose   # print graph size
 */
import { existsSync, readFileSync, statSync } from 'node:fs'
import { dirname, join, relative, resolve } from 'node:path'
import { fileURLToPath } from 'node:url'

const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url))
const ROOT = resolve(SCRIPT_DIR, '..')
const APP = join(ROOT, 'apps/sim')

/** Entry points that must never reach `blocks/`. Both are barrels an app module may import first. */
const ENTRIES = ['triggers/index.ts', 'triggers/registry.ts']

/** Directory the entries must not reach. */
const FORBIDDEN_DIR = join(APP, 'blocks')

const EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mjs']

/**
 * Static value imports and re-exports only. `import type` / `export type` are erased at
 * compile time, so a type-only edge costs nothing at runtime and cannot affect ordering.
 */
const IMPORT_RE = /(?:^|\n)\s*import\s+(?!type\b)(?:[\s\S]*?from\s*)?['"]([^'"]+)['"]/g
const REEXPORT_RE =
  /(?:^|\n)\s*export\s+(?!type\b)(?:\*(?:\s+as\s+[\w$]+)?|\{[\s\S]*?\})\s*from\s*['"]([^'"]+)['"]/g

/** Resolves `@/` and relative specifiers. Bare package specifiers are ignored. */
function resolveSpecifier(specifier: string, importer: string): string | null {
  let base: string
  if (specifier.startsWith('@/')) base = join(APP, specifier.slice(2))
  else if (specifier.startsWith('.')) base = resolve(dirname(importer), specifier)
  else return null

  if (existsSync(base) && statSync(base).isFile()) return base
  for (const ext of EXTENSIONS) {
    if (existsSync(base + ext)) return base + ext
  }
  if (existsSync(base) && statSync(base).isDirectory()) {
    for (const ext of EXTENSIONS) {
      const indexPath = join(base, `index${ext}`)
      if (existsSync(indexPath)) return indexPath
    }
  }
  return null
}

/**
 * Breadth-first so the reported chain is the shortest one. A depth-first walk reports
 * whichever path it wandered down, which can be dozens of hops long and unreadable.
 */
function findPathToBlocks(entry: string): { path: string[]; visited: number } {
  const importedBy = new Map<string, string | null>([[entry, null]])
  const queue: string[] = [entry]

  while (queue.length > 0) {
    const file = queue.shift() as string
    if (file.startsWith(`${FORBIDDEN_DIR}/`) || file === `${FORBIDDEN_DIR}.ts`) {
      const chain: string[] = []
      let cursor: string | null = file
      while (cursor) {
        chain.unshift(relative(APP, cursor))
        cursor = importedBy.get(cursor) ?? null
      }
      return { path: chain, visited: importedBy.size }
    }

    let source: string
    try {
      source = readFileSync(file, 'utf8')
    } catch {
      continue
    }

    for (const pattern of [IMPORT_RE, REEXPORT_RE]) {
      pattern.lastIndex = 0
      let match = pattern.exec(source)
      while (match !== null) {
        const resolved = resolveSpecifier(match[1], file)
        if (resolved && !importedBy.has(resolved)) {
          importedBy.set(resolved, file)
          queue.push(resolved)
        }
        match = pattern.exec(source)
      }
    }
  }

  return { path: [], visited: importedBy.size }
}

const verbose = process.argv.includes('--verbose')
let failed = false

for (const entry of ENTRIES) {
  const entryPath = join(APP, entry)
  if (!existsSync(entryPath)) {
    console.error(`✗ check-trigger-block-cycle: entry not found: ${entry}`)
    failed = true
    continue
  }

  const { path, visited } = findPathToBlocks(entryPath)
  if (path.length > 0) {
    failed = true
    console.error(`\n✗ ${entry} can statically reach blocks/:\n`)
    console.error(`    ${path.join('\n      -> ')}\n`)
  } else if (verbose) {
    console.log(`✓ ${entry} — ${visited} modules reachable, none under blocks/`)
  }
}

if (failed) {
  console.error(
    'The triggers <-> blocks import cycle is back. Block configs call getTrigger() at module\n' +
      'scope, so a static triggers -> blocks edge makes module evaluation order load-bearing:\n' +
      'importing @/triggers before @/blocks throws\n' +
      "  ReferenceError: Cannot access 'TRIGGER_REGISTRY' before initialization\n\n" +
      'Do not fix this by reordering imports at the call site — that guard is invisible to the\n' +
      'test suite and one unused-import cleanup away from breaking again. Either keep the\n' +
      'dependency out of the triggers/ tree, or load it with a dynamic import() from\n' +
      'apps/sim/triggers/editor-state.ts the way the editor-state readers do.\n'
  )
  process.exit(1)
}

console.log('✓ check-trigger-block-cycle: triggers/ has no static path into blocks/')