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

import v.ast
import v.token
import v.pkgconfig
import v.pref

fn (mut p Parser) if_expr(is_comptime bool, is_expr bool) ast.IfExpr {
	was_inside_if_expr := p.inside_if_expr
	was_inside_ct_if_expr := p.inside_ct_if_expr
	defer {
		p.inside_if_expr = was_inside_if_expr
		p.inside_ct_if_expr = was_inside_ct_if_expr
	}
	p.inside_if_expr = true
	is_expr_ := p.prev_tok.kind == .key_return || is_expr
	mut pos := p.tok.pos()
	if is_comptime {
		p.inside_ct_if_expr = true
		p.next() // `$`
		pos = p.prev_tok.pos().extend(p.tok.pos())
	}
	mut branches := []ast.IfBranch{}
	mut has_else := false
	mut comments := []ast.Comment{}
	mut prev_guard := false
	mut comptime_skip_curr_stmts := false
	mut comptime_has_true_branch := false
	for p.tok.kind in [.key_if, .key_else] {
		p.inside_if = true
		if is_comptime {
			p.inside_comptime_if = true
		}
		start_pos := if is_comptime { p.prev_tok.pos().extend(p.tok.pos()) } else { p.tok.pos() }
		if p.tok.kind == .key_else {
			comments << p.eat_comments()
			p.check(.key_else)
			comments << p.eat_comments()
			if p.tok.kind == .key_match {
				p.error('cannot use `match` with `if` statements')
				return ast.IfExpr{}
			}
			if p.tok.kind == .lcbr {
				// else {
				has_else = true
				p.inside_if = false
				p.inside_comptime_if = false
				end_pos := p.prev_tok.pos()
				body_pos := p.tok.pos()
				p.open_scope()
				// only declare `err` if previous branch was an `if` guard
				if prev_guard {
					p.scope.register(ast.Var{
						name:         'err'
						typ:          ast.error_type
						pos:          p.tok.pos()
						is_used:      false
						is_stack_obj: true
						is_special:   true
					})
				}
				if is_comptime && comptime_has_true_branch && !p.pref.is_fmt
					&& !p.pref.output_cross_c {
					p.skip_scope()
					branches << ast.IfBranch{
						pos:      start_pos.extend(end_pos)
						body_pos: body_pos.extend(p.tok.pos())
						comments: comments
						scope:    p.scope
					}
				} else {
					branches << ast.IfBranch{
						stmts:    p.parse_block_no_scope(false)
						pos:      start_pos.extend(end_pos)
						body_pos: body_pos.extend(p.tok.pos())
						comments: comments
						scope:    p.scope
					}
				}
				p.close_scope()
				comments = []
				break
			}
			if is_comptime {
				p.check(.dollar)
			}
		}
		if_pos := p.tok.pos()
		// `if` or `else if`
		p.check(.key_if)
		if p.tok.kind == .key_match {
			p.error('cannot use `match` with `if` statements')
			return ast.IfExpr{}
		}
		comments << p.eat_comments()
		mut cond := ast.empty_expr
		mut is_guard := false

		// if guard `if x,y := opt() {`
		if !is_comptime && p.peek_token_after_var_list().kind == .decl_assign {
			p.open_scope()
			is_guard = true
			mut vars := []ast.IfGuardVar{}
			mut var_names := []string{}
			for {
				mut var := ast.IfGuardVar{}
				mut is_mut := false
				if p.tok.kind == .key_mut {
					is_mut = true
					p.next()
				}
				var.is_mut = p.scope_var_is_mut(is_mut)
				var.pos = p.tok.pos()
				var.name = p.check_name()
				var_names << var.name

				if p.scope.known_var(var.name) {
					p.error_with_pos('redefinition of `${var.name}`', var.pos)
				}
				vars << var
				if p.tok.kind != .comma {
					break
				}
				p.next()
			}
			comments << p.eat_comments()
			p.check(.decl_assign)
			comments << p.eat_comments()
			old_assign_rhs := p.inside_assign_rhs
			p.inside_assign_rhs = true
			expr := p.expr(0)
			p.inside_assign_rhs = old_assign_rhs
			if expr !in [ast.CallExpr, ast.IndexExpr, ast.PrefixExpr, ast.SelectorExpr, ast.Ident] {
				p.error_with_pos('if guard condition expression is illegal, it should return an Option',
					expr.pos())
			}
			p.check_undefined_variables(var_names, expr) or {
				p.error_with_pos(err.msg(), pos)
				break
			}
			cond = ast.IfGuardExpr{
				vars: vars
				expr: expr
			}
			for var in vars {
				p.scope.register(ast.Var{
					name:   var.name
					is_mut: var.is_mut
					expr:   cond
					pos:    var.pos
				})
			}
			prev_guard = true
		} else {
			prev_guard = false
			p.comptime_if_cond = true
			p.inside_if_cond = true
			cond = p.expr(0)
			if is_comptime && p.is_in_top_level_comptime(p.inside_assign_rhs) {
				comptime_skip_curr_stmts = !p.comptime_if_cond(mut cond)
				if !comptime_skip_curr_stmts {
					comptime_has_true_branch = true
				}
			}
			if mut cond is ast.InfixExpr && !is_comptime {
				if cond.op in [.key_is, .not_is] {
					if mut cond.left is ast.Ident {
						if cond.left.name.len == 1 && cond.left.name.is_capital()
							&& cond.right is ast.TypeNode {
							p.error_with_pos('use `\$if` instead of `if`', if_pos)
							return ast.IfExpr{}
						}
					}
				}
			}
			p.inside_if_cond = false
			if p.if_cond_comments.len > 0 {
				comments << p.if_cond_comments
				p.if_cond_comments = []
			}
			p.comptime_if_cond = false
		}
		comments << p.eat_comments()
		end_pos := p.prev_tok.pos()
		body_pos := p.tok.pos()
		p.inside_if = false
		p.inside_comptime_if = false
		if p.opened_scopes > p.max_opened_scopes {
			p.should_abort = true
			p.error('too many nested conditionals, scopes: ${p.opened_scopes}')
			return ast.IfExpr{}
		}
		p.open_scope()
		if is_comptime && comptime_skip_curr_stmts
			&& p.is_in_top_level_comptime(p.inside_assign_rhs) && !p.pref.is_fmt
			&& !p.pref.output_cross_c {
			p.skip_scope()
			branches << ast.IfBranch{
				cond:     cond
				pos:      start_pos.extend(end_pos)
				body_pos: body_pos.extend(p.prev_tok.pos())
				comments: comments
				scope:    p.scope
			}
		} else {
			stmts := p.parse_block_no_scope(false)
			branches << ast.IfBranch{
				cond:     cond
				stmts:    stmts
				pos:      start_pos.extend(end_pos)
				body_pos: body_pos.extend(p.prev_tok.pos())
				comments: comments
				scope:    p.scope
			}
		}
		p.close_scope()
		if is_guard {
			p.close_scope()
		}
		comments = p.eat_comments()
		if is_comptime {
			if p.tok.kind == .key_else {
				p.error('use `\$else` instead of `else` in compile-time `if` branches')
				return ast.IfExpr{}
			}
			if p.tok.kind != .rcbr && p.peek_tok.kind == .key_else {
				p.check(.dollar)
			}
		}
		if p.tok.kind != .key_else {
			break
		}
	}
	pos.update_last_line(p.prev_tok.line_nr)
	if comments.len > 0 {
		pos.last_line = comments.last().pos.last_line
	}
	return ast.IfExpr{
		is_comptime:   is_comptime
		branches:      branches
		post_comments: comments
		pos:           pos
		has_else:      has_else
		is_expr:       is_expr_
	}
}

