// vtest build: !sanitized_job?
module scanner

import v.token
import v.pref

fn scan_kinds(text string) []token.Kind {
	mut scanner := new_plain_scanner(text, .skip_comments, &pref.Preferences{})
	mut token_kinds := []token.Kind{}
	for {
		tok := scanner.text_scan()
		if tok.kind == .eof {
			break
		}
		token_kinds << tok.kind
	}
	return token_kinds
}

fn scan_tokens(text string) []token.Token {
	mut scanner := new_plain_scanner(text, .parse_comments, &pref.Preferences{})
	mut tokens := []token.Token{}
	for {
		tok := scanner.text_scan()
		if tok.kind == .eof {
			break
		}
		tokens << tok
	}
	return tokens
}

fn test_scan() {
	token_kinds := scan_kinds('println(2 + 3)')
	assert token_kinds.len == 6
	assert token_kinds[0] == .name
	assert token_kinds[1] == .lpar
	assert token_kinds[2] == .number
	assert token_kinds[3] == .plus
	assert token_kinds[4] == .number
	assert token_kinds[5] == .rpar
}

fn test_number_constant_input_format() {
	mut c := 0xa0
	assert c == 0xa0
	c = 0b1001
	assert c == 9
	c = 1000000
	assert c == 1000000
}

fn test_float_conversion_and_reading() {
	d := 23000000e-3
	assert int(d) == 23000
	mut e := 1.2E3 * -1e-1
	assert e == -120.0
	e = 1.2E3 * 1e-1
	x := 55.0
	assert e == 120.0
	assert 1.23e+10 == 1.23e10
	assert 1.23e+10 == 1.23e0010
	assert (-1.23e+10) == (1.23e0010 * -1.0)
	assert x == 55.0
}

fn test_float_without_fraction() {
	mut result := scan_kinds('x := 10.0')
	assert result.len == 3
	assert result[0] == .name
	assert result[1] == .decl_assign
	assert result[2] == .number
	result = scan_kinds('return 3.0, 4.0')
	assert result.len == 4
	assert result[0] == .key_return
	assert result[1] == .number
	assert result[2] == .comma
	assert result[3] == .number
	result = scan_kinds('fun(5.0)')
	assert result.len == 4
	assert result[0] == .name
	assert result[1] == .lpar
	assert result[2] == .number
	assert result[3] == .rpar
}

fn test_reference_bools() {
	result := scan_kinds('true && false')
	assert result.len == 3
	assert result[0] == .key_true
	assert result[1] == .and
	assert result[2] == .key_false
}

fn test_reference_var() {
	result := scan_kinds('&foo')
	assert result.len == 2
	assert result[0] == .amp
	assert result[1] == .name
}

fn test_array_of_references() {
	result := scan_kinds('[]&foo')
	assert result.len == 4
	assert result[0] == .lsbr
	assert result[1] == .rsbr
	assert result[2] == .amp
	assert result[3] == .name
}

fn test_ref_array_of_references() {
	result := scan_kinds('&[]&foo')
	assert result.len == 5
	assert result[0] == .amp
	assert result[1] == .lsbr
	assert result[2] == .rsbr
	assert result[3] == .amp
	assert result[4] == .name
}

fn test_ref_ref_foo() {
	result := scan_kinds('&&foo')
	assert result.len == 3
	assert result[0] == .amp
	assert result[1] == .amp
	assert result[2] == .name
}

fn test_array_of_ref_ref_foo() {
	result := scan_kinds('[]&&foo')
	assert result.len == 5
	assert result[0] == .lsbr
	assert result[1] == .rsbr
	assert result[2] == .amp
	assert result[3] == .amp
	assert result[4] == .name
}

fn test_ref_ref_array_ref_ref_foo() {
	result := scan_kinds('&&[]&&foo')
	assert result.len == 7
	assert result[0] == .amp
	assert result[1] == .amp
	assert result[2] == .lsbr
	assert result[3] == .rsbr
	assert result[4] == .amp
	assert result[5] == .amp
	assert result[6] == .name
}

