// 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 cleanc

import v2.ast

fn const_bool_value(expr ast.Expr) ?bool {
	match expr {
		ast.BasicLiteral {
			if expr.kind == .key_true {
				return true
			}
			if expr.kind == .key_false {
				return false
			}
			if expr.value == 'true' {
				return true
			}
			if expr.value == 'false' {
				return false
			}
		}
		ast.Ident {
			if expr.name == 'true' {
				return true
			}
			if expr.name == 'false' {
				return false
			}
		}
		ast.Keyword {
			if expr.tok == .key_true {
				return true
			}
			if expr.tok == .key_false {
				return false
			}
		}
		ast.ParenExpr {
			return const_bool_value(expr.expr)
		}
		ast.ModifierExpr {
			return const_bool_value(expr.expr)
		}
		ast.CastExpr {
			return const_bool_value(expr.expr)
		}
		ast.ComptimeExpr {
			return const_bool_value(expr.expr)
		}
		ast.UnsafeExpr {
			if expr.stmts.len == 1 && expr.stmts[0] is ast.ExprStmt {
				stmt := expr.stmts[0] as ast.ExprStmt
				return const_bool_value(stmt.expr)
			}
		}
		ast.PrefixExpr {
			if expr.op == .not {
				if v := const_bool_value(expr.expr) {
					return !v
				}
			}
		}
		else {}
	}

	return none
}

fn (mut g Gen) gen_if_expr_assign_value(name string, value_type string, expr ast.Expr) {
	g.write_indent()
	if value_type.starts_with('Array_fixed_') && !value_type.ends_with('*') {
		if expr is ast.CallExpr {
			if call_ret := g.get_call_return_type(expr.lhs, expr.args) {
				if call_ret == value_type {
					wrapper_type := g.c_fn_return_type_from_v(value_type)
					g.sb.write_string('{ ${wrapper_type} _tmp = ')
					g.expr(expr)
					g.sb.writeln('; memcpy(${name}, _tmp.ret_arr, sizeof(${value_type})); }')
					return
				}
			}
		}
		g.sb.write_string('memcpy(${name}, ')
		if expr is ast.ArrayInitExpr {
			g.sb.write_string('((${value_type})')
			g.expr(expr)
			g.sb.write_string(')')
		} else {
			g.expr(expr)
		}
		g.sb.writeln(', sizeof(${value_type}));')
		return
	}
	g.sb.write_string('${name} = ')
	if g.get_sum_type_variants_for(value_type).len > 0 {
		g.gen_type_cast_expr(value_type, expr)
	} else {
		g.expr(expr)
	}
	g.sb.writeln(';')
}

fn (mut g Gen) gen_decl_if_expr_branch(name string, value_type string, stmts []ast.Stmt) {
	last_idx := last_non_empty_stmt_index(stmts)
	if last_idx < 0 {
		return
	}
	for i, stmt in stmts {
		if stmt is ast.EmptyStmt {
			continue
		}
		if i == last_idx && stmt is ast.ExprStmt {
			if stmt.expr is ast.IfExpr {
				nested_if := stmt.expr as ast.IfExpr
				if !g.if_expr_can_be_ternary(&nested_if) && nested_if.else_expr !is ast.EmptyExpr {
					g.gen_decl_if_expr(name, value_type, &nested_if)
					continue
				}
				if nested_if.else_expr is ast.EmptyExpr {
					if payload_expr := g.unsafe_expr_or_payload_value(stmts) {
						g.gen_stmt(stmt)
						g.gen_if_expr_assign_value(name, value_type, payload_expr)
						continue
					}
				}
			}
			// When the last expression is a void call (e.g. array__push from <<),
			// emit it as a standalone statement without assigning to the temp var.
			if g.expr_is_void_call(stmt.expr) {
				g.write_indent()
				g.expr(stmt.expr)
				g.sb.writeln(';')
			} else {
				g.gen_if_expr_assign_value(name, value_type, stmt.expr)
			}
		} else {
			g.gen_stmt(stmt)
		}
	}
}

