import os
import time
import v.pref

struct TestStruct {
    test string
}

fn (mut t TestStruct) test_struct() {
    assert @STRUCT == 'TestStruct'
}

fn (mut t TestStruct) test_struct_w_return() string {
    assert @STRUCT == 'TestStruct'
    return t.test
}

fn (mut t TestStruct) test_struct_w_high_order(cb fn (int) string) string {
    assert @STRUCT == 'TestStruct'
    return 'test' + cb(2)
}

fn TestStruct.static_method() string {
    assert @STRUCT == 'TestStruct'
    return @STRUCT
}

struct Abc {
}

fn (a Another) method() string {
    println(@STRUCT)
    return @STRUCT
}

struct Another {
}

fn (a Abc) method() string {
    println(@STRUCT)
    return @STRUCT
}

fn test_at_struct_ordering() {
    a := Abc{}
    assert a.method() == 'Abc'
    b := Another{}
    assert b.method() == 'Another'
}

struct TestFn {
}

fn (mut t TestFn) tst_1() {
    assert @FN == 'tst_1'
}

fn (mut t TestFn) tst_2(cb fn (int)) {
    assert @FN == 'tst_2'
    assert @METHOD == 'TestFn.tst_2'
    cb(1)
}

fn TestFn.static_fn() {
    assert @FN == 'static_fn'
    assert @METHOD == 'TestFn.static_fn'
    assert @STRUCT == 'TestFn'
}

fn fn_name_mod_level() {
    assert @FN == 'fn_name_mod_level'
    assert @METHOD == 'fn_name_mod_level'
}

fn fn_name_mod_level_high_order(cb fn (int)) {
    assert @FN == 'fn_name_mod_level_high_order'
    cb(1)
}

fn test_at_file() {
    // Test @FILE
    f := os.file_name(@FILE)
    assert f == 'comptime_at_test.v'
}

fn test_at_dir() {
    // Test @DIR
    f := os.file_name(@DIR)
    assert f == 'comptime'
    assert os.dir(@FILE) == @DIR
    d := @DIR
    assert d.len > 0
    assert !d.ends_with('.v')
}

fn test_at_file_len() {
    // Test @FILE_LINE
    line1, line2 := '${@LINE}', '${@FILE_LINE}'
    assert os.file_name(@FILE) + ':' + line1.str() == line2
}

fn test_at_fn() {
    // Test @FN
    assert @FN == 'test_at_fn'
    fn_name_mod_level()
    fn_name_mod_level_high_order(fn (i int) {
        t := i + 1
        assert t == 2
    })
    mut tfn := TestFn{}
    tfn.tst_1()
    tfn.tst_2(fn (i int) {
        t := i + 1
        assert t == 2
    })
    TestFn.static_fn()
}

fn test_at_mod() {
    // Test @MOD
    assert @MOD == 'main'
}

fn test_at_struct() {
    // Test @STRUCT
    assert @STRUCT == ''
    mut ts := TestStruct{
        test: 'test'
    }
    ts.test_struct()
    r1 := ts.test_struct_w_return()
    r2 := ts.test_struct_w_high_order(fn (i int) string {
        assert @STRUCT == ''
        return i.str()
    })
    assert r1 == 'test'
    assert r2 == 'test2'
    assert TestStruct.static_method() == 'TestStruct'
    assert @STRUCT == ''
}

fn test_vmod_file() {
    content := @VMOD_FILE
    assert content.len > 0
    assert content.contains('Module {')
    assert content.contains('name:')
    assert content.contains('version:')
    assert content.contains('description:')
}

fn test_comptime_at() {
    assert @VEXE == pref.vexe_path()
}

// Reasons for assertions that are not literal:
// to prevent assertion invalidation due to "line" changes in subsequent code changes
fn test_line_number_last_token() {
    line1, line2, line3 := @LINE, @LINE, @LINE
    assert line1 == line2
    assert line1 == line3
}

fn abc() {
    assert @LOCATION.contains('comptime_at_test.v:')
    assert @LOCATION.ends_with(', main.abc')
}

struct MyStruct {
}

fn MyStruct.new() MyStruct {
    assert @LOCATION.ends_with('main.MyStruct.new (static)')
    return MyStruct{}
}

fn (s MyStruct) mymethod() {
    assert @LOCATION.contains('comptime_at_test.v:')
    assert @LOCATION.ends_with('main.MyStruct{}.mymethod')
}

fn test_at_location() {
    abc()
    MyStruct.new().mymethod()
    assert @LOCATION.contains('comptime_at_test.v:')
    assert @LOCATION.ends_with('main.test_at_location')
}

fn test_at_build_date_time_timestamp() {
    bd := dump(@BUILD_DATE)
    bt := dump(@BUILD_TIME)
    bts := dump(@BUILD_TIMESTAMP)
    assert bd.len > 0
    assert bt.len > 0
    assert bd.count('-') == 2
    assert bt.count(':') == 2
    assert bts.len > 0
    assert bts.i64() > 1_000_000_000
    now_utc := dump(time.utc().unix())
    assert now_utc >= bts.i64()
}

fn test_at_os() {
    println('Current OS is ${@OS}')
    assert @OS in ['termux', 'android', 'wasm32_emscripten', 'linux', 'ios', 'macos', 'windows',
        'freebsd', 'openbsd', 'netbsd', 'dragonfly', 'serenity', 'plan9', 'vinix', 'solaris', 'haiku',
        'js_node', 'js_freestanding', 'js_browser']
}

fn test_at_ccompiler() {
    println('Current C Compiler is ${@CCOMPILER}')
    assert @CCOMPILER in ['gcc', 'tinyc', 'clang', 'emcc', 'mingw', 'msvc', 'cplusplus']
}

fn test_at_backend() {
    println('Current language backend is ${@BACKEND}')
    assert @BACKEND in ['c', 'interpret', 'js_node', 'js_browser', 'js_freestanding', 'native',
        'wasm']
}

fn test_at_platform() {
    println('Current Platform is ${@PLATFORM}')
    assert @PLATFORM in ['amd64', 'arm64', 'arm32', 'rv64', 'rv32', 'i386', 's390x', 'ppc64le',
        'loongarch64', 'js_node', 'js_browser', 'js_freestanding', 'wasm32']
}