/**
 * 把调用边收成调用树。边从测试里喂，不碰编辑器。
 * 身份是文件加名字起点；同一次查询里种类会变，种类只用来画图标。
 */

/** 往上走到第 8 层就停，这一层当作这棵树的根。 */
export const CALL_TREE_MAX_DEPTH = 8

/** 一个符号：文件、名字起点、给人看的路径和种类。 */
export interface CallSymbol {
  uri: string
  /** 名字起点，行和列都从 0 起 */
  line: number
  character: number
  name: string
  /** 块种类，只决定图标，不参与认人 */
  kind: string
  /** 从工作区文件夹算起的路径 */
  path: string
  detail?: string
}

/** 调用出现的范围，在调用方文件里，行和列从 0 起。 */
export interface CallRange {
  line: number
  character: number
  endLine: number
  endCharacter: number
}

/** 一次调用：谁在哪一段范围里调用了谁。同一段范围重复出现只算一次。 */
export interface CallEdge {
  caller: CallSymbol
  callee: CallSymbol
  at: CallRange
  /** 前端发请求调到接口的才有：方法和前端写的路径（`GET /api/v1/agents`），树上在调用方和接口之间多一个「请求」节点 */
  request?: string
}

/** 点节点跳到哪：文件和位置，行和列从 0 起。 */
export interface CallJump {
  uri: string
  line: number
  character: number
}

/** 树上的一个节点。当前块可以在同一棵里出现多次，每次一个节点。 */
export interface CallTreeNode {
  name: string
  /** 块种类；「请求」节点是 request */
  kind: string
  /** 第二行。根是「入口」（Next.js 页面是「页面 网址」），新建类是「进入这个类」，其余是符号自己的说明（没有就不写） */
  detail?: string
  /** 文件:行，行从 1 起 */
  where: string
  /** 符号是它的名字起点；「新建」「请求」节点是发生调用的那一处 */
  jump: CallJump
  current: boolean
  children: CallTreeNode[]
  /** 不在通向当前块的路径上的调用次数；没有就不画那一行 */
  otherCalls?: number
}

/** 一棵调用树：根是没有更上层调用者的入口。 */
export interface CallTree {
  id: string
  /** 入口的名字 */
  name: string
  /** 这一棵里当前块出现几次 */
  hits: number
  root: CallTreeNode
}

/** 文件加名字起点。种类不放进来。 */
export function symbolKey(symbol: Pick<CallSymbol, 'uri' | 'line' | 'character'>): string {
  return `${symbol.uri}#${symbol.line}:${symbol.character}`
}

function rangeKey(at: CallRange): string {
  return `${at.line}:${at.character}-${at.endLine}:${at.endCharacter}`
}

function edgeKey(edge: CallEdge): string {
  return `${symbolKey(edge.caller)}>${symbolKey(edge.callee)}@${rangeKey(edge.at)}`
}

function whereOf(symbol: CallSymbol): string {
  return `${symbol.path}:${symbol.line + 1}`
}

/** 调用方里发生这次调用的那一处：「新建」「请求」节点写它、点了跳到它。 */
function callSite(caller: CallSymbol, at: CallRange): Pick<CallTreeNode, 'where' | 'jump'> {
  return { where: `${caller.path}:${at.line + 1}`, jump: { uri: caller.uri, line: at.line, character: at.character } }
}

/**
 * Next.js 页面的网址：文件在某个 `app/` 目录下、名字是 `page.(tsx|ts|jsx|js)` 时按目录算，路由分组 `(xxx)`、并行路由 `@slot` 去掉，
 * 动态段 `[id]`、`[[...section]]` 原样留；`app/page.tsx` 是 `/`。不是页面文件时没有。
 * @param path `/` 分隔的路径，取第一层叫 app 的目录
 */
export function nextPageUrl(path: string): string | undefined {
  const segments = path.split('/')
  const app = segments.indexOf('app')
  if (app < 0 || !/^page\.[jt]sx?$/.test(segments.at(-1)!))
    return undefined
  const route = segments.slice(app + 1, -1).filter(segment => !/^\(.*\)$/.test(segment) && !segment.startsWith('@'))
  return `/${route.join('/')}`
}

/**
 * 从目标往上收到根，再顺着走回目标。
 * 不通向目标的调用不展开，记在父节点的 otherCalls 上。
 * 选中的是类时，直接调用它的那一层写成「新建 类名」；前端发请求调到接口的那一下写成「请求 方法 路径」。
 * 根的第二行是「入口」，Next.js 页面写成「页面 网址」。
 */
