// Copyright (c) 2019-2023 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 main

import os
import os.cmdline
import v.pref
import v.parser
import v.ast
import v.help
import term
import arrays

@[heap]
struct Vet {
mut:
	opt            Options
	errors         shared []VetError
	warns          shared []VetError
	notices        shared []VetError
	file           string
	mod            string
	filtered_lines FilteredLines
	analyze        VetAnalyze
	regex_vars     map[string]bool
}

struct Options {
	is_force            bool
	is_werror           bool
	is_verbose          bool
	show_warnings       bool
	use_color           bool
	doc_private_fns_too bool
	fn_sizing           bool
	repeated_code       bool
	fn_inlining         bool
mut:
	is_vfmt_off bool
}

const term_colors = term.can_show_color_on_stderr()
const clean_seq = ['[', '', ']', '', ' ', '']
const exclude_dirs = ['test', 'slow_test', 'testdata']

fn main() {
	vet_options := cmdline.options_after(os.args, ['vet'])
	mut vt := Vet{
		opt: Options{
			is_werror:           '-W' in vet_options
			is_verbose:          '-verbose' in vet_options || '-v' in vet_options
			show_warnings:       '-hide-warnings' !in vet_options && '-w' !in vet_options
			doc_private_fns_too: '-p' in vet_options
			use_color:           '-color' in vet_options
				|| (term_colors && '-nocolor' !in vet_options)
			repeated_code:       '-r' in vet_options
			fn_sizing:           '-F' in vet_options
			fn_inlining:         '-I' in vet_options
		}
	}
	mut paths := cmdline.only_non_options(vet_options)
	vtmp := os.getenv('VTMP')
	if vtmp != '' {
		// `v test-cleancode` passes also `-o tmpfolder` as well as all options in VFLAGS
		paths = paths.filter(!it.starts_with(vtmp))
	}
	if paths.len == 0 || '-help' in vet_options || '--help' in vet_options {
		help.print_and_exit('vet')
	}
	for path in paths {
		if !os.exists(path) {
			eprintln('File/folder ${path} does not exist')
			continue
		}
		if os.is_file(path) {
			vt.vet_file(path)
		}
		if os.is_dir(path) {
			vt.vprintln("vetting folder: '${path}' ...")
			overwrite_exclude := exclude_dirs.any(path.contains(it))
			os.walk(path, fn [mut vt, overwrite_exclude] (p string) {
				if p.ends_with('.v') || p.ends_with('.vv') {
					if !overwrite_exclude {
						for d in exclude_dirs {
							if p.contains(d) {
								return
							}
						}
					}
					vt.vet_file(p)
				}
			})
		}
	}
	vt.vet_code_analyze()
	vfmt_err_count := vt.errors.filter(it.fix == .vfmt).len
	for n in vt.notices {
		eprintln(vt.e2string(n))
	}
	if vt.opt.show_warnings {
		for w in vt.warns {
			eprintln(vt.e2string(w))
		}
	}
	for err in vt.errors {
		eprintln(vt.e2string(err))
	}
	if vfmt_err_count > 0 {
		rlock vt.errors {
			filtered_out := arrays.distinct(vt.errors.map(it.file_path))
			eprintln('Note: You can run `v fmt -w ${filtered_out.join(' ')}` to fix these errors automatically')
		}
	}
	if vt.errors.len > 0 {
		exit(1)
	}
}

// vet_file vets the file read from `path`.
fn (mut vt Vet) vet_file(path string) {
	vt.file = path
	mut prefs := pref.new_preferences()
	prefs.is_vet = true
	prefs.is_vsh = path.ends_with('.vsh')
	mut table := ast.new_table()
	vt.vprintln("vetting file '${path}'...")
	file := parser.parse_file(path, mut table, .parse_comments, prefs)
	vt.mod = file.mod.name
	vt.regex_vars = map[string]bool{}
	vt.stmts(file.stmts)
	source_lines := os.read_lines(vt.file) or { []string{} }
	for ln, line in source_lines {
		vt.vet_line(source_lines, line, ln)
	}
}

// vet_line vets the contents of `line` from `vet.file`.
fn (mut vt Vet) vet_line(lines []string, line string, lnumber int) {
	if line == '' {
		return
	}
	vt.vet_fn_documentation(lines, line, lnumber)
	vt.vet_space_usage(line, lnumber)
}

fn (mut vt Vet) vet_space_usage(line string, lnumber int) {
	if line.starts_with('// vfmt off') {
		vt.opt.is_vfmt_off = true
	} else if line.starts_with('// vfmt on') {
		vt.opt.is_vfmt_off = false
	}
	if vt.opt.is_vfmt_off {
		return
	}
	if lnumber !in vt.filtered_lines[.space_indent] {
		if line.starts_with(' ') {
			vt.error('Looks like you are using spaces for indentation.', lnumber, .vfmt)
		}
	}
	if lnumber !in vt.filtered_lines[.trailing_space] {
		if line.ends_with(' ') {
			vt.error('Looks like you have trailing whitespace.', lnumber, .unknown)
		}
	}
}