fn test_escape_rune() {
	assert `\x61` == `a`
	assert `\u0061` == `a`
	assert `\U00000061` == `a`

	assert `\141` == `a`
	assert `\xe2\x98\x85` == `★`
	assert `\342\230\205` == `★`

	// the following lines test the scanner module
	// even before it is compiled into the v executable

	// SINGLE CHAR ESCAPES
	// SINGLE CHAR APOSTROPHE
	mut result := scan_tokens(r"`'`")
	assert result[0].kind == .chartoken
	assert result[0].lit == r"\'"

	// SINGLE CHAR BACKTICK
	result = scan_tokens(r'`\``')
	assert result[0].kind == .chartoken
	assert result[0].lit == r'\`'

	// SINGLE CHAR SLASH
	result = scan_tokens(r'`\\`')
	assert result[0].kind == .chartoken
	assert result[0].lit == r'\\'

	// SINGLE CHAR 16-bit UNICODE ESCAPE
	result = scan_tokens(r'`\u2605`')
	assert result[0].kind == .chartoken
	assert result[0].lit == r'★'

	// SINGLE CHAR 32-bit UNICODE ESCAPE
	result = scan_tokens(r'`\U00002605`')
	assert result[0].kind == .chartoken
	assert result[0].lit == r'★'

	// SINGLE CHAR ESCAPED ASCII
	result = scan_tokens(r'`\x61`')
	assert result[0].kind == .chartoken
	assert result[0].lit == r'a'

	// SINGLE CHAR INCORRECT ESCAPE
	// result = scan_tokens(r'`\x61\x61`') // should always result in an error

	// SINGLE CHAR MULTI-BYTE UTF-8 (hex)
	result = scan_tokens(r'`\xe2\x98\x85`')
	assert result[0].lit == r'★'

	// SINGLE CHAR MULTI-BYTE UTF-8 (octal)
	result = scan_tokens(r'`\342\230\205`')
	assert result[0].lit == r'★'
}

