import type { Access, AttributeFacts, AttributeItem, CfgPredicate, ClassFacts, CodeBlock, CollectionFacts, CommentBlock, EnumBlock, FunctionBlock, ImplBlock, ImportBlock, ImportItem, LanguageAdapter, Node, ParameterFacts, SourceSpan, TokenRole, TraitBlock } from '../contract'
import type { CommentRules } from './shared'
import * as path from 'node:path'
import { leadingAttributes, visibilityFacts } from '../rules/rustTree'
import { attachComments, children, compoundShape, extendHeader, headerSpan, isCommentNode, leafBlock, leafShape, listBlocks, named, syntaxChildren } from './shared'

const STORAGE = new Set(['pub', 'async', 'const', 'static', 'mut', 'let'])

export function createRustAdapter(wasmDir: string): LanguageAdapter {
  return {
    id: 'rust',
    languageIds: ['rust'],
    grammarPath: () => path.join(wasmDir, 'tree-sitter-rust.wasm'),
    toBlocks: root => attachComments(topBlocks(named(root), -1), aboutModule),
    tokenRole: rustTokenRole,
    lineComment: '//',
    freshDoc,
    collection: rustCollection,
  }
}

/** 数组 `[a, b]`、元组 `(a, b)` 的各项；`[值; 个数]` 不是一项项写出来的，别的节点也没有。项前面的 `#[…]` 不算一项。 */
function rustCollection(node: Node): CollectionFacts | undefined {
  const listed = node.type === 'tuple_expression' || (node.type === 'array_expression' && !node.childForFieldName('length'))
  if (!listed)
    return undefined
  return { kind: 'sequence', elements: syntaxChildren(node).filter(child => child.type !== 'attribute_item').map(value => ({ kind: 'item', value })) }
}

/** extern 块本身不成一块源码，里面的签名跟所在这一层的别的项走同一条路。 */
function unwrapExtern(item: Node): Node[] {
  if (item.type !== 'foreign_mod_item')
    return [item]
  const body = item.childForFieldName('body')
  return body ? named(body).flatMap(unwrapExtern) : []
}

/**
 * `//` 普通注释、讲所在模块的 `//!`、讲下一项的 `///` 各是一种写法，只和同一种连成一块。
 * `///` 和 `/**` 开头的块注释是外部文档注释，讲紧跟着的那一项（中间可以隔着 `#[…]`）。
 */
const COMMENTS: CommentRules = {
  lineStyle: comment => comment.type === 'line_comment' ? `//${docMarker(comment)}` : undefined,
  isDoc: comment => named(comment).some(child => child.type === 'outer_doc_comment_marker'),
  documents: new Set(['function', 'class', 'trait', 'impl', 'module', 'enum', 'const', 'variable']),
}

/** 能带说明的项还没有说明时，在它紧上面插 `///`。 */
function freshDoc(block: CodeBlock): { line: number, shell: string } | undefined {
  if (!(COMMENTS.documents as ReadonlySet<string>).has(block.kind))
    return undefined
  return { line: block.header.startRow, shell: '/// _' }
}

/** 讲所在模块或 crate 的内部文档注释（`//!`、`/*!`）：写在文件开头是文件的说明，写在 `mod` 身体里交给那个模块。 */
function aboutModule(comment: CommentBlock): boolean {
  return named(comment.node).some(child => child.type === 'inner_doc_comment_marker')
}

/** 文档注释记号：外部的 `/`（块注释是 `*`）、内部的 `!`；普通注释没有。 */
function docMarker(comment: Node): string {
  return named(comment).find(child => child.type === 'outer_doc_comment_marker' || child.type === 'inner_doc_comment_marker')?.text ?? ''
}

/** 一层的各项（文件顶层、模块身体、impl 身体）→ 块；afterRow 同 listBlocks。`#[…]` 和多出来的空 `;` 不出块。 */
function topBlocks(items: Node[], afterRow: number): CodeBlock[] {
  return listBlocks(items.flatMap(unwrapExtern), afterRow, (item) => {
    if (item.type === 'attribute_item' || item.type === 'empty_statement')
      return []
    return [withAttributes(itemBlock(item))]
  }, COMMENTS)
}

