// vtest build: macos
module builder

import os
import v2.ast
import v2.pref

fn test_get_v_files_from_dir_uses_target_os() {
    tmp_dir := os.join_path(os.vtmp_dir(), 'v2_builder_target_os_${os.getpid()}')
    os.mkdir_all(tmp_dir) or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
    }
    os.write_file(os.join_path(tmp_dir, 'common.v'), 'module test') or { panic(err) }
    os.write_file(os.join_path(tmp_dir, 'platform_linux.v'), 'module test') or { panic(err) }
    os.write_file(os.join_path(tmp_dir, 'platform_macos.v'), 'module test') or { panic(err) }

    macos_files := get_v_files_from_dir(tmp_dir, []string{}, 'mac')
    macos_names := macos_files.map(os.file_name(it))
    assert 'common.v' in macos_names
    assert 'platform_macos.v' in macos_names
    assert 'platform_linux.v' !in macos_names

    linux_files := get_v_files_from_dir(tmp_dir, []string{}, 'linux')
    linux_names := linux_files.map(os.file_name(it))
    assert 'common.v' in linux_names
    assert 'platform_linux.v' in linux_names
    assert 'platform_macos.v' !in linux_names
}

fn test_get_v_files_from_dir_uses_d_and_notd_suffixes() {
    tmp_dir := os.join_path(os.vtmp_dir(), 'v2_builder_define_suffix_${os.getpid()}')
    os.mkdir_all(tmp_dir) or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
    }
    os.write_file(os.join_path(tmp_dir, 'common.v'), 'module test') or { panic(err) }
    os.write_file(os.join_path(tmp_dir, 'ssl_d_use_openssl.v'), 'module test') or { panic(err) }
    os.write_file(os.join_path(tmp_dir, 'ssl_notd_use_openssl.v'), 'module test') or { panic(err) }

    default_names := get_v_files_from_dir(tmp_dir, []string{}, 'mac').map(os.file_name(it))
    assert 'common.v' in default_names
    assert 'ssl_d_use_openssl.v' !in default_names
    assert 'ssl_notd_use_openssl.v' in default_names

    openssl_names := get_v_files_from_dir(tmp_dir, ['use_openssl'], 'mac').map(os.file_name(it))
    assert 'common.v' in openssl_names
    assert 'ssl_d_use_openssl.v' in openssl_names
    assert 'ssl_notd_use_openssl.v' !in openssl_names
}

fn test_get_v_files_from_dir_skips_prealloc_without_prealloc_flag() {
    tmp_dir := os.join_path(os.vtmp_dir(), 'v2_builder_prealloc_${os.getpid()}')
    os.mkdir_all(tmp_dir) or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
    }
    os.write_file(os.join_path(tmp_dir, 'common.v'), 'module test') or { panic(err) }
    os.write_file(os.join_path(tmp_dir, 'prealloc.c.v'), 'module test') or { panic(err) }

    default_names := get_v_files_from_dir(tmp_dir, []string{}, 'mac').map(os.file_name(it))
    assert 'common.v' in default_names
    assert 'prealloc.c.v' !in default_names

    prealloc_names := get_v_files_from_dir(tmp_dir, ['prealloc'], 'mac').map(os.file_name(it))
    assert 'common.v' in prealloc_names
    assert 'prealloc.c.v' in prealloc_names
}

fn test_get_v_files_from_dir_returns_lexically_sorted_files() {
    tmp_dir := os.join_path(os.vtmp_dir(), 'v2_builder_sorted_v_files_${os.getpid()}')
    os.mkdir_all(tmp_dir) or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
    }
    os.write_file(os.join_path(tmp_dir, 'foo.v'), 'module test') or { panic(err) }
    os.write_file(os.join_path(tmp_dir, 'foo.c.v'), 'module test') or { panic(err) }
    os.write_file(os.join_path(tmp_dir, 'bar.v'), 'module test') or { panic(err) }
    os.write_file(os.join_path(tmp_dir, 'ignore.txt'), 'not v') or { panic(err) }

    names := get_v_files_from_dir(tmp_dir, []string{}, 'linux').map(os.file_name(it))
    assert names == ['bar.v', 'foo.c.v', 'foo.v']
    assert names.index('foo.c.v') or { -1 } < names.index('foo.v') or { -1 }
}

