/**
 * 前端发 HTTP 请求的地方：openapi-fetch 的 `X.GET("/path", ...)` 这类（成员名是大写的 HTTP 方法），`fetch("/path", { method: "POST" })`，
 * 和经包装函数发的：一个函数把自己收到的网址参数原样作为第一个参数交给 fetch 或另一个包装函数（可以跨文件、可以多层），它就是包装函数，
 * 调用它的地方照 fetch 的规则取网址和方法。网址要写成字符串字面量或模板字符串，模板里的 `${名字}` 指向字符串常量的拼进常量的值，
 * 别的 `${...}` 照写，当参数段；接口的调用树拿它找前端调用了哪个接口（见 endpoint.ts）。
 *
 * 工作区索引按文件记下相关的调用和导出的字符串常量，连同被调的名字、网址里的名字在这份文件里指的是谁（本文件的定义、import 来源、全局的 fetch）；
 * 谁是包装函数、方法是什么查的时候才从 fetch 起一层层认（见 senders），导入的常量查的时候才取值（见 pathsOf），文件改了下回查就跟着变。
 */

import type { IndexEntry, Node } from '../contract'
import type { IndexedEntry, IndexFind, WorkspaceIndexOf } from '../workspaceIndex'
import type { CallRange } from './model'
import type { ImportedName, ModuleResolver } from './modules'
import { importFacts } from '../languages/typescript'
import { argumentsOf, exportedAs, isFunction, named, parametersOf, sameNode, stringContent, unwrap } from '../rules/reactTree'
import { compareLocations } from '../workspaceIndex'
import { exportOf, moduleResolver } from './modules'

/** openapi-fetch 客户端上发请求的方法名，也是 fetch 的 method 认得的值。 */
const METHODS = new Set(['GET', 'PUT', 'POST', 'DELETE', 'OPTIONS', 'HEAD', 'PATCH', 'TRACE'])

/** 方法跟着调用处走：照 fetch 的规则读调用处的第二个参数（fetch 自己就是这样）。 */
const FROM_CALLER = Symbol('fromCaller')

/** 一处调用、一个发请求的函数的方法：大写的 HTTP 方法，或跟着调用处走。 */
type Method = string | typeof FROM_CALLER

/**
 * 前端发的一个请求：键是大写的方法。名字是发请求的地方所在的最内层有名字的函数的名字（编辑器从它往上问调用者）；
 * 不在有名字的函数里时，名字是被调用的 fetch / GET / 包装函数本身。
 */
export interface RequestEntry extends IndexEntry {
  /** 写的路径：模板里指向字符串常量的 `${名字}` 换成常量的值，别的 `${...}` 照写；`?`、`#` 后面的，和最后一段末尾紧贴字面量的 `${...}`（查询串）去掉 */
  path: string
  /** 发请求那个调用的范围，行和列从 0 起 */
  at: CallRange
  /** 所在的有名字的函数叫什么；不在有名字的函数里时没有 */
  caller?: string
}

/**
 * 索引记下的一处调用。键是被调的函数定义处的名字（导入的是它导出时的名字，默认导出是 default），
 * `X.GET` 这类成员调用是点加成员名（`.GET`）。
 */
interface CallEntry extends IndexEntry {
  /** 被调的函数是导入的：import 后面写的模块 */
  from?: string
  /** 被调的函数定义在这份文件里：定义处名字的起点下标 */
  defined?: number
  /** 照 fetch 的规则从第二个参数读出的方法（见 methodOf）；读不出、成员调用没有 */
  method?: Method
}

/**
 * 网址的一截：照写的字，或一个 `${...}`（written 是照写的样子）。`${名字}` 的名字指向字符串常量时，constant 记着去哪取值：
 * 本文件定义的已经展开成几截，导入的记下模块和导出时的名字，查的时候才对到导出它的那份文件。
 */
type UrlPiece = string | { written: string, constant?: UrlPiece[] | ImportedName }

/** 第一个参数写着网址的一处调用：名字、范围、调用者同 RequestEntry。 */
interface SendEntry extends CallEntry, Pick<RequestEntry, 'at' | 'caller'> {
  /** 写的网址，拆成几截 */
  url: UrlPiece[]
}

