module builder

import os
import v2.ast
import v2.gen.v as gen_v
import v2.parser
import v2.pref
import v2.token

fn module_storage_cache_tmp_dir(label string) string {
	return os.join_path(os.temp_dir(), 'v2_module_storage_cache_${label}_${os.getpid()}')
}

fn module_storage_cached_header_source_for_test() string {
	tmp_dir := module_storage_cache_tmp_dir('source')
	os.rmdir_all(tmp_dir) or {}
	os.mkdir_all(os.join_path(tmp_dir, 'state')) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}
	source_file := os.join_path(tmp_dir, 'state', 'state.v')
	os.write_file(source_file, 'module state

pub __global mut total = 0
__global mut hidden = 0
') or {
		panic(err)
	}
	mut prefs := pref.new_preferences()
	mut b := new_builder(&prefs)
	source_files := b.parse_source_files_for_headers([source_file])
	header_ast := b.build_module_header_ast(source_files, 'state') or {
		panic('missing state header')
	}
	mut gen := gen_v.new_gen(b.pref)
	gen.gen(header_ast)
	return sanitize_header_source(gen.output_string(), map[string]string{})
}

fn module_mut_cached_header_source_for_test() string {
	tmp_dir := module_storage_cache_tmp_dir('module_mut_source')
	os.rmdir_all(tmp_dir) or {}
	os.mkdir_all(os.join_path(tmp_dir, 'state')) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}
	source_file := os.join_path(tmp_dir, 'state', 'state.v')
	os.write_file(source_file, 'module state

pub struct Counter {
pub module_mut:
	value int
pub mut:
	open int
}
') or {
		panic(err)
	}
	mut prefs := pref.new_preferences()
	mut b := new_builder(&prefs)
	source_files := b.parse_source_files_for_headers([source_file])
	header_ast := b.build_module_header_ast(source_files, 'state') or {
		panic('missing state header')
	}
	mut gen := gen_v.new_gen(b.pref)
	gen.gen(header_ast)
	return sanitize_header_source(gen.output_string(), map[string]string{})
}

fn module_mut_interface_cached_header_source_for_test() string {
	return module_mut_interface_cached_header_source_for_test_with_source_decls(false)
}

fn module_mut_interface_merged_cached_header_source_for_test() string {
	return module_mut_interface_cached_header_source_for_test_with_source_decls(true)
}

fn module_mut_interface_cached_header_source_for_test_with_source_decls(include_source_decls bool) string {
	tmp_dir := module_storage_cache_tmp_dir('module_mut_interface_source')
	os.rmdir_all(tmp_dir) or {}
	os.mkdir_all(os.join_path(tmp_dir, 'state')) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}
	source_file := os.join_path(tmp_dir, 'state', 'state.v')
	os.write_file(source_file, 'module state

pub type Handler = fn (int) bool

pub interface Mutator {
	handler Handler
	direct fn (int) bool
	handle(int) bool
mut:
	bump()
	reset()
}

pub struct Counter {
pub module_mut:
	iface Mutator
}
') or {
		panic(err)
	}
	mut prefs := pref.new_preferences()
	mut b := new_builder(&prefs)
	source_files := b.parse_source_files_for_headers([source_file])
	header_ast := b.build_module_header_ast(source_files, 'state') or {
		panic('missing state header')
	}
	mut gen := gen_v.new_gen(b.pref)
	gen.gen(header_ast)
	mut header_source := sanitize_header_source(gen.output_string(), map[string]string{})
	if include_source_decls {
		source_fn_decls := b.source_fn_decls_for_files([source_file])
		header_source = merge_missing_source_fn_decls(header_source, source_fn_decls)
	}
	return header_source
}

fn module_storage_cached_header_global(header_source string, name string) ast.FieldDecl {
	tmp_dir := module_storage_cache_tmp_dir('parse')
	os.rmdir_all(tmp_dir) or {}
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}
	header_path := os.join_path(tmp_dir, 'state.vh')
	os.write_file(header_path, header_source) or { panic(err) }
	mut prefs := pref.new_preferences()
	mut file_set := token.FileSet.new()
	mut par := parser.Parser.new(&prefs)
	files := par.parse_files([header_path], mut file_set)
	for stmt in files[0].stmts {
		if stmt is ast.GlobalDecl {
			for field in stmt.fields {
				if field.name == name {
					return field
				}
			}
		}
	}
	panic('missing cached header field ${name}')
}