fn collect_tags(line string) []string {
	mut cleaned := line.all_before('/')
	cleaned = cleaned.replace_each(clean_seq)
	return cleaned.split(',')
}

fn ident_fn_name(line string) string {
	mut fn_idx := line.index(' fn ') or { return '' }
	if line.len < fn_idx + 5 {
		return ''
	}
	mut tokens := line[fn_idx + 4..].split(' ')
	// Skip struct identifier
	if tokens.first().starts_with('(') {
		fn_idx = line.index(')') or { return '' }
		tokens = line[fn_idx..].split(' ')
		if tokens.len > 1 {
			tokens = [tokens[1]]
		}
	}
	if tokens.len > 0 {
		function_name_with_generic_parameters := tokens[0].all_before('(')
		return function_name_with_generic_parameters.all_before('[')
	}
	return ''
}

// vet_fn_documentation ensures that functions are documented
fn (mut vt Vet) vet_fn_documentation(lines []string, line string, lnumber int) {
	if line.starts_with('fn C.') {
		return
	}
	is_pub_fn := line.starts_with('pub fn ')
	is_fn := is_pub_fn || line.starts_with('fn ')
	if !is_fn {
		return
	}
	if line.starts_with('fn main') {
		return
	}
	if !(is_pub_fn || vt.opt.doc_private_fns_too) {
		return
	}
	// Scan function declarations for missing documentation
	mut line_above := lines[lnumber - 1] or { return }
	mut tags := []string{}
	if !line_above.starts_with('//') {
		mut grab := true
		for j := lnumber - 1; j >= 0; j-- {
			prev_line := lines[j]
			if prev_line.contains('}') { // We've looked back to the above scope, stop here
				break
			} else if prev_line.starts_with('@[') {
				tags << collect_tags(prev_line)
				continue
			} else if prev_line.starts_with('//') { // Single-line comment
				grab = false
				break
			}
		}
		if grab {
			clean_line := line.all_before_last('{').trim(' ')
			vt.warn('Function documentation seems to be missing for "${clean_line}".', lnumber,
				.doc)
		}
	} else {
		fn_name := ident_fn_name(line)
		mut grab := true
		for j := lnumber - 1; j >= 0; j-- {
			mut prev_prev_line := ''
			if j - 1 >= 0 {
				prev_prev_line = lines[j - 1]
			}
			prev_line := lines[j]

			if prev_line.starts_with('//') {
				if prev_line.starts_with('// ${fn_name} ') {
					grab = false
					break
				} else if prev_line.starts_with('// ${fn_name}')
					&& !prev_prev_line.starts_with('//') {
					grab = false
					clean_line := line.all_before_last('{').trim(' ')
					vt.warn('The documentation for "${clean_line}" seems incomplete.', lnumber,
						.doc)
					break
				}

				continue
			}

			if prev_line.contains('}') { // We've looked back to the above scope, stop here
				break
			} else if prev_line.starts_with('@[') {
				tags << collect_tags(prev_line)
				continue
			}
		}
		if grab {
			clean_line := line.all_before_last('{').trim(' ')
			vt.warn('A function name is missing from the documentation of "${clean_line}".',
				lnumber, .doc)
		}
	}
}

fn (mut vt Vet) stmts(stmts []ast.Stmt) {
	for stmt in stmts {
		vt.stmt(stmt)
	}
}

fn (mut vt Vet) stmt(stmt ast.Stmt) {
	match stmt {
		ast.ConstDecl {
			vt.const_decl(stmt)
		}
		ast.ExprStmt {
			vt.expr(stmt.expr)
		}
		ast.Return {
			vt.exprs(stmt.exprs)
		}
		ast.AssertStmt {
			vt.expr(stmt.expr)
			vt.expr(stmt.extra)
		}
		ast.AssignStmt {
			vt.exprs(stmt.left)
			vt.exprs(stmt.right)
			vt.track_regex_assign(stmt)
			vt.analyze.stmt(&vt, stmt)
		}
		ast.FnDecl {
			old_fn_decl := vt.analyze.cur_fn
			old_regex_vars := vt.regex_vars.clone()
			vt.regex_vars = map[string]bool{}
			vt.analyze.cur_fn = stmt
			vt.stmts(stmt.stmts)
			if vt.opt.fn_sizing {
				vt.analyze.long_or_empty_fns(mut vt, stmt)
			}
			if vt.opt.fn_inlining {
				vt.analyze.potential_non_inlined(mut vt, stmt)
			}
			vt.analyze.cur_fn = old_fn_decl
			vt.regex_vars = old_regex_vars.clone()
		}
		ast.StructDecl {
			vt.exprs(stmt.fields.map(it.default_expr))
		}
		else {}
	}
}