fn test_flag_helpers_use_target_os() {
    assert flag_os_matches('macos', 'mac')
    assert flag_os_matches('bsd', 'mac')
    assert flag_os_matches('bsd', 'freebsd')
    assert !flag_os_matches('linux', 'mac')
    assert comptime_cond_matches('macos', 'mac')
    assert comptime_cond_matches('linux || bsd', 'mac')
    assert !comptime_cond_matches('linux', 'mac')
    assert comptime_cond_matches('macos && !linux', 'mac')
    macos_flag := parse_flag_directive_line('#flag macos -framework Cocoa', '/tmp/source.v', 'mac') or {
        ''
    }
    linux_flag := parse_flag_directive_line('#flag linux -lm', '/tmp/source.v', 'mac') or { '' }
    assert macos_flag == '-framework Cocoa'
    assert linux_flag == ''
}

fn test_flag_helpers_expand_when_first_existing() {
    tmp_dir := os.join_path(os.vtmp_dir(), 'v2_builder_when_first_${os.getpid()}')
    existing_dir := os.join_path(tmp_dir, 'openssl_include')
    os.mkdir_all(existing_dir) or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
    }
    missing_dir := os.join_path(tmp_dir, 'missing')
    flag := parse_flag_directive_line("#flag darwin -I\$when_first_existing('${missing_dir}','${existing_dir}')", os.join_path(tmp_dir,
        'source.v'), 'mac') or { '' }
    assert flag == '-I${existing_dir}'
    none_flag := parse_flag_directive_line("#flag darwin -I\$when_first_existing('${missing_dir}')", os.join_path(tmp_dir,
        'source.v'), 'mac') or { '' }
    assert none_flag == ''
}

fn test_split_compile_and_link_flags_moves_c_sources_to_link_step() {
    compile_flags, link_flags :=
        split_compile_and_link_flags('-I /tmp/include -DMYFLAG thirdparty/sqlite/sqlite3.c -L/tmp/lib -lsqlite3 foo.o')
    assert compile_flags == '-I /tmp/include -DMYFLAG'
    assert link_flags == 'thirdparty/sqlite/sqlite3.c -L/tmp/lib -lsqlite3 foo.o'
}

fn test_sanitize_header_source_preserves_public_module_storage() {
    source := 'module state

pub __global (
    mut count int
    pub mut shared int
)

pub __global mut total int
'
    sanitized := sanitize_header_source(source, map[string]string{})
    assert sanitized.contains('pub __global (')
    assert sanitized.contains('mut count int')
    assert sanitized.contains('pub mut shared int')
    assert sanitized.contains('pub __global mut total int')
}

fn test_build_module_header_ast_preserves_module_storage_flags() {
    mut prefs := pref.new_preferences()
    mut b := new_builder(&prefs)
    source_file := ast.File{
        mod:   'state'
        name:  'state.v'
        stmts: [
            ast.Stmt(ast.ModuleStmt{
                name: 'state'
            }),
            ast.Stmt(ast.GlobalDecl{
                is_public: true
                fields:    [
                    ast.FieldDecl{
                        name:      'private_count'
                        typ:       ast.Ident{
                            name: 'int'
                        }
                        is_mut:    true
                        is_public: false
                    },
                    ast.FieldDecl{
                        name:      'shared_count'
                        typ:       ast.Ident{
                            name: 'int'
                        }
                        is_mut:    true
                        is_public: true
                    },
                ]
            }),
        ]
    }
    header := b.build_module_header_ast([source_file], 'state') or {
        panic('missing module storage header')
    }
    mut found := false
    for stmt in header.stmts {
        if stmt is ast.GlobalDecl {
            found = true
            assert stmt.is_public
            assert stmt.fields.len == 2
            assert stmt.fields[0].name == 'private_count'
            assert stmt.fields[0].is_mut
            assert !stmt.fields[0].is_public
            assert stmt.fields[1].name == 'shared_count'
            assert stmt.fields[1].is_mut
            assert stmt.fields[1].is_public
        }
    }
    assert found
}