/** 包装函数把自己收到的网址参数原样交给被调的函数的一处：名字是包装函数定义处的名字。 */
interface ForwardEntry extends CallEntry {
  /** 包装函数叫什么 */
  wrapper: string
  /** 包装函数在顶层定义、导出了时，导出时叫什么（默认导出是 default） */
  exported?: string
}

/** 顶层定义、导出了的字符串常量：键是导出时的名字（默认导出是 default），名字是定义处的名字。 */
interface ConstantEntry extends IndexEntry {
  /** 常量的值，同网址拆成几截 */
  pieces: UrlPiece[]
}

type IndexedCall = IndexedEntry<SendEntry | ForwardEntry>

type Indexed = IndexedEntry<SendEntry | ForwardEntry | ConstantEntry>

/** 对象字面量的键名：`method`、`"method"`。 */
function keyName(key: Node | null): string | undefined {
  return key?.type === 'property_identifier' ? key.text : stringContent(key)
}

/**
 * 照 fetch 的规则读第二个参数里的方法：没有第二个参数、对象里没写 method 是 GET，method 是字面量就照它；
 * method 不是字面量、第二个参数不是对象字面量、对象里带展开（可能藏着 method）都不认。
 * 包装函数转手时，fromCaller 认出它自己收到的选项（它的调用处的第二个参数）：原样交出、在对象里展开它又没写 method 的，
 * 方法跟着调用处走；展开了它又写了 method 的不认。
 */
function methodOf(init: Node | undefined, fromCaller: (node: Node | undefined) => boolean = () => false): Method | undefined {
  if (!init)
    return 'GET'
  if (fromCaller(init))
    return FROM_CALLER
  if (init.type !== 'object')
    return undefined
  const members = named(init)
  const spreads = members.flatMap(member => member.type === 'spread_element' ? [unwrap(named(member)[0])] : [])
  const written = members.find(member => member.type === 'pair' ? keyName(member.childForFieldName('key')) === 'method' : member.type === 'shorthand_property_identifier' && member.text === 'method')
  if (!written)
    return spreads.length === 0 ? 'GET' : spreads.every(fromCaller) ? FROM_CALLER : undefined
  if (spreads.some(fromCaller))
    return undefined
  const method = written.type === 'pair' ? stringContent(unwrap(written.childForFieldName('value')))?.toUpperCase() : undefined
  return method && METHODS.has(method) ? method : undefined
}

/**
 * 函数自己的名字，和编辑器的调用关系认的一样：函数声明、方法写的；箭头函数、函数表达式取赋给的 const 变量名、类字段名。
 * 匿名的、赋给 let / var 的没有。
 */
function functionName(fn: Node): Node | undefined {
  if (fn.type === 'function_declaration' || fn.type === 'generator_function_declaration' || fn.type === 'method_definition')
    return fn.childForFieldName('name') ?? undefined
  const holder = fn.parent
  if (!holder || !sameNode(holder.childForFieldName('value'), fn))
    return undefined
  const name = holder.childForFieldName('name')
  if (holder.type === 'variable_declarator' && holder.parent?.childForFieldName('kind')?.text === 'const')
    return name?.type === 'identifier' ? name : undefined
  return holder.type === 'public_field_definition' && name?.type === 'property_identifier' ? name : undefined
}

/** node 所在的最内层有名字的函数的名字；匿名回调往外找，不在有名字的函数里时没有。 */
function callerName(node: Node): Node | undefined {
  for (let current = node.parent; current; current = current.parent) {
    const name = isFunction(current) ? functionName(current) : undefined
    if (name)
      return name
  }
  return undefined
}

// ─── 名字指的是谁 ─────────────────────────────────────────────────────────────

/** 名字在这份文件里指的是什么：定义的函数（定义处的名字）、字符串常量（它的值）、导入的、某个函数的第几个参数，或别的变量。 */
type Binding
  = | { kind: 'function', name: Node }
    | { kind: 'constant', value: Node }
    | ({ kind: 'import' } & ImportedName)
    | { kind: 'parameter', fn: Node, index: number }
    | { kind: 'variable' }

