import os

const vexe = @VEXE

fn test_skip_unused_prunes_unused_generic_fn_instantiations() {
	tmp_dir := os.join_path(os.vtmp_dir(), 'v_issue_26019')
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}
	source_path := os.join_path(tmp_dir, 'issue_26019.v')
	source := [
		'module main',
		'',
		'fn new[T]() map[u8]T {',
		'\tx := map[u8]T{}',
		'\treturn x',
		'}',
		'',
		'fn not_used_fn() map[u8]int {',
		'\tx := new[int]()',
		'\treturn x',
		'}',
		'',
		'fn main() {',
		'\tx := new[u32]()',
		'\tdump(x)',
		'}',
	].join('\n')
	os.write_file(source_path, source) or { panic(err) }
	res := os.execute('${os.quoted_path(vexe)} -o - ${os.quoted_path(source_path)}')
	if res.exit_code != 0 {
		panic(res.output)
	}
	assert res.output.contains('VV_LOC Map_u8_u32 main__new_T_u32(void)')
	assert !res.output.contains('VV_LOC Map_u8_int main__new_T_int(void)')
}

fn test_skip_unused_keeps_generic_offsetof_struct_instantiations() {
	tmp_dir := os.join_path(os.vtmp_dir(), 'v_issue_27283_generic_offsetof')
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}
	source_path := os.join_path(tmp_dir, 'issue_27283_generic_offsetof.v')
	binary_path := os.join_path(tmp_dir, 'issue_27283_generic_offsetof')
	source := [
		'module main',
		'',
		'struct Box[T] {',
		'\ta int',
		'\tb T',
		'}',
		'',
		'fn off[T]() u32 {',
		'\treturn __offsetof(Box[T], b)',
		'}',
		'',
		'fn main() {',
		'\tprintln(off[int]())',
		'\tprintln(off[string]())',
		'}',
	].join('\n')
	os.write_file(source_path, source) or { panic(err) }
	res :=
		os.execute('${os.quoted_path(vexe)} -skip-unused -o ${os.quoted_path(binary_path)} ${os.quoted_path(source_path)}')
	if res.exit_code != 0 {
		panic(res.output)
	}
}

fn test_skip_unused_does_not_emit_impl_methods_for_interface_extensions() {
	tmp_dir := os.join_path(os.vtmp_dir(), 'v_skip_unused_interface_extension_collision')
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}
	source_path := os.join_path(tmp_dir, 'interface_extension_collision.v')
	source := [
		'module main',
		'',
		'import crypto.internal.subtle',
		'',
		'interface Elem {}',
		'',
		'struct Thing {}',
		'',
		'struct Holder {',
		'\titems []Elem',
		'}',
		'',
		'fn (el Elem) equal(_ Elem) bool {',
		'\treturn true',
		'}',
		'',
		'fn (t Thing) equal(_ Thing) bool {',
		'\treturn subtle.constant_time_compare([u8(1)], [u8(1)]) == 1',
		'}',
		'',
		'fn (h Holder) ok() bool {',
		'\tfor i, item in h.items {',
		'\t\tfor j, obj in h.items {',
		'\t\t\tif i == j {',
		'\t\t\t\treturn item.equal(obj)',
		'\t\t\t}',
		'\t\t}',
		'\t}',
		'\treturn false',
		'}',
		'',
		'fn main() {',
		'\th := Holder{items: [Elem(Thing{}), Elem(Thing{})]}',
		'\tprintln(h.ok())',
		'}',
	].join('\n')
	os.write_file(source_path, source) or { panic(err) }
	res := os.execute('${os.quoted_path(vexe)} -o - ${os.quoted_path(source_path)}')
	if res.exit_code != 0 {
		panic(res.output)
	}
	assert res.output.contains('VV_LOC bool main__Elem_equal(')
	assert !res.output.contains('main__Thing_equal(')
}

fn test_skip_unused_keeps_json2_embedded_struct_decode_helpers() {
	tmp_dir := os.join_path(os.vtmp_dir(), 'v_issue_26928')
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}
	source_path := os.join_path(tmp_dir, 'issue_26928.v')
	source := [
		'module main',
		'',
		'import time',
		'import x.json2',
		'',
		'struct Meta {',
		'\tcreated_at ?time.Time',
		'}',
		'',
		'struct Req {',
		'\tMeta',
		'\tname string',
		'}',
		'',
		'fn main() {',
		'\t_ := json2.decode[Req](\'{"name":"x"}\') or { panic(err) }',
		'}',
	].join('\n')
	os.write_file(source_path, source) or { panic(err) }
	res := os.execute('${os.quoted_path(vexe)} -w -o - ${os.quoted_path(source_path)}')
	if res.exit_code != 0 {
		panic(res.output)
	}
	assert res.output.contains('x__json2__decode_struct_key_T_main__Req')
	assert res.output.contains('x__json2__check_required_struct_fields_T_main__Req')
	// the `?time.Time` payload of the embedded `Meta` is decoded through a generic
	// instantiation reachable only via comptime `$for field` codegen; skip-unused
	// must keep it. Assert the payload decoder itself rather than a specific json2
	// helper name, so the test does not break when those helpers are refactored.
	assert res.output.contains('x__json2__Decoder_decode_value_T_time__Time')
}

