import os

struct WasmVarUint {
    value    u32
    next_idx int
}

struct WasmModuleSummary {
mut:
    exports           []string
    has_start_section bool
}

fn test_wasm_browser_target_allows_empty_main() {
    vexe := os.quoted_path(@VEXE)
    wrkdir := os.join_path(os.vtmp_dir(), 'wasm_browser_tests')
    os.mkdir_all(wrkdir)!
    defer {
        os.rmdir_all(wrkdir) or {}
    }

    source_path := os.join_path(wrkdir, 'empty_main.wasm.v')
    os.write_file(source_path, 'pub fn main() {}\n')!

    flags_sets := [
        '-no-bounds-checking -b wasm -os browser',
        '-no-bounds-checking -enable-globals -b wasm -os browser',
    ]

    for idx, flags in flags_sets {
        output_path := os.join_path(wrkdir, 'empty_main_${idx}.wasm')
        res :=
            os.execute('${vexe} ${flags} -o ${os.quoted_path(output_path)} ${os.quoted_path(source_path)}')
        assert res.exit_code == 0, 'compilation failed for `${flags}`: ${res.output}'
        assert os.exists(output_path), 'missing output for `${flags}`'
    }
}

fn test_wasm_shared_library_exports_custom_names_without_main() {
    vexe := os.quoted_path(@VEXE)
    wrkdir := os.join_path(os.vtmp_dir(), 'wasm_shared_library_tests')
    os.mkdir_all(wrkdir)!
    defer {
        os.rmdir_all(wrkdir) or {}
    }

    source_path := os.join_path(wrkdir, 'my_wasm_lib.v')
    output_path := os.join_path(wrkdir, 'my_wasm_lib.wasm')
    source := [
        'module my_wasm_lib',
        '',
        "@[export: 'myFunction']",
        'fn my_function(a int, b int) int {',
        '\treturn a + b',
        '}',
    ].join_lines()
    os.write_file(source_path, source)!

    res :=
        os.execute('${vexe} -b wasm -shared -o ${os.quoted_path(output_path)} ${os.quoted_path(source_path)}')
    assert res.exit_code == 0, 'compilation failed: ${res.output}'
    assert os.exists(output_path), 'missing output for shared wasm library'

    wasm_bytes := os.read_bytes(output_path)!
    summary := inspect_wasm_module(wasm_bytes) or { panic(err) }

    assert 'myFunction' in summary.exports
    assert '_start' !in summary.exports
    assert summary.has_start_section
}

fn inspect_wasm_module(wasm_bytes []u8) !WasmModuleSummary {
    if wasm_bytes.len < 8 {
        return error('wasm module is too short')
    }
    if wasm_bytes[0] != 0x00 || wasm_bytes[1] != 0x61 || wasm_bytes[2] != 0x73
        || wasm_bytes[3] != 0x6d || wasm_bytes[4] != 0x01 || wasm_bytes[5] != 0x00
        || wasm_bytes[6] != 0x00 || wasm_bytes[7] != 0x00 {
        return error('invalid wasm header')
    }

    mut summary := WasmModuleSummary{}
    mut idx := 8
    for idx < wasm_bytes.len {
        section_id := wasm_bytes[idx]
        idx++
        section_len := read_wasm_u32(wasm_bytes, idx)!
        idx = section_len.next_idx
        section_end := idx + int(section_len.value)
        if section_end > wasm_bytes.len {
            return error('wasm section exceeds module bounds')
        }
        match section_id {
            u8(7) {
                mut export_idx := idx
                exports_len := read_wasm_u32(wasm_bytes, export_idx)!
                export_idx = exports_len.next_idx
                for _ in 0 .. int(exports_len.value) {
                    name_len := read_wasm_u32(wasm_bytes, export_idx)!
                    export_idx = name_len.next_idx
                    name_end := export_idx + int(name_len.value)
                    if name_end > section_end {
                        return error('wasm export name exceeds section bounds')
                    }
                    summary.exports << wasm_bytes[export_idx..name_end].bytestr()
                    export_idx = name_end
                    if export_idx >= section_end {
                        return error('wasm export kind is missing')
                    }
                    export_idx++
                    export_ref := read_wasm_u32(wasm_bytes, export_idx)!
                    export_idx = export_ref.next_idx
                }
            }
            u8(8) {
                summary.has_start_section = true
            }
            else {}
        }

        idx = section_end
    }
    return summary
}

fn read_wasm_u32(wasm_bytes []u8, start int) !WasmVarUint {
    mut value := u32(0)
    mut shift := u32(0)
    mut idx := start
    for idx < wasm_bytes.len {
        b := wasm_bytes[idx]
        value |= u32(b & 0x7f) << shift
        idx++
        if b & 0x80 == 0 {
            return WasmVarUint{
                value:    value
                next_idx: idx
            }
        }
        shift += 7
        if shift >= 35 {
            break
        }
    }
    return error('invalid wasm varuint32 encoding')
}