fn (mut g Gen) gen_scoped_decl_if_expr_branch(name string, value_type string, stmts []ast.Stmt) {
	saved_runtime_local_types := g.runtime_local_types.clone()
	saved_runtime_decl_types := g.runtime_decl_types.clone()
	saved_not_local_var_cache := g.not_local_var_cache.clone()
	g.gen_decl_if_expr_branch(name, value_type, stmts)
	g.runtime_local_types = saved_runtime_local_types.clone()
	g.runtime_decl_types = saved_runtime_decl_types.clone()
	g.not_local_var_cache = saved_not_local_var_cache.clone()
}

// expr_is_void_call checks if the expression is a function call that returns void.
// Used to prevent assigning void results to temp variables in if-expression branches.
fn (mut g Gen) expr_is_void_call(expr ast.Expr) bool {
	if expr is ast.CallExpr {
		if ret := g.get_call_return_type(expr.lhs, expr.args) {
			return ret == 'void'
		}
		// Check resolved name
		c_name := g.resolve_call_name(expr.lhs, expr.args.len)
		if c_name != '' {
			if ret := g.fn_return_types[c_name] {
				return ret == 'void'
			}
		}
		// panic/v_panic always returns void (noreturn)
		if expr.lhs is ast.Ident {
			if expr.lhs.name in ['panic', 'v_panic'] {
				return true
			}
		}
	}
	return false
}

fn (mut g Gen) gen_decl_if_expr(name string, value_type string, if_expr &ast.IfExpr) {
	if if_expr.cond is ast.EmptyExpr {
		g.gen_scoped_decl_if_expr_branch(name, value_type, if_expr.stmts)
		return
	}
	g.write_indent()
	g.sb.write_string('if (')
	g.expr(if_expr.cond)
	g.sb.writeln(') {')
	g.indent++
	g.gen_scoped_decl_if_expr_branch(name, value_type, if_expr.stmts)
	g.indent--
	g.write_indent()
	g.sb.write_string('}')
	if if_expr.else_expr is ast.IfExpr {
		else_if := if_expr.else_expr as ast.IfExpr
		if else_if.cond is ast.EmptyExpr {
			g.sb.writeln(' else {')
			g.indent++
			g.gen_scoped_decl_if_expr_branch(name, value_type, else_if.stmts)
			g.indent--
			g.write_indent()
			g.sb.writeln('}')
		} else {
			g.sb.writeln(' else {')
			g.indent++
			g.gen_decl_if_expr(name, value_type, &else_if)
			g.indent--
			g.write_indent()
			g.sb.writeln('}')
		}
	} else if if_expr.else_expr !is ast.EmptyExpr {
		g.sb.writeln(' else {')
		g.indent++
		g.gen_if_expr_assign_value(name, value_type, if_expr.else_expr)
		g.indent--
		g.write_indent()
		g.sb.writeln('}')
	} else {
		g.sb.writeln('')
	}
}

fn (mut g Gen) gen_return_if_branch(stmts []ast.Stmt) {
	if stmts.len == 0 {
		return
	}
	for i, stmt in stmts {
		if i == stmts.len - 1 && stmt is ast.ExprStmt {
			if stmt.expr is ast.IfExpr {
				nested_if := stmt.expr as ast.IfExpr
				if !g.if_expr_can_be_ternary(&nested_if) && nested_if.else_expr !is ast.EmptyExpr {
					g.gen_return_if_expr(nested_if, true)
					continue
				}
			}
			mut ret_exprs := []ast.Expr{cap: 1}
			ret_exprs << stmt.expr
			ret_stmt := ast.ReturnStmt{
				exprs: ret_exprs
			}
			prev_suppress := g.suppress_return_drop_emit
			g.suppress_return_drop_emit = true
			g.gen_stmt(ret_stmt)
			g.suppress_return_drop_emit = prev_suppress
		} else {
			g.gen_stmt(stmt)
		}
	}
}

