module parser

import v.ast
import v.token
import v.util
import strings

struct EnumDeclFieldState {
mut:
	uses_exprs bool
}

fn (mut p Parser) enum_val_expr(mod string) ast.EnumVal {
	// `Color.green`
	mut enum_name := p.check_name()
	enum_name_pos := p.prev_tok.pos()
	if mod != '' {
		enum_name = mod + '.' + enum_name
	} else {
		enum_name = p.imported_symbols[enum_name] or { p.prepend_mod(enum_name) }
	}
	p.check(.dot)
	val := p.check_name()
	p.expr_mod = ''
	p.last_enum_name = enum_name
	p.last_enum_mod = mod
	return ast.EnumVal{
		enum_name: enum_name
		val:       val
		pos:       enum_name_pos.extend(p.prev_tok.pos())
		mod:       mod
	}
}

// `.green`
// `pref.BuildMode.default_mode`
fn (mut p Parser) enum_val() ast.EnumVal {
	start_pos := p.tok.pos()
	p.check(.dot)
	val := p.check_name()
	return ast.EnumVal{
		val: val
		pos: start_pos.extend(p.prev_tok.pos())
	}
}

fn (mut p Parser) enum_decl_field(mut enum_attrs map[string][]ast.Attr, mut state EnumDeclFieldState) ast.EnumField {
	pre_comments := p.eat_comments()
	pos := p.tok.pos()
	has_prev_newline := p.has_prev_newline()
	has_break_line := has_prev_newline || p.has_prev_line_comment_or_label()
	val := p.check_name()
	mut expr := ast.empty_expr
	mut has_expr := false
	if p.tok.kind == .assign {
		p.next()
		old_assign_rhs := p.inside_assign_rhs
		p.inside_assign_rhs = true
		expr = p.expr(0)
		p.inside_assign_rhs = old_assign_rhs
		has_expr = true
		state.uses_exprs = true
	}
	mut attrs := []ast.Attr{}
	if p.tok.kind == .lsbr || p.tok.kind == .at {
		p.attributes()
		attrs << p.attrs
		enum_attrs[val] = attrs
		p.attrs = []
	}
	comments := p.eat_comments(same_line: true)
	next_comments := p.eat_comments(follow_up: true)
	return ast.EnumField{
		name:             val
		source_name:      source_name(val)
		pos:              pos
		expr:             expr
		has_expr:         has_expr
		has_prev_newline: has_prev_newline
		has_break_line:   has_break_line
		pre_comments:     pre_comments
		comments:         comments
		next_comments:    next_comments
		attrs:            attrs
	}
}

fn (mut p Parser) enum_decl_fields(mut vals []string, mut fields []ast.EnumField, mut enum_attrs map[string][]ast.Attr, mut state EnumDeclFieldState) {
	for p.tok.kind != .eof && p.tok.kind != .rcbr {
		if p.tok.kind == .dollar && p.peek_tok.kind == .key_if {
			p.enum_decl_comptime_fields(mut vals, mut fields, mut enum_attrs, mut state)
			continue
		}
		field := p.enum_decl_field(mut enum_attrs, mut state)
		if field.name == '' {
			return
		}
		vals << field.name
		fields << field
	}
}

fn (mut p Parser) enum_decl_comptime_fields(mut vals []string, mut fields []ast.EnumField, mut enum_attrs map[string][]ast.Attr, mut state EnumDeclFieldState) {
	p.check(.dollar)
	mut has_true_branch := false
	for {
		if p.tok.kind == .key_else {
			p.check(.key_else)
			if p.tok.kind == .lcbr {
				if has_true_branch {
					p.skip_scope()
				} else {
					p.check(.lcbr)
					p.enum_decl_fields(mut vals, mut fields, mut enum_attrs, mut state)
					p.check(.rcbr)
				}
				break
			}
			p.check(.dollar)
		}
		old_inside_ct_if_expr := p.inside_ct_if_expr
		p.inside_ct_if_expr = true
		p.check(.key_if)
		mut cond := p.expr(0)
		p.inside_ct_if_expr = old_inside_ct_if_expr
		is_true := p.comptime_if_cond(mut cond)
		if is_true && !has_true_branch {
			has_true_branch = true
			p.check(.lcbr)
			p.enum_decl_fields(mut vals, mut fields, mut enum_attrs, mut state)
			p.check(.rcbr)
		} else if p.tok.kind == .lcbr {
			p.skip_scope()
		} else {
			p.check(.lcbr)
		}
		if p.tok.kind == .dollar && p.peek_tok.kind == .key_else {
			p.check(.dollar)
			continue
		}
		break
	}
}