export function buildCallTrees(edges: readonly CallEdge[], target: CallSymbol, options?: { classTarget?: boolean }): CallTree[] {
  const symbols = new Map<string, CallSymbol>()
  const remember = (symbol: CallSymbol): CallSymbol => {
    const key = symbolKey(symbol)
    const known = symbols.get(key)
    if (known)
      return known
    symbols.set(key, symbol)
    return symbol
  }
  const targetSymbol = remember(target)
  const targetKey = symbolKey(targetSymbol)
  const unique: CallEdge[] = []
  const seen = new Set<string>()
  for (const edge of edges) {
    const normalized: CallEdge = { ...edge, caller: remember(edge.caller), callee: remember(edge.callee) }
    const key = edgeKey(normalized)
    if (seen.has(key))
      continue
    seen.add(key)
    unique.push(normalized)
  }

  const byCallee = new Map<string, CallEdge[]>()
  const byCaller = new Map<string, CallEdge[]>()
  for (const edge of unique) {
    pushTo(byCallee, symbolKey(edge.callee), edge)
    pushTo(byCaller, symbolKey(edge.caller), edge)
  }
  if ((byCallee.get(targetKey) ?? []).length === 0)
    return []

  const depthOf = new Map<string, number>()
  const roots: CallSymbol[] = []
  const rootSeen = new Set<string>()
  const addRoot = (symbol: CallSymbol) => {
    const key = symbolKey(symbol)
    if (rootSeen.has(key))
      return
    rootSeen.add(key)
    roots.push(symbol)
  }
  const climb = (node: CallSymbol, depth: number, path: ReadonlySet<string>) => {
    const key = symbolKey(node)
    const known = depthOf.get(key)
    if (known !== undefined && known <= depth)
      return
    depthOf.set(key, depth)
    if (depth >= CALL_TREE_MAX_DEPTH) {
      addRoot(node)
      return
    }
    const callers = new Map<string, CallSymbol>()
    for (const edge of byCallee.get(key) ?? []) {
      const callerKey = symbolKey(edge.caller)
      if (!path.has(callerKey) && !callers.has(callerKey))
        callers.set(callerKey, edge.caller)
    }
    if (callers.size === 0) {
      addRoot(node)
      return
    }
    const nextPath = new Set(path)
    nextPath.add(key)
    for (const caller of callers.values())
      climb(caller, depth + 1, nextPath)
  }
  climb(targetSymbol, 0, new Set())

  const classTarget = options?.classTarget === true
  const render = (node: CallSymbol, path: ReadonlySet<string>): CallTreeNode => {
    const key = symbolKey(node)
    const current = key === targetKey
    const nodeDepth = depthOf.get(key) ?? 0
    const children: CallTreeNode[] = []
    let otherCalls = 0
    if (!current) {
      const nextPath = new Set(path)
      nextPath.add(key)
      for (const edge of byCaller.get(key) ?? []) {
        const calleeKey = symbolKey(edge.callee)
        if (nextPath.has(calleeKey))
          continue
        const calleeDepth = depthOf.get(calleeKey)
        if (calleeDepth === undefined) {
          otherCalls++
          continue
        }
        if (calleeDepth >= nodeDepth)
          continue
        children.push(calleeKey === targetKey ? targetChild(node, edge, nextPath) : render(edge.callee, nextPath))
      }
    }
    return {
      name: node.name,
      kind: node.kind,
      ...(node.detail && { detail: node.detail }),
      where: whereOf(node),
      jump: { uri: node.uri, line: node.line, character: node.character },
      current,
      children,
      ...(otherCalls > 0 && { otherCalls }),
    }
  }

  /** 直接调到目标的那一下：前端发的请求、新建类，各在中间多一个节点写调用的那一处；其余直接是目标。 */
  function targetChild(caller: CallSymbol, edge: CallEdge, path: ReadonlySet<string>): CallTreeNode {
    const target = render(edge.callee, path)
    if (edge.request)
      return { name: `请求 ${edge.request}`, kind: 'request', ...callSite(caller, edge.at), current: false, children: [target] }
    if (classTarget)
      return { name: `新建 ${targetSymbol.name}`, kind: 'class', detail: '进入这个类', ...callSite(caller, edge.at), current: false, children: [target] }
    return target
  }

  return roots.map((root) => {
    const rendered = render(root, new Set())
    const page = nextPageUrl(root.path)
    rendered.detail = page === undefined ? '入口' : `页面 ${page}`
    return { id: symbolKey(root), name: root.name, hits: countCurrent(rendered), root: rendered }
  })
}

function pushTo(map: Map<string, CallEdge[]>, key: string, edge: CallEdge): void {
  const list = map.get(key)
  if (list)
    list.push(edge)
  else
    map.set(key, [edge])
}

function countCurrent(node: CallTreeNode): number {
  return (node.current ? 1 : 0) + node.children.reduce((sum, child) => sum + countCurrent(child), 0)
}