/** 参数、变量声明里写的各个名字（解构的、带默认值的、`...rest` 都算）。 */
function patternNames(pattern: Node | null | undefined): string[] {
  switch (pattern?.type) {
    case 'identifier':
    case 'shorthand_property_identifier_pattern':
      return [pattern.text]
    case 'object_pattern':
    case 'array_pattern':
    case 'rest_pattern':
      return named(pattern).flatMap(patternNames)
    case 'pair_pattern':
      return patternNames(pattern.childForFieldName('value'))
    case 'assignment_pattern':
    case 'object_assignment_pattern':
      return patternNames(pattern.childForFieldName('left'))
    default:
      return []
  }
}

/** 赋给 const 的字符串常量：名字和值（字符串字面量或模板字符串，`as const` 这类包裹去掉）；别的声明没有。 */
function stringConstant(declarator: Node): { name: Node, value: Node } | undefined {
  const name = declarator.childForFieldName('name')
  const value = unwrap(declarator.childForFieldName('value'))
  if (declarator.parent?.childForFieldName('kind')?.text !== 'const' || name?.type !== 'identifier' || (value?.type !== 'string' && value?.type !== 'template_string'))
    return undefined
  return { name, value }
}

/**
 * 一条语句声明的名字记进 names：函数声明和赋给 const 的函数是定义的函数，赋给 const 的字符串字面量、模板字符串是字符串常量，
 * import 的是导入的（只导入类型的不算），别的是变量。
 */
function declare(statement: Node | null, names: Map<string, Binding>): void {
  const add = (name: string, binding: Binding): void => {
    if (!names.has(name))
      names.set(name, binding)
  }
  switch (statement?.type) {
    case 'export_statement':
      declare(statement.childForFieldName('declaration'), names)
      break
    case 'function_declaration':
    case 'generator_function_declaration': {
      const name = statement.childForFieldName('name')
      if (name)
        add(name.text, { kind: 'function', name })
      break
    }
    case 'class_declaration':
    case 'abstract_class_declaration':
      patternNames(statement.childForFieldName('name')).forEach(name => add(name, { kind: 'variable' }))
      break
    case 'lexical_declaration':
    case 'variable_declaration':
      for (const declarator of named(statement).filter(child => child.type === 'variable_declarator')) {
        const value = declarator.childForFieldName('value')
        const name = value && isFunction(value) ? functionName(value) : undefined
        const constant = stringConstant(declarator)
        if (name)
          add(name.text, { kind: 'function', name })
        else if (constant)
          add(constant.name.text, { kind: 'constant', value: constant.value })
        else
          patternNames(declarator.childForFieldName('name')).forEach(declared => add(declared, { kind: 'variable' }))
      }
      break
    case 'import_statement': {
      const facts = importFacts(statement, true)
      const from = stringContent(facts.sources[0])
      if (facts.typeOnly || from === undefined)
        break
      for (const item of facts.items) {
        if (item.kind === 'named')
          add((item.alias ?? item.name).text, { kind: 'import', from, name: item.name.text })
        else if (item.kind === 'default')
          add(item.alias.text, { kind: 'import', from, name: 'default' })
        else if (item.alias)
          add(item.alias.text, { kind: 'variable' })
      }
      break
    }
  }
}

/** 这一层声明的名字：函数的参数，程序和语句块里的声明，for 头里的、catch 的参数；别的节点不声明名字。 */
function declarations(scope: Node): Map<string, Binding> | undefined {
  const names = new Map<string, Binding>()
  if (isFunction(scope)) {
    parametersOf(scope).forEach(({ name }, index) => {
      for (const declared of patternNames(name)) {
        if (!names.has(declared))
          names.set(declared, name.type === 'identifier' ? { kind: 'parameter', fn: scope, index } : { kind: 'variable' })
      }
    })
    return names
  }
  switch (scope.type) {
    case 'program':
    case 'statement_block':
      named(scope).forEach(statement => declare(statement, names))
      return names
    case 'for_statement':
      declare(scope.childForFieldName('initializer'), names)
      return names
    case 'for_in_statement':
      if (scope.childForFieldName('kind'))
        patternNames(scope.childForFieldName('left')).forEach(name => names.set(name, { kind: 'variable' }))
      return names
    case 'catch_clause':
      patternNames(scope.childForFieldName('parameter')).forEach(name => names.set(name, { kind: 'variable' }))
      return names
    default:
      return undefined
  }
}