fn (mut p Parser) is_only_array_type() bool {
	if p.tok.kind == .lsbr {
		for i in 1 .. 20 {
			if p.peek_token(i).kind == .rsbr {
				next_kind := p.peek_token(i + 1).kind
				if next_kind == .name {
					return true
				} else if next_kind == .question && p.peek_token(i + 2).kind == .name {
					return true
				} else if next_kind == .lsbr {
					continue
				} else {
					return false
				}
			}
		}
	}
	return false
}

fn (mut p Parser) is_match_sumtype_type() bool {
	is_option := p.tok.kind == .question
	name_tok := if is_option { p.peek_tok } else { p.tok }
	next_tok_kind := if is_option { p.peek_token(2).kind } else { p.peek_tok.kind }
	next_next_idx := if is_option { 3 } else { 2 }
	next_next_tok := p.peek_token(next_next_idx)
	return name_tok.kind == .name && !(name_tok.lit == 'C' && next_tok_kind == .dot)
		&& (((ast.builtin_type_names_matcher.matches(name_tok.lit) || name_tok.lit[0].is_capital())
		&& next_tok_kind != .lpar && !(next_tok_kind == .dot && next_next_tok.kind == .name
		&& p.peek_token(next_next_idx + 1).kind == .lpar)) || (next_tok_kind == .dot
		&& next_next_tok.lit.len > 0 && next_next_tok.lit[0].is_capital()))
}

