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

import v.ast
import v.token
import encoding.utf8.validate
import v.util

fn (mut c Checker) get_default_fmt(ftyp ast.Type, typ ast.Type) u8 {
	if ftyp.has_option_or_result() {
		return `s`
	} else if typ.is_float() {
		return `g`
	} else if typ.is_signed() || typ.is_int_literal() {
		return `d`
	} else if typ.is_unsigned() {
		return `u`
	} else if typ.is_pointer() {
		return `p`
	} else {
		mut sym := c.table.sym(c.unwrap_generic(ftyp))
		if sym.kind == .alias {
			// string aliases should be printable
			info := sym.info as ast.Alias
			sym = c.table.sym(info.parent_type)
			if info.parent_type == ast.string_type {
				return `s`
			}
		}
		if sym.kind == .function {
			return `s`
		}
		if ftyp in [ast.string_type, ast.bool_type]
			|| sym.kind in [.enum, .array, .array_fixed, .struct, .generic_inst, .map, .multi_return, .sum_type, .interface, .aggregate, .none]
			|| ftyp.has_option_or_result() || sym.has_method('str') {
			return `s`
		} else {
			return `_`
		}
	}
}

fn (mut c Checker) get_string_inter_default_fmt(expr ast.Expr, ftyp ast.Type, typ ast.Type) u8 {
	if expr is ast.Ident {
		if expr.obj is ast.Var {
			obj := expr.obj
			if obj.typ.is_ptr() && !obj.is_arg {
				pointee_typ := obj.typ.deref()
				if c.table.final_sym(pointee_typ).kind != .enum {
					final_pointee_typ := c.table.final_type(pointee_typ)
					if final_pointee_typ in [ast.string_type, ast.bool_type] {
						return `p`
					}
				}
			}
		}
	}
	return c.get_default_fmt(ftyp, typ)
}

fn (mut c Checker) check_string_inter_lit_format_expr(mut expr ast.Expr, what string) {
	if expr is ast.EmptyExpr {
		return
	}
	expected_type := c.expected_type
	c.expected_type = ast.int_type
	mut typ := c.expr(mut expr)
	c.expected_type = expected_type
	typ = c.type_resolver.get_type_or_default(expr, c.check_expr_option_or_result_call(expr, typ))
	typ = c.table.unalias_num_type(typ)
	if typ != ast.int_type && !typ.is_int_literal() {
		c.error('${what} expression should return `int`', expr.pos())
	}
}