function itemBlock(item: Node): CodeBlock {
  switch (item.type) {
    case 'use_declaration':
      return useBlock(item)
    case 'struct_item':
      return structBlock(item)
    case 'enum_item':
      return enumBlock(item)
    case 'impl_item':
      return implBlock(item)
    case 'trait_item':
      return traitBlock(item)
    case 'mod_item':
      return moduleBlock(item)
    case 'const_item':
      return valueBlock(item, 'const')
    case 'static_item':
      return valueBlock(item, 'variable')
    case 'function_item':
    case 'function_signature_item':
      return functionBlock(item)
    case 'inner_attribute_item':
      return innerAttributeBlock(item)
    default:
      return leafBlock('statement', item)
  }
}

/** 没有身体的 `mod 名字;` 不拆。有身体的模块，身体和文件顶层同一套规则。 */
function moduleBlock(node: Node): CodeBlock {
  const body = node.childForFieldName('body')
  if (!body)
    return leafBlock('statement', node)
  const { access, attributes } = visibilityFacts(node)
  return {
    kind: 'module',
    ...compoundShape(node, body.startIndex, named(body), topBlocks),
    ...(attributes && { attributes }),
    facts: classFacts(node, access),
  }
}

/** const 是常量，static 是变量；名称、类型、值交给现成的常量 / 变量属性表。 */
function valueBlock(node: Node, kind: 'const' | 'variable'): CodeBlock {
  const name = node.childForFieldName('name')
  if (!name)
    return leafBlock('statement', node)
  const type = node.childForFieldName('type') ?? undefined
  const value = node.childForFieldName('value') ?? undefined
  const { access, attributes } = visibilityFacts(node)
  return {
    kind,
    ...leafShape(node),
    ...(attributes && { attributes }),
    facts: { access, declarators: [{ name, type, value }] },
  }
}

const PLACEMENTS: Record<string, AttributeFacts['placement']> = { source_file: 'file', mod_item: 'module', impl_item: 'impl' }

/** `#![…]`：写给所在 crate 或模块的编译属性。`cfg_attr(条件, a, b)` 拆成生效条件和 a、b。 */
function innerAttributeBlock(node: Node): CodeBlock {
  const attribute = named(node).find(child => child.type === 'attribute')
  if (!attribute)
    return leafBlock('statement', node)
  const meta = metaItem(tokens(attribute))
  const [condition, ...applied] = meta.name === 'cfg_attr' ? meta.list ?? [] : []
  const conditional = condition !== undefined && applied.length > 0
  const container = node.parent?.type === 'source_file' ? node.parent : node.parent?.parent
  const placement = container ? PLACEMENTS[container.type] : undefined
  return {
    kind: 'attribute',
    ...leafShape(node),
    facts: {
      attributes: conditional ? applied.map(item => attributeItem(metaItem(item))) : [attributeItem(meta)],
      ...(conditional && { condition: cfgPredicate(condition) }),
      ...(placement && { placement }),
    },
  }
}

/** 属性的写法：名字（路径），后面 `= 值` 或括号里逗号隔开的各段。tokens 是这一段的各个词。 */
interface MetaItem {
  tokens: Node[]
  name: string
  value?: Node
  list?: Node[][]
}

function metaItem(words: Node[]): MetaItem {
  const at = words.findIndex(word => word.type === '=' || word.type === 'token_tree')
  const path = at < 0 ? words : words.slice(0, at)
  const mark = words[at]
  return {
    tokens: words,
    name: textOf(path),
    ...(mark?.type === '=' && words[at + 1] && { value: words[at + 1] }),
    ...(mark?.type === 'token_tree' && { list: listItems(mark) }),
  }
}

/** 括号里逗号隔开的各段，每段是它的各个词。 */
function listItems(tree: Node): Node[][] {
  const items: Node[][] = [[]]
  for (const word of tokens(tree).slice(1, -1)) {
    if (word.type === ',')
      items.push([])
    else
      items[items.length - 1].push(word)
  }
  return items.filter(item => item.length > 0)
}

function attributeItem(meta: MetaItem): AttributeItem {
  return {
    span: spanOf(meta.tokens),
    name: meta.name,
    ...(meta.value && { value: literalText(meta.value) }),
    arguments: (meta.list ?? []).map(textOf),
  }
}

