// 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 `FlatBuilder.append_flat` — the flat-to-flat merge primitive behind
// the flat parallel transform. It concatenates a whole `src` FlatAst into a
// builder, relocating node ids / edge targets and re-interning strings so the
// merged result decodes identically to `src` standalone. The key correctness
// risks: (1) node-id / edge relocation, (2) name_id string remap across a
// DIFFERENT intern order in the destination, (3) re-interning the three kinds
// whose `extra` slot holds a string id (file mod, stmt_directive value,
// stmt_import alias) while leaving packed-int extras (counts/flags) untouched.

fn make_ident_stmt(name string) Stmt {
	return Stmt(ExprStmt{
		expr: Expr(Ident{
			name: name
		})
	})
}

fn make_for_with_idents(names []string) Stmt {
	mut body := []Stmt{}
	for n in names {
		body << make_ident_stmt(n)
	}
	return Stmt(ForStmt{
		init:  Stmt(EmptyStmt{})
		cond:  Expr(BasicLiteral{
			kind:  .number
			value: '1'
		})
		stmts: body
	})
}

// build a small flat with a file root whose stmt list is `stmts`.
fn build_named_flat(file_name string, mod string, stmts []Stmt) (FlatBuilder, FlatNodeId) {
	mut b := new_flat_builder()
	mut ids := []FlatNodeId{}
	for s in stmts {
		ids << b.emit_stmt(s)
	}
	file_id := b.append_file_with_stmt_ids(File{
		name: file_name
		mod:  mod
	}, ids)
	return b, file_id
}

// Seed a destination builder with DIFFERENT strings so the src->dst string
// remap is non-trivial (src ids must not coincide with dst ids).
fn seeded_dst() FlatBuilder {
	mut dst := new_flat_builder()
	dst.intern('zzz_pre_a')
	dst.intern('zzz_pre_b')
	dst.intern('zzz_pre_c')
	dst.emit_stmt(make_ident_stmt('zzz_pre_d'))
	return dst
}

fn test_append_flat_preserves_subtree_structure_and_name_strings() {
	mut a, a_file := build_named_flat('a.v', 'main', [
		make_for_with_idents(['alpha', 'beta']),
		make_ident_stmt('gamma'),
	])
	// edge 2 of a .file node is the stmts list; rooting the signature there
	// avoids the intern-order-dependent .file `extra` slot.
	a_stmts := a.flat.child_at(a_file, 2)
	a_sig := a.flat.subtree_signature(a_stmts)

	mut dst := seeded_dst()
	pre_nodes := dst.flat.nodes.len
	pre_edges := dst.flat.edges.len

	off := dst.append_flat(a.flat)

	assert off == pre_nodes
	assert dst.flat.nodes.len == pre_nodes + a.flat.nodes.len
	assert dst.flat.edges.len == pre_edges + a.flat.edges.len
	// Structure + every interned ident/value survives the id+string relocation.
	assert dst.flat.subtree_signature(a_stmts + off) == a_sig
}

fn test_append_flat_two_sources_stay_independent() {
	mut a, a_file := build_named_flat('a.v', 'main', [
		make_for_with_idents(['alpha', 'beta']),
	])
	mut b, b_file := build_named_flat('b.v', 'other', [make_ident_stmt('delta'),
		make_ident_stmt('epsilon')])
	a_sig := a.flat.subtree_signature(a.flat.child_at(a_file, 2))
	b_sig := b.flat.subtree_signature(b.flat.child_at(b_file, 2))

	mut dst := seeded_dst()
	off_a := dst.append_flat(a.flat)
	off_b := dst.append_flat(b.flat)

	assert dst.flat.files.len == 2
	assert dst.flat.subtree_signature(a.flat.child_at(a_file, 2) + off_a) == a_sig
	assert dst.flat.subtree_signature(b.flat.child_at(b_file, 2) + off_b) == b_sig
	// b's offset accounts for everything already present (seed + a).
	assert off_b == off_a + a.flat.nodes.len
}