fn (mut c Checker) string_inter_lit(mut node ast.StringInterLiteral) ast.Type {
	inside_interface_deref_save := c.inside_interface_deref
	c.inside_interface_deref = true
	for i, mut expr in node.exprs {
		expected_type := c.expected_type
		c.expected_type = ast.string_type
		mut ftyp := c.expr(mut expr)
		c.expected_type = expected_type
		ftyp = c.type_resolver.get_type_or_default(expr,
			c.check_expr_option_or_result_call(expr, ftyp))
		if ftyp == ast.void_type || ftyp == 0 {
			c.error('expression does not return a value', expr.pos())
		} else if ftyp == ast.char_type && ftyp.nr_muls() == 0 {
			c.error('expression returning type `char` cannot be used in string interpolation directly, print its address or cast it to an integer instead',
				expr.pos())
		} else if c.fail_if_private_implicit_str(ftyp, expr.pos(), 'interpolate') {
			return ast.string_type
		}
		if ftyp == 0 {
			return ast.void_type
		}
		c.markused_string_inter_lit(mut node, ftyp)
		c.fail_if_unreadable(expr, ftyp, 'interpolation object')
		node.expr_types << ftyp
		if i < node.fwidth_exprs.len {
			mut width_expr := node.fwidth_exprs[i]
			c.check_string_inter_lit_format_expr(mut width_expr, 'width')
			node.fwidth_exprs[i] = width_expr
		}
		if i < node.precision_exprs.len {
			mut precision_expr := node.precision_exprs[i]
			c.check_string_inter_lit_format_expr(mut precision_expr, 'precision')
			node.precision_exprs[i] = precision_expr
		}
		ftyp_sym := c.table.sym(ftyp)
		typ := if ftyp_sym.kind == .alias && !ftyp_sym.has_method('str') {
			c.table.unalias_num_type(ftyp)
		} else {
			ftyp
		}
		mut fmt := node.fmts[i]
		// During generic recheck, reset auto-determined format specifiers
		// since the type may have changed between instantiations
		if c.table.cur_concrete_types.len > 0 && !node.need_fmts[i] && fmt != `_` {
			fmt = `_`
		}
		// analyze and validate format specifier
		if fmt !in [`E`, `F`, `G`, `e`, `f`, `g`, `d`, `u`, `x`, `X`, `o`, `c`, `s`, `S`, `p`,
			`b`, `_`, `r`, `R`] {
			c.error('unknown format specifier `${fmt:c}`', node.fmt_poss[i])
		}
		if fmt == `_` { // set default representation for type if none has been given
			fmt = c.get_string_inter_default_fmt(expr, ftyp, typ)
			if fmt == `_` {
				if typ != ast.void_type && !(typ.has_flag(.generic) && (c.inside_lambda
					|| c.table.cur_concrete_types.len > 0
					|| (c.table.cur_fn != unsafe { nil } && c.table.cur_fn.generic_names.len > 0))) {
					c.error('no known default format for type `${c.table.get_type_name(ftyp)}`',
						node.fmt_poss[i])
				}
			} else if c.comptime.is_comptime(expr)
				&& c.type_resolver.get_type_or_default(expr, ast.void_type) != ast.void_type {
				// still `_` placeholder for comptime variable without specifier
				node.need_fmts[i] = false
			} else {
				node.fmts[i] = fmt
				node.need_fmts[i] = false
			}
		} else { // check if given format specifier is valid for type
			has_dynamic_precision := i < node.precision_exprs.len
				&& node.precision_exprs[i] !is ast.EmptyExpr
			if (node.precisions[i] != 987698 || has_dynamic_precision) && !typ.is_float() {
				c.error('precision specification only valid for float types', node.fmt_poss[i])
			}
			if node.pluss[i] && !typ.is_number() {
				c.error('plus prefix only allowed for numbers', node.fmt_poss[i])
			}
			if ((typ.is_unsigned() && fmt !in [`u`, `x`, `X`, `o`, `c`, `b`])
				|| (typ.is_signed() && fmt !in [`d`, `x`, `X`, `o`, `c`, `b`])
				|| (typ.is_int_literal() && fmt !in [`d`, `c`, `x`, `X`, `o`, `u`, `b`])
				|| (typ.is_float() && fmt !in [`E`, `F`, `G`, `e`, `f`, `g`])
				|| (typ.is_pointer() && fmt !in [`p`, `x`, `X`])
				|| (typ.is_string() && fmt !in [`s`, `S`, `r`, `R`])
				|| (typ.idx() in [ast.i64_type_idx, ast.f64_type_idx] && fmt == `c`))
				&& !(typ.is_ptr() && fmt in [`p`, `x`, `X`]) {
				c.error('illegal format specifier `${fmt:c}` for type `${c.table.get_type_name(ftyp)}`',
					node.fmt_poss[i])
			}
			if c.table.final_sym(typ).kind in [.array, .array_fixed, .struct, .interface, .none, .map, .sum_type]
				&& fmt in [`E`, `F`, `G`, `e`, `f`, `g`, `d`, `u`, `x`, `X`, `o`, `c`, `p`, `b`, `r`, `R`]
				&& !(typ.is_ptr() && fmt in [`p`, `x`, `X`]) {
				c.error('illegal format specifier `${fmt:c}` for type `${c.table.get_type_name(ftyp)}`',
					node.fmt_poss[i])
			}
			node.need_fmts[i] = fmt != c.get_default_fmt(ftyp, typ)
				|| (typ.is_float() && fmt in [`g`, `G`])
		}
		// check recursive str
		if c.table.cur_fn != unsafe { nil } && c.table.cur_fn.is_method
			&& c.table.cur_fn.name == 'str' && c.table.cur_fn.receiver.name == '${expr}' {
			c.error('cannot call `str()` method recursively', expr.pos())
		}
	}
	c.inside_interface_deref = inside_interface_deref_save
	if c.pref.warn_about_allocs {
		c.warn_alloc('string interpolation', node.pos)
	}
	return ast.string_type
}

const unicode_lit_overflow_message = 'unicode character exceeds max allowed value of 0x10ffff, consider using a unicode literal (\\u####)'

fn is_source_char_escaped(source string, idx int) bool {
	mut backslashes := 0
	mut i := idx - 1
	for i >= 0 && source[i] == `\\` {
		backslashes++
		i--
	}
	return (backslashes & 1) == 1
}

fn raw_string_literal_source(source string, approx_pos int) ?string {
	if source.len == 0 {
		return none
	}
	mut hint := approx_pos
	if hint < 0 {
		hint = 0
	} else if hint >= source.len {
		hint = source.len - 1
	}
	mut start := hint
	for start >= 0 {
		if source[start] in [`'`, `"`] && !is_source_char_escaped(source, start) {
			quote := source[start]
			is_raw := start > 0 && source[start - 1] == `r`
			mut end := start + 1
			for end < source.len {
				if source[end] == quote && (is_raw || !is_source_char_escaped(source, end)) {
					if end >= hint {
						return source[start..end + 1]
					}
					break
				}
				end++
			}
		}
		start--
	}
	return none
}