fn (mut p Parser) resolve_at_expr(expr ast.AtExpr) !string {
	match expr.kind {
		.mod_name {
			return p.mod
		}
		.os {
			return pref.get_host_os().lower()
		}
		.ccompiler {
			return p.pref.ccompiler_type.str()
		}
		.backend {
			return p.pref.backend.str()
		}
		.platform {
			return p.pref.arch.str()
		}
		else {
			return error('top level comptime only support `@MOD` `@OS` `@CCOMPILER` `@BACKEND` or `@PLATFORM`')
		}
	}

	return ''
}

enum MatchCondOrBlockMode {
	unsupported
	no_err_var
	with_err_var
	already_set
}

fn (p &Parser) match_cond_or_block_mode(cond ast.Expr) MatchCondOrBlockMode {
	return match cond {
		ast.CallExpr {
			if cond.or_block.kind == ast.OrKind.absent {
				MatchCondOrBlockMode.with_err_var
			} else {
				MatchCondOrBlockMode.already_set
			}
		}
		ast.Ident {
			if cond.or_expr.kind == ast.OrKind.absent {
				MatchCondOrBlockMode.no_err_var
			} else {
				MatchCondOrBlockMode.already_set
			}
		}
		ast.IndexExpr {
			if cond.or_expr.kind == ast.OrKind.absent {
				MatchCondOrBlockMode.no_err_var
			} else {
				MatchCondOrBlockMode.already_set
			}
		}
		ast.ParExpr {
			p.match_cond_or_block_mode(cond.expr)
		}
		ast.PrefixExpr {
			if cond.op == .arrow {
				if cond.or_block.kind == ast.OrKind.absent {
					MatchCondOrBlockMode.with_err_var
				} else {
					MatchCondOrBlockMode.already_set
				}
			} else {
				MatchCondOrBlockMode.unsupported
			}
		}
		ast.SelectorExpr {
			if cond.or_block.kind == ast.OrKind.absent {
				MatchCondOrBlockMode.with_err_var
			} else {
				MatchCondOrBlockMode.already_set
			}
		}
		else {
			MatchCondOrBlockMode.unsupported
		}
	}
}

fn (mut p Parser) set_match_cond_or_block(mut cond ast.Expr, or_expr ast.OrExpr) {
	match mut cond {
		ast.CallExpr {
			cond.or_block = or_expr
		}
		ast.Ident {
			cond.or_expr = or_expr
		}
		ast.IndexExpr {
			cond.or_expr = or_expr
		}
		ast.ParExpr {
			p.set_match_cond_or_block(mut cond.expr, or_expr)
		}
		ast.PrefixExpr {
			cond.or_block = or_expr
		}
		ast.SelectorExpr {
			cond.or_block = or_expr
		}
		else {}
	}
}

