// Copyright (c) 2026 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module transformer

import os
import v2.ast
import v2.parser
import v2.pref as vpref
import v2.token
import v2.types

fn parse_optional_test_code(code string, target_os string, defines []string) []ast.File {
	tmp_file := '/tmp/v2_parser_optional_cond_test_${os.getpid()}.v'
	os.write_file(tmp_file, code) or { panic('failed to write temp file') }
	defer {
		os.rm(tmp_file) or {}
	}
	prefs := &vpref.Preferences{
		backend:               .cleanc
		no_parallel:           true
		target_os:             target_os
		user_defines:          defines
		explicit_user_defines: defines.clone()
	}
	mut file_set := token.FileSet.new()
	mut par := parser.Parser.new(prefs)
	return par.parse_files([tmp_file], mut file_set)
}

fn transform_optional_test_code(code string, target_os string, defines []string) []ast.File {
	tmp_file := '/tmp/v2_transformer_optional_cond_test_${os.getpid()}.v'
	os.write_file(tmp_file, code) or { panic('failed to write temp file') }
	defer {
		os.rm(tmp_file) or {}
	}
	prefs := &vpref.Preferences{
		backend:               .cleanc
		no_parallel:           true
		target_os:             target_os
		user_defines:          defines
		explicit_user_defines: defines.clone()
	}
	mut file_set := token.FileSet.new()
	mut par := parser.Parser.new(prefs)
	files := par.parse_files([tmp_file], mut file_set)
	mut env := types.Environment.new()
	mut checker := types.Checker.new(prefs, file_set, env)
	checker.check_files(files)
	mut trans := Transformer.new_with_pref(env, prefs)
	return trans.transform_files(files)
}

fn optional_test_struct_field_names(file ast.File, struct_name string) []string {
	for stmt in file.stmts {
		if stmt is ast.StructDecl && stmt.name == struct_name {
			mut names := []string{cap: stmt.fields.len}
			for field in stmt.fields {
				names << field.name
			}
			return names
		}
	}
	return []string{}
}

fn optional_test_fn_stmt_count(files []ast.File, name string) int {
	for file in files {
		for stmt in file.stmts {
			if stmt is ast.FnDecl && stmt.name == name {
				return stmt.stmts.len
			}
		}
	}
	return -1
}

fn optional_test_first_return_number(files []ast.File, name string) string {
	for file in files {
		for stmt in file.stmts {
			if stmt is ast.FnDecl && stmt.name == name {
				for nested in stmt.stmts {
					if nested is ast.ReturnStmt && nested.exprs.len == 1
						&& nested.exprs[0] is ast.BasicLiteral {
						return (nested.exprs[0] as ast.BasicLiteral).value
					}
				}
			}
		}
	}
	return ''
}

fn test_parser_struct_field_attr_optional_os_requires_user_define() {
	source := '
module main

struct Container {
	name string
	plain_linux int @[if linux]
	optional_linux int @[if linux ?]
}
'
	no_define_files := parse_optional_test_code(source, 'linux', [])
	assert no_define_files.len == 1
	assert optional_test_struct_field_names(no_define_files[0], 'Container') == [
		'name',
		'plain_linux',
	]

	defined_files := parse_optional_test_code(source, 'linux', ['linux'])
	assert defined_files.len == 1
	assert optional_test_struct_field_names(defined_files[0], 'Container') == ['name', 'plain_linux',
		'optional_linux']
}

fn test_transformer_comptime_optional_os_requires_user_define() {
	source := '
module main

fn optional_branch() int {
	$if linux ? {
		return 1
	} $else {
		return 2
	}
}

fn plain_os_branch() int {
	$if linux {
		return 3
	} $else {
		return 4
	}
}
'
	no_define_files := transform_optional_test_code(source, 'linux', [])
	assert optional_test_first_return_number(no_define_files, 'optional_branch') == '2'
	assert optional_test_first_return_number(no_define_files, 'plain_os_branch') == '3'

	defined_files := transform_optional_test_code(source, 'linux', ['linux'])
	assert optional_test_first_return_number(defined_files, 'optional_branch') == '1'
	assert optional_test_first_return_number(defined_files, 'plain_os_branch') == '3'
}

fn test_transformer_function_attr_optional_os_requires_user_define() {
	source := '
module main

@[if linux ?]
fn optional_fn() int {
	return 1
}

@[if linux]
fn plain_os_fn() int {
	return 2
}
'
	no_define_files := transform_optional_test_code(source, 'linux', [])
	assert optional_test_fn_stmt_count(no_define_files, 'optional_fn') == 0
	assert optional_test_fn_stmt_count(no_define_files, 'plain_os_fn') > 0

	defined_files := transform_optional_test_code(source, 'linux', ['linux'])
	assert optional_test_fn_stmt_count(defined_files, 'optional_fn') > 0
	assert optional_test_fn_stmt_count(defined_files, 'plain_os_fn') > 0
}