fn (mut g Gen) gen_return_if_expr(if_expr ast.IfExpr, emit_indent bool) {
	if if_expr.cond is ast.EmptyExpr {
		g.gen_return_if_branch(if_expr.stmts)
		return
	}
	if emit_indent {
		g.write_indent()
	}
	g.sb.write_string('if (')
	g.expr(if_expr.cond)
	g.sb.writeln(') {')
	g.indent++
	g.gen_return_if_branch(if_expr.stmts)
	g.indent--
	g.write_indent()
	g.sb.write_string('}')
	if if_expr.else_expr is ast.IfExpr {
		else_if := if_expr.else_expr as ast.IfExpr
		if else_if.cond is ast.EmptyExpr {
			g.sb.writeln(' else {')
			g.indent++
			g.gen_return_if_branch(else_if.stmts)
			g.indent--
			g.write_indent()
			g.sb.writeln('}')
		} else {
			g.sb.writeln(' else {')
			g.indent++
			g.gen_return_if_expr(else_if, true)
			g.indent--
			g.write_indent()
			g.sb.writeln('}')
		}
	} else if if_expr.else_expr !is ast.EmptyExpr {
		g.sb.writeln(' else {')
		g.indent++
		mut else_exprs := []ast.Expr{cap: 1}
		else_exprs << if_expr.else_expr
		else_stmt := ast.ReturnStmt{
			exprs: else_exprs
		}
		prev_suppress := g.suppress_return_drop_emit
		g.suppress_return_drop_emit = true
		g.gen_stmt(else_stmt)
		g.suppress_return_drop_emit = prev_suppress
		g.indent--
		g.write_indent()
		g.sb.writeln('}')
	} else {
		g.sb.writeln('')
	}
}

fn (g &Gen) if_expr_can_be_ternary(node &ast.IfExpr) bool {
	if node.cond !is ast.EmptyExpr {
		if node.stmts.len != 1 || node.stmts[0] !is ast.ExprStmt {
			return false
		}
		if node.else_expr is ast.EmptyExpr {
			return false
		}
	}
	if node.cond is ast.EmptyExpr {
		return node.stmts.len == 1 && node.stmts[0] is ast.ExprStmt
	}
	if node.else_expr is ast.IfExpr {
		else_if := node.else_expr as ast.IfExpr
		return g.if_expr_can_be_ternary(&else_if)
	}
	return true
}

fn (g &Gen) extract_if_expr(expr ast.Expr) ?ast.IfExpr {
	match expr {
		ast.IfExpr {
			return expr
		}
		ast.ParenExpr {
			return g.extract_if_expr(expr.expr)
		}
		ast.ModifierExpr {
			return g.extract_if_expr(expr.expr)
		}
		ast.UnsafeExpr {
			if expr.stmts.len == 1 {
				stmt0 := expr.stmts[0]
				if stmt0 is ast.ExprStmt {
					expr_stmt := stmt0 as ast.ExprStmt
					return g.extract_if_expr(expr_stmt.expr)
				}
			}
			return none
		}
		else {
			return none
		}
	}
}

fn last_non_empty_stmt_index(stmts []ast.Stmt) int {
	mut idx := stmts.len - 1
	for idx >= 0 && stmts[idx] is ast.EmptyStmt {
		idx--
	}
	return idx
}

fn (mut g Gen) branch_result_type(stmts []ast.Stmt) string {
	last_idx := last_non_empty_stmt_index(stmts)
	if last_idx < 0 {
		return ''
	}
	last := stmts[last_idx]
	match last {
		ast.BlockStmt {
			return g.branch_result_type(last.stmts)
		}
		ast.ExprStmt {
			if nested := g.extract_if_expr(last.expr) {
				return g.get_if_expr_type(&nested)
			}
			mut typ := g.get_expr_type(last.expr)
			if (typ == '' || typ == 'int' || typ == 'void*' || typ == 'voidptr')
				&& last.expr is ast.Ident {
				if local_typ := g.branch_declared_ident_type(stmts, last_idx, last.expr.name) {
					typ = local_typ
				}
			}
			if typ == '' || typ == 'int' || typ == 'void*' || typ == 'voidptr' {
				if raw := g.get_raw_type(last.expr) {
					raw_type := g.types_type_to_c(raw)
					if raw_type != '' && raw_type != 'void*' && raw_type != 'voidptr' {
						typ = raw_type
					}
				}
			}
			return typ
		}
		else {
			return ''
		}
	}
}