/** 一份文件里名字指的是什么：从用到它的地方往外一层层找声明，各层声明了哪些名字按节点记下。 */
class Scopes {
  private readonly declared = new Map<number, Map<string, Binding> | undefined>()

  /** 名字指的是哪个声明；哪层都没声明（全局的）时没有。 */
  resolve(name: Node): Binding | undefined {
    for (let scope = name.parent; scope; scope = scope.parent) {
      if (!this.declared.has(scope.id))
        this.declared.set(scope.id, declarations(scope))
      const binding = this.declared.get(scope.id)?.get(name.text)
      if (binding)
        return binding
    }
    return undefined
  }

  /** node 是 fn 的第 index 个参数（同名的、被里层的声明挡住的不算）。 */
  isParameter(node: Node | null | undefined, fn: Node, index: number): boolean {
    const binding = node?.type === 'identifier' ? this.resolve(node) : undefined
    return binding?.kind === 'parameter' && binding.index === index && sameNode(binding.fn, fn)
  }
}

// ─── 索引 ─────────────────────────────────────────────────────────────────────

/**
 * 写的网址：字符串字面量或模板字符串拆成几截，别的写法没有。模板里的 `${名字}` 指向字符串常量的记下去哪取值（见 constantOf），
 * outer 是正在展开的各个常量的值。
 */
function urlOf(node: Node | undefined, scopes: Scopes, outer: readonly Node[] = []): UrlPiece[] | undefined {
  if (node?.type === 'string')
    return [stringContent(node) ?? '']
  if (node?.type !== 'template_string')
    return undefined
  return named(node).map((part) => {
    if (part.type !== 'template_substitution')
      return part.text
    const constant = constantOf(named(part)[0], scopes, outer)
    return { written: part.text, ...(constant && { constant }) }
  })
}

/** 本文件的字符串常量的值展开成几截：值里的 `${...}` 都得指向常量才算，绕回正在展开的常量（循环）不算。 */
function expanded(value: Node, scopes: Scopes, outer: readonly Node[]): UrlPiece[] | undefined {
  if (outer.some(other => sameNode(other, value)))
    return undefined
  const pieces = urlOf(value, scopes, [...outer, value])
  return pieces?.every(piece => typeof piece === 'string' || piece.constant) ? pieces : undefined
}

/**
 * `${名字}` 的名字指向的字符串常量去哪取值：本文件定义的展开成几截（见 expanded），导入的是模块和导出时的名字。
 * 不是名字本身的（`${cfg.prefix}`、函数调用）、被参数和别的变量挡住的、展开不了的没有。
 */
function constantOf(expression: Node | undefined, scopes: Scopes, outer: readonly Node[]): UrlPiece[] | ImportedName | undefined {
  const binding = expression?.type === 'identifier' ? scopes.resolve(expression) : undefined
  if (binding?.kind === 'import')
    return { from: binding.from, name: binding.name }
  return binding?.kind === 'constant' ? expanded(binding.value, scopes, outer) : undefined
}

/** 顶层定义、导出了的字符串常量（别的文件的网址可能导入它），值展开不了的不记。 */
function constantsOf(root: Node, scopes: Scopes): ConstantEntry[] {
  return named(root).flatMap((statement) => {
    const declaration = statement.type === 'export_statement' ? statement.childForFieldName('declaration') : statement
    if (declaration?.type !== 'lexical_declaration')
      return []
    return named(declaration).flatMap((declarator): ConstantEntry[] => {
      const constant = declarator.type === 'variable_declarator' ? stringConstant(declarator) : undefined
      const exported = constant && exportedAs(statement, constant.name.text)
      if (!constant || !exported)
        return []
      const pieces = expanded(constant.value, scopes, [])
      return pieces ? [{ key: exported, name: { startIndex: constant.name.startIndex, endIndex: constant.name.endIndex }, pieces }] : []
    })
  })
}

