// Copyright (c) 2019-2024 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 c

import v.ast

enum AssertMetainfoKind {
	pass
	fail
	panic
}

fn (mut g Gen) assert_stmt(original_assert_statement ast.AssertStmt) {
	if !original_assert_statement.is_used {
		return
	}
	mut node := original_assert_statement
	g.writeln('// assert')

	mut save_left := ast.empty_expr
	mut save_right := ast.empty_expr

	if mut node.expr is ast.InfixExpr {
		// Don't extract subexpressions to ctemps for && and || operators,
		// as this would break short-circuit evaluation semantics.
		// The right side of && must only execute after the left side is true.
		if node.expr.op !in [.and, .logical_or] {
			mut left_expr_type := node.expr.left_type
			mut right_expr_type := node.expr.right_type
			if g.cur_fn != unsafe { nil } && g.cur_concrete_types.len > 0 {
				resolved_left_type := g.resolved_expr_type(node.expr.left, node.expr.left_type)
				if resolved_left_type != 0 {
					resolved_sym := g.table.sym(resolved_left_type)
					left_sym := g.table.sym(left_expr_type)
					if resolved_sym.kind !in [.sum_type, .interface]
						|| left_sym.kind in [.sum_type, .interface] {
						left_expr_type = resolved_left_type
					}
				}
				resolved_right_type := g.resolved_expr_type(node.expr.right, node.expr.right_type)
				if resolved_right_type != 0 {
					resolved_sym := g.table.sym(resolved_right_type)
					right_sym := g.table.sym(right_expr_type)
					if resolved_sym.kind !in [.sum_type, .interface]
						|| right_sym.kind in [.sum_type, .interface] {
						right_expr_type = resolved_right_type
					}
				}
			}
			if subst_expr := g.assert_subexpression_to_ctemp(node.expr.left, left_expr_type) {
				save_left = node.expr.left
				node.expr.left = subst_expr
			}
			// For || and && operators, do not pre-evaluate the right side
			// to allow short-circuit evaluation to work correctly.
			if node.expr.op !in [.logical_or, .and] {
				if subst_expr := g.assert_subexpression_to_ctemp(node.expr.right, right_expr_type) {
					save_right = node.expr.right
					node.expr.right = subst_expr
				}
			}
		}
	}
	metaname := g.gen_assert_metainfo_common(node)
	g.set_current_pos_as_last_stmt_pos()
	g.inside_ternary++
	if g.pref.is_test {
		g.write('if (')
		prev_inside_ternary := g.inside_ternary
		g.inside_ternary = 0
		g.expr(node.expr)
		g.inside_ternary = prev_inside_ternary
		g.write(')')
		g.decrement_inside_ternary()
		g.writeln(' {')
		g.gen_assert_metainfo(node, .pass, metaname)
		g.writeln('\tmain__TestRunner_name_table[test_runner._typ]._method_assert_pass(test_runner._object, &${metaname});')
		g.writeln('} else {')
		g.gen_assert_metainfo(node, .fail, metaname)
		g.writeln('\tmain__TestRunner_name_table[test_runner._typ]._method_assert_fail(test_runner._object, &${metaname});')
		g.gen_assert_postfailure_mode(node)
		g.writeln('}')
	} else {
		g.write('if (!(')
		prev_inside_ternary := g.inside_ternary
		g.inside_ternary = 0
		g.expr(node.expr)
		g.inside_ternary = prev_inside_ternary
		g.write('))')
		g.decrement_inside_ternary()
		g.writeln(' {')
		g.gen_assert_metainfo(node, .panic, metaname)
		g.writeln('\tbuiltin____print_assert_failure(&${metaname});')
		g.gen_assert_postfailure_mode(node)
		g.writeln('}')
	}

	if mut node.expr is ast.InfixExpr {
		restore_left := node.expr.left is ast.CTempVar
		restore_right := node.expr.right is ast.CTempVar
		if restore_left {
			node.expr.left = save_left
		}
		if restore_right {
			node.expr.right = save_right
		}
	}
}