fn (mut g Gen) branch_declared_ident_type(stmts []ast.Stmt, before_idx int, name string) ?string {
	if name == '' {
		return none
	}
	mut i := before_idx - 1
	for i >= 0 {
		stmt := stmts[i]
		if stmt is ast.AssignStmt {
			if stmt.op == .decl_assign && stmt.lhs.len == stmt.rhs.len {
				for j, lhs in stmt.lhs {
					if lhs is ast.Ident && lhs.name == name {
						mut typ := g.get_expr_type(stmt.rhs[j])
						if typ == '' || typ == 'int' || typ == 'void*' || typ == 'voidptr' {
							if raw := g.get_raw_type(stmt.rhs[j]) {
								raw_type := g.types_type_to_c(raw)
								if raw_type != '' && raw_type != 'void*' && raw_type != 'voidptr' {
									typ = raw_type
								}
							}
						}
						if typ != '' && typ != 'int' && typ != 'void*' && typ != 'voidptr' {
							return typ
						}
					}
				}
			}
		}
		i--
	}
	return none
}

fn (mut g Gen) gen_if_expr_stmt(node &ast.IfExpr) {
	// Skip empty conditions (pure else blocks shouldn't appear at top level)
	if node.cond is ast.EmptyExpr {
		return
	}
	if cond_value := const_bool_value(node.cond) {
		if cond_value {
			g.gen_scoped_stmts(node.stmts)
			return
		}
		if node.else_expr is ast.IfExpr {
			else_if := node.else_expr as ast.IfExpr
			if else_if.cond is ast.EmptyExpr {
				g.gen_scoped_stmts(else_if.stmts)
			} else {
				g.gen_if_expr_stmt(&else_if)
			}
		} else if node.else_expr !is ast.EmptyExpr {
			g.gen_scoped_expr_stmts(node.else_expr)
		}
		return
	}
	g.sb.write_string('if (')
	g.expr(node.cond)
	g.sb.writeln(') {')
	g.indent++
	g.gen_scoped_stmts(node.stmts)
	g.indent--
	g.write_indent()
	g.sb.write_string('}')
	// Handle else / else-if
	if node.else_expr !is ast.EmptyExpr {
		if node.else_expr is ast.IfExpr {
			else_if := node.else_expr as ast.IfExpr
			if else_if.cond is ast.EmptyExpr {
				g.sb.writeln(' else {')
				g.indent++
				g.gen_scoped_stmts(else_if.stmts)
				g.indent--
				g.write_indent()
				g.sb.write_string('}')
			} else {
				g.sb.write_string(' else ')
				g.gen_if_expr_stmt(&else_if)
			}
		} else {
			g.sb.writeln(' else {')
			g.indent++
			g.gen_scoped_expr_stmts(node.else_expr)
			g.indent--
			g.write_indent()
			g.sb.write_string('}')
		}
	}
	g.sb.writeln('')
}

fn (mut g Gen) gen_if_expr_ternary(node &ast.IfExpr) {
	if node.cond is ast.EmptyExpr {
		if node.stmts.len == 1 && node.stmts[0] is ast.ExprStmt {
			stmt := node.stmts[0] as ast.ExprStmt
			g.expr(stmt.expr)
		} else {
			g.sb.write_string('0')
		}
		return
	}
	g.sb.write_string('(')
	g.expr(node.cond)
	g.sb.write_string(' ? ')
	if node.stmts.len == 1 && node.stmts[0] is ast.ExprStmt {
		stmt := node.stmts[0] as ast.ExprStmt
		if nested := g.extract_if_expr(stmt.expr) {
			g.gen_if_expr_value(&nested)
		} else {
			g.expr(stmt.expr)
		}
	} else {
		g.sb.write_string('0')
	}
	g.sb.write_string(' : ')
	if node.else_expr is ast.IfExpr {
		else_if := node.else_expr as ast.IfExpr
		g.gen_if_expr_value(&else_if)
	} else if node.else_expr is ast.EmptyExpr {
		g.sb.write_string('0')
	} else {
		if nested := g.extract_if_expr(node.else_expr) {
			g.gen_if_expr_value(&nested)
		} else {
			g.expr(node.else_expr)
		}
	}
	g.sb.write_string(')')
}