/** 被调的是谁：这份文件定义的函数、导入的，或全局的 fetch；参数、别的变量、别的全局函数没有。 */
function calleeOf(callee: Node, scopes: Scopes): Pick<CallEntry, 'key' | 'from' | 'defined'> | undefined {
  const binding = scopes.resolve(callee)
  if (!binding)
    return callee.text === 'fetch' ? { key: 'fetch' } : undefined
  if (binding.kind === 'function')
    return { key: binding.name.text, defined: binding.name.startIndex }
  return binding.kind === 'import' ? { key: binding.name, from: binding.from } : undefined
}

/** 函数里给它的第一个参数重新赋过值（`url = …`、`url += …`、`url++`）：交出去的就不是收到的网址了。 */
function reassigned(fn: Node, scopes: Scopes): boolean {
  return fn.descendantsOfType(['assignment_expression', 'augmented_assignment_expression', 'update_expression'])
    .some(node => !!node && scopes.isParameter(unwrap(node.childForFieldName('left') ?? node.childForFieldName('argument')), fn, 0))
}

/** 顶层定义的函数导出时叫什么（见 exportedAs）；不在顶层定义、没导出时没有。 */
function exportedName(fn: Node, name: Node): string | undefined {
  const declaration = fn.type === 'function_declaration' || fn.type === 'generator_function_declaration' ? fn : fn.parent?.parent
  const statement = declaration?.parent?.type === 'export_statement' ? declaration.parent : declaration
  return statement?.parent?.type === 'program' ? exportedAs(statement, name.text) : undefined
}

/** 第一个参数写着网址的一处：名字归最内层有名字的函数，不在有名字的函数里时是被调的 callee。 */
function sendEntry(call: Node, callee: Node, target: Omit<CallEntry, 'name'>, url: UrlPiece[]): SendEntry {
  const caller = callerName(call)
  const name = caller ?? callee
  return {
    ...target,
    name: { startIndex: name.startIndex, endIndex: name.endIndex },
    url,
    at: { line: call.startPosition.row, character: call.startPosition.column, endLine: call.endPosition.row, endCharacter: call.endPosition.column },
    ...(caller && { caller: caller.text }),
  }
}

/**
 * 一处调用记不记：`X.GET(网址)` 这类；第一个参数写着网址、被调的是这份文件定义的函数、导入的或 fetch；
 * 第一个参数是一个有名字的函数（函数声明、赋给 const 的）的第一个参数、函数里没给它重新赋过值的，记成那个函数转手。
 */
function callOf(call: Node, scopes: Scopes): (SendEntry | ForwardEntry)[] {
  const callee = unwrap(call.childForFieldName('function'))
  const [first, init] = argumentsOf(call).map(unwrap)
  if (callee?.type === 'member_expression') {
    const property = callee.childForFieldName('property')
    const url = property && METHODS.has(property.text) ? urlOf(first, scopes) : undefined
    return property && url ? [sendEntry(call, property, { key: `.${property.text}` }, url)] : []
  }
  if (callee?.type !== 'identifier')
    return []
  const target = calleeOf(callee, scopes)
  if (!target)
    return []
  const url = urlOf(first, scopes)
  if (url) {
    const method = methodOf(init)
    return [sendEntry(call, callee, { ...target, ...(method && { method }) }, url)]
  }
  const binding = first?.type === 'identifier' ? scopes.resolve(first) : undefined
  const fn = binding?.kind === 'parameter' && binding.index === 0 ? binding.fn : undefined
  const name = fn && functionName(fn)
  if (!fn || name?.type !== 'identifier' || reassigned(fn, scopes))
    return []
  const method = methodOf(init, node => scopes.isParameter(node, fn, 1))
  const exported = exportedName(fn, name)
  return [{ ...target, name: { startIndex: name.startIndex, endIndex: name.endIndex }, wrapper: name.text, ...(method && { method }), ...(exported && { exported }) }]
}

/**
 * 前端源码里和发请求有关的调用，和导出的字符串常量（TSX 的语法包也读得了 .ts、.js）。包装函数一层层转手最后总落到 fetch 上，
 * 跨文件要靠 import，导出常量要写 export，所以 fetch、import、export、`.GET(` 这类都不提的文件里不会有，不解析。
 */
