import type { BlockShape, CodeBlock, CommandFacts, CommandWord, DeclaratorFacts, FunctionFacts, InterpreterFacts, LanguageAdapter, LocalSymbol, Node, OptionsFacts, PositionalParameter, Redirect, SourceRange, StepBlocks, SwitchFacts, TextKind, TokenRole } from '../contract'
import type { CommentRules, ListBlocks } from './shared'
import * as path from 'node:path'
import { bashNameReader } from './bashNames'
import { children, compoundShape, leafBlock, leafShape, listBlocks, named } from './shared'

/** 按习惯当常量用的名字：全大写（可带数字、下划线）。 */
const CONSTANT_NAME = /^[A-Z][A-Z0-9_]*$/
const POSITIONAL = /^[1-9]$/
/** 流程关键字（按关键字着色）和声明关键字（按声明着色）。 */
const FLOW_KEYWORDS = new Set(['if', 'then', 'else', 'elif', 'fi', 'for', 'while', 'until', 'do', 'done', 'case', 'esac', 'in', 'select'])
const DECLARATION_KEYWORDS = new Set(['local', 'export', 'readonly', 'declare', 'typeset', 'function', 'unset'])
/** 写在 `set` 里的单字母开关 → bash 的长名字（`set -o` 用的那个）。 */
const SHORT_SWITCHES: Record<string, string> = {
  a: 'allexport',
  b: 'notify',
  e: 'errexit',
  f: 'noglob',
  h: 'hashall',
  k: 'keyword',
  m: 'monitor',
  n: 'noexec',
  t: 'onecmd',
  u: 'nounset',
  v: 'verbose',
  x: 'xtrace',
  B: 'braceexpand',
  C: 'noclobber',
  E: 'errtrace',
  H: 'histexpand',
  P: 'physical',
  T: 'functrace',
}
/** 打印到输出的内置命令：函数里没重定向的这几句是函数的输出。 */
const PRINTERS = new Set(['echo', 'printf'])
const LOOPS = new Set(['for_statement', 'c_style_for_statement', 'while_statement'])
/** 分情况里一个情况最多几句、每句一行写完，才整个排成一张表（不拆成子块）。 */
const COMPACT_CASE_STATEMENTS = 3
const SIMPLE_STATEMENTS = new Set(['command', 'redirected_statement', 'variable_assignment', 'declaration_command', 'negated_command'])
/** 不出值的展开：命令替换、变量展开、算术展开、进程替换；值里有它们就不是写死的。 */
const EXPANSIONS = new Set(['simple_expansion', 'expansion', 'command_substitution', 'arithmetic_expansion', 'process_substitution'])

const COMMENTS: CommentRules = {
  lineStyle: () => '#',
  // 紧贴在函数上面一行的注释是函数的说明
  isDoc: (comment) => {
    const next = comment.nextSibling
    return next?.type === 'function_definition' && next.startPosition.row === comment.endPosition.row + 1
  },
  documents: new Set(['function']),
}

function statements(items: Node[], afterRow: number, top: boolean): CodeBlock[] {
  return listBlocks(items, afterRow, item => statementBlocks(item, top), COMMENTS)
}

const nested: ListBlocks = (items, afterRow) => statements(items, afterRow, false)

/** 节点里（不进嵌套的函数定义）满足 test 的节点，先序。 */
function descendants(node: Node, test: (node: Node) => boolean, out: Node[] = []): Node[] {
  for (const child of children(node)) {
    if (test(child))
      out.push(child)
    if (child.type !== 'function_definition')
      descendants(child, test, out)
  }
  return out
}

function commandName(command: Node | null | undefined): string | undefined {
  return command?.type === 'command' ? command.childForFieldName('name')?.text : undefined
}

/** 语句本身执行的那条命令：`cmd`，或带重定向的 `cmd >&2` 里的 cmd。 */
function commandOf(statement: Node): Node | undefined {
  if (statement.type === 'command')
    return statement
  const body = statement.type === 'redirected_statement' ? statement.childForFieldName('body') : null
  return body?.type === 'command' ? body : undefined
}