fn test_append_flat_reinterns_string_extra_kinds() {
	mut a := new_flat_builder()
	imp_id := a.emit_stmt(Stmt(ImportStmt{
		name:       'os'
		alias:      'myos'
		is_aliased: true
	}))
	dir_id := a.emit_stmt(Stmt(Directive{
		name:  'flag'
		value: '-lpthread'
	}))
	file_id := a.append_file_with_stmt_ids(File{
		name: 'a.v'
		mod:  'mymod'
	}, [imp_id, dir_id])

	mut dst := new_flat_builder()
	// Shift the intern table so src string ids differ from dst string ids.
	dst.intern('os')
	dst.intern('zzz')
	dst.intern('flag_other')
	dst.intern('unrelated_mod')

	off := dst.append_flat(a.flat)

	// stmt_import.alias lives in `extra` — must resolve to the merged table.
	merged_imp := Cursor{
		flat: &dst.flat
		id:   imp_id + off
	}.stmt() as ImportStmt
	assert merged_imp.name == 'os'
	assert merged_imp.alias == 'myos'
	assert merged_imp.is_aliased

	// stmt_directive.value lives in `extra`.
	merged_dir := Cursor{
		flat: &dst.flat
		id:   dir_id + off
	}.stmt() as Directive
	assert merged_dir.name == 'flag'
	assert merged_dir.value == '-lpthread'

	// file mod is carried both in FlatFile.mod_idx (decoder reads this) and in
	// the .file node's `extra` (must also be re-interned for consistency).
	mf := dst.flat.files[dst.flat.files.len - 1]
	assert dst.flat.string_at(mf.name_idx) == 'a.v'
	assert dst.flat.string_at(mf.mod_idx) == 'mymod'
	assert dst.flat.string_at(dst.flat.nodes[file_id + off].extra) == 'mymod'
}

fn test_append_flat_empty_source_is_noop() {
	mut dst := seeded_dst()
	pre_nodes := dst.flat.nodes.len
	pre_edges := dst.flat.edges.len
	pre_files := dst.flat.files.len
	empty := FlatAst{}
	off := dst.append_flat(&empty)
	assert off == pre_nodes
	assert dst.flat.nodes.len == pre_nodes
	assert dst.flat.edges.len == pre_edges
	assert dst.flat.files.len == pre_files
}

fn test_copy_subtree_from_preserves_stmt_shape_and_strings() {
	mut src := new_flat_builder()
	imp_id := src.emit_stmt(Stmt(ImportStmt{
		name:       'os'
		alias:      'myos'
		is_aliased: true
	}))
	dir_id := src.emit_stmt(Stmt(Directive{
		name:  'flag'
		value: '-lm'
	}))
	for_id := src.emit_stmt(make_for_with_idents(['alpha', 'beta']))

	mut dst := seeded_dst()
	copied_imp := dst.copy_subtree_from(&src.flat, imp_id)
	copied_dir := dst.copy_subtree_from(&src.flat, dir_id)
	copied_for := dst.copy_subtree_from(&src.flat, for_id)

	assert dst.flat.subtree_signature(copied_for) == src.flat.subtree_signature(for_id)

	merged_imp := Cursor{
		flat: &dst.flat
		id:   copied_imp
	}.stmt() as ImportStmt
	assert merged_imp.name == 'os'
	assert merged_imp.alias == 'myos'
	assert merged_imp.is_aliased

	merged_dir := Cursor{
		flat: &dst.flat
		id:   copied_dir
	}.stmt() as Directive
	assert merged_dir.name == 'flag'
	assert merged_dir.value == '-lm'
}

fn test_copy_subtree_from_invalid_root_returns_invalid() {
	mut src := new_flat_builder()
	mut dst := new_flat_builder()
	assert dst.copy_subtree_from(&src.flat, -1) == invalid_flat_node_id
	assert dst.copy_subtree_from(&src.flat, 100) == invalid_flat_node_id
}