fn (mut p Parser) match_expr(is_comptime bool, is_expr bool) ast.MatchExpr {
	mut match_first_pos := p.tok.pos()
	old_inside_ct_match := p.inside_ct_match
	is_expr_ := p.prev_tok.kind == .key_return || is_expr
	if is_comptime {
		p.next() // `$`
		match_first_pos = p.prev_tok.pos().extend(p.tok.pos())
		p.inside_ct_match = true
	}
	old_inside_match := p.inside_match
	p.inside_match = true
	p.check(.key_match)
	mut is_sum_type := false
	mut cond := p.expr(0)
	mut cond_str := ''
	if is_comptime && cond is ast.AtExpr && p.is_in_top_level_comptime(p.inside_assign_rhs) {
		cond_str = p.resolve_at_expr(cond as ast.AtExpr) or {
			p.error(err.msg())
			return ast.MatchExpr{}
		}
	}
	p.inside_match = old_inside_match
	p.inside_ct_match = old_inside_ct_match
	no_lcbr := p.tok.kind != .lcbr
	if !no_lcbr {
		p.check(.lcbr)
	}
	comments := p.eat_comments() // comments before the first branch
	mut branches := []ast.MatchBranch{}
	mut comptime_skip_curr_stmts := false
	mut comptime_has_true_branch := false
	for p.tok.kind != .eof {
		branch_first_pos := p.tok.pos()
		mut exprs := []ast.Expr{}
		mut ecmnts := [][]ast.Comment{}
		// final else
		mut is_else := false
		if is_comptime {
			if p.tok.kind == .key_else {
				p.error('use `\$else` instead of `else` in compile-time `match` branches')
				return ast.MatchExpr{}
			}
			if p.tok.kind != .rcbr && p.peek_tok.kind == .key_else {
				p.check(.dollar)
			}
		}
		if p.tok.kind == .key_else {
			is_else = true
			p.next()
		} else if p.is_match_sumtype_type() || p.is_only_array_type()
			|| p.tok.kind == .key_fn
			|| (p.tok.kind == .lsbr && p.peek_token(2).kind == .amp) {
			mut types := []ast.Type{}
			for {
				// Sum type match
				parsed_type := p.parse_type()
				types << parsed_type
				exprs << ast.TypeNode{
					typ: parsed_type
					pos: p.prev_tok.pos()
				}
				if p.tok.kind != .comma {
					ecmnts << p.eat_comments()
					break
				}
				p.check(.comma)
				if p.pref.is_fmt {
					if p.tok.kind == .lcbr {
						break
					}
					for p.tok.kind == .comma {
						p.next()
					}
					ecmnts << p.eat_comments()
				}
			}
			is_sum_type = true
		} else {
			if p.tok.kind == .rcbr {
				p.next()
				return ast.MatchExpr{
					pos: match_first_pos
				}
			}
			// Expression match
			for {
				if is_comptime {
					p.inside_ct_match_case = true
				}
				p.inside_match_case = true
				mut range_pos := p.tok.pos()
				mut case_str := ''
				mut expr := p.expr(0)
				p.inside_match_case = false
				p.inside_ct_match_case = false
				match mut expr {
					ast.StringLiteral {
						case_str = expr.val
					}
					ast.IntegerLiteral {
						case_str = expr.val.str()
					}
					ast.BoolLiteral {
						case_str = expr.val.str()
					}
					else {}
				}

				comptime_skip_curr_stmts = cond_str != case_str
				if !comptime_skip_curr_stmts {
					comptime_has_true_branch = true
				}
				if p.tok.kind == .dotdot {
					p.error_with_pos('match only supports inclusive (`...`) ranges, not exclusive (`..`)',
						p.tok.pos())
					return ast.MatchExpr{}
				} else if p.tok.kind == .ellipsis {
					p.next()
					if is_comptime {
						p.inside_ct_match_case = true
					}
					p.inside_match_case = true
					expr2 := p.expr(0)
					p.inside_match_case = false
					p.inside_ct_match_case = false
					exprs << ast.RangeExpr{
						low:      expr
						high:     expr2
						has_low:  true
						has_high: true
						pos:      range_pos.extend(p.prev_tok.pos())
					}
				} else {
					exprs << expr
				}
				if p.tok.kind != .comma {
					ecmnts << p.eat_comments()
					break
				}

				p.check(.comma)
				if p.pref.is_fmt {
					if p.tok.kind == .lcbr {
						break
					}
					for p.tok.kind == .comma {
						p.next()
					}
					ecmnts << p.eat_comments()
				}
			}
		}
		branch_last_pos := p.prev_tok.pos()
		// p.warn('match block')
		if is_comptime {
			p.inside_ct_match_body = true
		}
		p.inside_match_body = true
		p.open_scope()
		mut stmts := []ast.Stmt{}
		if is_comptime && ((!is_else && comptime_skip_curr_stmts)
			|| (is_else && comptime_has_true_branch))
			&& p.is_in_top_level_comptime(p.inside_assign_rhs) && !p.pref.is_fmt
			&& !p.pref.output_cross_c {
			p.skip_scope()
		} else {
			stmts = p.parse_block_no_scope(false)
		}
		branch_scope := p.scope
		p.close_scope()
		p.inside_match_body = false
		p.inside_ct_match_body = false
		pos := branch_first_pos.extend_with_last_line(branch_last_pos, p.prev_tok.line_nr)
		branch_pos := branch_first_pos.extend_with_last_line(p.tok.pos(), p.tok.line_nr)
		post_comments := p.eat_comments()
		branches << ast.MatchBranch{
			exprs:         exprs
			ecmnts:        ecmnts
			stmts:         stmts
			pos:           pos
			branch_pos:    branch_pos
			is_else:       is_else
			post_comments: post_comments
			scope:         branch_scope
		}
		if p.tok.kind == .rcbr || (is_else && no_lcbr) {
			break
		}
	}
	mut match_last_pos := p.tok.pos()
	if p.tok.kind == .rcbr {
		p.check(.rcbr)
		match_last_pos = p.prev_tok.pos()
	}
	if p.tok.kind == .key_orelse {
		cond_or_mode := p.match_cond_or_block_mode(cond)
		if cond_or_mode == .already_set {
			p.error_with_pos('match condition already has an `or {}` block', p.tok.pos())
			return ast.MatchExpr{}
		}
		if cond_or_mode == .unsupported {
			p.error_with_pos('trailing `or {}` is only supported for match conditions that can use `or {}` directly',
				p.tok.pos())
			return ast.MatchExpr{}
		}
		err_var_mode := if cond_or_mode == .with_err_var {
			OrBlockErrVarMode.with_err_var
		} else {
			OrBlockErrVarMode.no_err_var
		}
		or_stmts, or_pos, or_scope := p.or_block(err_var_mode)
		p.set_match_cond_or_block(mut cond, ast.OrExpr{
			kind:  .block
			stmts: or_stmts
			pos:   or_pos
			scope: or_scope
		})
		match_last_pos = p.prev_tok.pos()
	}
	// return ast.StructInit{}
	mut pos := token.Pos{
		line_nr: match_first_pos.line_nr
		pos:     match_first_pos.pos
		len:     match_last_pos.pos - match_first_pos.pos + match_last_pos.len
		col:     match_first_pos.col
	}
	pos.update_last_line(match_last_pos.line_nr)
	return ast.MatchExpr{
		is_comptime: is_comptime
		is_expr:     is_expr_
		branches:    branches
		cond:        cond
		is_sum_type: is_sum_type
		pos:         pos
		comments:    comments
	}
}

