import v.reflection

@[test_struct]
struct Test {
	m map[int]string @[test]
	n ?string        @[test2; test3]
}

enum Flags {
	foo
	bar
}

type MySum = f64 | int

type MyAlias = int

fn foo() ?string {
	return ''
}

fn bar() !string {
	return ''
}

fn baz() (int, f64, string) {
	return 1, 2.0, 'foo'
}

fn test_flag_option() {
	funcs := reflection.get_funcs().filter(it.name == 'foo')
	assert funcs[0].return_typ.has_flag(.option)
}

fn test_flag_result() {
	funcs := reflection.get_funcs().filter(it.name == 'bar')
	assert funcs[0].return_typ.has_flag(.result)
}

fn test_array_sym() {
	var := ['abc', 'def']
	typ := reflection.type_of(var)
	assert typ.sym.kind == .array
	assert typ.sym.language == .v
	assert typ.sym.methods.len > 0
	assert typ.sym.methods.any(it.name == 'join')
	assert typ.sym.name == '[]string'
	assert (typ.sym.info as reflection.Array).nr_dims == 1
	assert (typ.sym.info as reflection.Array).elem_type == typeof[string]().idx
}

fn test_sumtype_sym() {
	var := MySum(1)
	typ := reflection.type_of(var)
	assert typ.sym.kind == .sum_type
	assert (typ.sym.info as reflection.SumType).variants[0] == typeof[f64]().idx
	assert (typ.sym.info as reflection.SumType).variants[1] == typeof[int]().idx
}

fn test_alias_sym() {
	var := MyAlias(1)
	typ := reflection.type_of(var)
	assert typ.sym.kind == .alias
	assert typ.sym.language == .v
	assert (typ.sym.info as reflection.Alias).parent_idx == typeof[int]().idx
	assert typ.sym.methods.len == 0
}

fn test_multi_return_sym() {
	func := reflection.get_funcs().filter(it.name == 'baz')[0]
	assert func.name == 'baz'
	assert func.args.len == 0
	assert func.is_variadic == false
	assert func.return_typ.has_flag(.option) == false
	assert func.return_typ.has_flag(.result) == false
	assert func.return_typ.has_flag(.shared_f) == false
	assert func.receiver_typ == 0
	assert func.is_pub == false

	typ := reflection.get_type(int(func.return_typ))?
	assert typ.name == '(int, f64, string)'
	assert typ.sym.mod == ''
	assert typ.sym.language == .v
	assert typ.sym.kind == .multi_return
}

fn test_enum_sym() {
	var := reflection.type_of(Flags.foo)
	assert var.sym.name == 'Flags'
	assert var.sym.mod == 'main'
	assert var.sym.parent_idx == 0
	assert var.sym.kind == .enum
	assert var.sym.language == .v
	assert (var.sym.info as reflection.Enum).vals == ['foo', 'bar']
}

fn test_struct_sym() {
	var := reflection.type_of(Test{})
	assert var.sym.kind == .struct
	assert var.sym.mod == 'main'
	assert (var.sym.info as reflection.Struct).attrs.len == 1
	assert (var.sym.info as reflection.Struct).attrs == [
		VAttribute{
			name: 'test_struct'
			kind: .plain
		},
	]

	field := (var.sym.info as reflection.Struct).fields[0]
	field_typ := field.typ
	field_sym := reflection.get_type(field_typ.idx())?
	assert field_sym.name == 'map[int]string'
	assert field_sym.sym.kind == .map
	assert (field_sym.sym.info as reflection.Map).key_type.idx() == typeof[int]().idx
	assert (field_sym.sym.info as reflection.Map).value_type.idx() == typeof[string]().idx
	assert field.attrs.len == 1
	assert field.attrs == [
		VAttribute{
			name: 'test'
			kind: .plain
		},
	]

	field2 := (var.sym.info as reflection.Struct).fields[1]
	field2_typ := (var.sym.info as reflection.Struct).fields[1].typ
	assert field2_typ.has_flag(.option)
	assert field2.name == 'n'
	assert field2.attrs.len == 2
	assert field2.attrs == [
		VAttribute{
			name: 'test2'
			kind: .plain
		},
		VAttribute{
			name: 'test3'
			kind: .plain
		},
	]
	assert field2.is_pub == false
}