fn (mut g Gen) assert_subexpression_to_ctemp(expr ast.Expr, expr_type ast.Type) ?ast.Expr {
	match expr {
		ast.CallExpr {
			return g.new_ctemp_var_then_gen(expr, expr_type)
		}
		ast.ParExpr {
			if expr.expr is ast.CallExpr {
				return g.new_ctemp_var_then_gen(ast.Expr(expr.expr), expr_type)
			}
		}
		ast.PostfixExpr {
			return g.new_ctemp_var_then_gen(expr, expr_type)
		}
		ast.SelectorExpr {
			if expr.expr is ast.CallExpr {
				sym := g.table.final_sym(g.unwrap_generic(expr.expr.return_type))
				if sym.kind == .struct {
					if (sym.info as ast.Struct).is_union {
						return none
					}
				}
				return g.new_ctemp_var_then_gen(expr, expr_type)
			}
			if g.need_tmp_var_in_expr(expr) {
				return g.new_ctemp_var_then_gen(expr, expr_type)
			}
		}
		ast.LockExpr {
			return g.new_ctemp_var_then_gen(expr, expr_type)
		}
		ast.ArrayInit {
			if expr.has_callexpr || g.need_tmp_var_in_expr(expr) {
				return g.new_ctemp_var_then_gen(expr, expr_type)
			}
		}
		ast.StructInit {
			if g.need_tmp_var_in_expr(expr) {
				return g.new_ctemp_var_then_gen(expr, expr_type)
			}
		}
		else {
			if g.need_tmp_var_in_expr(expr) {
				return g.new_ctemp_var_then_gen(expr, expr_type)
			}
		}
	}

	return none
}

fn (mut g Gen) gen_assert_postfailure_mode(node ast.AssertStmt) {
	g.write_v_source_line_info_stmt(node)
	if g.pref.assert_failure_mode == .continues
		|| g.fn_decl.attrs.any(it.name == 'assert_continues') {
		return
	}
	if g.pref.is_test && !g.inside_defer_generation && g.cur_fn != unsafe { nil }
		&& g.cur_fn.scope != unsafe { nil } {
		g.write_defer_stmts_when_needed(g.innermost_active_defer_scope(node.pos), true, node.pos)
	}
	if g.pref.assert_failure_mode == .aborts || g.fn_decl.attrs.any(it.name == 'assert_aborts') {
		g.writeln('\tabort();')
	}
	if g.pref.assert_failure_mode == .backtraces
		|| g.fn_decl.attrs.any(it.name == 'assert_backtraces') {
		if _ := g.table.fns['print_backtrace'] {
			g.writeln('\tbuiltin__print_backtrace();')
		}
	}
	if g.pref.is_test {
		g.writeln('\tlongjmp(g_jump_buffer, 1);')
	}
	if g.pref.assert_failure_mode != .continues {
		g.writeln('\tbuiltin___v_panic(_S("Assertion failed..."));')
	}
}

fn (mut g Gen) gen_assert_metainfo(node ast.AssertStmt, kind AssertMetainfoKind, metaname string) {
	if kind == .pass {
		return
	}
	if node.extra is ast.EmptyExpr {
		g.writeln('\t${metaname}.has_msg = false;')
		g.writeln('\t${metaname}.message = _SLIT0;')
	} else {
		g.writeln('\t${metaname}.has_msg = true;')
		g.write('\t${metaname}.message = ')
		g.gen_assert_single_expr(node.extra, ast.string_type)
		g.writeln(';')
	}
	match node.expr {
		ast.InfixExpr {
			mut left_type := if node.expr.left_ct_expr {
				g.type_resolver.get_type_or_default(node.expr.left, node.expr.left_type)
			} else {
				node.expr.left_type
			}
			mut right_type := if node.expr.right_ct_expr {
				g.type_resolver.get_type(node.expr.right)
			} else {
				node.expr.right_type
			}
			if g.cur_fn != unsafe { nil } && g.cur_concrete_types.len > 0 {
				resolved_left := g.resolved_expr_type(node.expr.left, node.expr.left_type)
				if resolved_left != 0 {
					resolved_sym := g.table.sym(resolved_left)
					left_sym := g.table.sym(left_type)
					if resolved_sym.kind !in [.sum_type, .interface]
						|| left_sym.kind in [.sum_type, .interface] {
						left_type = resolved_left
					}
				}
				resolved_right := g.resolved_expr_type(node.expr.right, node.expr.right_type)
				if resolved_right != 0 {
					resolved_sym := g.table.sym(resolved_right)
					right_sym := g.table.sym(right_type)
					if resolved_sym.kind !in [.sum_type, .interface]
						|| right_sym.kind in [.sum_type, .interface] {
						right_type = resolved_right
					}
				}
			}
			g.write('\t${metaname}.lvalue = ')
			g.gen_assert_single_expr(node.expr.left, left_type)
			g.writeln(';')
			// For && and || operators, use a placeholder for rvalue
			// to avoid issues with go_before_last_stmt() which can generate
			// temporary variables outside the conditional scope.
			// - For &&: if left is false, right is short-circuited
			// - For ||: if left is true, right is short-circuited
			if node.expr.op in [.logical_or, .and] {
				g.writeln('\t${metaname}.rvalue = _S("<short-circuited>");')
			} else {
				g.write('\t${metaname}.rvalue = ')
				g.gen_assert_single_expr(node.expr.right, right_type)
				g.writeln(';')
			}
		}
		else {}
	}
}