fn (mut vt Vet) exprs(exprs []ast.Expr) {
	for expr in exprs {
		vt.expr(expr)
	}
}

fn (mut vt Vet) expr(expr ast.Expr) {
	match expr {
		ast.Comment {
			vt.filtered_lines.comments(expr.is_multi, expr.pos)
		}
		ast.StringLiteral {
			vt.filtered_lines.assigns(expr.pos)
			vt.analyze.expr(&vt, expr)
		}
		ast.StringInterLiteral {
			vt.filtered_lines.assigns(expr.pos)
			vt.analyze.expr(&vt, expr)
		}
		ast.ArrayInit {
			vt.filtered_lines.assigns(expr.pos)
			vt.expr(expr.len_expr)
			vt.expr(expr.cap_expr)
			vt.expr(expr.init_expr)
			vt.exprs(expr.exprs)
		}
		ast.InfixExpr {
			vt.vet_in_condition(expr)
			vt.vet_empty_str(expr)
			vt.expr(expr.left)
			vt.expr(expr.right)
			vt.analyze.expr(&vt, expr)
		}
		ast.ParExpr {
			vt.expr(expr.expr)
		}
		ast.CallExpr {
			vt.expr(expr.left)
			vt.exprs(expr.args.map(it.expr))
			vt.vet_confusing_regex(expr)
			vt.analyze.expr(&vt, expr)
		}
		ast.MatchExpr {
			vt.expr(expr.cond)
			for b in expr.branches {
				vt.exprs(b.exprs)
				vt.stmts(b.stmts)
			}
		}
		ast.IfExpr {
			for b in expr.branches {
				vt.expr(b.cond)
				vt.stmts(b.stmts)
			}
		}
		ast.SelectorExpr {
			vt.analyze.expr(&vt, expr)
		}
		ast.IndexExpr {
			vt.analyze.expr(&vt, expr)
		}
		ast.AsCast {
			vt.analyze.expr(&vt, expr)
			vt.expr(expr.expr)
		}
		ast.UnsafeExpr {
			vt.expr(expr.expr)
		}
		ast.CastExpr {
			vt.expr(expr.expr)
		}
		ast.StructInit {
			vt.expr(expr.update_expr)
			vt.exprs(expr.init_fields.map(it.expr))
		}
		ast.DumpExpr {
			vt.expr(expr.expr)
		}
		else {}
	}
}

fn (mut vt Vet) const_decl(stmt ast.ConstDecl) {
	for field in stmt.fields {
		if field.expr is ast.ArrayInit && !field.expr.is_fixed {
			vt.notice('Use a fixed array instead of a dynamic one', field.expr.pos.line_nr,
				.unknown)
		}
		vt.expr(field.expr)
	}
}

fn (mut vt Vet) track_regex_assign(stmt ast.AssignStmt) {
	for i, left in stmt.left {
		if i >= stmt.right.len {
			break
		}
		mut ident_name := ''
		match left {
			ast.Ident {
				ident_name = left.name
			}
			else {
				continue
			}
		}

		if vt.is_regex_value_expr(stmt.right[i]) {
			vt.regex_vars[ident_name] = true
		} else {
			vt.regex_vars.delete(ident_name)
		}
	}
}

fn (mut vt Vet) vet_confusing_regex(expr ast.CallExpr) {
	if expr.args.len == 0 || !vt.is_regex_pattern_call(expr) {
		return
	}
	pattern_expr := expr.args[0].expr
	pattern := if pattern_expr is ast.StringLiteral { pattern_expr } else { return }
	snippet, suggestion := confusing_regex_branch(pattern.val) or { return }
	vt.warn('Confusing regex `|` in `${snippet}`: V regex applies `|` to adjacent tokens, not whole branches. Use `${suggestion}` if you intended alternation.',
		pattern.pos.line_nr, .unknown)
}

fn (vt &Vet) is_regex_pattern_call(expr ast.CallExpr) bool {
	short_name := expr.name.all_after_last('.')
	if short_name in ['regex_opt', 'regex_base'] {
		return vt.is_regex_fn_call(expr)
	}
	if expr.name == 'compile_opt' && expr.is_method {
		return vt.is_regex_value_expr(expr.left)
	}
	return false
}

fn (vt &Vet) is_regex_value_expr(expr ast.Expr) bool {
	match expr {
		ast.CallExpr {
			short_name := expr.name.all_after_last('.')
			if short_name == 'new' {
				return vt.is_regex_fn_call(expr)
			}
			if short_name == 'regex_opt' {
				return vt.is_regex_fn_call(expr)
			}
			return false
		}
		ast.Ident {
			return expr.name in vt.regex_vars
		}
		else {
			return false
		}
	}
}

