module scanner

import v3.token
import v3.pref

// Mode lists mode values used by scanner.
@[flag]
pub enum Mode {
	normal
	scan_comments
	skip_interpolation
}

// Scanner represents scanner data used by scanner.
pub struct Scanner {
	pref               &pref.Preferences
	mode               Mode
	skip_interpolation bool
mut:
	file        &token.File = unsafe { nil }
	insert_semi bool
pub mut:
	src                 string
	offset              int
	pos                 int
	lit                 string
	in_str_incomplete   bool
	in_str_inter        bool
	str_inter_cbr_depth int
	str_quote           u8
}

// peek_byte supports peek byte handling for Scanner.
@[direct_array_access; inline]
fn (s &Scanner) peek_byte(n int) u8 {
	idx := s.offset + n
	if idx < 0 || idx >= s.src.len {
		return 0
	}
	return s.src[idx]
}

// new_scanner supports new scanner handling for scanner.
pub fn new_scanner(prefs &pref.Preferences, mode Mode) Scanner {
	unsafe {
		return Scanner{
			pref:               prefs
			mode:               mode
			skip_interpolation: mode.has(.skip_interpolation)
		}
	}
}

// init supports init handling for Scanner.
pub fn (mut s Scanner) init(file &token.File, src string) {
	s.offset = 0
	s.pos = 0
	s.lit = ''
	s.insert_semi = false
	s.in_str_incomplete = false
	s.in_str_inter = false
	s.str_inter_cbr_depth = 0
	s.str_quote = 0
	s.file = unsafe { file }
	s.src = src
}

@[inline]
fn (s &Scanner) source_lit(start int, end int) string {
	if end <= start {
		return ''
	}
	unsafe {
		return tos(s.src.str + start, end - start)
	}
}

// scan_char_literal reads scan char literal input for scanner.
fn (mut s Scanner) scan_char_literal(quote u8) token.Token {
	s.offset++
	for s.offset < s.src.len {
		c2 := s.src[s.offset]
		if c2 == quote {
			break
		}
		if c2 == `\\` && s.offset + 1 < s.src.len {
			s.offset += 2
			continue
		}
		s.offset++
	}
	mut end := s.offset
	if s.offset < s.src.len && s.src[s.offset] == quote {
		end = s.offset
		s.offset++
	}
	s.lit = s.source_lit(s.pos + 1, end)
	s.insert_semi = true
	return .char
}

// current_file returns current file data for Scanner.
pub fn (s &Scanner) current_file() &token.File {
	return unsafe { s.file }
}

