module main

import time
import sync
import os
import runtime
import v.util.version

// Define closure type alias
type ClosureFN = fn () int

// Test closures with different capture sizes
fn create_closure_small() ClosureFN {
    a := 0
    return fn [a] () int {
        return a
    }
}

fn create_closure_medium() ClosureFN {
    a, b, c, d := 1, 2, 3, 4
    return fn [a, b, c, d] () int {
        return a + b - c * d
    }
}

struct LargeData {
    array [10]int
}

fn create_closure_large() ClosureFN {
    data := LargeData{
        array: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]!
    }
    return fn [data] () int {
        mut sum := 0
        for i in 0 .. 10 {
            sum += data.array[i]
        }
        return sum
    }
}

// Result structs
struct TestResult {
    test_name   string
    iterations  int
    time_ms     i64
    ops_per_sec f64 // Operations per second
    notes       string
}

struct MemoryResult {
    test_name         string
    count             int
    start_mem_kb      int
    end_mem_kb        int
    delta_kb          int
    bytes_per_closure int
    check_sum         int
}

// Benchmark group - returns result structs
fn benchmark_closure_creation(iterations int) []TestResult {
    mut results := []TestResult{}

    // Test small closure creation
    mut start := time.ticks()
    for _ in 0 .. iterations {
        _ = create_closure_small()
    }
    small_time := time.ticks() - start
    mut ops_per_sec := f64(iterations) * 1000.0 / f64(small_time)
    results << TestResult{'Small Closure Creation', iterations, small_time, ops_per_sec, ''}

    // Test medium closure creation
    start = time.ticks()
    for _ in 0 .. iterations {
        _ = create_closure_medium()
    }
    medium_time := time.ticks() - start
    ops_per_sec = f64(iterations) * 1000.0 / f64(medium_time)
    results << TestResult{'Medium Closure Creation', iterations, medium_time, ops_per_sec, ''}

    // Test large closure creation
    large_iter := iterations / 10
    start = time.ticks()
    for _ in 0 .. large_iter {
        _ = create_closure_large()
    }
    large_time := time.ticks() - start
    ops_per_sec = f64(large_iter) * 1000.0 / f64(large_time)
    results << TestResult{'Large Closure Creation', large_iter, large_time, ops_per_sec, ''} //, "Equivalent iterations: ${iterations/10}"}
    return results
}

fn benchmark_closure_call(iterations int) []TestResult {
    mut results := []TestResult{}

    closure_small := create_closure_small()
    closure_medium := create_closure_medium()
    closure_large := create_closure_large()

    // Test small closure call
    mut start := time.ticks()
    for _ in 0 .. iterations {
        _ = closure_small()
    }
    small_time := time.ticks() - start
    mut ops_per_sec := f64(iterations) * 1000.0 / f64(small_time)
    results << TestResult{'Small Closure Call', iterations, small_time, ops_per_sec, ''}

    // Test medium closure call
    start = time.ticks()
    for _ in 0 .. iterations {
        _ = closure_medium()
    }
    medium_time := time.ticks() - start
    ops_per_sec = f64(iterations) * 1000.0 / f64(medium_time)
    results << TestResult{'Medium Closure Call', iterations, medium_time, ops_per_sec, ''}

    // Test large closure call
    large_iter := iterations / 10
    start = time.ticks()
    for _ in 0 .. large_iter {
        _ = closure_large()
    }
    large_time := time.ticks() - start
    ops_per_sec = f64(large_iter) * 1000.0 / f64(large_time)
    results << TestResult{'Large Closure Call', large_iter, large_time, ops_per_sec, ''}

    return results
}

fn benchmark_threaded_creation(threads int, iterations_per_thread int) TestResult {
    total_iterations := threads * iterations_per_thread

    mut wg := sync.new_waitgroup()
    wg.add(threads)

    start := time.ticks()

    for _ in 0 .. threads {
        go fn [mut wg, iterations_per_thread] () {
            defer { wg.done() }
            for _ in 0 .. iterations_per_thread {
                _ = create_closure_medium()
            }
        }()
    }

    wg.wait()
    elapsed := time.ticks() - start
    ops_per_sec := f64(total_iterations) * 1000.0 / f64(elapsed)

    return TestResult{
        test_name:   'Multi-threaded Creation'
        iterations:  total_iterations
        time_ms:     elapsed
        ops_per_sec: ops_per_sec
        notes:       'Threads: ${threads} Iterations per thread: ${iterations_per_thread}'
    }
}

