// vtest flaky: true
// vtest retry: 3
// vtest build: !windows && !docker-ubuntu-musl && !sanitize-memory-clang && !sanitize-address-clang-without-gc
import os
import time
import net.http

const sport = 13085
const localserver = '127.0.0.1:${sport}'
const exit_after_time = 30000
const vexe = os.getenv('VEXE')
const vroot = os.dir(vexe)
const serverexe = os.join_path(os.cache_dir(), 'veb_memory_test_server.exe')

fn testsuite_begin() {
    os.chdir(vroot) or {}
    if os.exists(serverexe) {
        os.rm(serverexe) or {}
    }
}

fn testsuite_end() {
    if os.exists(serverexe) {
        os.rm(serverexe) or {}
    }
}

fn test_server_compiles() {
    did_compile :=
        os.system('${os.quoted_path(vexe)} -o ${os.quoted_path(serverexe)} vlib/veb/tests/memory_leak_test_server.v')
    assert did_compile == 0
    assert os.exists(serverexe)
}

fn test_server_runs_in_background() {
    spawn os.system('${os.quoted_path(serverexe)} ${sport} ${exit_after_time}')
    for _ in 0 .. 50 {
        resp := http.get('http://${localserver}/heap') or {
            time.sleep(100 * time.millisecond)
            continue
        }
        if resp.status_code == 200 {
            return
        }
        time.sleep(100 * time.millisecond)
    }
    assert false, 'Timed out waiting for background server to start'
}

fn test_large_responses_work_correctly() {
    // Make requests with large response bodies and verify they work
    request_count := 20
    mut successful := 0
    for _ in 0 .. request_count {
        resp := http.get('http://${localserver}/large') or { continue }
        if resp.status_code == 200 && resp.body.len > 50000 {
            successful += 1
        }
    }
    // Ensure most requests succeeded (allows for some network variability)
    assert successful >= request_count - 2, 'Only ${successful}/${request_count} requests succeeded'
}

fn test_heap_usage_endpoint_works() {
    resp := http.get('http://${localserver}/heap') or {
        assert false, 'Failed to get heap usage: ${err}'
        return
    }
    heap := resp.body.i64()
    // Just verify we get a reasonable value (more than 1MB, less than 1GB)
    assert heap > 1024 * 1024, 'Heap usage ${heap} seems too low'
    assert heap < 1024 * 1024 * 1024, 'Heap usage ${heap} seems too high'
}

fn test_gc_collect_endpoint_works() {
    resp := http.get('http://${localserver}/gc') or {
        assert false, 'Failed to trigger GC: ${err}'
        return
    }
    assert resp.status_code == 200
}

fn test_multipart_upload_does_not_expand_heap_excessively() {
    http.get('http://${localserver}/gc') or {
        assert false, 'Failed to trigger GC before measuring heap: ${err}'
        return
    }
    before_resp := http.get('http://${localserver}/heap') or {
        assert false, 'Failed to get baseline heap usage: ${err}'
        return
    }
    before_heap := before_resp.body.i64()
    payload_size := 1024 * 1024
    mut files := []http.FileData{}
    files << http.FileData{
        filename:     'payload.bin'
        content_type: 'application/octet-stream'
        data:         'X'.repeat(payload_size)
    }
    resp := http.post_multipart_form('http://${localserver}/upload', http.PostMultipartFormConfig{
        files: {
            'file': files
        }
    }) or {
        assert false, 'Failed to post multipart upload: ${err}'
        return
    }
    assert resp.status_code == 200
    assert resp.body == payload_size.str()
    http.get('http://${localserver}/gc') or {
        assert false, 'Failed to trigger GC after upload: ${err}'
        return
    }
    after_resp := http.get('http://${localserver}/heap') or {
        assert false, 'Failed to get post-upload heap usage: ${err}'
        return
    }
    after_heap := after_resp.body.i64()
    heap_growth := if after_heap > before_heap { after_heap - before_heap } else { i64(0) }
    assert heap_growth < 8 * 1024 * 1024, 'Multipart upload grew heap by ${heap_growth} bytes'
}