// ─── 块 ──────────────────────────────────────────────────────────────────────

function statementBlocks(node: Node, top: boolean): CodeBlock[] {
  switch (node.type) {
    case 'variable_assignment':
      return [variableBlock(node, [node], top, false)]
    case 'variable_assignments':
      return [variableBlock(node, named(node).filter(child => child.type === 'variable_assignment'), top, false)]
    case 'declaration_command':
      return [declarationBlock(node, top)]
    case 'function_definition':
      return [functionBlock(node)]
    case 'if_statement':
      return ifBlocks(node)
    case 'for_statement':
    case 'c_style_for_statement':
    case 'while_statement':
      return [loopBlock('loop', node, node)]
    case 'case_statement':
      return [caseBlock(node)]
    case 'pipeline':
      return [pipelineBlock(node)]
    case 'redirected_statement': {
      const body = node.childForFieldName('body')
      return body && body.type !== 'command' ? statementBlocks(body, top) : [commandBlock(node)]
    }
    case 'command':
      return [commandBlock(node)]
    case 'negated_command':
    case 'test_command':
      return [leafBlock(isTest(node) ? 'if' : 'command', node)]
    case 'list':
      return [leafBlock(conditionList(node) ? 'if' : 'command', node)]
    default:
      return [leafBlock('statement', node)]
  }
}

/** 值里没有展开（变量、命令替换……），是写死的。 */
function isLiteral(value: Node): boolean {
  return !EXPANSIONS.has(value.type) && named(value).every(isLiteral)
}

/** 常量：readonly 的，或脚本顶层、名字全大写、值写死的。 */
function variableBlock(node: Node, assignments: Node[], top: boolean, readonly: boolean): CodeBlock {
  const declarators = assignments.flatMap((assignment): DeclaratorFacts[] => {
    if (assignment.type !== 'variable_assignment')
      return [{ name: assignment }]
    const name = assignment.childForFieldName('name')
    const value = assignment.childForFieldName('value')
    return name ? [{ name, ...(value && { value }) }] : []
  })
  const constant = readonly || (top && declarators.length > 0 && declarators.every(({ name, value }) => CONSTANT_NAME.test(name.text) && value && isLiteral(value)))
  return { kind: constant ? 'const' : 'variable', ...leafShape(node), facts: { declarators } }
}

/** local / export / readonly / declare：声明的变量是一块；什么都没声明（`export -f fn`）的当命令。 */
function declarationBlock(node: Node, top: boolean): CodeBlock {
  const keyword = node.child(0)?.type
  const declared = named(node).filter(child => child.type === 'variable_assignment' || child.type === 'variable_name')
  if (declared.length === 0)
    return leafBlock('command', node)
  const readonly = keyword === 'readonly' || named(node).some(child => child.type === 'word' && /^-\w*r/.test(child.text))
  return variableBlock(node, declared, top, readonly)
}

function commandBlock(node: Node): CodeBlock {
  const command = commandOf(node)
  const name = commandName(command)
  if (name === 'set' && command && node.type === 'command') {
    const switches = optionSwitches(named(command).filter(child => child.type !== 'command_name'))
    if (switches)
      return { kind: 'options', ...leafShape(node), facts: { switches } }
  }
  return leafBlock(name === 'return' ? 'return' : 'command', node)
}

/** `set -euo pipefail`、`set +x`、`set -o nounset` 的各个开关；有不是开关的词（`set -- a b`）时不是。 */
function optionSwitches(words: Node[]): OptionsFacts['switches'] | undefined {
  const switches: SwitchFacts[] = []
  for (let i = 0; i < words.length; i++) {
    const text = words[i].text
    const match = /^([-+])([a-z]+)$/i.exec(text)
    if (!match)
      return undefined
    const on = match[1] === '-'
    for (const letter of match[2]) {
      if (letter === 'o') {
        const name = words[++i]?.text
        if (!name || !/^[a-z]+$/.test(name))
          return undefined
        switches.push({ id: name, on, flag: `${match[1]}o ${name}` })
        continue
      }
      switches.push({ id: SHORT_SWITCHES[letter] ?? letter, on, flag: `${match[1]}${letter}` })
    }
  }
  return switches.length > 0 ? switches : undefined
}