fn (mut p Parser) select_expr() ast.SelectExpr {
	match_first_pos := p.tok.pos()
	p.check(.key_select)
	no_lcbr := p.tok.kind != .lcbr
	if !no_lcbr {
		p.check(.lcbr)
	}
	mut branches := []ast.SelectBranch{}
	mut has_else := false
	mut has_timeout := false
	for {
		branch_first_pos := p.tok.pos()
		comment := p.check_comment() // comment before {}
		p.open_scope()
		// final else
		mut is_else := false
		mut is_timeout := false
		mut stmt := ast.empty_stmt
		if p.tok.kind == .key_else {
			if has_timeout {
				p.error_with_pos('timeout `> t` and `else` are mutually exclusive `select` keys',
					p.tok.pos())
				return ast.SelectExpr{}
			}
			if has_else {
				p.error_with_pos('at most one `else` branch allowed in `select` block', p.tok.pos())
				return ast.SelectExpr{}
			}
			is_else = true
			has_else = true
			p.next()
		} else {
			mut is_gt := false
			if p.tok.kind == .gt {
				is_gt = true
				p.note_with_pos('`>` is deprecated and will soon be forbidden - just state the timeout in nanoseconds',
					p.tok.pos())
				p.next()
			}
			p.inside_match = true
			p.inside_select = true
			exprs := p.expr_list(true)
			if exprs.len != 1 {
				p.error('only one expression allowed as `select` key')
				return ast.SelectExpr{}
			}
			if p.tok.kind in [.assign, .decl_assign] {
				stmt = p.partial_assign_stmt(exprs)
			} else {
				stmt = ast.ExprStmt{
					expr:     exprs[0]
					pos:      exprs[0].pos()
					comments: [comment]
					is_expr:  true
				}
			}
			p.inside_match = false
			p.inside_select = false
			match mut stmt {
				ast.ExprStmt {
					mut check_timeout := false
					if !stmt.is_expr {
						p.error_with_pos('select: invalid expression', stmt.pos)
						return ast.SelectExpr{}
					} else {
						match mut stmt.expr {
							ast.InfixExpr {
								if stmt.expr.op != .arrow {
									check_timeout = true
								} else if is_gt {
									p.error_with_pos('send expression cannot be used as timeout',
										stmt.pos)
								}
							}
							else {
								check_timeout = true
							}
						}
					}
					if check_timeout {
						if has_else {
							p.error_with_pos('`else` and timeout value are mutually exclusive `select` keys',
								stmt.pos)
							return ast.SelectExpr{}
						}
						if has_timeout {
							p.error_with_pos('at most one timeout branch allowed in `select` block',
								stmt.pos)
							return ast.SelectExpr{}
						}
						is_timeout = true
						has_timeout = true
					}
				}
				ast.AssignStmt {
					expr := stmt.right[0]
					match expr {
						ast.PrefixExpr {
							if expr.op != .arrow {
								p.error_with_pos('select key: `<-` operator expected', expr.pos)
								return ast.SelectExpr{}
							}
						}
						else {
							p.error_with_pos('select key: receive expression expected',
								stmt.right[0].pos())
							return ast.SelectExpr{}
						}
					}
				}
				else {
					p.error_with_pos('select: transmission statement, timeout (in ns) or `else` expected',
						stmt.pos)
					return ast.SelectExpr{}
				}
			}
		}
		branch_last_pos := p.tok.pos()
		p.inside_match_body = true
		p.inside_for = false
		stmts := p.parse_block_no_scope(false)
		branch_scope := p.scope
		p.close_scope()
		p.inside_match_body = false
		mut pos := token.Pos{
			line_nr: branch_first_pos.line_nr
			pos:     branch_first_pos.pos
			len:     branch_last_pos.pos - branch_first_pos.pos + branch_last_pos.len
			col:     branch_first_pos.col
		}
		post_comments := p.eat_comments()
		pos.update_last_line(p.prev_tok.line_nr)
		if post_comments.len > 0 {
			pos.last_line = post_comments.last().pos.last_line
		}
		branches << ast.SelectBranch{
			stmt:          stmt
			stmts:         stmts
			pos:           pos
			scope:         branch_scope
			comment:       comment
			is_else:       is_else
			is_timeout:    is_timeout
			post_comments: post_comments
		}
		if p.tok.kind == .rcbr || ((is_else || is_timeout) && no_lcbr) {
			break
		}
	}
	match_last_pos := p.tok.pos()
	pos := token.Pos{
		line_nr: match_first_pos.line_nr
		pos:     match_first_pos.pos
		len:     match_last_pos.pos - match_first_pos.pos + match_last_pos.len
		col:     match_first_pos.col
	}
	if p.tok.kind == .rcbr {
		p.check(.rcbr)
	}
	p.register_auto_import('sync')
	return ast.SelectExpr{
		branches:      branches
		pos:           pos.extend_with_last_line(p.prev_tok.pos(), p.prev_tok.line_nr)
		has_exception: has_else || has_timeout
	}
}