fn module_storage_cached_header_struct(header_source string, name string) ast.StructDecl {
	tmp_dir := module_storage_cache_tmp_dir('parse_struct')
	os.rmdir_all(tmp_dir) or {}
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}
	header_path := os.join_path(tmp_dir, 'state.vh')
	os.write_file(header_path, header_source) or { panic(err) }
	mut prefs := pref.new_preferences()
	mut file_set := token.FileSet.new()
	mut par := parser.Parser.new(&prefs)
	files := par.parse_files([header_path], mut file_set)
	for stmt in files[0].stmts {
		if stmt is ast.StructDecl {
			if stmt.name == name {
				return stmt
			}
		}
	}
	panic('missing cached header struct ${name}')
}

fn module_storage_cached_header_interface(header_source string, name string) ast.InterfaceDecl {
	tmp_dir := module_storage_cache_tmp_dir('parse_interface')
	os.rmdir_all(tmp_dir) or {}
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}
	header_path := os.join_path(tmp_dir, 'state.vh')
	os.write_file(header_path, header_source) or { panic(err) }
	mut prefs := pref.new_preferences()
	mut file_set := token.FileSet.new()
	mut par := parser.Parser.new(&prefs)
	files := par.parse_files([header_path], mut file_set)
	for stmt in files[0].stmts {
		if stmt is ast.InterfaceDecl {
			if stmt.name == name {
				return stmt
			}
		}
	}
	panic('missing cached header interface ${name}')
}

fn module_storage_run_cached_header_check(label string, header_source string, main_source string) (int, string) {
	tmp_dir := module_storage_cache_tmp_dir(label)
	os.rmdir_all(tmp_dir) or {}
	os.mkdir_all(os.join_path(tmp_dir, 'state')) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}
	os.write_file(os.join_path(tmp_dir, 'state', 'state.v'), header_source) or { panic(err) }
	main_path := os.join_path(tmp_dir, 'main.v')
	os.write_file(main_path, main_source) or { panic(err) }
	out_path := os.join_path(tmp_dir, 'out.txt')
	cmd := '${os.quoted_path(@VEXE)} -v2 -backend v -o ${os.quoted_path(out_path)} ${os.quoted_path(main_path)} 2>&1'
	res := os.execute(cmd)
	return res.exit_code, res.output
}

fn test_module_storage_cached_header_preserves_flags() {
	header_source := module_storage_cached_header_source_for_test()
	assert header_source.contains('pub __global (')
	assert header_source.contains('mut total int')
	assert header_source.contains('__global (')
	assert header_source.contains('mut hidden int')
	public_field := module_storage_cached_header_global(header_source, 'total')
	assert public_field.is_public
	assert public_field.is_mut
	private_field := module_storage_cached_header_global(header_source, 'hidden')
	assert !private_field.is_public
	assert private_field.is_mut
}

fn test_module_storage_cached_header_preserves_module_mut_struct_fields() {
	header_source := module_mut_cached_header_source_for_test()
	assert header_source.contains('pub module_mut:')
	assert !header_source.contains('@[module_mut]')
	counter := module_storage_cached_header_struct(header_source, 'Counter')
	assert counter.fields[0].name == 'value'
	assert counter.fields[0].is_public
	assert counter.fields[0].is_mut
	assert counter.fields[0].is_module_mut
	assert counter.fields[1].name == 'open'
	assert counter.fields[1].is_public
	assert counter.fields[1].is_mut
	assert !counter.fields[1].is_module_mut
}

