import veb

const embedded_file = $embed_file(r'C:\Users\user\path\to\file')

struct App {
	a string
	b string
mut:
	c int
	d f32
pub:
	e f32
	f u64
pub mut:
	g string
	h u8
}

fn comptime_for() {
	println(@FN)
	$for method in App.methods {
		println('  method: ${method.name} | ${method}')
	}
}

fn comptime_for_with_if() {
	println(@FN)
	$for method in App.methods {
		println('  method: ${method}')
		$if method.typ is fn () {
			assert method.name in ['run', 'method2']
		}
		$if method.return_type is int {
			assert method.name in ['int_method1', 'int_method2']
		}
		$if method.args[0].typ is string {
			assert method.name == 'my_method'
		}
	}
}

fn comptime_for_fields() {
	println(@FN)
	$for field in App.fields {
		println('  field: ${field.name} | ${field}')
		$if field.typ is string {
			assert field.name in ['a', 'b', 'g']
		}
		$if field.typ is f32 {
			assert field.name in ['d', 'e']
		}
		if field.is_mut {
			assert field.name in ['c', 'd', 'g', 'h']
		}
		if field.is_pub {
			assert field.name in ['e', 'f', 'g', 'h']
		}
		if field.is_pub && field.is_mut {
			assert field.name in ['g', 'h']
		}
	}
}

struct Result {}

fn (mut a App) my_method(p string) Result {
	println('>>>> ${@FN} | p: ${p}')
	return Result{}
}

fn handle_conn[T](mut app T) {
	$for method in T.methods {
		$if method.return_type is Result {
			app.$method('abc', 'def')
		}
	}
}

fn comptime_call_dollar_method() {
	mut app := App{}
	handle_conn[App](mut app)
}

fn (mut app App) create() veb.Result {
	return $veb.html()
}

fn main() {
	comptime_for()
	comptime_for_with_if()
	comptime_for_fields()
	comptime_call_dollar_method()
}