fn test_skip_unused_marks_dependencies_inside_generic_anon_fns() {
	tmp_dir := os.join_path(os.vtmp_dir(), 'v_generic_anon_fn_dependencies')
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}
	source_path := os.join_path(tmp_dir, 'generic_anon_fn_dependencies.v')
	binary_path := os.join_path(tmp_dir, 'generic_anon_fn_dependencies')
	source := [
		'module main',
		'',
		'struct Holder[T] {',
		'\tdata []T',
		'}',
		'',
		'fn (h &Holder[T]) nmap[T](others []&Holder[T], f fn ([]T) T) T {',
		'\treturn f([h.data[0], others[0].data[0]])',
		'}',
		'',
		'fn (a &Holder[T]) subtract[T](b &Holder[T]) T {',
		'\treturn a.nmap([b], fn [T] (xs []T) T {',
		'\t\tx := xs[0]',
		'\t\ty := xs[1]',
		'\t\t$if T is string {',
		"\t\t\treturn x.replace(y, '')",
		'\t\t} $else {',
		'\t\t\treturn x - y',
		'\t\t}',
		'\t})',
		'}',
		'',
		'fn unused_string() {',
		"\ta := &Holder[string]{data: ['abc']}",
		"\tb := &Holder[string]{data: ['b']}",
		'\tprintln(a.subtract(b))',
		'}',
		'',
		'fn main() {',
		'\ta := &Holder[int]{data: [1]}',
		'\tb := &Holder[int]{data: [2]}',
		'\tprintln(a.subtract(b))',
		'}',
	].join('\n')
	os.write_file(source_path, source) or { panic(err) }
	res :=
		os.execute('${os.quoted_path(vexe)} -d no_backtrace -o ${os.quoted_path(binary_path)} ${os.quoted_path(source_path)}')
	if res.exit_code != 0 {
		panic(res.output)
	}
}

fn test_skip_unused_keeps_generic_next_for_for_in_when_direct_calls_use_other_types() {
	// Regression for https://github.com/vlang/v/issues/27147 .
	// A `for in` over a generic iterator instantiation (e.g. `Range[big.Integer]`)
	// must emit the matching `next` instantiation, even when other code calls
	// methods on a different instantiation of the same generic struct directly
	// (e.g. `iter.next()` on a `Range[int]`).
	tmp_dir := os.join_path(os.vtmp_dir(), 'v_issue_27147')
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}
	source_path := os.join_path(tmp_dir, 'issue_27147.v')
	binary_path := os.join_path(tmp_dir, 'issue_27147')
	source := [
		'module main',
		'',
		'import math.big',
		'',
		'struct Range[T] {',
		'\tstart T',
		'\tend   T',
		'\tstep  T',
		'mut:',
		'\tcur T',
		'}',
		'',
		'pub fn (mut r Range[T]) next() ?T {',
		'\tif r.cur > r.end {',
		'\t\treturn none',
		'\t}',
		'\tdefer { r.cur += r.step }',
		'\treturn r.cur',
		'}',
		'',
		'pub fn (mut r Range[T]) reset() {',
		'\tr.cur = r.start',
		'}',
		'',
		'pub fn range[T](start T, end T, step T) Range[T] {',
		'\treturn Range[T]{start: start, end: end, step: step, cur: start}',
		'}',
		'',
		'fn main() {',
		'\tmut iter := range(0, 5, 1)',
		'\titer.reset()',
		'\titer.next()',
		'\tend := big.integer_from_int(3)',
		'\tfor i in range[big.Integer](big.zero_int, end, big.one_int) {',
		'\t\tprintln(i)',
		'\t}',
		'}',
	].join('\n')
	os.write_file(source_path, source) or { panic(err) }
	res :=
		os.execute('${os.quoted_path(vexe)} -o ${os.quoted_path(binary_path)} ${os.quoted_path(source_path)}')
	if res.exit_code != 0 {
		panic(res.output)
	}
}