fn test_module_storage_cached_header_preserves_mut_interface_methods_for_module_mut_field() {
	header_source := module_mut_interface_cached_header_source_for_test()
	assert header_source.contains('pub interface Mutator {')
	assert header_source.contains('handler Handler')
	assert header_source.contains('direct fn(int) bool')
	assert header_source.contains('handle(int) bool')
	assert header_source.contains('mut:')
	assert header_source.contains('bump()')
	assert !header_source.contains('direct(int) bool')
	assert !header_source.contains('bump fn(')
	mutator := module_storage_cached_header_interface(header_source, 'Mutator')
	assert mutator.fields[0].name == 'handler'
	assert !mutator.fields[0].is_interface_method
	assert mutator.fields[1].name == 'direct'
	assert !mutator.fields[1].is_interface_method
	assert mutator.fields[2].name == 'handle'
	assert mutator.fields[2].is_interface_method
	assert mutator.fields[3].name == 'bump'
	assert mutator.fields[3].is_mut
	assert mutator.fields[3].is_interface_method
	assert mutator.fields[4].name == 'reset'
	assert mutator.fields[4].is_mut
	assert mutator.fields[4].is_interface_method

	module_mut_code, module_mut_output := module_storage_run_cached_header_check('module_mut_interface_method',
		header_source, 'module main

import state

fn main() {
	mut c := state.Counter{}
	c.iface.bump()
}
')
	assert module_mut_code != 0, 'cached module_mut interface method mutation should fail'
	assert module_mut_output.contains('cannot mutate module-mutable field `state.Counter.iface` outside module `state`'), module_mut_output
}

fn test_module_storage_cached_header_does_not_synthesize_interface_fn_field_decls() {
	header_source := module_mut_interface_merged_cached_header_source_for_test()
	assert header_source.contains('pub interface Mutator {')
	assert header_source.contains('direct fn(int) bool')
	assert header_source.contains('handle(int) bool')
	assert header_source.contains('pub fn (it Mutator) handle(int) bool')
	assert header_source.contains('pub fn (mut it Mutator) bump()')
	assert header_source.contains('pub fn (mut it Mutator) reset()')
	assert !header_source.contains('pub fn (it Mutator) direct fn')
	assert !header_source.contains('fn (it Mutator) direct fn')
	assert !header_source.contains('pub fn (it Mutator) bump()')

	module_mut_code, module_mut_output := module_storage_run_cached_header_check('module_mut_interface_merged_method',
		header_source, 'module main

import state

fn main() {
	mut c := state.Counter{}
	c.iface.bump()
}
')
	assert module_mut_code != 0, 'merged cached module_mut interface method mutation should fail'
	assert module_mut_output.contains('cannot mutate module-mutable field `state.Counter.iface` outside module `state`'), module_mut_output
}

fn test_module_storage_cached_header_visibility_matches_source_module() {
	header_source := module_storage_cached_header_source_for_test()
	public_code, public_output := module_storage_run_cached_header_check('public', header_source, 'module main

import state

fn main() {
	state.total += 1
}
')
	assert public_code == 0, public_output

	private_code, private_output := module_storage_run_cached_header_check('private',
		header_source, 'module main

import state

fn main() {
	state.hidden += 1
}
')
	assert private_code != 0, 'cached private module storage should fail'
	assert private_output.contains('module global `state.hidden` is private'), private_output
}

fn test_module_storage_cached_header_module_mut_visibility_matches_source_module() {
	header_source := module_mut_cached_header_source_for_test()
	public_code, public_output := module_storage_run_cached_header_check('module_mut_public',
		header_source, 'module main

import state

fn main() {
	mut c := state.Counter{}
	println(c.value)
	c.open++
}
')
	assert public_code == 0, public_output

	module_mut_code, module_mut_output := module_storage_run_cached_header_check('module_mut_private',
		header_source, 'module main

import state

fn main() {
	mut c := state.Counter{}
	c.value++
}
')
	assert module_mut_code != 0, 'cached module_mut field mutation should fail'
	assert module_mut_output.contains('cannot mutate module-mutable field `state.Counter.value` outside module `state`'), module_mut_output
}

fn test_module_storage_c_extern_import_cache_uses_raw_symbol() {
	tmp_dir := module_storage_cache_tmp_dir('c_extern_import')
	os.rmdir_all(tmp_dir) or {}
	os.mkdir_all(os.join_path(tmp_dir, 'ext')) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}
	mut prefs := pref.new_preferences()
	mut cache_builder := new_builder(&prefs)
	cache_dir := cache_builder.core_cache_dir()
	os.rmdir_all(cache_dir) or {}
	c_path := os.join_path(tmp_dir, 'raw_status.c')
	os.write_file(c_path, 'int raw_status = 7;\n') or { panic(err) }
	os.write_file(os.join_path(tmp_dir, 'ext', 'ext.v'), 'module ext

@[c_extern]
pub __global raw_status int

pub fn read_status() int {
	return raw_status
}
') or {
		panic(err)
	}
	main_path := os.join_path(tmp_dir, 'main.v')
	os.write_file(main_path, 'module main

import ext

#flag ${c_path}

fn main() {
	_ = ext.raw_status
	_ = ext.read_status()
}
') or {
		panic(err)
	}
	out_path := os.join_path(tmp_dir, 'out')
	cmd := '${os.quoted_path(@VEXE)} -v -v2 -keepc -o ${os.quoted_path(out_path)} ${os.quoted_path(main_path)} 2>&1'
	res := os.execute(cmd)
	assert res.exit_code == 0, res.output
	ext_header := os.read_file(cache_builder.core_header_path('ext')) or { panic(err) }
	assert ext_header.contains('@[c_extern]'), ext_header
	imports_c := os.read_file(os.join_path(cache_dir, 'imports.c')) or { panic(err) }
	assert imports_c.contains('return raw_status;'), imports_c
	assert !imports_c.contains('ext__raw_status'), imports_c
}