module c

import strings

// c_reserved_words is a set (not a list) so `name in c_reserved_words` is an O(1) hash
// lookup. c_name() runs on every emitted identifier, so a linear scan here is costly.
const c_reserved_words = {
	'auto':     true
	'break':    true
	'case':     true
	'char':     true
	'const':    true
	'continue': true
	'copy':     true
	'default':  true
	'do':       true
	'double':   true
	'else':     true
	'enum':     true
	'extern':   true
	'float':    true
	'for':      true
	'goto':     true
	'if':       true
	'inline':   true
	'int':      true
	'long':     true
	'register': true
	'restrict': true
	'return':   true
	'short':    true
	'signed':   true
	'sizeof':   true
	'static':   true
	'struct':   true
	'switch':   true
	'typedef':  true
	'union':    true
	'unsigned': true
	'void':     true
	'volatile': true
	'while':    true
	'unix':     true
}

// c_libc_collisions are libc function names that are not C keywords but clash at
// link/declaration time when a user defines a plain (module `main`) function with
// the same name (e.g. `fn rint(...)` vs libc's `double rint(double)`). They are
// mangled to `v_<name>` consistently at definition and call sites. `C.<name>`
// calls are unaffected (the `C.` prefix is stripped before this check).
const c_libc_collisions = {
	'rint':  true
	'y0':    true
	'y1':    true
	'yn':    true
	'j0':    true
	'j1':    true
	'jn':    true
	'drem':  true
	'scalb': true
}

// c_name converts c name data for c.
fn c_name(name string) string {
	if name.starts_with('C.') {
		return name[2..]
	}
	if name == 'malloc' {
		return 'v_malloc'
	}
	if name == 'int_str' {
		return 'int__str'
	}
	// The V builtin `exit` wraps `C.exit`; both lower to the C symbol `exit`.
	// Rename the V function (and its call sites) to `v_exit` so its body's
	// `C.exit(code)` call resolves to libc `exit` instead of recursing forever.
	// `C.exit` itself is handled by the `C.` strip above, so it stays `exit`.
	if name == 'exit' {
		return 'v_exit'
	}
	if c_name_is_plain(name) {
		if name in c_reserved_words || name in c_libc_collisions {
			return 'v_${name}'
		}
		return name
	}
	n := c_name_sanitize(name)
	if n in c_reserved_words || n in c_libc_collisions {
		return 'v_${n}'
	}
	return n
}

// c_name_sanitize converts c name sanitize data for c.
fn c_name_sanitize(name string) string {
	mut b := strings.new_builder(name.len + 8)
	mut i := 0
	for i < name.len {
		c := name[i]
		if c == `[` {
			if i + 1 < name.len && name[i + 1] == `]` {
				b.write_string('Array_')
				i += 2
				continue
			}
			b.write_u8(`_`)
		} else if c == `]` {
			i++
			continue
		} else if c == `.` {
			if i + 1 < name.len {
				next := name[i + 1]
				if next == `-` {
					b.write_string('__minus')
					i += 2
					continue
				}
				if next == `+` {
					b.write_string('__plus')
					i += 2
					continue
				}
				if next == `*` {
					b.write_string('__mul')
					i += 2
					continue
				}
				if next == `/` {
					b.write_string('__div')
					i += 2
					continue
				}
				if next == `%` {
					b.write_string('__mod')
					i += 2
					continue
				}
				if next == `&` {
					b.write_string('__and')
					i += 2
					continue
				}
				if next == `|` {
					b.write_string('__or')
					i += 2
					continue
				}
				if next == `^` {
					b.write_string('__xor')
					i += 2
					continue
				}
				if i + 2 < name.len {
					op := name[i + 2]
					if next == `=` && op == `=` {
						b.write_string('__eq')
						i += 3
						continue
					}
					if next == `!` && op == `=` {
						b.write_string('__ne')
						i += 3
						continue
					}
					if next == `<` && op == `=` {
						b.write_string('__le')
						i += 3
						continue
					}
					if next == `>` && op == `=` {
						b.write_string('__ge')
						i += 3
						continue
					}
					if next == `<` && op == `<` {
						b.write_string('__left_shift')
						i += 3
						continue
					}
					if next == `>` && op == `>` {
						b.write_string('__right_shift')
						i += 3
						continue
					}
				}
				if next == `<` {
					b.write_string('__lt')
					i += 2
					continue
				}
				if next == `>` {
					b.write_string('__gt')
					i += 2
					continue
				}
			}
			b.write_string('__')
		} else if c == `&` {
			b.write_string('ptr')
		} else if c == `@` {
			i++
			continue
		} else if c == `,` || c == ` ` {
			b.write_u8(`_`)
		} else {
			b.write_u8(c)
		}
		i++
	}
	return b.str()
}

// c_name_is_plain converts c name is plain data for c.
fn c_name_is_plain(name string) bool {
	for i in 0 .. name.len {
		c := name[i]
		if (c >= `a` && c <= `z`) || (c >= `A` && c <= `Z`) || (c >= `0` && c <= `9`) || c == `_` {
			continue
		}
		return false
	}
	return true
}

fn c_local_name(name string) string {
	local_name := if name.contains('.') { name.all_after_last('.') } else { name }
	return c_name(local_name)
}

// c_escape supports c escape handling for c.
fn c_escape(s string) string {
	return s.replace('\\', '\\\\').replace('"', '\\"').replace('\n', '\\n').replace('\t', '\\t').replace('\r',
		'\\r')
}