fn (mut p Parser) comptime_if_cond(mut cond ast.Expr) bool {
	mut is_true := false
	match mut cond {
		ast.BoolLiteral {
			return cond.val
		}
		ast.ParExpr {
			return p.comptime_if_cond(mut cond.expr)
		}
		ast.PrefixExpr {
			if cond.op != .not {
				p.error('invalid \$if prefix operator, only allow `!`.')
				return false
			}
			return !p.comptime_if_cond(mut cond.right)
		}
		ast.PostfixExpr {
			if cond.op != .question {
				p.error('invalid \$if postfix operator, only allow `?`.')
				return false
			}
			if cond.expr !is ast.Ident {
				p.error('invalid \$if postfix condition, only allow `Indent`.')
				return false
			}
			cname := (cond.expr as ast.Ident).name
			return cname in p.pref.compile_defines
		}
		ast.InfixExpr {
			match cond.op {
				.and, .logical_or {
					l := p.comptime_if_cond(mut cond.left)
					r := p.comptime_if_cond(mut cond.right)
					// if at least one of the cond has `keep_stmts`, we should keep stmts
					return if cond.op == .and { l && r } else { l || r }
				}
				.eq, .ne, .gt, .lt, .ge, .le {
					match mut cond.left {
						ast.AtExpr {
							// @OS == 'linux'
							left_str := p.resolve_at_expr(cond.left) or {
								p.error(err.msg())
								return false
							}
							if cond.right !is ast.StringLiteral {
								p.error('`${cond.left} can only compare with string type')
								return false
							}
							right_str := (cond.right as ast.StringLiteral).val
							if cond.op == .eq {
								is_true = left_str == right_str
							} else if cond.op == .ne {
								is_true = left_str != right_str
							} else {
								p.error('string type only support `==` and `!=` operator')
								return false
							}
							return is_true
						}
						ast.Ident {
							// $if version == 2
							match mut cond.right {
								ast.StringLiteral {
									match cond.op {
										.eq {
											is_true = cond.left.str() == cond.right.str()
										}
										.ne {
											is_true = cond.left.str() != cond.right.str()
										}
										else {
											p.error('string type only support `==` and `!=` operator')
											return false
										}
									}
								}
								ast.IntegerLiteral {
									match cond.op {
										.eq {
											is_true = cond.left.str().i64() == cond.right.val.i64()
										}
										.ne {
											is_true = cond.left.str().i64() != cond.right.val.i64()
										}
										.gt {
											is_true = cond.left.str().i64() > cond.right.val.i64()
										}
										.lt {
											is_true = cond.left.str().i64() < cond.right.val.i64()
										}
										.ge {
											is_true = cond.left.str().i64() >= cond.right.val.i64()
										}
										.le {
											is_true = cond.left.str().i64() <= cond.right.val.i64()
										}
										else {
											p.error('int type only support `==` `!=` `>` `<` `>=` and `<=` operator')
											return false
										}
									}
								}
								ast.BoolLiteral {
									match cond.op {
										.eq {
											is_true = cond.left.str().bool() == cond.right.val
										}
										.ne {
											is_true = cond.left.str().bool() != cond.right.val
										}
										else {
											p.error('bool type only support `==` and `!=` operator')
											return false
										}
									}
								}
								else {
									p.error('compare only support string int and bool type')
									return false
								}
							}

							return is_true
						}
						else {
							p.error('invalid \$if condition')
							return false
						}
					}

					p.error('invalid \$if condition')
					return false
				}
				else {
					p.error('invalid \$if operator: ${cond.op}')
					return false
				}
			}
		}
		ast.Ident {
			cname := cond.name
			if cname in ast.valid_comptime_not_user_defined {
				if cname == 'threads' {
					is_true = p.table.gostmts > 0
				} else {
					is_true = ast.eval_comptime_not_user_defined_ident(cname, p.pref) or {
						p.error(err.msg())
						return false
					}
				}
			} else {
				p.error('invalid \$if condition: unknown indent `${cname}`')
				return false
			}
			return is_true
		}
		ast.ComptimeCall {
			if cond.kind == .pkgconfig {
				if mut m := pkgconfig.main([cond.args_var]) {
					if _ := m.run() {
						is_true = true
					} else {
						// pkgconfig not found, do not issue error, just set false
						is_true = false
					}
				} else {
					p.error(err.msg())
					is_true = false
				}
				return is_true
			}
			if cond.kind == .d {
				is_true = cond.compile_value.bool()
				return is_true
			}
			p.error('invalid \$if condition: unknown ComptimeCall')
			return false
		}
		else {
			p.error('invalid \$if condition ${cond}')
			return false
		}
	}

	return is_true
}