// scan supports scan handling for Scanner.
@[direct_array_access]
pub fn (mut s Scanner) scan() token.Token {
	if s.in_str_incomplete {
		s.in_str_incomplete = false
		s.pos = s.offset
		s.string_literal(false, s.str_quote)
		s.lit = s.source_lit(s.pos, s.offset)
		return .string
	}
	start:
	s.whitespace()
	if s.offset == s.src.len {
		s.lit = ''
		if s.insert_semi {
			s.insert_semi = false
			return .semicolon
		}
		return .eof
	}
	c := s.src[s.offset]
	s.pos = s.offset
	s.lit = ''
	preserve_insert_semi := s.insert_semi
	s.insert_semi = false
	if c == `\n` {
		s.lit = ''
		return .semicolon
	} else if c == `/` {
		c2 := s.peek_byte(1)
		if c2 == `/` || c2 == `*` {
			if preserve_insert_semi {
				s.insert_semi = true
			}
			s.comment()
			if !s.mode.has(.scan_comments) {
				unsafe {
					goto start
				}
			}
			s.lit = s.source_lit(s.pos, s.offset)
			return .comment
		} else if c2 == `=` {
			s.offset += 2
			return .div_assign
		}
		s.offset++
		return .div
	} else if c >= `0` && c <= `9` {
		s.number()
		s.lit = s.source_lit(s.pos, s.offset)
		s.insert_semi = true
		return .number
	} else if (c >= `a` && c <= `z`) || (c >= `A` && c <= `Z`) || c == `_` || c == `@` {
		s.offset++
		if c == `@` && s.peek_byte(0) == `[` {
			s.offset++
			return .attribute
		}
		for s.offset < s.src.len {
			c3 := s.src[s.offset]
			if (c3 >= `a` && c3 <= `z`) || (c3 >= `A` && c3 <= `Z`)
				|| (c3 >= `0` && c3 <= `9`) || c3 == `_` {
				s.offset++
				continue
			}
			break
		}
		s.lit = s.source_lit(s.pos, s.offset)
		if s.lit == 'c' && s.offset < s.src.len && s.src[s.offset] == `'` {
			s.pos = s.offset
			tok := s.scan_char_literal(`'`)
			s.lit = 'c:${s.lit}'
			return tok
		}
		if s.lit == 'r' && s.offset < s.src.len
			&& (s.src[s.offset] == `'` || s.src[s.offset] == `"`) {
			quote := s.src[s.offset]
			s.offset++
			if !s.in_str_inter {
				s.str_quote = quote
			}
			s.string_literal(true, quote)
			s.lit = s.source_lit(s.pos, s.offset)
			s.insert_semi = true
			return .string
		}
		tok := token.Token.from_string_tinyv(s.lit)
		if tok in [.key_break, .key_continue, .key_nil, .key_none, .key_return, .key_false, .key_true,
			.name] {
			s.insert_semi = true
		}
		return tok
	} else if c == `'` || c == `"` {
		s.offset++
		if !s.in_str_inter {
			s.str_quote = c
		}
		s.string_literal(s.in_str_inter || (s.offset >= 2 && s.src[s.offset - 2] == `r`), c)
		s.lit = s.source_lit(s.pos, s.offset)
		s.insert_semi = true
		return .string
	} else if c == `\`` {
		return s.scan_char_literal(c)
	}
	s.lit = ''
	s.offset++
	match c {
		`.` {
			c2 := s.peek_byte(0)
			if c2 >= `0` && c2 <= `9` {
				s.number()
				s.lit = s.source_lit(s.pos, s.offset)
				return .number
			} else if c2 == `.` {
				s.offset++
				if s.peek_byte(0) == `.` {
					s.offset++
					return .ellipsis
				}
				return .dotdot
			}
			return .dot
		}
		`:` {
			if s.peek_byte(0) == `=` {
				s.offset++
				return .decl_assign
			}
			return .colon
		}
		`!` {
			c2 := s.peek_byte(0)
			if c2 == `=` {
				s.offset++
				return .ne
			} else if c2 == `i` {
				c3 := s.peek_byte(1)
				c4 := s.peek_byte(2)
				c4_is_space := c4 == ` ` || c4 == `\t`
				if c3 == `n` && c4_is_space {
					s.offset += 2
					return .not_in
				} else if c3 == `s` && c4_is_space {
					s.offset += 2
					return .not_is
				}
			}
			s.insert_semi = true
			return .not
		}
		`=` {
			if s.peek_byte(0) == `=` {
				s.offset++
				return .eq
			}
			return .assign
		}
		`+` {
			c2 := s.peek_byte(0)
			if c2 == `+` {
				s.offset++
				return .inc
			} else if c2 == `=` {
				s.offset++
				return .plus_assign
			}
			return .plus
		}
		`-` {
			c2 := s.peek_byte(0)
			if c2 == `-` {
				s.offset++
				return .dec
			} else if c2 == `=` {
				s.offset++
				return .minus_assign
			}
			return .minus
		}
		`%` {
			if s.peek_byte(0) == `=` {
				s.offset++
				return .mod_assign
			}
			return .mod
		}
		`*` {
			if s.peek_byte(0) == `=` {
				s.offset++
				return .mul_assign
			}
			return .mul
		}
		`^` {
			if s.peek_byte(0) == `=` {
				s.offset++
				return .xor_assign
			}
			return .xor
		}
		`&` {
			c2 := s.peek_byte(0)
			if c2 == `&` {
				if s.peek_byte(1) == `=` {
					s.offset += 2
					return .and_assign
				}
				s.offset++
				return .and
			} else if c2 == `=` {
				s.offset++
				return .and_assign
			}
			return .amp
		}
		`|` {
			c2 := s.peek_byte(0)
			if c2 == `|` {
				if s.peek_byte(1) == `=` {
					s.offset += 2
					return .or_assign
				}
				s.offset++
				return .logical_or
			} else if c2 == `=` {
				s.offset++
				return .or_assign
			}
			return .pipe
		}
		`<` {
			c2 := s.peek_byte(0)
			if c2 == `<` {
				s.offset++
				if s.peek_byte(0) == `=` {
					s.offset++
					return .left_shift_assign
				}
				return .left_shift
			} else if c2 == `=` {
				s.offset++
				return .le
			} else if c2 == `-` {
				s.offset++
				return .arrow
			}
			return .lt
		}
		`>` {
			c2 := s.peek_byte(0)
			if c2 == `>` {
				s.offset++
				c3 := s.peek_byte(0)
				if c3 == `>` {
					s.offset++
					if s.peek_byte(0) == `=` {
						s.offset++
						return .right_shift_unsigned_assign
					}
					return .right_shift_unsigned
				} else if c3 == `=` {
					s.offset++
					return .right_shift_assign
				}
				return .right_shift
			} else if c2 == `=` {
				s.offset++
				return .ge
			}
			return .gt
		}
		`#` {
			if s.peek_byte(0) == `[` {
				s.offset++
				return .lsbr
			}
			start := s.offset
			for s.offset < s.src.len && s.src[s.offset] != `\n` {
				s.offset++
			}
			s.lit = s.source_lit(start, s.offset).trim_space()
			s.insert_semi = true
			return .hash
		}
		`~` {
			return .bit_not
		}
		`,` {
			return .comma
		}
		`$` {
			if s.in_str_inter {
				return .str_dollar
			}
			return .dollar
		}
		`{` {
			if s.in_str_inter {
				s.str_inter_cbr_depth++
			}
			return .lcbr
		}
		`}` {
			if s.in_str_inter {
				s.str_inter_cbr_depth--
				if s.str_inter_cbr_depth == 0 {
					s.in_str_incomplete = true
					s.in_str_inter = false
				}
			}
			s.insert_semi = true
			return .rcbr
		}
		`(` {
			return .lpar
		}
		`)` {
			s.insert_semi = true
			return .rpar
		}
		`[` {
			return .lsbr
		}
		`]` {
			s.insert_semi = true
			return .rsbr
		}
		`;` {
			return .semicolon
		}
		`?` {
			s.insert_semi = true
			return .question
		}
		else {
			return .unknown
		}
	}
}