fn (vt &Vet) is_regex_fn_call(expr ast.CallExpr) bool {
	if expr.name in ['regex.regex_opt', 'regex.regex_base', 'regex.new'] {
		return true
	}
	if vt.mod == 'regex' && expr.name in ['regex_opt', 'regex_base', 'new'] {
		return true
	}
	return false
}

fn confusing_regex_branch(pattern string) ?(string, string) {
	mut escaped := false
	mut in_char_class := false
	for i := 0; i < pattern.len; i++ {
		ch := pattern[i]
		if escaped {
			escaped = false
			continue
		}
		if ch == `\\` {
			escaped = true
			continue
		}
		if in_char_class {
			if ch == `]` {
				in_char_class = false
			}
			continue
		}
		if ch == `[` {
			in_char_class = true
			continue
		}
		if ch != `|` || i == 0 || i + 1 >= pattern.len {
			continue
		}
		if !is_regex_plain_letter(pattern[i - 1]) || !is_regex_plain_letter(pattern[i + 1]) {
			continue
		}
		if !((i >= 2 && is_regex_plain_letter(pattern[i - 2]))
			|| (i + 2 < pattern.len && is_regex_plain_letter(pattern[i + 2]))) {
			continue
		}
		mut left_start := i - 1
		for left_start > 0 && is_regex_plain_letter(pattern[left_start - 1]) {
			left_start--
		}
		mut right_end := i + 1
		for right_end + 1 < pattern.len && is_regex_plain_letter(pattern[right_end + 1]) {
			right_end++
		}
		left := pattern[left_start..i]
		right := pattern[i + 1..right_end + 1]
		return pattern[left_start..right_end + 1], '(${left})|(${right})'
	}
	return none
}

fn is_regex_plain_letter(ch u8) bool {
	return ch.is_letter()
}

fn (mut vt Vet) vet_empty_str(expr ast.InfixExpr) {
	if expr.left is ast.SelectorExpr && expr.right is ast.IntegerLiteral {
		operand := (expr.left as ast.SelectorExpr) // TODO: remove as-casts when multiple conds can be smart-casted.
		if operand.expr is ast.Ident && operand.field_name == 'len'
			&& operand.expr.info.typ == ast.string_type_idx {
			if expr.op != .lt && expr.right.val == '0' {
				// Case: `var.len > 0`, `var.len == 0`, `var.len != 0`
				op := if expr.op == .gt { '!=' } else { expr.op.str() }
				vt.notice("Use `${operand.expr.name} ${op} ''` instead of `${operand.expr.name}.len ${expr.op} 0`",
					expr.pos.line_nr, .unknown)
			} else if expr.op == .lt && expr.right.val == '1' {
				// Case: `var.len < 1`
				vt.notice("Use `${operand.expr.name} == ''` instead of `${operand.expr.name}.len ${expr.op} 1`",
					expr.pos.line_nr, .unknown)
			}
		}
	} else if expr.left is ast.IntegerLiteral && expr.right is ast.SelectorExpr {
		operand := expr.right
		if operand.expr is ast.Ident && operand.expr.info.typ == ast.string_type_idx
			&& operand.field_name == 'len' {
			if expr.op != .gt && (expr.left as ast.IntegerLiteral).val == '0' {
				// Case: `0 < var.len`, `0 == var.len`, `0 != var.len`
				op := if expr.op == .lt { '!=' } else { expr.op.str() }
				vt.notice("Use `'' ${op} ${operand.expr.name}` instead of `0 ${expr.op} ${operand.expr.name}.len`",
					expr.pos.line_nr, .unknown)
			} else if expr.op == .gt && (expr.left as ast.IntegerLiteral).val == '1' {
				// Case: `1 > var.len`
				vt.notice("Use `'' == ${operand.expr.name}` instead of `1 ${expr.op} ${operand.expr.name}.len`",
					expr.pos.line_nr, .unknown)
			}
		}
	}
}

fn (vt &Vet) vprintln(s string) {
	if !vt.opt.is_verbose {
		return
	}
	println(s)
}

fn (mut vt Vet) vet_in_condition(expr ast.InfixExpr) {
	if expr.right is ast.ArrayInit && expr.right.exprs.len == 1 && expr.op in [.key_in, .not_in] {
		left := expr.left.str()
		right := expr.right.exprs[0].str()
		eq := if expr.op == .key_in { '==' } else { '!=' }
		vt.error('Use `${left} ${eq} ${right}` instead of `${left} ${expr.op} [${right}]`',
			expr.pos.line_nr, .vfmt)
	}
}