// 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
import strings

fn (mut g Gen) gen_string_inter_literal(node ast.StringInterLiteral) {
	if g.is_freestanding_target() {
		g.sb.write_string(g.c_freestanding_missing_format_string_expr())
		return
	}
	// Two-pass snprintf: first into a 256-byte stack buffer to measure,
	// then use it directly or heap-allocate only when it doesn't fit.
	// This avoids the unconditional heap allocation of asprintf.
	// Wrapped in GCC compound expression ({ ... })
	mut fmt_str := strings.new_builder(64)
	for i, raw_val in node.values {
		mut val := raw_val
		// Strip only the outer string delimiters. Using trim_* here can over-strip
		// escaped quotes in edge chunks like: 'A "${x}"', leaving a trailing `\`.
		if i == 0 && val.len > 0 && val[0] in [`'`, `"`] {
			val = val[1..]
		}
		if i == node.values.len - 1 && val.len > 0 && val[val.len - 1] in [`'`, `"`] {
			val = val[..val.len - 1]
		}
		escaped := val.replace('%', '%%').replace('\t', '\\t')
		fmt_str.write_string(escaped)
		if i < node.inters.len {
			inter := node.inters[i]
			fmt_str.write_string(g.get_sprintf_format(inter))
		}
	}
	fmt_lit := c_string_literal_content_to_c(fmt_str.str())

	// Build the argument list string once (used in both snprintf calls).
	// write_sprintf_arg writes to g.sb, so we temporarily swap it out,
	// capture the result, and restore it.
	mut args_sb := strings.new_builder(64)
	for inter in node.inters {
		args_sb.write_string(', ')
		saved := g.sb
		g.sb = strings.new_builder(64)
		g.write_sprintf_arg(inter)
		arg_str := g.sb.str()
		g.sb = saved
		args_sb.write_string(arg_str)
	}
	args_str := args_sb.str()

	// Emit: try stack buffer first, fall back to malloc only if needed.
	g.sb.write_string('({ char _sib[256]; int _sil = snprintf(_sib, sizeof(_sib), ${fmt_lit}${args_str}); ')
	g.sb.write_string('char* _sip; if (_sil < (int)sizeof(_sib)) { _sip = memdup(_sib, _sil + 1); } ')
	g.sb.write_string('else { _sip = (char*)malloc(_sil + 1); snprintf(_sip, _sil + 1, ${fmt_lit}${args_str}); } ')
	g.sb.write_string('${c_v_string_expr_from_ptr_len('_sip', '_sil', false)}; })')
}

fn string_inter_needs_selector_type_fallback(expr_type string) bool {
	return expr_type == '' || expr_type == 'int' || expr_type == 'int_literal'
		|| expr_type == 'void' || expr_type == 'void*' || expr_type == 'voidptr'
}

fn (mut g Gen) string_inter_expr_type(expr ast.Expr) string {
	expr_type := g.get_expr_type(expr)
	if expr is ast.SelectorExpr && string_inter_needs_selector_type_fallback(expr_type) {
		declared_type := g.selector_declared_field_type(expr)
		if !string_inter_needs_selector_type_fallback(declared_type) {
			return declared_type
		}
		field_type := g.selector_field_type(expr)
		if !string_inter_needs_selector_type_fallback(field_type) {
			return field_type
		}
	}
	return expr_type
}