fn (mut g Gen) gen_if_expr_value(node &ast.IfExpr) {
	mut value_type := g.get_if_expr_type(node)
	if value_type == '' || value_type == 'void' {
		g.sb.write_string('({ ')
		g.gen_if_expr_stmt(node)
		g.sb.write_string('; 0; })')
		return
	}
	if value_type == 'int_literal' {
		value_type = 'int'
	}
	tmp_name := '_if_expr_t${g.tmp_counter}'
	g.tmp_counter++
	g.sb.write_string('({ ${value_type} ${tmp_name} = ${zero_value_for_type(value_type)}; ')
	g.gen_decl_if_expr(tmp_name, value_type, node)
	if value_type.starts_with('Array_fixed_') && !value_type.ends_with('*') {
		_, fixed_len := parse_fixed_array_elem_type(value_type)
		if fixed_len > 0 {
			g.sb.write_string(' (${value_type}){')
			for i in 0 .. fixed_len {
				if i > 0 {
					g.sb.write_string(', ')
				}
				g.sb.write_string('${tmp_name}[${i}]')
			}
			g.sb.write_string('}; })')
			return
		}
	}
	g.sb.write_string(' ${tmp_name}; })')
}

fn (mut g Gen) get_if_expr_type(node &ast.IfExpr) string {
	mut env_type := ''
	if t := g.get_expr_type_from_env(ast.Expr(*node)) {
		if t != '' {
			env_type = t
		}
	}
	mut branch_type := g.branch_result_type(node.stmts)
	if branch_type == 'int_literal' {
		branch_type = 'int'
	}
	mut else_type := ''
	if node.else_expr is ast.IfExpr {
		else_if := node.else_expr as ast.IfExpr
		else_type = g.get_if_expr_type(&else_if)
	} else if node.else_expr !is ast.EmptyExpr {
		if nested := g.extract_if_expr(node.else_expr) {
			else_type = g.get_if_expr_type(&nested)
		} else {
			else_type = g.get_expr_type(node.else_expr)
			if else_type == '' || else_type == 'int' || else_type == 'void*'
				|| else_type == 'voidptr' {
				if raw := g.get_raw_type(node.else_expr) {
					raw_type := g.types_type_to_c(raw)
					if raw_type != '' && raw_type != 'void*' && raw_type != 'voidptr' {
						else_type = raw_type
					}
				}
			}
		}
	}
	if else_type == 'int_literal' {
		else_type = 'int'
	}
	if branch_type != '' && else_type != '' && branch_type == else_type {
		if branch_type != 'int' || env_type == '' || env_type == 'int' || env_type == 'void*'
			|| env_type == 'voidptr' {
			return branch_type
		}
	}
	if branch_type != '' && branch_type != 'int' {
		if env_type == '' || env_type == 'int' || branch_type.starts_with('${env_type}_T_') {
			return branch_type
		}
	}
	if env_type != '' {
		if g.cur_fn_ret_type.starts_with('${env_type}_T_') {
			return g.cur_fn_ret_type
		}
		return env_type
	}
	if else_type != '' {
		return else_type
	}
	return 'int'
}

// expr_produces_pointer checks if an expression produces a pointer value in C.
// More comprehensive than expr_is_pointer - handles casts, pointer arithmetic, etc.
// Used in gen_call_arg to avoid wrapping pointer expressions in compound literals.