// 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.prepend_to_fn_body`. The helper is the seed primitive
// for the remaining prepend-style post_pass mutations
// (`inject_main_runtime_const_init_calls`, `inject_live_reload`): it re-emits
// a stmt_fn_decl with extras prepended to its body, returning the new
// FlatNodeId so callers can rewire the surrounding file/stmt list.
//
// We compare via `subtree_signature(fn_id)` rather than the whole-file
// `signature()` because the file root's `extra=intern(mod)` slot would leak
// intern order between the reference (which builds extras before file mod
// gets re-interned) and subject (which interns extras AFTER file mod) paths.

fn make_fn_decl_with_body(name string, body []Stmt) Stmt {
	return Stmt(FnDecl{
		name:  name
		stmts: body
	})
}

fn make_const_stmt(name string, value string) Stmt {
	return Stmt(ConstDecl{
		fields: [
			FieldInit{
				name:  name
				value: Expr(BasicLiteral{
					kind:  .number
					value: value
				})
			},
		]
	})
}

// Reference: emit a FnDecl whose body is already `[extras + old]`.
fn build_reference_fn_with_prepended() (FlatAst, FlatNodeId) {
	mut b := new_flat_builder()
	fn_id := b.emit_stmt(make_fn_decl_with_body('foo', [
		make_const_stmt('A', '1'),
		make_const_stmt('B', '2'),
		make_const_stmt('C', '3'),
	]))
	return b.flat, fn_id
}

// Subject: emit a FnDecl whose body is `[old]`, emit extras separately,
// then prepend via the primitive under test.
fn build_subject_fn_with_prepended() (FlatAst, FlatNodeId) {
	mut b := new_flat_builder()
	base_fn_id := b.emit_stmt(make_fn_decl_with_body('foo', [
		make_const_stmt('C', '3'),
	]))
	a_id := b.emit_stmt(make_const_stmt('A', '1'))
	b_id := b.emit_stmt(make_const_stmt('B', '2'))
	new_fn_id := b.prepend_to_fn_body(base_fn_id, [a_id, b_id])
	return b.flat, new_fn_id
}

fn test_prepend_to_fn_body_signature_matches_reference() {
	ref_flat, ref_fn_id := build_reference_fn_with_prepended()
	sub_flat, sub_fn_id := build_subject_fn_with_prepended()
	ref_sig := ref_flat.subtree_signature(ref_fn_id)
	sub_sig := sub_flat.subtree_signature(sub_fn_id)
	assert ref_sig == sub_sig
}

fn test_prepend_to_fn_body_zero_extras_returns_existing_id() {
	mut b := new_flat_builder()
	original_id := b.emit_stmt(make_fn_decl_with_body('foo', [
		make_const_stmt('C', '3'),
	]))
	returned_id := b.prepend_to_fn_body(original_id, [])
	assert returned_id == original_id
}

fn test_prepend_to_fn_body_invalid_id_returns_invalid() {
	mut b := new_flat_builder()
	a_id := b.emit_stmt(make_const_stmt('A', '1'))
	returned_id := b.prepend_to_fn_body(FlatNodeId(-1), [a_id])
	assert returned_id == invalid_flat_node_id
}

fn test_prepend_to_fn_body_non_fn_decl_returns_invalid() {
	// Pass a non-FnDecl node id (a ConstDecl) — primitive must refuse.
	mut b := new_flat_builder()
	const_id := b.emit_stmt(make_const_stmt('C', '3'))
	extra_id := b.emit_stmt(make_const_stmt('A', '1'))
	returned_id := b.prepend_to_fn_body(const_id, [extra_id])
	assert returned_id == invalid_flat_node_id
}

fn test_prepend_to_fn_body_empty_original_body() {
	// FnDecl with no original body stmts; prepending should still produce a
	// new FnDecl whose body is exactly the extras.
	ref_flat, ref_fn_id := fn () (FlatAst, FlatNodeId) {
		mut b := new_flat_builder()
		fn_id := b.emit_stmt(make_fn_decl_with_body('foo', [make_const_stmt('A', '1')]))
		return b.flat, fn_id
	}()

	mut sb := new_flat_builder()
	base_fn_id := sb.emit_stmt(make_fn_decl_with_body('foo', []))
	a_id := sb.emit_stmt(make_const_stmt('A', '1'))
	new_fn_id := sb.prepend_to_fn_body(base_fn_id, [a_id])

	assert ref_flat.subtree_signature(ref_fn_id) == sb.flat.subtree_signature(new_fn_id)
}