module builtin

// String: This is a minimal implementation of the "string" builtin until the WASM backend
// is able to compile the original builtin implementation

pub struct string {
pub:
	str &u8
	len int
}

// Concatenation operator: var += str / str + str
// Note: This will alloc a new string with the content of these two strings
pub fn (s string) + (other string) string {
	if s.len == 0 {
		return other
	}
	if other.len == 0 {
		return s
	}
	total_len := s.len + other.len
	result_ptr := unsafe { malloc(total_len) }
	if result_ptr == 0 {
		panic('string.+: malloc failed')
	}
	unsafe {
		vmemcpy(result_ptr, s.str, s.len)
		vmemcpy(result_ptr + s.len, other.str, other.len)
	}
	return string{
		str: result_ptr
		len: total_len
	}
}

// Equality comparison: checks if two strings are identical
pub fn (s string) == (other string) bool {
	if s.len != other.len {
		return false
	}

	for i in 0 .. s.len {
		if s[i] != other[i] {
			return false
		}
	}

	return true
}

// Less-than comparison: lexicographically compares two strings
pub fn (s string) < (other string) bool {
	// Taken from the C Backend
	for i in 0 .. s.len {
		if i >= other.len || s[i] > other[i] {
			return false
		} else if s[i] < other[i] {
			return true
		}
	}
	if s.len < other.len {
		return true
	}
	return false
}

// at returns the byte at index `idx`.
// Example: assert 'ABC'.at(1) == u8(`B`)
// NOTE: Adapted from C built-in, modified for WASM
pub fn (s string) at(idx int) u8 {
	$if !no_bounds_checking {
		if idx < 0 || idx >= s.len {
			panic('string index out of range')
		}
	}
	return unsafe { s.str[idx] }
}

// Convert C string to V string
pub fn cstring_to_vstring(ptr &u8) string {
	if ptr == 0 {
		return ''
	}

	mut len := 0
	unsafe {
		for ptr[len] != 0 {
			len++
		}
	}
	unsafe {
		return string{
			str: ptr
			len: len
		}
	}
}