fn test_escape_string() {
	// these lines work if the v compiler is working
	assert '\x61' == 'a'
	assert '\x62' == 'b'
	assert '\u0061' == 'a'
	assert '\U00000061' == 'a'
	assert '\141' == 'a'
	assert '\xe2\x98\x85' == '★'
	assert '\342\230\205' == '★'

	// the following lines test the scanner module
	// even before it is compiled into the v executable

	// STRING ESCAPES =================
	// STRING APOSTROPHE
	mut result := scan_tokens(r"'\''")
	assert result[0].kind == .string
	assert result[0].lit == r"\'"

	// STRING BACKTICK
	result = scan_tokens(r"'\`'")
	assert result[0].kind == .string
	assert result[0].lit == r'\`'

	// STRING SLASH
	result = scan_tokens(r"'\\'")
	assert result[0].kind == .string
	assert result[0].lit == r'\\'

	// STRING 16-bit UNICODE ESCAPE
	result = scan_tokens(r"'\u2605'")
	assert result[0].kind == .string
	assert result[0].lit == r'★'
	result = scan_tokens(r"'H\u2605H'")
	assert result[0].kind == .string
	assert result[0].lit == r'H★H'

	// STRING 32-bit UNICODE ESCAPE
	result = scan_tokens(r"'\U00002605'")
	assert result[0].kind == .string
	assert result[0].lit == r'★'
	result = scan_tokens(r"'H\U00002605H'")
	assert result[0].kind == .string
	assert result[0].lit == r'H★H'

	// STRING ESCAPED ASCII
	result = scan_tokens(r"'\x61'")
	assert result[0].kind == .string
	assert result[0].lit == r'a'

	// STRING ESCAPED EXTENDED ASCII
	// (should not be converted to unicode)
	result = scan_tokens(r"'\xe29885'")
	assert result[0].kind == .string
	assert result[0].lit.bytes() == [u8(0xe2), `9`, `8`, `8`, `5`]

	// MIX STRING ESCAPES with UTF-16 escapes
	result = scan_tokens(r"'\x61\u2605'")
	assert result[0].kind == .string
	assert result[0].lit == r'a★'
	result = scan_tokens(r"'\u2605\x61'")
	assert result[0].kind == .string
	assert result[0].lit == r'★a'

	// MIX STRING ESCAPES with UTF-16 escapes with offset
	result = scan_tokens(r"'x  \x61\u2605\x61'")
	assert result[0].kind == .string
	assert result[0].lit == r'x  a★a'
	result = scan_tokens(r"'x  \u2605\x61\u2605'")
	assert result[0].kind == .string
	assert result[0].lit == r'x  ★a★'

	// MIX STRING ESCAPES with UTF-32 escapes
	result = scan_tokens(r"'\x61\U00002605'")
	assert result[0].kind == .string
	assert result[0].lit == r'a★'
	result = scan_tokens(r"'\U00002605\x61'")
	assert result[0].kind == .string
	assert result[0].lit == r'★a'

	// MIX STRING ESCAPES with UTF-32 escapes with offset
	result = scan_tokens(r"'x  \x61\U00002605\x61'")
	assert result[0].kind == .string
	assert result[0].lit == r'x  a★a'
	result = scan_tokens(r"'x  \U00002605\x61\U00002605'")
	assert result[0].kind == .string
	assert result[0].lit == r'x  ★a★'

	// MIX STRING ESCAPES with UTF-16 and UTF-32 escapes
	result = scan_tokens(r"'\u2605\x61\U00002605'")
	assert result[0].kind == .string
	assert result[0].lit == r'★a★'
	result = scan_tokens(r"'\U00002605\x61\u2605'")
	assert result[0].kind == .string
	assert result[0].lit == r'★a★'

	// MIX STRING ESCAPES with UTF-16 and UTF-32 escapes with offset
	result = scan_tokens(r"'x  \x61\U00002605\x61\u2605'")
	assert result[0].kind == .string
	assert result[0].lit == r'x  a★a★'
	result = scan_tokens(r"'x  \x61\u2605\x61\U00002605'")
	assert result[0].kind == .string
	assert result[0].lit == r'x  a★a★'

	// SHOULD RESULT IN ERRORS
	// result = scan_tokens(r'`\x61\x61`') // should always result in an error
	// result = scan_tokens(r"'\x'") // should always result in an error
	// result = scan_tokens(r'`hello`') // should always result in an error
}

fn assert_str_interpolation_works(mlen int, text string) {
	mut max_len := 0
	mut scanner := new_plain_scanner(text, .skip_comments, &pref.Preferences{})
	for {
		tok := scanner.text_scan()
		if scanner.str_helper_tokens.len > max_len {
			max_len = scanner.str_helper_tokens.len
		}
		if tok.kind == .eof {
			break
		}
	}
	assert max_len == mlen
	assert scanner.errors.len == 0
	assert scanner.str_helper_tokens.len == 0
}

fn test_string_interpolation_with_nested_string_does_not_grow_str_helper_tokens_too_much() {
	sinterpolation := " s := 'x \${if true { '{' } else { '}' }} y' "
	assert_str_interpolation_works(3, sinterpolation)
	assert_str_interpolation_works(3, sinterpolation + sinterpolation + sinterpolation)
	assert_str_interpolation_works(3, '{'.repeat(100) + sinterpolation + '}'.repeat(100))
	assert_str_interpolation_works(0, '{'.repeat(100) + '}'.repeat(100))
}

fn test_dollar_sign_is_literal_without_braces() {
	mut result := scan_tokens("'a$b'")
	assert result.len == 1
	assert result[0].kind == .string
	assert result[0].lit == 'a$b'

	result = scan_tokens('"a$b"')
	assert result.len == 1
	assert result[0].kind == .string
	assert result[0].lit == 'a$b'
}

fn test_comment_string() {
	mut result := scan_tokens('// single line comment will get an \\x01 prepended')
	assert result[0].kind == .comment
	assert result[0].lit[0] == u8(1) // \x01
	// result = scan_tokens('/// doc comment will keep third / at beginning')
	// result = scan_tokens('/* block comment will be stripped of whitespace */')
	// result = scan_tokens('a := 0 // line end comment also gets \\x01 prepended')
}