@[direct_array_access]
fn (mut s Scanner) whitespace() {
	for s.offset < s.src.len {
		c := s.src[s.offset]
		if c == ` ` || c == `\t` || c == `\r` {
			s.offset++
			continue
		} else if c == `\n` {
			if s.insert_semi {
				return
			}
			s.offset++
			continue
		}
		break
	}
}

@[direct_array_access]
fn (mut s Scanner) line() {
	for s.offset < s.src.len {
		if s.src[s.offset] == `\n` {
			break
		}
		s.offset++
	}
}

@[direct_array_access]
fn (mut s Scanner) comment() {
	s.offset++
	if s.offset >= s.src.len {
		return
	}
	c := s.src[s.offset]
	if c == `/` {
		s.line()
	} else if c == `*` {
		s.offset++
		mut ml_comment_depth := 1
		for s.offset < s.src.len {
			c2 := s.src[s.offset]
			c3 := s.peek_byte(1)
			if c2 == `\n` {
				s.offset++
			} else if c2 == `/` && c3 == `*` {
				s.offset += 2
				ml_comment_depth++
			} else if c2 == `*` && c3 == `/` {
				s.offset += 2
				ml_comment_depth--
				if ml_comment_depth == 0 {
					break
				}
			} else {
				s.offset++
			}
		}
	}
}

@[direct_array_access]
fn (mut s Scanner) string_literal(scan_as_raw bool, c_quote u8) {
	if scan_as_raw {
		for s.offset < s.src.len {
			c := s.src[s.offset]
			if c == c_quote {
				break
			}
			if c == `\n` {
				s.offset++
				continue
			}
			s.offset++
		}
		if s.offset < s.src.len {
			s.offset++
		}
		return
	}
	for s.offset < s.src.len {
		c := s.src[s.offset]
		if c == `\\` {
			s.offset += 2
			continue
		} else if c == `\n` {
			s.offset++
			continue
		} else if c == `$` && s.peek_byte(1) == `{` {
			s.in_str_inter = true
			if s.skip_interpolation {
				s.str_inter_cbr_depth++
				s.offset += 2
				continue
			} else {
				return
			}
		} else if s.skip_interpolation && s.in_str_inter {
			if c == `{` {
				s.str_inter_cbr_depth++
			} else if c == `}` {
				s.str_inter_cbr_depth--
				if s.str_inter_cbr_depth == 0 {
					s.in_str_inter = false
				}
			}
		} else if c == c_quote && !s.in_str_inter {
			s.offset++
			break
		}
		s.offset++
	}
}

@[direct_array_access]
fn (mut s Scanner) number() {
	if s.offset < s.src.len && s.src[s.offset] == `0` {
		s.offset++
		c := s.peek_byte(0)
		if c == `b` || c == `B` {
			s.offset++
			for s.offset < s.src.len {
				c2 := s.src[s.offset]
				if c2 == `0` || c2 == `1` || c2 == `_` {
					s.offset++
					continue
				}
				return
			}
			return
		} else if c == `x` || c == `X` {
			s.offset++
			for s.offset < s.src.len {
				c2 := s.src[s.offset]
				if (c2 >= `0` && c2 <= `9`) || (c2 >= `a` && c2 <= `f`)
					|| (c2 >= `A` && c2 <= `F`) || c2 == `_` {
					s.offset++
					continue
				}
				return
			}
			return
		} else if c == `o` || c == `O` {
			s.offset++
			for s.offset < s.src.len {
				c2 := s.src[s.offset]
				if (c2 >= `0` && c2 <= `7`) || c2 == `_` {
					s.offset++
					continue
				}
				return
			}
			return
		}
	}
	mut has_decimal := false
	mut has_exponent := false
	for s.offset < s.src.len {
		c := s.src[s.offset]
		if (c >= `0` && c <= `9`) || c == `_` {
			s.offset++
			continue
		} else if !has_decimal && c == `.` {
			next := s.peek_byte(1)
			if next != `.` && next >= `0` && next <= `9` {
				has_decimal = true
				s.offset++
				continue
			}
		} else if !has_exponent && (c == `e` || c == `E`) {
			has_exponent = true
			s.offset++
			if s.offset < s.src.len && (s.src[s.offset] == `+` || s.src[s.offset] == `-`) {
				s.offset++
			}
			continue
		}
		break
	}
}