fn (mut p Parser) enum_decl() ast.EnumDecl {
	p.top_level_statement_start()
	is_pub := p.tok.kind == .key_pub
	start_pos := p.tok.pos()
	if is_pub {
		p.next()
	}
	p.check(.key_enum)
	end_pos := p.tok.pos()
	mut comments_before_key_enum := if p.pref.is_vls {
		p.cur_comments.clone()
	} else {
		[]
	}
	if p.disallow_declarations_in_script_mode() {
		return ast.EnumDecl{}
	}
	enum_name := p.check_name()
	if enum_name.len == 0 {
		p.error_with_pos('enum names can not be empty', end_pos)
		return ast.EnumDecl{}
	}
	if enum_name.len == 1 {
		p.error_with_pos('single letter capital names are reserved for generic template types.',
			end_pos)
		return ast.EnumDecl{}
	}
	if p.is_imported_symbol(enum_name) {
		p.error_with_pos('cannot register enum `${enum_name}`, this type was already imported',
			end_pos)
		return ast.EnumDecl{}
	}
	name := p.prepend_mod(enum_name)
	already_exists := if _ := p.table.enum_decls[name] { true } else { false }
	mut enum_type := ast.int_type
	mut typ_pos := token.Pos{}
	if p.tok.kind == .key_as {
		p.next()
		typ_pos = p.tok.pos()
		enum_type = p.parse_type()
	}
	mut enum_decl_comments := p.eat_comments()
	p.check(.lcbr)
	enum_decl_comments << p.eat_comments()
	senum_type := p.table.get_type_name(enum_type)
	mut vals := []string{}
	// mut default_exprs := []ast.Expr{}
	mut fields := []ast.EnumField{}
	mut state := EnumDeclFieldState{}
	mut enum_attrs := map[string][]ast.Attr{}
	p.enum_decl_fields(mut vals, mut fields, mut enum_attrs, mut state)
	p.top_level_statement_end()
	p.check(.rcbr)
	is_flag := p.attrs.contains('flag')
	is_typedef := p.attrs.contains('typedef')
	is_multi_allowed := p.attrs.contains('_allow_multiple_values')
	pubfn := if p.mod == 'main' { '@[flag_enum_fn] fn' } else { '@[flag_enum_fn] pub fn' }
	if is_flag {
		if fields.len > 64 {
			p.error('when an enum is used as bit field, it must have a max of 64 fields')
			return ast.EnumDecl{}
		}
		for f in fields {
			if f.has_expr {
				p.error_with_pos('when an enum is used as a bit field, you can not assign custom values',
					f.pos)
				return ast.EnumDecl{}
			}
		}
		if !already_exists {
			// enum already exists, skip method creation to avoid duplicate method errors
			all_bits_set_value := '0b' + '1'.repeat(fields.len)
			p.codegen('
//
@[inline] ${pubfn} (    e &${enum_name}) is_empty() bool           { return  ${senum_type}(*e) == 0 }
@[inline] ${pubfn} (    e &${enum_name}) has(flag_ ${enum_name}) bool { return  (${senum_type}(*e) &  (${senum_type}(flag_))) != 0 }
@[inline] ${pubfn} (    e &${enum_name}) all(flag_ ${enum_name}) bool { return  (${senum_type}(*e) &  (${senum_type}(flag_))) == ${senum_type}(flag_) }
@[inline] ${pubfn} (mut e  ${enum_name}) set(flag_ ${enum_name})      { unsafe{ *e = ${enum_name}(${senum_type}(*e) |  (${senum_type}(flag_))) } }
@[inline] ${pubfn} (mut e  ${enum_name}) set_all()                   { unsafe{ *e = ${enum_name}(${all_bits_set_value}) } }
@[inline] ${pubfn} (mut e  ${enum_name}) clear(flag_ ${enum_name})    { unsafe{ *e = ${enum_name}(${senum_type}(*e) & ~(${senum_type}(flag_))) } }
@[inline] ${pubfn} (mut e  ${enum_name}) clear_all()                 { unsafe{ *e = ${enum_name}(0) } }
@[inline] ${pubfn} (mut e  ${enum_name}) toggle(flag_ ${enum_name})   { unsafe{ *e = ${enum_name}(${senum_type}(*e) ^  (${senum_type}(flag_))) } }
//
')
		}
	}
	// Add the generic `Enum.from[T](x T) !T {` static method too:
	mut isb := strings.new_builder(1024)
	isb.write_string('\n')
	if is_flag {
		isb.write_string('@[inline] ${pubfn} ${enum_name}.zero() ${enum_name} {\n')
		isb.write_string('		return unsafe{ ${enum_name}(0) }\n')
		isb.write_string('}\n')
	}
	// TODO: see why changing `W` to `T` below, later fails with seemingly unrelated error
	isb.write_string('${pubfn} ${enum_name}.from[W](input W) !${enum_name} {\n')
	isb.write_string('	\$if input is \$int {\n')
	isb.write_string('		val := unsafe{ ${enum_name}(input) }\n')
	if is_flag {
		isb.write_string('		if input == 0 { return val }\n')
		all_bits_set_value := '0b' + '1'.repeat(fields.len)
		isb.write_string('		if input & ~${all_bits_set_value} == 0 { return val }\n')
	} else {
		isb.write_string('		match val {\n')
		for f in fields {
			isb.write_string('			.${f.source_name} { return ${enum_name}.${f.source_name} }\n')
		}
		if is_flag {
			isb.write_string('			else{}\n')
		}
		isb.write_string('		}\n')
	}
	isb.write_string('	}\n')
	isb.write_string('	\$if input is \$string {\n')
	isb.write_string('		val := input.str()\n') // TODO: this should not be needed, the `$if input is $string` above should have already smartcasted `input`
	if is_flag {
		isb.write_string('		if val == \'\' { return unsafe{ ${enum_name}(0) } }\n')
	}
	isb.write_string('		match val {\n')
	for f in fields {
		isb.write_string('			\'${f.name}\' { return ${enum_name}.${f.source_name} }\n')
	}
	isb.write_string('			else{}\n')
	isb.write_string('		}\n')
	isb.write_string('	}\n')
	isb.write_string("	return error('invalid value')\n")
	isb.write_string('}\n')
	isb.write_string('\n')
	code_for_from_fn := isb.str()
	$if debug_enumcodegen ? {
		if p.mod == 'main' {
			dump(code_for_from_fn)
		}
	}
	if enum_name[0].is_capital() && fields.len > 0 {
		p.codegen(code_for_from_fn)
	}

	idx := p.table.register_sym(ast.TypeSymbol{
		kind:   .enum
		name:   name
		cname:  util.no_dots(name)
		mod:    p.mod
		info:   ast.Enum{
			vals:             vals
			is_flag:          is_flag
			is_typedef:       is_typedef
			is_multi_allowed: is_multi_allowed
			uses_exprs:       state.uses_exprs
			typ:              enum_type
			attrs:            enum_attrs
		}
		is_pub: is_pub
	})

	if idx in [ast.string_type_idx, ast.rune_type_idx, ast.array_type_idx, ast.map_type_idx]
		&& !p.pref.is_fmt {
		p.error_with_pos('cannot register enum `${name}`, another type with this name exists',
			end_pos)
	}

	if idx == ast.invalid_type_idx {
		enum_type = idx
	}

	enum_decl := ast.EnumDecl{
		name:             name
		typ:              enum_type
		typ_pos:          typ_pos
		is_pub:           is_pub
		is_flag:          is_flag
		is_multi_allowed: is_multi_allowed
		fields:           fields
		pos:              start_pos.extend_with_last_line(end_pos, p.prev_tok.line_nr)
		attrs:            p.attrs
		comments:         enum_decl_comments
	}

	if !already_exists {
		p.table.register_enum_decl(enum_decl)
		if p.pref.is_vls {
			key := 'enum_${name}'
			mut has_decl_end_comment := false
			if enum_decl.comments.len > 0
				&& enum_decl.comments[0].pos.line_nr == enum_decl.pos.line_nr {
				// enum MyEnum { // MyEnum end_comment1
				comments_before_key_enum << enum_decl.comments[0]
				has_decl_end_comment = true
			}
			val := ast.VlsInfo{
				pos: typ_pos
				doc: p.keyword_comments_to_string(enum_name, comments_before_key_enum)
			}
			p.table.register_vls_info(key, val)
			for i, f in fields {
				f_key := 'enum_${name}.${f.name}'
				f_val := if i == 0 {
					first_field_pre_comment := if has_decl_end_comment {
						enum_decl.comments[1..].clone()
					} else {
						enum_decl.comments
					}
					ast.VlsInfo{
						pos: f.pos
						doc: p.comments_to_string(first_field_pre_comment) +
							p.comments_to_string(f.comments)
					}
				} else {
					ast.VlsInfo{
						pos: f.pos
						doc: p.comments_to_string(fields[i - 1].next_comments) +
							p.comments_to_string(f.comments)
					}
				}
				p.table.register_vls_info(f_key, f_val)
			}
		}
	}
	return enum_decl
}