const CALLS_INDEX: WorkspaceIndexOf<SendEntry | ForwardEntry | ConstantEntry> = {
  id: 'callTree.calls',
  languageId: 'typescriptreact',
  include: '**/*.{ts,tsx,js,jsx}',
  mentions: source => /\b(?:fetch|import|export)\b|\.(?:GET|PUT|POST|DELETE|OPTIONS|HEAD|PATCH|TRACE)\s*\(/.test(source),
  entries: (root) => {
    const scopes = new Scopes()
    return [...root.descendantsOfType('call_expression').flatMap(call => call ? callOf(call, scopes) : []), ...constantsOf(root, scopes)]
  },
}

// ─── 查 ───────────────────────────────────────────────────────────────────────

/** 发请求的函数（fetch、认出的包装函数）的方法；转手的几处读出的方法对不上、读不出时是 null，这样的不认。 */
type Status = Method | null

function isSend(indexed: Indexed): indexed is IndexedEntry<SendEntry> {
  return 'url' in indexed.entry
}

function isForward(indexed: Indexed): indexed is IndexedEntry<ForwardEntry> {
  return 'wrapper' in indexed.entry
}

function isConstant(indexed: Indexed): indexed is IndexedEntry<ConstantEntry> {
  return 'pieces' in indexed.entry
}

/** 包装函数的编号：定义在哪份文件，定义处名字的起点下标。 */
function wrapperId(uri: string, offset: number): string {
  return `${uri}#${offset}`
}

/**
 * 从 fetch 起一层层认包装函数：转手给已认出的函数的各处，所在的函数就是下一层的包装函数。方法按转手的那处读：
 * 被调的写死了方法就是它，跟着调用处走的就照转手时交出的选项读；几处读出的不一样就定不下来。认出新的包装函数就接着查调它的各处，
 * 直到不再有新的。被调的名字按调用处那份文件的定义、import 来源对到包装函数，对不上、对上不止一个的不认（见 exportOf）。
 * 交回查到的各处，和问一处调用调的函数的方法（不是发请求的函数时没有）。
 */
async function senders(find: IndexFind, resolve: ModuleResolver): Promise<{ calls: Indexed[], statusOf: (call: IndexedCall) => Status | undefined }> {
  const loaded = new Map<string, Indexed[]>()
  const wrappers = new Map<string, { id: string, uri: string, names: string[], exported?: string }>()
  let status = new Map<string, Status>()

  const statusOf = ({ entry, location }: IndexedCall): Status | undefined => {
    if (entry.defined !== undefined)
      return status.get(wrapperId(location.uri, entry.defined))
    if (entry.from === undefined)
      return entry.key === 'fetch' ? FROM_CALLER : undefined
    const wrapper = exportOf(resolve, location.uri, { from: entry.from, name: entry.key }, [...wrappers.values()])
    return wrapper && status.get(wrapper.id)
  }

  for (let pending = ['fetch']; pending.length > 0;) {
    for (const name of pending)
      loaded.set(name, await find(CALLS_INDEX, name))
    const forwards = [...loaded.values()].flat().filter(isForward)
    for (const { location, entry } of forwards) {
      const id = wrapperId(location.uri, entry.name.startIndex)
      wrappers.set(id, { id, uri: location.uri, names: [entry.wrapper, ...(entry.exported ? [entry.exported] : [])], ...(entry.exported && { exported: entry.exported }) })
    }
    for (let changed = true; changed;) {
      const next = new Map<string, Status>()
      for (const forward of forwards) {
        const target = statusOf(forward)
        if (target === undefined)
          continue
        const own = target === FROM_CALLER ? forward.entry.method ?? null : target
        const id = wrapperId(forward.location.uri, forward.entry.name.startIndex)
        next.set(id, next.has(id) && next.get(id) !== own ? null : own)
      }
      changed = next.size !== status.size || [...next].some(([id, value]) => status.get(id) !== value)
      status = next
    }
    pending = [...new Set([...status.keys()].flatMap(id => wrappers.get(id)?.names ?? []))].filter(name => !loaded.has(name))
  }
  return { calls: [...loaded.values()].flat(), statusOf }
}

/**
 * 网址拼成路径（uri 是网址所在的文件）：`${名字}` 取得到常量的值就拼进去，取不到的照写；`?`、`#` 后面的去掉，照写的 `${...}` 里的不算；
 * 最后一段是字面量文字后面紧贴一个照写的 `${...}`（`messages${qs}`）时，它是拼上去的查询串，也去掉。
 * 导入的常量和包装函数一样按 import 来源对到导出它的那处（见 exportOf），它的值里又导入的接着取；对不上、绕回正在取的（循环）取不到。
 * 一份查询里同一个常量只取一次；取值时记着正在取的，所以要一处处拼，不能同时拼。
 */
function pathsOf(find: IndexFind, resolve: ModuleResolver): (uri: string, url: readonly UrlPiece[]) => Promise<string> {
  const values = new Map<string, string | undefined>()

  /** 一个 `${...}` 指向的常量的值；不指向常量、取不到的没有。 */
  async function valueOf(uri: string, constant: UrlPiece[] | ImportedName | undefined): Promise<string | undefined> {
    if (!constant)
      return undefined
    if (Array.isArray(constant))
      return joined(uri, constant)
    const exports = (await find(CALLS_INDEX, constant.name)).filter(isConstant).map(found => ({ uri: found.location.uri, exported: found.entry.key, found }))
    const target = exportOf(resolve, uri, constant, exports)
    if (!target)
      return undefined
    const id = `${target.uri}#${target.found.entry.name.startIndex}`
    if (!values.has(id)) {
      // 先占上：取值途中绕回这个常量就是循环，取不到
      values.set(id, undefined)
      values.set(id, await joined(target.uri, target.found.entry.pieces))
    }
    return values.get(id)
  }

  /** 常量的值拼起来：每个 `${...}` 都取得到才算。 */
  async function joined(uri: string, pieces: readonly UrlPiece[]): Promise<string | undefined> {
    let text = ''
    for (const piece of pieces) {
      const value = typeof piece === 'string' ? piece : await valueOf(uri, piece.constant)
      if (value === undefined)
        return undefined
      text += value
    }
    return text
  }

  return async (uri, url) => {
    let path = ''
    // 上一个照写的 `${...}` 在 path 里的结尾；末尾照写的 `${...}` 当查询串去掉时从哪截
    let written = 0
    let query: number | undefined
    for (const piece of url) {
      const value = typeof piece === 'string' ? piece : await valueOf(uri, piece.constant)
      if (value === undefined) {
        const segment = path.lastIndexOf('/') + 1
        query = segment >= written && segment < path.length ? path.length : undefined
        path += typeof piece === 'string' ? piece : piece.written
        written = path.length
        continue
      }
      const end = value.search(/[?#]/)
      const literal = end >= 0 ? value.slice(0, end) : value
      path += literal
      if (literal)
        query = undefined
      if (end >= 0)
        break
    }
    return query === undefined ? path : path.slice(0, query)
  }
}

/** 前端发方法是 method 的请求的各处：`X.GET` 这类、调 fetch 的、调包装函数的，照文件、位置排。 */
export async function frontendRequests(find: IndexFind, method: string): Promise<IndexedEntry<RequestEntry>[]> {
  const resolve = await moduleResolver(find)
  const { calls, statusOf } = await senders(find, resolve)
  const members = await find(CALLS_INDEX, `.${method}`)
  const wrapped = calls.filter(isSend).filter((call) => {
    const target = statusOf(call)
    return (target === FROM_CALLER ? call.entry.method : target) === method
  })
  const pathOf = pathsOf(find, resolve)
  const found: IndexedEntry<RequestEntry>[] = []
  for (const { location, entry } of [...members.filter(isSend), ...wrapped])
    found.push({ location, entry: { key: method, name: entry.name, path: await pathOf(location.uri, entry.url), at: entry.at, ...(entry.caller && { caller: entry.caller }) } })
  return found.sort((a, b) => compareLocations(a.location, b.location) || a.entry.at.line - b.entry.at.line || a.entry.at.character - b.entry.at.character)
}