fn (mut g Gen) gen_assert_metainfo_common(node ast.AssertStmt) string {
	mod_path := cestring(g.file.path)
	fn_name := g.fn_decl.name
	line_nr := node.pos.line_nr
	mut src := node.expr.str()
	if node.extra !is ast.EmptyExpr {
		src += ', ' + node.extra.str()
	}
	src = cestring(src)
	metaname := 'v_assert_meta_info_${g.new_tmp_var()}'
	g.writeln('VAssertMetaInfo ${metaname} = {0};')
	g.writeln('${metaname}.fpath = ${ctoslit(mod_path)};')
	g.writeln('${metaname}.line_nr = ${line_nr};')
	g.writeln('${metaname}.fn_name = ${ctoslit(fn_name)};')
	metasrc := cnewlines(ctoslit(src))
	g.writeln('${metaname}.src = ${metasrc};')
	g.writeln('${metaname}.has_msg = false;')
	match node.expr {
		ast.InfixExpr {
			expr_op_str := ctoslit(node.expr.op.str())
			expr_left_str := cnewlines(ctoslit(node.expr.left.str()))
			expr_right_str := cnewlines(ctoslit(node.expr.right.str()))
			g.writeln('${metaname}.op = ${expr_op_str};')
			g.writeln('${metaname}.llabel = ${expr_left_str};')
			g.writeln('${metaname}.rlabel = ${expr_right_str};')
		}
		ast.CallExpr {
			g.writeln('${metaname}.op = _S("call");')
		}
		else {}
	}

	return metaname
}

fn (mut g Gen) gen_assert_single_expr(expr ast.Expr, typ ast.Type) {
	// eprintln('> gen_assert_single_expr typ: ${typ} | expr: ${expr} | typeof(expr): ${typeof(expr)}')
	expr_str := '${expr}'
	match expr {
		ast.CastExpr {
			if typ.is_float() || g.table.final_sym(typ).is_float() {
				g.gen_expr_to_string(expr.expr, typ)
			} else {
				g.write(ctoslit(expr_str))
			}
		}
		ast.ParExpr {
			g.gen_assert_single_expr(expr.expr, typ)
		}
		ast.IfExpr, ast.MatchExpr, ast.RangeExpr {
			g.write(ctoslit(expr_str))
		}
		ast.IndexExpr {
			g.gen_expr_to_string(expr, typ)
		}
		ast.PrefixExpr {
			if expr.right is ast.CastExpr {
				// TODO: remove this check;
				// vlib/builtin/map_test.v (a map of &int, set to &int(0)) fails
				// without special casing ast.CastExpr here
				g.write(ctoslit(expr_str))
			} else if expr.right is ast.Ident {
				g.write(ctoslit(expr_str))
			} else {
				g.gen_expr_to_string(expr, typ)
			}
		}
		ast.TypeNode {
			sym := g.table.sym(g.unwrap_generic(typ))
			g.write(ctoslit('${sym.name}'))
		}
		else {
			mut should_clone := true
			if typ == ast.string_type
				&& expr in [ast.IndexExpr, ast.CallExpr, ast.StringLiteral, ast.StringInterLiteral] {
				should_clone = false
			}
			if expr is ast.CTempVar && expr.orig is ast.CallExpr {
				should_clone = false
				if expr.orig.or_block.kind == .propagate_option {
					should_clone = true
				}
				if expr.orig.is_method && expr.orig.args.len == 0 && expr.orig.name == 'type_name' {
					should_clone = true
				}
			}
			if should_clone {
				g.write('builtin__string_clone(')
			}
			g.gen_expr_to_string(expr, typ)
			if should_clone {
				g.write(')')
			}
		}
	}
}