/** 条件：`[ … ]`、`[[ … ]]`，前面可以带 `!`。 */
function isTest(node: Node): boolean {
  if (node.type === 'negated_command')
    return named(node).some(isTest)
  return node.type === 'test_command'
}

/** `a && b || c` 里用 && / || 连起来的各句，照源码顺序。 */
function listOperands(node: Node): Node[] {
  return node.type === 'list' ? named(node).filter(child => child.type !== 'comment').flatMap(listOperands) : [node]
}

/**
 * 当条件读的一串：全是条件（`[ -f x ] && [ … ]`，读成「成立：…」），或前面全是条件、最后跟一句（`[ … ] || continue`、
 * `[ -f x ] && rm x`，读成「如果（不是）〔…〕，…」）。
 */
function conditionList(node: Node): boolean {
  const operands = listOperands(node)
  return operands.slice(0, -1).every(isTest) && (isTest(operands[operands.length - 1]) || operands.length > 1)
}

/** 语句块（`{ … }`、do … done、then 后面）里的各句连同注释：去掉关键字、分号。 */
function bodyItems(nodes: Node[]): Node[] {
  return nodes.filter(child => child.isNamed)
}

/** 复合语句块：头部到第一句之前（没有句子时到 fromEnd 为止），子块是各句。 */
function compound(kind: TextKind, outer: Node, items: Node[], fromEnd: number): CodeBlock {
  const shape: BlockShape = compoundShape(outer, items[0]?.startIndex ?? fromEnd, items, nested)
  return { kind, ...shape }
}

/** 循环：头部到 do 为止，子块是 do … done 里的各句。管道后面跟的 while 也是这样拆，只是块本身是整个管道。 */
function loopBlock(kind: TextKind, outer: Node, loop: Node): CodeBlock {
  const body = loop.childForFieldName('body')
  const items = body ? bodyItems(children(body)) : []
  const open = body?.child(0)
  return compound(kind, outer, items, open?.endIndex ?? loop.endIndex)
}

/** if 一块，elif / else 展平成紧跟它的兄弟块（同 Python）。 */
function ifBlocks(node: Node): CodeBlock[] {
  const clauses = named(node).filter(child => child.type === 'elif_clause' || child.type === 'else_clause')
  return [clauseBlock('if', node), ...clauses.map(clause => clauseBlock('else', clause))]
}

/** if、elif 的主体是 then 后面、下一个 elif / else 之前的各句；else 的主体是 else 后面的各句。 */
function clauseBlock(kind: TextKind, node: Node): CodeBlock {
  const all = children(node)
  const opener = all.findIndex(child => child.type === (node.type === 'else_clause' ? 'else' : 'then'))
  const rest = all.slice(opener + 1)
  const end = rest.findIndex(child => child.type === 'elif_clause' || child.type === 'else_clause' || child.type === 'fi')
  const items = bodyItems(end < 0 ? rest : rest.slice(0, end))
  return compound(kind, node, items, all[opener]?.endIndex ?? node.endIndex)
}

function caseItems(node: Node): Node[] {
  return named(node).filter(child => child.type === 'case_item')
}

/** 一个情况里要做的各句（连同注释）：`)` 后面的、`;;` 之前的。 */
function caseBody(item: Node): Node[] {
  const all = children(item)
  const close = all.findIndex(child => child.type === ')')
  return bodyItems(all.slice(close + 1))
}

/** 每个情况都只有几句、每句一行写完、没有注释和嵌套的语句块。 */
function compactCase(node: Node): boolean {
  return caseItems(node).every((item) => {
    const body = caseBody(item)
    return body.length <= COMPACT_CASE_STATEMENTS && body.every(statement => SIMPLE_STATEMENTS.has(statement.type)
      && statement.startPosition.row === statement.endPosition.row
      && (statement.type !== 'redirected_statement' || commandOf(statement) !== undefined))
  })
}

