fn_call.v

// Copyright (c) 2024 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by a GPL license that can be found in the LICENSE file.

fn (mut app App) call_expr(call CallExpr) {
	mut fn_name := ''
	mut is_println := false

	// fmt.Println => println
	fun := call.fun
	if fun is SelectorExpr {
		if fun.sel.name == 'String' && fun.x is CallExpr {
			app.expr(fun.x)
			app.gen('.str()')
			return
		} else if fun.x is Ident {
			if fun.x.name == 'fmt' && fun.sel.name in ['Println', 'Print'] {
				fn_name = fun.sel.name.to_lower()
				is_println = true
			} else if fun.sel.name == 'len' {
				app.genln('LEN')
			} else {
				// mod.fn_call() is handled lower
			}
		}
	} else if fun is Ident {
		if fun.name in ['len', 'cap'] {
			app.expr(call.args[0])
			app.gen('.')
			app.gen(fun.name)
			return
		} else if fun.name == 'new' {
			// new(Foo) => &Foo{}
			app.gen('&')
			app.expr(call.args[0])
			app.gen('{}')
			return
		} else if fun.name == 'delete' {
			arg0 := call.args[0]
			match arg0 {
				Ident {
					app.gen('${arg0.name}')
				}
				SelectorExpr {
					app.expr(arg0)
				}
				else {
					app.gen('// UNHANDLED delete type')
				}
			}
			app.gen('.${fun.name}(')
			app.expr(call.args[1])
			app.genln(')')
			return
		} else if fun.name == 'string' {
			app.expr(call.args[0])
			app.genln('.str()')
			return
		} else if fun.name != go2v_type(fun.name) {
			app.gen(go2v_type(fun.name))
			app.gen('(')
			app.expr(call.args[0])
			app.gen(')')
			return
		} else if fun.name == 'make' {
			app.make_call(call)
			return
		} else if fun.name in ['print', 'println'] {
			fn_name = fun.name
			is_println = true
		}
	}

	// []byte(str) => str.bytes()
	if fun is ArrayType {
		elt := fun.elt
		if elt is Ident && elt.name == 'byte' {
			x := call.args[0]
			// TODO not every expr/type can be handled like this?
			// if x is BasicLit {
			app.expr(x)
			app.gen('.bytes()')
			return
		}
	}

	if !is_println {
		if fun is SelectorExpr {
			// Custom selector expr fn for lower case
			app.selector_expr_fn_call(call, fun) // fun)
		} else {
			app.expr(fun)
		}
	}

	// Can be empty if not println
	fn_name = app.go2v_ident(fn_name)

	app.gen('${fn_name}(') // fn_name is empty unless print

	if call.args.len > 0 {
		if is_println {
			// In V println can only accept one argument, so convert multiple arguments into a single string
			// with concatenation:
			// `fmt.Println(a, b)` => `println('${a} ${b}')`
			more_than_one := call.args.len > 1
			if more_than_one {
				app.gen("'")
			}
			for i, arg in call.args {
				if i > 0 {
					app.gen(' ')
				}
				if arg is BinaryExpr {
					app.expr(arg)
				} else {
					if more_than_one {
						app.gen('\${')
					}
					app.expr(arg)
					if more_than_one {
						app.gen('}')
					}
				}
			}
			if more_than_one {
				app.gen("'")
			}
		} else if fun is SelectorExpr {
			mut count := 0
			for idx, arg in call.args {
				if idx == 0 && fun.x is Ident && fun.x.name == 'strings' {
					continue
				}
				if count > 0 {
					app.gen(', ')
				}
				app.expr(arg)
				count++
			}
		} else if fun is Ident {
			if call.args.len > 0 {
				for arg in call.args {
					app.expr(arg)
				}
			}
		}
	}
	app.gen(')')
}

const nonexistent_modules = ['fmt', 'path', 'strings']

fn (mut app App) selector_expr_fn_call(call CallExpr, sel SelectorExpr) {
	// app.genln('///selector_expr_fn_call')
	if sel.x is Ident {
		if sel.x.name in nonexistent_modules {
			app.handle_nonexistent_module_call(sel, sel.x.name, sel.sel.name, call)
			return
		}
	}
	app.selector_xxx(sel)
}

fn (mut app App) selector_xxx(sel SelectorExpr) {
	app.expr(sel.x)
	app.gen('.')
	mut sel_name := sel.sel.name //.to_lower()
	if sel_name == 'string' {
		sel_name = 'str'
	}
	app.gen(app.go2v_ident(sel_name))
}

fn (mut app App) make_call(call CallExpr) {
	// app.genln('//make ${call.fun.type_name()} ar0=${call.args[0].type_name()}')
	app.expr(call.args[0])
	// len only
	if call.args.len == 2 {
		app.gen('{ len: ')
		app.expr(call.args[1])
		app.gen(' }')
	}
	// cap + len
	else if call.args.len == 3 {
		app.gen('{ len: ')
		app.expr(call.args[1])
		app.gen(', cap: ')
		app.expr(call.args[2])
		app.gen(' }')
	} else {
		app.gen('{}')
	}
}

fn (mut app App) handle_nonexistent_module_call(sel SelectorExpr, mod_name string, fn_name string, node CallExpr) {
	match mod_name {
		'strings' {
			app.handle_strings_call(app.go2v_ident(fn_name), node.args)
		}
		'path' {
			app.handle_path_call(sel, app.go2v_ident(fn_name), node.args)
		}
		'fmt' {
			app.handle_fmt_call(app.go2v_ident(fn_name), node.args)
		}
		else {}
	}
}

// handle_strings_call maps Go strings functions to string methods in V
fn (mut app App) handle_strings_call(fn_name string, args []Expr) {
	app.expr(args[0])
	app.gen('.')
	app.gen(fn_name)
	app.skip_first_arg = true
}

fn (mut app App) handle_path_call(sel SelectorExpr, fn_name string, x []Expr) {
	if fn_name == 'base' {
		app.gen('os.base')
	}
	// Go allows module name shadowing, so we can have a variable
	// `path`
	else {
		app.selector_xxx(sel)
	}
}

fn (mut app App) handle_fmt_call(fn_name string, _ []Expr) {
	// app.genln('//fmt_call fn_name=${fn_name}')
	match fn_name {
		'sprintf' {
			app.gen('strconv.v_sprintf')
		}
		else {
			app.gen('strconv.' + fn_name)
		}
	}
}