function cfgPredicate(words: Node[]): CfgPredicate {
  const meta = metaItem(words)
  if (meta.list && (meta.name === 'all' || meta.name === 'any'))
    return { kind: meta.name, operands: meta.list.map(cfgPredicate) }
  if (meta.list?.length === 1 && meta.name === 'not')
    return { kind: 'not', operand: cfgPredicate(meta.list[0]) }
  if (!meta.list && words[0]?.type === 'identifier' && (words.length === 1 || meta.value))
    return { kind: 'option', name: meta.name, ...(meta.value && { value: literalText(meta.value) }) }
  return { kind: 'other', text: textOf(words) }
}

/** 节点的各个词（含标点），注释不算。 */
function tokens(node: Node): Node[] {
  return children(node).filter(child => !isCommentNode(child))
}

/** 连着的几个词在源码里的原文（它们是同一个节点的子节点）。 */
function textOf(words: Node[]): string {
  const [first] = words
  const last = words[words.length - 1]
  const parent = first?.parent
  if (!first || !last || !parent)
    return ''
  return parent.text.slice(first.startIndex - parent.startIndex, last.endIndex - parent.startIndex)
}

function spanOf(words: Node[]): SourceSpan {
  const first = words[0]
  const last = words[words.length - 1]
  return { startIndex: first.startIndex, endIndex: last.endIndex, startRow: first.startPosition.row, endRow: last.endPosition.row }
}

/** 字面量的值：字符串去掉引号，别的照原文。 */
function literalText(node: Node): string {
  if (node.type !== 'string_literal')
    return node.text
  return named(node).find(child => child.type === 'string_content')?.text ?? ''
}

/** 写在前面的 `#[…]` 算进头部。 */
function withAttributes(block: CodeBlock): CodeBlock {
  const [attribute] = leadingAttributes(block.node)
  return attribute && block.header.startIndex > attribute.startIndex ? extendHeader(block, attribute) : block
}

function useBlock(node: Node): ImportBlock {
  const argument = node.childForFieldName('argument')
  const { source, items } = argument ? useParts(argument) : { items: [] }
  return { kind: 'import', ...leafShape(node), facts: { sources: source ? [source] : [], items } }
}

function useParts(node: Node): { source?: Node, items: ImportItem[] } {
  switch (node.type) {
    case 'scoped_identifier': {
      const source = node.childForFieldName('path') ?? undefined
      const name = node.childForFieldName('name')
      return { source, items: name ? [{ kind: 'named', name }] : [] }
    }
    case 'scoped_use_list': {
      const source = node.childForFieldName('path') ?? undefined
      const list = node.childForFieldName('list')
      return { source, items: list ? useList(list) : [] }
    }
    case 'use_list':
      return { items: useList(node) }
    case 'use_as_clause':
      return { items: asItem(node) }
    case 'use_wildcard':
      return { items: [{ kind: 'namespace' }] }
    case 'identifier':
      return { items: [{ kind: 'named', name: node }] }
    default:
      return { items: [] }
  }
}

function useList(list: Node): ImportItem[] {
  return named(list).flatMap((child) => {
    if (child.type === 'identifier')
      return [{ kind: 'named' as const, name: child }]
    if (child.type === 'use_as_clause')
      return asItem(child)
    if (child.type === 'use_wildcard')
      return [{ kind: 'namespace' as const }]
    if (child.type === 'scoped_identifier') {
      const name = child.childForFieldName('name')
      return name ? [{ kind: 'named' as const, name }] : []
    }
    return []
  })
}

function asItem(node: Node): ImportItem[] {
  const name = node.childForFieldName('path')
  const alias = node.childForFieldName('alias') ?? undefined
  return name ? [{ kind: 'named', name, alias }] : []
}

function structBlock(node: Node): CodeBlock {
  const { access, attributes } = visibilityFacts(node)
  return {
    kind: 'class',
    ...shape(node),
    ...(attributes && { attributes }),
    facts: classFacts(node, access),
  }
}

function enumBlock(node: Node): EnumBlock {
  const { access, attributes } = visibilityFacts(node)
  const body = node.childForFieldName('body')
  const members = named(body).flatMap((variant) => {
    if (variant.type !== 'enum_variant')
      return []
    const name = variant.childForFieldName('name')
    if (!name)
      return []
    const payload = variant.childForFieldName('body') ?? undefined
    return [{ name, ...(payload && { value: payload }), docs: [] }]
  })
  return {
    kind: 'enum',
    ...shape(node),
    ...(attributes && { attributes }),
    facts: { name: node.childForFieldName('name') ?? node, doc: undefined, access, decorators: [], bases: [], members },
  }
}

