// Copyright (c) 2026 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module ast

// Tests for the Cursor API live alongside the implementation since they
// operate on hand-built FlatAst fixtures — building them via the parser
// would introduce a circular dep (parser depends on ast). The fixtures
// mirror the shape that parse_file emits for a few representative inputs.

// build_minimal_file constructs a FlatAst with one file containing:
//   module foo
//   fn add(a int, b int) int { return a + b }
// using the FlatBuilder API directly. We then exercise Cursor over it.
fn build_minimal_file() FlatAst {
	mut b := new_flat_builder()
	src := File{
		name:  'inline_minimal.v'
		mod:   'foo'
		stmts: [
			Stmt(ModuleStmt{
				name: 'foo'
			}),
			Stmt(FnDecl{
				name:  'add'
				typ:   FnType{
					params:      [
						Parameter{
							name: 'a'
							typ:  Expr(Ident{
								name: 'int'
							})
						},
						Parameter{
							name: 'b'
							typ:  Expr(Ident{
								name: 'int'
							})
						},
					]
					return_type: Expr(Ident{
						name: 'int'
					})
				}
				stmts: [
					Stmt(ReturnStmt{
						exprs: [
							Expr(InfixExpr{
								op:  .plus
								lhs: Expr(Ident{
									name: 'a'
								})
								rhs: Expr(Ident{
									name: 'b'
								})
							}),
						]
					}),
				]
			}),
		]
	}
	b.append_file(src)
	return b.flat
}

fn test_file_cursor_basics() {
	flat := build_minimal_file()
	assert flat.files.len == 1
	fc := flat.file_cursor(0)
	assert fc.name() == 'inline_minimal.v'
	assert fc.mod() == 'foo'
	root := fc.root()
	assert root.is_valid()
	assert root.kind() == .file
}

fn test_file_cursor_stmts_iteration() {
	flat := build_minimal_file()
	fc := flat.file_cursor(0)
	stmts := fc.stmts()
	// module decl + fn decl
	assert stmts.len() == 2
	assert stmts.at(0).kind() == .stmt_module
	assert stmts.at(0).name() == 'foo'
	assert stmts.at(1).kind() == .stmt_fn_decl
	assert stmts.at(1).name() == 'add'
}

fn test_fn_decl_flags_and_body() {
	flat := build_minimal_file()
	fc := flat.file_cursor(0)
	fn_cur := fc.stmts().at(1)
	assert fn_cur.kind() == .stmt_fn_decl
	// is_method/is_public/is_static all false for plain `fn add(...)`
	assert !fn_cur.flag(flag_is_method)
	assert !fn_cur.flag(flag_is_public)
	assert !fn_cur.flag(flag_is_static)
	// edge layout per read_stmt: 0=receiver, 1=typ, 2=attrs, 3=stmts(aux_list)
	stmts := fn_cur.list_at(3)
	assert stmts.len() == 1
	ret := stmts.at(0)
	assert ret.kind() == .stmt_return
}

fn test_fn_decl_signature_from_cursor() {
	flat := build_minimal_file()
	fn_cur := flat.file_cursor(0).stmts().at(1)
	decl := fn_cur.fn_decl_signature()
	assert decl.name == 'add'
	assert !decl.is_method
	assert decl.stmts.len == 0
	assert decl.typ.params.len == 2
	assert decl.typ.params[0].name == 'a'
	assert decl.typ.params[0].typ is Ident
	assert (decl.typ.params[0].typ as Ident).name == 'int'
	assert decl.typ.params[1].name == 'b'
	assert decl.typ.return_type is Ident
	assert (decl.typ.return_type as Ident).name == 'int'
}

fn test_fn_decl_from_cursor_reads_body() {
	flat := build_minimal_file()
	fn_cur := flat.file_cursor(0).stmts().at(1)
	decl := fn_cur.fn_decl()
	assert decl.name == 'add'
	assert decl.stmts.len == 1
	assert decl.stmts[0] is ReturnStmt
}

fn test_stmt_and_expr_escape_hatches_from_cursor() {
	flat := build_minimal_file()
	ret_cur := flat.file_cursor(0).stmts().at(1).list_at(3).at(0)
	ret_stmt := ret_cur.stmt()
	assert ret_stmt is ReturnStmt
	infix_expr := ret_cur.edge(0).expr()
	assert infix_expr is InfixExpr
	assert (infix_expr as InfixExpr).op == .plus
}

fn test_return_stmt_exprs_via_edges() {
	flat := build_minimal_file()
	fc := flat.file_cursor(0)
	ret := fc.stmts().at(1).list_at(3).at(0)
	assert ret.kind() == .stmt_return
	// ReturnStmt stores its exprs as direct edges of the parent (not aux_list)
	assert ret.edge_count() == 1
	infix := ret.edge(0)
	assert infix.kind() == .expr_infix
	// InfixExpr edges: 0=lhs, 1=rhs (per read_expr)
	assert infix.edge_count() == 2
	lhs := infix.edge(0)
	rhs := infix.edge(1)
	assert lhs.kind() == .expr_ident
	assert lhs.name() == 'a'
	assert rhs.kind() == .expr_ident
	assert rhs.name() == 'b'
}

fn test_invalid_cursor_sentinels() {
	flat := build_minimal_file()
	fc := flat.file_cursor(0)
	bogus := fc.stmts().at(99) // out of range
	assert !bogus.is_valid()
	bogus_edge := fc.root().edge(99) // out of range
	assert !bogus_edge.is_valid()
	empty_list := fc.root().list_at(99)
	assert empty_list.len() == 0
}