fn (c &Checker) source_string_literal_is_valid_utf8(node ast.StringLiteral) bool {
	if node.pos.file_idx < 0 || node.pos.file_idx >= c.table.filelist.len {
		return validate.utf8_string(node.val)
	}
	source := util.read_file(c.table.filelist[node.pos.file_idx]) or {
		return validate.utf8_string(node.val)
	}
	raw_source := raw_string_literal_source(source, node.pos.pos) or {
		return validate.utf8_string(node.val)
	}
	return validate.utf8_string(raw_source)
}

// unicode character literals are limited to a maximum value of 0x10ffff
// https://stackoverflow.com/questions/52203351/why-unicode-is-restricted-to-0x10ffff
@[direct_array_access]
fn (mut c Checker) string_lit(mut node ast.StringLiteral) ast.Type {
	// Validate the bytes that came from the source file, not the decoded string value.
	// `\x..` escapes are allowed to produce arbitrary bytes intentionally.
	valid_utf8 := c.source_string_literal_is_valid_utf8(node)
	if !valid_utf8 {
		c.note('invalid utf8 byte sequence in string literal', node.pos)
	}
	mut idx := 0
	for idx < node.val.len {
		match node.val[idx] {
			`\\` {
				mut start_pos := token.Pos{
					...node.pos
					col: u16(node.pos.col + 1 + idx)
				}
				start_idx := idx
				idx++
				next_ch := node.val[idx] or { return ast.string_type }
				if next_ch == `\\` {
					// ignore escaping char
					idx++
				} else if next_ch == `u` {
					idx++
					mut ch := node.val[idx] or { return ast.string_type }
					mut hex_char_count := 0
					for ch.is_hex_digit() {
						hex_char_count++
						end_pos := token.Pos{
							...start_pos
							len: idx + 1 - start_idx
						}
						match hex_char_count {
							1...5 {}
							6 {
								first_digit := node.val[idx - 5] - 48
								second_digit := node.val[idx - 4] - 48
								if first_digit > 1 {
									c.error(unicode_lit_overflow_message, end_pos)
								} else if first_digit == 1 && second_digit > 0 {
									c.error(unicode_lit_overflow_message, end_pos)
								}
							}
							else {
								c.error(unicode_lit_overflow_message, end_pos)
							}
						}

						idx++
						ch = node.val[idx] or { return ast.string_type }
					}
				}
			}
			else {
				idx++
			}
		}
	}
	return ast.string_type
}

struct LoHiLimit {
	lower  string
	higher string
}

const iencoding_map = {
	`B`: LoHiLimit{'1000000000000000000000000000000000000000000000000000000000000000', '1111111111111111111111111111111111111111111111111111111111111111'}
	`O`: LoHiLimit{'1000000000000000000000', '1777777777777777777777'}
	`_`: LoHiLimit{'9223372036854775808', '18446744073709551615'}
	`X`: LoHiLimit{'8000000000000000', 'FFFFFFFFFFFFFFFF'}
}

fn (mut c Checker) int_lit(mut node ast.IntegerLiteral) ast.Type {
	if node.val.len < 17 {
		// can not be a too large number, no need for more expensive checks
		return ast.int_literal_type
	}
	lit := node.val.replace('_', '').all_after('-').to_upper_ascii()
	is_neg := node.val.starts_with('-')
	if lit.len > 2 && lit[0] == `0` && lit[1] in [`B`, `X`, `O`] {
		if lohi := iencoding_map[lit[1]] {
			c.check_num_literal(lohi, is_neg, lit[2..]) or { c.num_lit_overflow_error(node) }
		}
	} else {
		lohi := iencoding_map[`_`]
		c.check_num_literal(lohi, is_neg, lit) or { c.num_lit_overflow_error(node) }
	}
	return ast.int_literal_type
}

@[direct_array_access]
fn (mut c Checker) check_num_literal(lohi LoHiLimit, is_neg bool, lit string) ! {
	limit := if is_neg { lohi.lower } else { lohi.higher }
	if lit.len < limit.len {
		return
	}
	if lit.len > limit.len {
		return error('length overflow')
	}
	if lit.len == limit.len {
		for i, digit in lit {
			if digit > limit[i] {
				return error('value overflow at i: ${i}')
			} else if digit < limit[i] {
				break
			}
		}
	}
}

fn (mut c Checker) num_lit_overflow_error(node &ast.IntegerLiteral) {
	if c.inside_integer_literal_cast {
		return
	}
	c.error('integer literal ${node.val} overflows int', node.pos)
}