/** 分情况：几个情况都短时整条语句一块（情况排成表），否则头部到 in 为止、每个情况一块子块。 */
function caseBlock(node: Node): CodeBlock {
  if (compactCase(node))
    return leafBlock('case', node)
  const items = caseItems(node)
  const inKeyword = children(node).find(child => child.type === 'in')
  const shape = compoundShape(node, items[0]?.startIndex ?? inKeyword?.endIndex ?? node.endIndex, [], nested)
  return { kind: 'case', ...shape, children: [...shape.children, ...items.map(branchBlock)] }
}

/** 一个情况：头部是它的模式（到 `)` 为止），子块是要做的各句。 */
function branchBlock(item: Node): CodeBlock {
  const body = caseBody(item)
  const close = children(item).find(child => child.type === ')')
  return compound('case', item, body, close?.endIndex ?? item.endIndex)
}

/** 管道：最后一段是循环（`find … | while read -r x; do … done`）时循环的主体是子块。 */
function pipelineBlock(node: Node): CodeBlock {
  const last = named(node).at(-1)
  if (last && LOOPS.has(last.type))
    return loopBlock('pipeline', node, last)
  return leafBlock('pipeline', node)
}

// ─── 函数 ────────────────────────────────────────────────────────────────────

/** `$1`、`"$1"`、`${1}` 这种只是取第几个参数的值：取的是第几个。 */
function positionalValue(value: Node | null): number | undefined {
  if (!value)
    return undefined
  const inner = value.type === 'string' && named(value).length === 1 ? named(value)[0] : value
  if (inner.type !== 'simple_expansion' && inner.type !== 'expansion')
    return undefined
  const expanded = named(inner)
  const name = expanded.length === 1 ? expanded[0] : undefined
  return name?.type === 'variable_name' && POSITIONAL.test(name.text) ? Number(name.text) : undefined
}

/** 函数里用到的第几个参数，和它们在函数里的名字（`local url="$1"`、`url=$1`）。 */
function positionalParameters(body: Node): PositionalParameter[] {
  const used = new Set(descendants(body, node => node.type === 'variable_name' && POSITIONAL.test(node.text)
    && (node.parent?.type === 'simple_expansion' || node.parent?.type === 'expansion')).map(node => Number(node.text)))
  const names = new Map<number, Node>()
  for (const assignment of descendants(body, node => node.type === 'variable_assignment')) {
    const position = positionalValue(assignment.childForFieldName('value'))
    const name = assignment.childForFieldName('name')
    if (position !== undefined && name && !names.has(position))
      names.set(position, name)
  }
  return [...used].sort((a, b) => a - b).map(position => ({ position, ...(names.has(position) && { name: names.get(position) }) }))
}

/** 重定向了输出（`>&2`、`> file`）的语句不算打印到输出。 */
function printsToOutput(statement: Node): boolean {
  const name = commandName(commandOf(statement))
  if (!name || !PRINTERS.has(name))
    return false
  return redirectsOf(statement).every(redirect => redirect.kind === 'read' || redirect.stream === 'error')
}

/** 函数自己的各句（进 if、循环、分情况，不进命令替换、管道、嵌套的函数）里打印到输出的那几句。 */
function printedStatements(body: Node): Node[] {
  const out: Node[] = []
  const visit = (node: Node): void => {
    for (const child of named(node)) {
      if (child.type === 'command' || child.type === 'redirected_statement') {
        if (printsToOutput(child))
          out.push(child)
      }
      else if (child.type !== 'function_definition' && child.type !== 'pipeline' && child.type !== 'command_substitution') {
        visit(child)
      }
    }
  }
  visit(body)
  return out
}

/** 同一文件里有没有 `$(name …)`：函数的输出被拿去用了。 */
function captured(root: Node, name: string): boolean {
  return descendants(root, node => node.type === 'command_substitution'
    && named(node).some(inner => commandName(inner) === name || commandName(listOperands(inner)[0]) === name)).length > 0
}