fn test_type_expr_from_cursor_reads_signature_types() {
	mut b := new_flat_builder()
	src := File{
		name:  'inline_type_expr.v'
		mod:   'foo'
		stmts: [
			Stmt(ModuleStmt{
				name: 'foo'
			}),
			Stmt(FnDecl{
				name: 'use_box'
				typ:  FnType{
					params:      [
						Parameter{
							name: 'items'
							typ:  Expr(Type(ArrayType{
								elem_type: Expr(GenericArgs{
									lhs:  Expr(Ident{
										name: 'Box'
									})
									args: [
										Expr(Ident{
											name: 'int'
										}),
									]
								})
							}))
						},
					]
					return_type: Expr(Type(OptionType{
						base_type: Expr(Ident{
							name: 'string'
						})
					}))
				}
			}),
		]
	}
	b.append_file(src)
	fn_cur := b.flat.file_cursor(0).stmts().at(1)
	fn_type := fn_cur.edge(1)
	params := fn_type.list_at(1)
	param_typ := params.at(0).edge(0).type_expr()
	assert param_typ is Type
	array_typ := param_typ as Type
	assert array_typ is ArrayType
	array_expr := array_typ as ArrayType
	assert array_expr.elem_type is GenericArgs
	generic := array_expr.elem_type as GenericArgs
	assert generic.lhs is Ident
	assert (generic.lhs as Ident).name == 'Box'
	assert generic.args.len == 1
	assert generic.args[0] is Ident
	assert (generic.args[0] as Ident).name == 'int'
	return_typ := fn_type.edge(2).type_expr()
	assert return_typ is Type
	option_typ := return_typ as Type
	assert option_typ is OptionType
	option_expr := option_typ as OptionType
	assert option_expr.base_type is Ident
	assert (option_expr.base_type as Ident).name == 'string'
}

fn test_decl_readers_from_cursor() {
	mut b := new_flat_builder()
	src := File{
		name:  'inline_decl_readers.v'
		mod:   'foo'
		stmts: [
			Stmt(ModuleStmt{
				name: 'foo'
			}),
			Stmt(ConstDecl{
				fields: [
					FieldInit{
						name:  'answer'
						value: Expr(BasicLiteral{
							kind:  .number
							value: '42'
						})
					},
				]
			}),
			Stmt(EnumDecl{
				name:       'Mode'
				attributes: [
					Attribute{
						name: 'flag'
					},
				]
				fields:     [
					FieldDecl{
						name:  'read'
						value: Expr(BasicLiteral{
							kind:  .number
							value: '1'
						})
					},
				]
			}),
			Stmt(StructDecl{
				name:       'Person'
				attributes: [
					Attribute{
						name: 'heap'
					},
				]
				fields:     [
					FieldDecl{
						name:       'name'
						typ:        Expr(Ident{
							name: 'string'
						})
						value:      Expr(StringLiteral{
							value: 'unknown'
						})
						attributes: [
							Attribute{
								name:  'json'
								value: Expr(StringLiteral{
									value: 'full_name'
								})
							},
						]
						is_public:  true
					},
				]
			}),
		]
	}
	b.append_file(src)
	stmts := b.flat.file_cursor(0).stmts()
	const_decl := stmts.at(1).const_decl()
	assert const_decl.fields.len == 1
	assert const_decl.fields[0].name == 'answer'
	assert const_decl.fields[0].value is BasicLiteral
	assert (const_decl.fields[0].value as BasicLiteral).value == '42'
	enum_decl := stmts.at(2).enum_decl(true)
	assert enum_decl.name == 'Mode'
	assert enum_decl.attributes.has('flag')
	assert enum_decl.fields.len == 1
	assert enum_decl.fields[0].value is BasicLiteral
	assert (enum_decl.fields[0].value as BasicLiteral).value == '1'
	struct_decl := stmts.at(3).struct_decl()
	assert struct_decl.name == 'Person'
	assert struct_decl.attributes.has('heap')
	assert struct_decl.fields.len == 1
	assert struct_decl.fields[0].name == 'name'
	assert struct_decl.fields[0].is_public
	assert struct_decl.fields[0].typ is Ident
	assert (struct_decl.fields[0].typ as Ident).name == 'string'
	assert struct_decl.fields[0].value is StringLiteral
	assert (struct_decl.fields[0].value as StringLiteral).value == 'unknown'
	assert struct_decl.fields[0].attributes.len == 1
	assert struct_decl.fields[0].attributes[0].name == 'json'
	assert struct_decl.fields[0].attributes[0].value is StringLiteral
	assert (struct_decl.fields[0].attributes[0].value as StringLiteral).value == 'full_name'
}

// count_unique_kinds_via_cursor walks the whole graph rooted at fc through
// edges with dedup (the FlatBuilder shares aux_list nodes for empty lists,
// so a naive DFS revisits them). Used to cross-check that Cursor traversal
// reaches every reachable node in the FlatAst.
fn count_unique_kinds_via_cursor(fc FileCursor) (map[string]int, int) {
	flat := fc.flat
	mut seen := []bool{len: flat.nodes.len}
	mut out := map[string]int{}
	mut stack := []Cursor{cap: 64}
	mut unique := 0
	stack << fc.root()
	for stack.len > 0 {
		c := stack.pop()
		if !c.is_valid() || seen[c.id] {
			continue
		}
		seen[c.id] = true
		unique++
		out[c.kind().str()]++
		for i in 0 .. c.edge_count() {
			stack << c.edge(i)
		}
	}
	return out, unique
}

fn test_cursor_walk_matches_reachable_count() {
	flat := build_minimal_file()
	_, unique := count_unique_kinds_via_cursor(flat.file_cursor(0))
	// Walking from the single file root via Cursor must reach the same
	// set of unique nodes as the reference reachability walker.
	assert unique == flat.count_reachable_nodes()
}