fn baseline_call_performance(iterations int) TestResult {
    start := time.ticks()
    for _ in 0 .. iterations {
        _ = normal_function()
    }
    elapsed := time.ticks() - start
    ops_per_sec := f64(iterations) * 1000.0 / f64(elapsed)

    return TestResult{
        test_name:   'Normal Function Call'
        iterations:  iterations
        time_ms:     elapsed
        ops_per_sec: ops_per_sec
        notes:       'Baseline'
    }
}

fn benchmark_memory_usage(count int) MemoryResult {
    mut closures := []ClosureFN{}
    start_mem := runtime.used_memory() or { panic(err) }

    for i in 0 .. count {
        the_closure := create_closure_medium()
        closures << the_closure

        if i % 1000 == 0 {
            _ = the_closure()
        }
    }

    end_mem := runtime.used_memory() or { panic(err) }
    delta := int(end_mem) - int(start_mem)
    bytes_per_closure := delta / count

    // Calculate verification sum
    mut check_sum := 0
    n := if closures.len < 100 { closures.len } else { 100 }
    for idx in 0 .. n {
        check_sum += closures[idx]()
    }

    return MemoryResult{
        test_name:         'Closure Memory Overhead'
        count:             count
        start_mem_kb:      int(start_mem / 1024)
        end_mem_kb:        int(end_mem / 1024)
        delta_kb:          delta / 1024
        bytes_per_closure: bytes_per_closure
        check_sum:         check_sum
    }
}

fn normal_function() int {
    return 42
}

// Format performance data for readability
fn format_perf(ops_per_sec f64) string {
    if ops_per_sec >= 1_000_000 {
        return '${ops_per_sec / 1_000_000:5.2f} Mop/s'
    } else if ops_per_sec >= 1_000 {
        return '${ops_per_sec / 1_000:5.2f} Kop/s'
    } else {
        return '${ops_per_sec:5.2f} op/s'
    }
}

fn print_results_table(results []TestResult, title string) {
    println('|---------------------------|------------|----------|--------------|--------------|')
    for res in results {
        perf_str := format_perf(res.ops_per_sec)
        println('| ${res.test_name:-25} | ${res.iterations:10} | ${res.time_ms:8} | ${perf_str:-12} | ${res.notes:-12} |')
    }
}

fn main() {
    println('# V Language Closure Performance Benchmark Report')

    // Configurable test parameters
    base_iter := 100_000_000 // 100 million iterations
    creation_iter := 10_000_000 // 1 million iterations
    mem_count := 100_000
    threads := 8
    thread_iter := 125_000

    // Execute tests
    baseline_result := baseline_call_performance(base_iter)
    creation_results := benchmark_closure_creation(creation_iter)
    call_results := benchmark_closure_call(base_iter)
    thread_result := benchmark_threaded_creation(threads, thread_iter)
    mem_result := benchmark_memory_usage(mem_count)

    // Print result tables
    println('\n## 1. Closure Performance Analysis')
    println('| Test Name                 | Iterations | Time(ms) | Ops/sec      | Notes        |')
    print_results_table([baseline_result], '1. Performance Baseline')
    print_results_table(creation_results, '2. Closure Creation Performance')
    print_results_table(call_results, '3. Closure Call Performance')
    print_results_table([thread_result], '4. Multi-threaded Performance')

    // Print memory results
    println('\n## 2. Memory Overhead Analysis')
    println('| Test Name               | Closure Count | Start Mem(KB) | End Mem(KB) | Delta(KB) | Bytes/Closure |')
    println('|-------------------------|---------------|---------------|------------|-----------|---------------|')
    println('| ${mem_result.test_name:-20} | ${mem_result.count:13} | ${mem_result.start_mem_kb:13} | ${mem_result.end_mem_kb:10} | ${mem_result.delta_kb:9} | ${mem_result.bytes_per_closure:13} |')
    println('\n**Verification Sum: ${mem_result.check_sum}** (Calculated from random sample of 100 closures)')

    println('\n## Test Environment')
    println('- V Language Version: ${version.full_v_version(false)}')
    println('- CPU Cores: ${runtime.nr_cpus()}')
    println('- System Memory: ${runtime.total_memory()! / 1024 / 1024} MB')
    println('- Operating System: ${os.user_os()}')
    println('\n> Test Time: ${time.now().format_ss_micro()}')
}