function functionBlock(node: Node): CodeBlock {
  const name = node.childForFieldName('name')
  const body = node.childForFieldName('body')
  const items = body?.type === 'compound_statement' ? bodyItems(children(body)) : []
  const open = body?.child(0)
  const shape = compoundShape(node, items[0]?.startIndex ?? open?.endIndex ?? node.endIndex, items, nested)
  const facts: FunctionFacts = {
    ...(name && { name }),
    decorators: [],
    parameters: [],
    positional: body ? positionalParameters(body) : [],
    prints: body ? printedStatements(body) : [],
    captured: !!name && captured(node.tree.rootNode, name.text),
    returns: body ? descendants(body, child => commandName(child) === 'return') : [],
  }
  return { kind: 'function', ...shape, facts }
}

// ─── 解释器 ──────────────────────────────────────────────────────────────────

/** `#!/usr/bin/env bash`、`#!/bin/sh -e`。 */
function interpreterFacts(shebang: Node): InterpreterFacts {
  const command = shebang.text.slice(2).trim()
  const [program = '', ...rest] = command.split(/\s+/)
  if (path.posix.basename(program) === 'env') {
    const named = rest.find(word => !word.startsWith('-'))
    return { program: named ? path.posix.basename(named) : 'env', lookup: 'env', command }
  }
  return { program: path.posix.basename(program), lookup: 'path', command }
}

function programBlocks(root: Node): CodeBlock[] {
  const items = named(root)
  const [first] = items
  if (first?.type === 'comment' && first.startPosition.row === 0 && first.text.startsWith('#!')) {
    const interpreter: CodeBlock = { kind: 'interpreter', ...leafShape(first), facts: interpreterFacts(first) }
    return [interpreter, ...statements(items.slice(1), 0, true)]
  }
  return statements(items, -1, true)
}

// ─── 命令 ────────────────────────────────────────────────────────────────────

/** 一个 `>`、`>>`、`>&2`、`2>&1`、`&>`、`<` 重定向；heredoc 这类不算。 */
function redirectOf(node: Node): Redirect | undefined {
  if (node.type !== 'file_redirect')
    return undefined
  const descriptor = named(node).find(child => child.type === 'file_descriptor')?.text
  const operator = children(node).find(child => !child.isNamed)?.type
  const target = node.childForFieldName('destination')
  if (!operator || !target)
    return undefined
  const stream = descriptor === '2' ? 'error' : 'output'
  switch (operator) {
    case '>&':
      if (target.text === '1' || target.text === '2')
        return { kind: 'merge', stream, into: target.text === '2' ? 'error' : 'output' }
      return { kind: 'write', stream, target }
    case '>':
    case '>|':
      return { kind: 'write', stream, target }
    case '>>':
      return { kind: 'append', stream, target }
    case '&>':
      return { kind: 'write', stream: 'both', target }
    case '&>>':
      return { kind: 'append', stream: 'both', target }
    case '<':
      return { kind: 'read', source: target }
    default:
      return undefined
  }
}

function redirectsOf(statement: Node): Redirect[] {
  if (statement.type !== 'redirected_statement')
    return []
  return statement.childrenForFieldName('redirect').flatMap((redirect) => {
    const found = redirect ? redirectOf(redirect) : undefined
    return found ? [found] : []
  })
}

