-- ============================================================================
-- test_performance.lua - Нагрузочный тест
-- ============================================================================
-- Назначение: Оценка производительности под нагрузкой
-- Покрывает: Пропускную способность, латентность, параллелизм

local function measure_latency(operation, fn)
    local start_time = os.clock()
    local result = fn()
    local end_time = os.clock()
    local latency_ms = (end_time - start_time) * 1000
    
    if not result then
        print("  ✗ " .. operation .. " failed")
        return nil
    end
    
    print(string.format("  ✓ %s: %.2f ms", operation, latency_ms))
    return latency_ms
end

local function performance_insert_test(count)
    print(string.format("\n[Performance] Insert %d documents...", count))
    
    local latencies = {}
    local successes = 0
    
    for i = 1, count do
        local latency = measure_latency("Insert " .. i, function()
            local resp = http.request("POST", "http://localhost:8080/api/db/perf_test/benchmark",
                {["X-Session-ID"] = "test_session"},
                {
                    _id = "perf_" .. i,
                    value = math.random(1, 1000000),
                    text = string.rep("x", 100),
                    timestamp = os.time()
                }
            )
            if resp and resp.success then
                successes = successes + 1
                return true
            end
            return false
        end)
        
        if latency then
            table.insert(latencies, latency)
        end
    end
    
    -- Calculate statistics
    local total_ms = 0
    for _, lat in ipairs(latencies) do
        total_ms = total_ms + lat
    end
    
    local avg_latency = total_ms / #latencies
    local throughput = (successes / (total_ms / 1000))
    
    print(string.format("\n  Results: %d/%d successful", successes, count))
    print(string.format("  Average latency: %.2f ms", avg_latency))
    print(string.format("  Throughput: %.2f ops/sec", throughput))
    
    return {successes = successes, avg_latency = avg_latency, throughput = throughput}
end

local function performance_read_test(doc_count)
    print(string.format("\n[Performance] Read %d documents...", doc_count))
    
    local latencies = {}
    local successes = 0
    
    for i = 1, doc_count do
        local latency = measure_latency("Read " .. i, function()
            local resp = http.request("GET", "http://localhost:8080/api/db/perf_test/benchmark/perf_" .. i,
                {["X-Session-ID"] = "test_session"}
            )
            if resp and resp.success then
                successes = successes + 1
                return true
            end
            return false
        end)
        
        if latency then
            table.insert(latencies, latency)
        end
    end
    
    local total_ms = 0
    for _, lat in ipairs(latencies) do
        total_ms = total_ms + lat
    end
    
    local avg_latency = total_ms / #latencies
    local throughput = (successes / (total_ms / 1000))
    
    print(string.format("\n  Results: %d/%d successful", successes, doc_count))
    print(string.format("  Average latency: %.2f ms", avg_latency))
    print(string.format("  Throughput: %.2f ops/sec", throughput))
    
    return {successes = successes, avg_latency = avg_latency, throughput = throughput}
end

local function performance_index_query_test()
    print("\n[Performance] Index query test...")
    
    -- Create index
    local idx_resp = http.request("POST", "http://localhost:8080/api/index/perf_test/benchmark/create",
        {["X-Session-ID"] = "test_session"},
        {name = "value_idx", fields = {"value"}, unique = false}
    )
    
    local latencies = {}
    local queries = 100
    
    for i = 1, queries do
        local search_value = math.random(1, 1000000)
        
        local latency = measure_latency("Query " .. i, function()
            local resp = http.request("GET", 
                "http://localhost:8080/api/db/perf_test/benchmark?index=value_idx&value=" .. search_value,
                {["X-Session-ID"] = "test_session"}
            )
            return resp and resp.success
        end)
        
        if latency then
            table.insert(latencies, latency)
        end
    end
    
    local total_ms = 0
    for _, lat in ipairs(latencies) do
        total_ms = total_ms + lat
    end
    
    local avg_latency = total_ms / #latencies
    print(string.format("\n  Average index query latency: %.2f ms", avg_latency))
    
    return avg_latency
end