fn test_cflags_need_objc_mode_only_for_objc_inputs() {
    assert cflags_need_objc_mode('-framework Cocoa')
    assert cflags_need_objc_mode('/tmp/clipboard_darwin.m -framework Foundation')
    assert !cflags_need_objc_mode('-I /tmp/include -lssl -lcrypto /tmp/sqlite3.c')
    assert !cflags_need_objc_mode('-I /tmp/project.m/include')
}

fn test_file_has_incompatible_os_suffix_windows() {
    assert pref.file_has_incompatible_os_suffix('time_solaris.c.v', 'windows')
    assert pref.file_has_incompatible_os_suffix('time_freebsd.c.v', 'windows')
    assert pref.file_has_incompatible_os_suffix('time_openbsd.c.v', 'windows')
    assert pref.file_has_incompatible_os_suffix('time_netbsd.c.v', 'windows')
    assert pref.file_has_incompatible_os_suffix('time_dragonfly.c.v', 'windows')
    assert pref.file_has_incompatible_os_suffix('time_nix.c.v', 'windows')
    assert !pref.file_has_incompatible_os_suffix('time_windows.c.v', 'windows')
}

fn test_file_has_incompatible_os_suffix_non_windows_targets() {
    assert !pref.file_has_incompatible_os_suffix('time_solaris.c.v', 'solaris')
    assert !pref.file_has_incompatible_os_suffix('time_freebsd.c.v', 'freebsd')
    assert !pref.file_has_incompatible_os_suffix('time_bsd.c.v', 'macos')
    assert pref.file_has_incompatible_os_suffix('time_bsd.c.v', 'linux')
    assert !pref.file_has_incompatible_os_suffix('time_darwin.c.v', 'macos')
    assert !pref.file_has_incompatible_os_suffix('time_macos.c.v', 'darwin')
    assert !pref.file_has_incompatible_os_suffix('time_android_outside_termux.c.v', 'android')
    assert pref.file_has_incompatible_os_suffix('time_windows.c.v', 'linux')
    assert pref.file_has_incompatible_os_suffix('time_android_outside_termux.c.v', 'linux')
}

fn test_default_cc_uses_tcc_when_available() {
    vroot := os.dir(os.dir(@FILE))
    tcc_path := os.join_path(vroot, 'thirdparty', 'tcc', 'tcc.exe')
    cc := default_cc(vroot)
    if os.exists(tcc_path) {
        assert cc.contains('tcc')
    } else {
        assert cc == 'cc'
    }
}

fn test_cc_recompile_flags_from_cmd_keeps_include_paths() {
    cmd := 'cc -I /tmp/include -I/tmp/other -Dfoo=1 -x objective-c -std=gnu11 -fwrapv "/tmp/main.c" -x none "/tmp/lib.o" -L/tmp/lib -lm -o "app"'
    flags := cc_recompile_flags_from_cmd(cmd)
    assert flags.contains('-I /tmp/include')
    assert flags.contains('-I/tmp/other')
    assert flags.contains('-Dfoo=1')
    assert flags.contains('-x objective-c')
    assert flags.contains('-std=gnu11')
    assert flags.contains('-fwrapv')
    assert !flags.contains('/tmp/lib.o')
    assert !flags.contains('-L/tmp/lib')
    assert !flags.contains('-lm')
    assert !flags.contains('-o')
}