/** 一个词写死的文字：去掉引号、反斜杠转义；里面有展开的没有。 */
function literalOf(word: Node): string | undefined {
  switch (word.type) {
    case 'word':
    case 'number':
    case 'extglob_pattern':
      return word.text.replace(/\\(.)/g, '$1')
    case 'raw_string':
      return word.text.slice(1, -1)
    case 'command_name': {
      const [inner] = named(word)
      return inner ? literalOf(inner) : undefined
    }
    case 'string': {
      const parts = named(word)
      return parts.every(part => part.type === 'string_content') ? parts.map(part => part.text.replace(/\\([$`"\\])/g, '$1')).join('') : undefined
    }
    case 'concatenation': {
      const parts = named(word).map(literalOf)
      return parts.every(part => part !== undefined) ? parts.join('') : undefined
    }
    default:
      return undefined
  }
}

function commandWord(node: Node): CommandWord {
  const literal = literalOf(node)
  return literal === undefined ? { node } : { node, literal }
}

/** 一条命令（带不带重定向）：命令名、后面的各个词（连写死的文字）、重定向。 */
function bashCommand(node: Node): CommandFacts | undefined {
  const command = commandOf(node)
  const name = command?.childForFieldName('name')
  if (!command || !name)
    return undefined
  const args = command.childrenForFieldName('argument').filter(arg => arg !== null)
  const inherited = node.type === 'command' ? redirectedChain(node) : undefined
  return { name: commandWord(name), arguments: args.map(commandWord), redirects: [...redirectsOf(node), ...(inherited ? redirectsOf(inherited) : [])] }
}

/** 一串 `a && b` 里的最后一句。 */
function lastOperand(list: Node): Node | undefined {
  return named(list).filter(child => child.type !== 'comment').at(-1)
}

/**
 * tree-sitter-bash 把 `a && b > f` 读成整串带着重定向（redirected_statement 的 body 是 `a && b`），其实重定向只属于最后那条命令 b：
 * command 是这样一串的最后一条时给出那个 redirected_statement，它的重定向算在 command 上。
 */
function redirectedChain(command: Node): Node | undefined {
  let child = command
  let parent = command.parent
  while (parent?.type === 'list' && lastOperand(parent)?.id === child.id) {
    child = parent
    parent = parent.parent
  }
  return child.id !== command.id && parent?.type === 'redirected_statement' && parent.childForFieldName('body')?.id === child.id ? parent : undefined
}

// ─── 名字 ────────────────────────────────────────────────────────────────────

function rangeOf(node: Node): SourceRange {
  return { startIndex: node.startIndex, endIndex: node.endIndex }
}

/**
 * 同一文件里认得出的名字：函数（定义处是函数名，用到的是同名的命令），变量（定义处是赋值、local / export 声明、for 的变量、
 * read 读进的名字，用到的是 `$x`、`${x…}` 和这些定义处）。第几个参数、`$?` 这类不算。
 */
function bashSymbols(root: Node): LocalSymbol[] {
  const symbols = new Map<string, LocalSymbol>()
  const symbol = (key: string): LocalSymbol => {
    let found = symbols.get(key)
    if (!found) {
      found = { definitions: [], occurrences: [] }
      symbols.set(key, found)
    }
    return found
  }
  const define = (key: string, node: Node): void => {
    const entry = symbol(key)
    entry.definitions.push(rangeOf(node))
    entry.occurrences.push(rangeOf(node))
  }
  const functions = new Set(descendants(root, node => node.type === 'function_definition').map(fn => fn.childForFieldName('name')?.text))
  const visit = (node: Node): void => {
    const parent = node.parent
    if (node.type === 'function_definition') {
      const name = node.childForFieldName('name')
      if (name)
        define(`function:${name.text}`, name)
    }
    else if (node.type === 'word' && parent?.type === 'command_name' && functions.has(node.text)) {
      symbol(`function:${node.text}`).occurrences.push(rangeOf(node))
    }
    else if (node.type === 'variable_name' && !POSITIONAL.test(node.text)) {
      const defining = parent?.type === 'variable_assignment' || parent?.type === 'declaration_command' || parent?.type === 'for_statement'
      if (defining)
        define(`variable:${node.text}`, node)
      else if (parent?.type === 'simple_expansion' || parent?.type === 'expansion')
        symbol(`variable:${node.text}`).occurrences.push(rangeOf(node))
    }
    else if (node.type === 'command' && commandName(node) === 'read') {
      for (const arg of node.childrenForFieldName('argument')) {
        if (arg?.type === 'word' && /^[a-z_]\w*$/i.test(arg.text))
          define(`variable:${arg.text}`, arg)
      }
    }
    for (const child of children(node))
      visit(child)
  }
  visit(root)
  return [...symbols.values()].filter(entry => entry.definitions.length > 0)
}

// ─── 词性 ────────────────────────────────────────────────────────────────────

function insideString(leaf: Node): boolean {
  for (let node = leaf.parent; node; node = node.parent) {
    if (EXPANSIONS.has(node.type))
      return false
    if (node.type === 'string' || node.type === 'heredoc_body')
      return true
  }
  return false
}

function bashTokenRole(leaf: Node): TokenRole {
  const parent = leaf.parent
  switch (leaf.type) {
    case 'comment':
      return 'comment'
    case 'string_content':
    case 'raw_string':
    case 'ansi_c_string':
    case 'heredoc_content':
    case 'heredoc_body':
    case 'extglob_pattern':
    case 'regex':
      return 'string'
    case 'number':
      return 'number'
    case 'variable_name':
      return CONSTANT_NAME.test(leaf.text) ? 'constant' : 'variable'
    case 'special_variable_name':
      return 'variable'
    case 'test_operator':
      return 'operator'
    case 'file_descriptor':
      return 'number'
    case 'word':
      if (parent?.type === 'command_name' || parent?.type === 'function_definition')
        return 'function'
      if (insideString(leaf) || parent?.type === 'case_item')
        return 'string'
      return /^\d+(?:\.\d+)*$/.test(leaf.text) ? 'number' : 'plain'
    case '"':
      return 'string'
  }
  if (FLOW_KEYWORDS.has(leaf.type))
    return 'keyword'
  return DECLARATION_KEYWORDS.has(leaf.type) ? 'storage' : 'plain'
}

/** 一串 `a && b` 本身（整串带着重定向的，见 redirectedChain，是它 body 里的那串）。 */
function chainList(node: Node): Node | undefined {
  const body = node.type === 'redirected_statement' ? node.childForFieldName('body') : node
  return body?.type === 'list' ? body : undefined
}

/** 一串里的各条命令，照源码顺序；整串带着重定向的往里拆（重定向算在最后一条上）。 */
function chainOperands(node: Node): Node[] {
  const list = chainList(node)
  return list ? named(list).filter(child => child.type !== 'comment').flatMap(chainOperands) : [node]
}

/** `a && b && c`：只用 && 连着的一串（都不是条件）。 */
function andChain(node: Node): boolean {
  const operators = (list: Node): string[] => children(list).flatMap((child) => {
    const inner = chainList(child)
    return inner ? operators(inner) : child.isNamed ? [] : [child.type]
  })
  const list = chainList(node)
  return !!list && operators(list).every(operator => operator === '&&') && !chainOperands(node).some(isTest)
}

/** 一步的块：整串带着的重定向算在最后一条上，它的头部延到重定向结尾。 */
function stepBlocks(operand: Node): CodeBlock[] {
  const redirected = operand.type === 'command' ? redirectedChain(operand) : undefined
  return statementBlocks(operand, true).map(block => redirected ? { ...block, header: { ...block.header, endIndex: redirected.endIndex, endRow: redirected.endPosition.row } } : block)
}

/**
 * 被别的语言当一串步骤执行的 shell（Dockerfile 的 RUN）：只有一句、是只用 && 连着的一串命令时拆开，一条命令一步（一步失败就停）；
 * 别的照 toBlocks 一句一步。
 */
function bashSteps(root: Node): StepBlocks {
  const items = named(root)
  const [only, ...more] = items.filter(item => item.type !== 'comment')
  if (only && more.length === 0 && andChain(only))
    return { blocks: chainOperands(only).flatMap(stepBlocks), chained: true }
  return { blocks: statements(items, -1, true), chained: false }
}

/** bash / sh / zsh 脚本（VS Code 的 languageId 是 shellscript）的语言插件。@param wasmDir 语法包 .wasm 所在目录 */
export function createBashAdapter(wasmDir: string): LanguageAdapter {
  return {
    id: 'bash',
    languageIds: ['shellscript'],
    grammarPath: () => path.join(wasmDir, 'tree-sitter-bash.wasm'),
    toBlocks: root => programBlocks(root),
    steps: root => bashSteps(root),
    tokenRole: bashTokenRole,
    command: bashCommand,
    symbols: root => bashSymbols(root),
    displayNames: bashNameReader,
  }
}