function traitBlock(node: Node): TraitBlock {
  const { access, attributes } = visibilityFacts(node)
  return { kind: 'trait', ...shape(node), ...(attributes && { attributes }), facts: classFacts(node, access) }
}

function implBlock(node: Node): ImplBlock {
  const { access, attributes } = visibilityFacts(node)
  const body = node.childForFieldName('body')
  return {
    kind: 'impl',
    ...compoundShape(node, body?.startIndex ?? node.endIndex, named(body), topBlocks),
    ...(attributes && { attributes }),
    facts: classFacts(node, access, implType(node)),
  }
}

function functionBlock(node: Node): FunctionBlock {
  const { access, attributes } = visibilityFacts(node)
  const body = node.childForFieldName('body')
  const headerEnd = body?.startIndex ?? node.endIndex
  return {
    kind: 'function',
    node,
    header: headerSpan(node, headerEnd),
    children: [],
    ...(attributes && { attributes }),
    facts: {
      name: node.childForFieldName('name') ?? undefined,
      access,
      ...(isAsync(node) && { async: true }),
      decorators: leadingAttributes(node),
      parameters: parametersOf(node.childForFieldName('parameters')),
      returnType: node.childForFieldName('return_type') ?? undefined,
    },
  }
}

function classFacts(node: Node, access: Access | undefined, name = node.childForFieldName('name') ?? undefined): ClassFacts {
  return { name, access, decorators: leadingAttributes(node), typeParameters: [], bases: [], implements: [] }
}

/** impl 的自己的类型：impl Trait for Type 取 Type，impl Type 取 Type。 */
function implType(node: Node): Node | undefined {
  return node.childForFieldName('type') ?? node.childForFieldName('trait') ?? undefined
}

function shape(node: Node): { node: Node, header: { startIndex: number, endIndex: number, startRow: number, endRow: number }, children: CodeBlock[] } {
  const body = node.childForFieldName('body')
  return body ? { node, header: headerSpan(node, body.startIndex), children: [] } : { ...leafShape(node) }
}

function parametersOf(list: Node | null): ParameterFacts[] {
  if (!list)
    return []
  return named(list).flatMap((child) => {
    if (child.type === 'self_parameter') {
      const name = [...child.children].reverse().find(token => token?.type === 'self')
      return name ? [{ name, optional: false, type: child }] : []
    }
    if (child.type !== 'parameter')
      return []
    const name = child.childForFieldName('pattern')
    const type = child.childForFieldName('type') ?? undefined
    return name ? [{ name, optional: false, type }] : []
  })
}

function isAsync(node: Node): boolean {
  const modifiers = named(node).find(child => child.type === 'function_modifiers')
  return modifiers?.children.some(child => child?.type === 'async') ?? false
}

function rustTokenRole(leaf: Node): TokenRole {
  if (leaf.type === 'line_comment' || leaf.type === 'block_comment' || inside(leaf, 'line_comment') || inside(leaf, 'block_comment'))
    return 'comment'
  if (inside(leaf, 'string_literal') || leaf.type === 'string_content')
    return 'string'
  if (leaf.type === 'integer_literal' || leaf.type === 'float_literal' || leaf.type === 'char_literal')
    return 'number'
  if (leaf.type === 'primitive_type' || leaf.type === 'type_identifier')
    return 'type'
  if (leaf.type === 'mutable_specifier')
    return 'keyword'
  if (!leaf.isNamed)
    return STORAGE.has(leaf.type) ? 'storage' : /^[a-z]+$/.test(leaf.type) ? 'keyword' : 'plain'
  if (leaf.type === 'identifier' || leaf.type === 'field_identifier' || leaf.type === 'self') {
    const parent = leaf.parent?.type
    return parent === 'function_item' || parent === 'function_signature_item' ? 'function' : 'variable'
  }
  return 'plain'
}

function inside(node: Node, type: string): boolean {
  let current = node.parent
  while (current) {
    if (current.type === type)
      return true
    current = current.parent
  }
  return false
}