module cleanc

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

fn module_storage_csrc_for_test_sources(sources map[string]string) string {
    tmp_dir := os.join_path(os.temp_dir(), 'v2_module_storage_codegen_${os.getpid()}')
    os.rmdir_all(tmp_dir) or {}
    os.mkdir_all(tmp_dir) or { panic('failed to create temp dir') }
    defer {
        os.rmdir_all(tmp_dir) or {}
    }
    mut paths := []string{}
    for rel_path, code in sources {
        tmp_file := os.join_path(tmp_dir, rel_path)
        os.mkdir_all(os.dir(tmp_file)) or { panic('failed to create temp source dir') }
        os.write_file(tmp_file, code) or { panic('failed to write temp source') }
        paths << tmp_file
    }
    prefs := &vpref.Preferences{
        backend:     .cleanc
        no_parallel: true
    }
    mut file_set := token.FileSet.new()
    mut par := parser.Parser.new(prefs)
    files := par.parse_files(paths, mut file_set)
    env := types.Environment.new()
    mut checker := types.Checker.new(prefs, file_set, env)
    checker.check_files(files)
    mut trans := transformer.Transformer.new_with_pref(env, prefs)
    trans.set_file_set(file_set)
    transformed_files := trans.transform_files(files)
    mut gen := Gen.new_with_env_and_pref(transformed_files, env, prefs)
    return gen.gen()
}

fn test_generate_c_uses_module_prefix_for_qualified_module_storage() {
    csrc := module_storage_csrc_for_test_sources({
        'report/report.v': 'module report

pub __global mut errors = 0
'
        'main.v':          'module main

import report

fn main() {
    report.errors += 1
}
'
    })
    assert csrc.contains('int report__errors'), csrc
    assert csrc.contains('report__errors'), csrc
    assert !csrc.contains('\nint errors'), csrc
}

fn test_generate_c_resolves_module_storage_import_alias() {
    csrc := module_storage_csrc_for_test_sources({
        'report/report.v': 'module report

pub __global mut errors = 0
'
        'main.v':          'module main

import report as r

fn main() {
    r.errors += 1
}
'
    })
    assert csrc.contains('report__errors'), csrc
    assert !csrc.contains('r__errors'), csrc
}

fn test_generate_c_keeps_same_short_module_storage_names_distinct() {
    csrc := module_storage_csrc_for_test_sources({
        'a/a.v':  'module a

pub __global state = 1
'
        'b/b.v':  'module b

pub __global state = 2
'
        'main.v': 'module main

import a
import b

fn main() {
    _ = a.state + b.state
}
'
    })
    assert csrc.contains('int a__state = 1;'), csrc
    assert csrc.contains('int b__state = 2;'), csrc
    assert !csrc.contains('\nint state ='), csrc
}

fn test_generate_c_prefixes_module_storage_names_containing_dunders() {
    csrc := module_storage_csrc_for_test_sources({
        'a/a.v':  'module a

pub __global mut state__x = 1

pub fn bump() int {
    state__x += 1
    return state__x
}
    '
        'b/b.v':  'module b

pub __global mut state__x = 2

pub fn bump() int {
    state__x += 1
    return state__x
}
    '
        'main.v': 'module main

import a
import b

fn main() {
    _ = a.bump() + b.bump()
    _ = a.state__x + b.state__x
}
'
    })
    assert csrc.contains('int a__state__x = 1;'), csrc
    assert csrc.contains('int b__state__x = 2;'), csrc
    assert csrc.contains('a__state__x += 1;'), csrc
    assert csrc.contains('return a__state__x;'), csrc
    assert csrc.contains('b__state__x += 1;'), csrc
    assert csrc.contains('return b__state__x;'), csrc
    assert !csrc.contains('\nint state__x ='), csrc
    assert !csrc.contains('\n\tstate__x += 1;'), csrc
    assert !csrc.contains('\n\treturn state__x;'), csrc
}

fn test_generate_c_keeps_c_global_declaration_unmangled() {
    csrc := module_storage_csrc_for_test_sources({
        'main.v': 'module main

@[c_extern]
__global C.errno int

@[c_extern]
__global C.stdin voidptr

@[c_extern]
__global C.stdout voidptr

@[c_extern]
__global C.stderr voidptr

fn main() {
    _ = C.errno
    _ = C.stdin
    _ = C.stdout
    _ = C.stderr
}
'
    })
    assert !csrc.contains('main__C.errno'), csrc
    assert !csrc.contains('main__errno'), csrc
    assert !csrc.contains('main__stdin'), csrc
    assert !csrc.contains('main__stdout'), csrc
    assert !csrc.contains('main__stderr'), csrc
    assert csrc.contains('errno'), csrc
    assert csrc.contains('stdin'), csrc
    assert csrc.contains('stdout'), csrc
    assert csrc.contains('stderr'), csrc
}

fn test_generate_c_keeps_c_extern_global_attributes_unmangled() {
    csrc := module_storage_csrc_for_test_sources({
        'main.v': 'module main

@[c_extern; export: "raw_counter"; weak; hidden; markused]
__global raw_counter int

fn main() {
    _ = raw_counter
}
'
    })
    assert csrc.contains('extern int raw_counter;'), csrc
    assert csrc.contains('raw_counter'), csrc
    assert !csrc.contains('main__raw_counter'), csrc
}

fn test_generate_c_keeps_translated_c_v_extern_global_unmangled() {
    csrc := module_storage_csrc_for_test_sources({
        'cwrap/runtime.c.v': '@[translated]
module cwrap

@[c_extern; hidden; markused]
__global raw_status int

pub fn read_status() int {
    return raw_status
}
'
        'main.v':            'module main

import cwrap

fn main() {
    _ = cwrap.read_status()
    _ = cwrap.raw_status
}
'
    })
    assert csrc.contains('extern int raw_status;'), csrc
    assert csrc.contains('return raw_status;'), csrc
    assert csrc.count('raw_status') >= 3, csrc
    assert !csrc.contains('cwrap__raw_status'), csrc
}

fn test_generate_c_keeps_qualified_c_extern_global_alias_unmangled() {
    csrc := module_storage_csrc_for_test_sources({
        'cwrap/runtime.c.v': '@[translated]
module cwrap

@[c_extern; hidden; markused]
__global raw_status int
'
        'main.v':            'module main

import cwrap as cw

fn main() {
    _ = cw.raw_status
}
'
    })
    assert csrc.contains('extern int raw_status;'), csrc
    assert csrc.count('raw_status') >= 2, csrc
    assert !csrc.contains('cwrap__raw_status'), csrc
    assert !csrc.contains('cw__raw_status'), csrc
}

fn test_generate_c_keeps_plain_module_c_extern_global_unmangled() {
    csrc := module_storage_csrc_for_test_sources({
        'ext/ext.v': 'module ext

@[c_extern]
pub __global raw_status int

pub fn read_status() int {
    return raw_status
}
'
        'main.v':    'module main

import ext

fn main() {
    _ = ext.raw_status
    _ = ext.read_status()
}
'
    })
    assert csrc.contains('extern int raw_status;'), csrc
    assert csrc.contains('return raw_status;'), csrc
    assert csrc.contains('(void)(raw_status);'), csrc
    assert !csrc.contains('ext__raw_status'), csrc
}