local function performance_concurrent_test()
    print("\n[Performance] Concurrent operations test...")
    print("  ⚠ This test simulates concurrent operations")
    print("  Note: Lua concurrency is simulated via sequential requests")
    
    local concurrency_levels = {10, 50, 100}
    local results = {}
    
    for _, level in ipairs(concurrency_levels) do
        print(string.format("\n  Testing concurrency level: %d", level))
        
        local start_time = os.clock()
        local success_count = 0
        
        for i = 1, level do
            local resp = http.request("POST", "http://localhost:8080/api/db/perf_test/concurrent",
                {["X-Session-ID"] = "test_session"},
                {
                    _id = "concurrent_" .. i .. "_" .. os.time(),
                    thread_id = i,
                    timestamp = os.time()
                }
            )
            if resp and resp.success then
                success_count = success_count + 1
            end
        end
        
        local duration = os.clock() - start_time
        local throughput = success_count / duration
        
        table.insert(results, {
            level = level,
            duration = duration,
            throughput = throughput,
            success_rate = (success_count / level) * 100
        })
        
        print(string.format("    Duration: %.2f sec", duration))
        print(string.format("    Throughput: %.2f ops/sec", throughput))
        print(string.format("    Success rate: %.1f%%", (success_count / level) * 100))
    end
    
    return results
end

local function performance_mixed_workload_test()
    print("\n[Performance] Mixed workload (70% read, 20% write, 10% update)...")
    
    local operations = 200
    local reads = 0
    local writes = 0
    local updates = 0
    
    local start_time = os.clock()
    
    for i = 1, operations do
        local rand = math.random(1, 100)
        
        if rand <= 70 then
            -- Read operation
            local doc_id = "perf_" .. math.random(1, 100)
            local resp = http.request("GET", "http://localhost:8080/api/db/perf_test/benchmark/" .. doc_id,
                {["X-Session-ID"] = "test_session"}
            )
            if resp and resp.success then reads = reads + 1 end
            
        elseif rand <= 90 then
            -- Write operation
            local resp = http.request("POST", "http://localhost:8080/api/db/perf_test/benchmark",
                {["X-Session-ID"] = "test_session"},
                {
                    _id = "mixed_" .. i .. "_" .. os.time(),
                    data = "mixed workload test",
                    timestamp = os.time()
                }
            )
            if resp and resp.success then writes = writes + 1 end
            
        else
            -- Update operation
            local doc_id = "perf_" .. math.random(1, 100)
            local resp = http.request("PUT", "http://localhost:8080/api/db/perf_test/benchmark/" .. doc_id,
                {["X-Session-ID"] = "test_session"},
                {updated = true, update_time = os.time()}
            )
            if resp and resp.success then updates = updates + 1 end
        end
    end
    
    local duration = os.clock() - start_time
    
    print(string.format("\n  Results:"))
    print(string.format("    Total operations: %d", operations))
    print(string.format("    Reads: %d (%.1f%%)", reads, (reads/operations)*100))
    print(string.format("    Writes: %d (%.1f%%)", writes, (writes/operations)*100))
    print(string.format("    Updates: %d (%.1f%%)", updates, (updates/operations)*100))
    print(string.format("    Total duration: %.2f sec", duration))
    print(string.format("    Overall throughput: %.2f ops/sec", operations/duration))
    
    return {reads = reads, writes = writes, updates = updates, duration = duration}
end

-- Run performance tests
print("\n" .. string.rep("=", 50))
print("PERFORMANCE TEST SUITE")
print(string.rep("=", 50))

-- Warm-up
print("\n[Performance] Warming up...")
for i = 1, 10 do
    http.request("POST", "http://localhost:8080/api/db/perf_test/benchmark",
        {["X-Session-ID"] = "test_session"},
        {_id = "warmup_" .. i, data = "warmup"}
    )
end

local insert_results = performance_insert_test(100)
local read_results = performance_read_test(100)
local index_latency = performance_index_query_test()
local concurrent_results = performance_concurrent_test()
local mixed_results = performance_mixed_workload_test()

print("\n" .. string.rep("=", 50))
print("PERFORMANCE SUMMARY")
print(string.rep("=", 50))
print(string.format("Insert throughput: %.2f ops/sec", insert_results.throughput or 0))
print(string.format("Read throughput: %.2f ops/sec", read_results.throughput or 0))
print(string.format("Index query latency: %.2f ms", index_latency or 0))
print(string.format("Mixed workload throughput: %.2f ops/sec", mixed_results.duration and 200/mixed_results.duration or 0))

print("\n✓ PERFORMANCE TESTS COMPLETED ✓\n")