fn (mut g Gen) write_sprintf_arg(inter ast.StringInter) {
	expr_type := g.string_inter_expr_type(inter.expr)
	expr_src := g.expr_to_string(inter.expr)
	fmt := g.get_sprintf_format(inter)
	// Keep vararg C types aligned with the emitted format string.
	// If formatter expects a non-string argument, pass expression as-is.
	if !fmt.ends_with('s') {
		if expr_src == '' {
			g.sb.write_string('0')
		} else {
			g.sb.write_string(expr_src)
		}
		return
	}
	str_fn := g.get_str_fn_for_type(expr_type) or { '' }
	// Float types: use V's str() for default formatting ('0.0' not '0.000000')
	if expr_type in ['f64', 'f32', 'float_literal'] && inter.format == .unformatted {
		str_name := if expr_type == 'f32' { 'f32__str' } else { 'f64__str' }
		g.sb.write_string('${str_name}(')
		if expr_src == '' {
			g.sb.write_string('0')
		} else {
			g.sb.write_string(expr_src)
		}
		g.sb.write_string(').str')
		return
	}
	if expr_type == 'string' {
		if expr_src == '' {
			g.sb.write_string('""')
			return
		}
		g.sb.write_string(expr_src)
		g.sb.write_string('.str')
	} else if expr_type == 'bool' {
		g.sb.write_string('(')
		if expr_src == '' {
			g.sb.write_string('false')
		} else {
			g.sb.write_string(expr_src)
		}
		g.sb.write_string(' ? "true" : "false")')
	} else if str_fn != '' {
		g.sb.write_string('${str_fn}(')
		if expr_src == '' {
			g.sb.write_string('0')
		} else {
			g.sb.write_string(expr_src)
		}
		g.sb.write_string(').str')
	} else {
		if expr_src == '' {
			g.sb.write_string('0')
		} else {
			g.sb.write_string(expr_src)
		}
	}
}

fn (mut g Gen) get_sprintf_format(inter ast.StringInter) string {
	mut fmt := '%'
	mut width := inter.width
	mut precision := inter.precision
	// Extract width/precision from format_expr if not set explicitly
	if width == 0 && precision == 0 && inter.format_expr !is ast.EmptyExpr {
		if inter.format_expr is ast.BasicLiteral {
			val := inter.format_expr.value
			if val.contains('.') {
				// ".3" or "0.3" → precision
				parts := val.split('.')
				if parts.len == 2 {
					if parts[0].len > 0 && parts[0] != '0' {
						width = parts[0].int()
					}
					precision = parts[1].int()
				}
			} else {
				// Plain number → width (e.g., "03" for zero-padded)
				if val.starts_with('0') && val.len > 1 {
					fmt += '0'
				}
				width = val.int()
			}
		} else if inter.format_expr is ast.PrefixExpr {
			// Negative alignment: -10 → left-align with width 10
			if inter.format_expr.op == .minus && inter.format_expr.expr is ast.BasicLiteral {
				fmt += '-'
				width = inter.format_expr.expr.value.int()
			}
		}
	}
	// Width
	if width > 0 {
		fmt += '${width}'
	}
	// Precision
	if precision > 0 {
		fmt += '.${precision}'
	}
	// Format specifier
	expr_type := g.string_inter_expr_type(inter.expr)
	if inter.format != .unformatted {
		match inter.format {
			.decimal { fmt += 'd' }
			.float { fmt += 'f' }
			.hex { fmt += 'x' }
			.octal { fmt += 'o' }
			.character { fmt += 'c' }
			.exponent { fmt += 'e' }
			.exponent_short { fmt += 'g' }
			.binary { fmt += 'd' } // binary not supported in printf, fallback to decimal
			.pointer_address { fmt += 'p' }
			.string { fmt += 's' }
			.unformatted { fmt += 'd' }
		}

		return fmt
	}
	if inter.resolved_fmt != '' {
		if expr_type in ['string', 'bool', 'f32', 'f64', 'float_literal'] {
			return '%s'
		}
		if _ := g.get_str_fn_for_type(expr_type) {
			return '%s'
		}
		return inter.resolved_fmt
	}
	// Infer from expression type
	match expr_type {
		'string' {
			return '%s'
		}
		'int', 'i8', 'i16', 'i32' {
			return '%d'
		}
		'i64' {
			return '%lld'
		}
		'u8', 'u16', 'u32' {
			return '%u'
		}
		'u64' {
			return '%llu'
		}
		'f32', 'f64', 'float_literal' {
			// Use %s with V's str() function for default formatting,
			// since C's %f produces '0.000000' instead of V's '0.0'.
			return '%s'
		}
		'bool' {
			return '%s'
		}
		'rune' {
			return '%c'
		}
		'char' {
			return '%c'
		}
		else {
			if _ := g.get_str_fn_for_type(expr_type) {
				return '%s'
			}
			return '%d'
		}
	}
}

// get_str_fn_for_type returns the name of the str() function for a type, if one exists.