// vtest build: !windows // msvc hung, maybe sync/atomic bug, gcc on windows does too, although less frequently
import time
import sync
import pool
import rand

// Mock connection implementation
struct MockConn {
mut:
	healthy    bool
	close_flag bool
	reset_flag bool
	closed     int
	id         string
}

fn (mut c MockConn) validate() !bool {
	return c.healthy
}

fn (mut c MockConn) close() ! {
	if c.close_flag {
		return error('simulated close error')
	}
	c.closed++
}

fn (mut c MockConn) reset() ! {
	if c.reset_flag {
		return error('simulated reset error')
	}
	c.reset_flag = true
}

// Test utility functions
fn create_mock_factory(mut arr []&pool.ConnectionPoolable, healthy bool, fail_times int) fn () !&pool.ConnectionPoolable {
	mut count := 0
	return fn [mut arr, healthy, fail_times, mut count] () !&pool.ConnectionPoolable {
		if count < fail_times {
			count++
			return error('connection creation failed')
		}
		mut conn := &MockConn{
			healthy: healthy
			id:      rand.uuid_v7()
		}
		arr << conn
		return conn
	}
}

fn is_same_conn(conn1 &pool.ConnectionPoolable, conn2 &pool.ConnectionPoolable) bool {
	c1 := conn1 as MockConn
	c2 := conn2 as MockConn
	return c1.id == c2.id
}

// Test cases
fn test_basic_usage() {
	for _ in 0 .. 1 {
		mut test_conns := []&pool.ConnectionPoolable{}
		factory := create_mock_factory(mut test_conns, true, 0)
		config := pool.ConnectionPoolConfig{
			max_conns:      5
			min_idle_conns: 2
			idle_timeout:   100 * time.millisecond
			get_timeout:    50 * time.millisecond
		}

		mut p := pool.new_connection_pool(factory, config)!

		// Acquire a connection
		mut conn1 := p.get()!
		assert p.stats().active_conns == 1

		// Acquire multiple connections
		mut conns := [p.get()!, p.get()!, p.get()!]
		assert p.stats().active_conns == 4

		// Return connections
		for c in conns {
			p.put(c)!
		}
		p.put(conn1)!
		assert p.stats().active_conns == 0
		assert p.stats().total_conns >= 4
		p.close()
	}
}

fn test_pool_exhaustion() {
	for i in 0 .. 1 {
		mut test_conns := []&pool.ConnectionPoolable{}
		factory := create_mock_factory(mut test_conns, true, 0)
		config := pool.ConnectionPoolConfig{
			max_conns:      2
			min_idle_conns: 1
			get_timeout:    10 * time.millisecond
		}

		mut p := pool.new_connection_pool(factory, config)!

		// Acquire all connections
		c1 := p.get()!
		c2 := p.get()!
		assert p.stats().active_conns == 2

		// Attempt to acquire third connection (should timeout)
		p.get() or { assert err.msg().contains('timeout') }

		// After returning, should be able to acquire again
		p.put(c2)!
		c3 := p.get()!
		assert is_same_conn(c3, c2)
		assert p.stats().active_conns == 2
		p.close()
	}
}

fn test_connection_validation() {
	mut test_conns := []&pool.ConnectionPoolable{}
	factory := create_mock_factory(mut test_conns, false, 0) // Create unhealthy connections
	config := pool.ConnectionPoolConfig{
		min_idle_conns: 1
	}

	mut p := pool.new_connection_pool(factory, config) or {
		assert err.msg().contains('connection validation failed')
		return
	}
	defer {
		p.close()
	}
}

fn test_eviction() {
	mut test_conns := []&pool.ConnectionPoolable{}
	factory := create_mock_factory(mut test_conns, true, 0)
	config := pool.ConnectionPoolConfig{
		max_lifetime:   10 * time.millisecond
		idle_timeout:   10 * time.millisecond
		min_idle_conns: 0
	}

	mut p := pool.new_connection_pool(factory, config)!
	defer {
		p.close()
	}

	// Acquire and return a connection
	c1 := p.get()!
	p.put(c1)!

	// Wait longer than timeout thresholds
	time.sleep(100 * time.millisecond)
	p.send_eviction(.urgent)
	time.sleep(10 * time.millisecond)
	stats := p.stats()
	assert stats.evicted_count > 0
	assert stats.total_conns == 0
	assert stats.idle_conns == 0
	c2 := p.get()!
	assert !is_same_conn(c1, c2)
	assert p.stats().total_conns == 1
	assert p.stats().evicted_count > 0
}

fn test_retry_mechanism() {
	mut test_conns := []&pool.ConnectionPoolable{}
	factory := create_mock_factory(mut test_conns, true, 3) // First 3 attempts fail
	config := pool.ConnectionPoolConfig{
		max_retry_attempts: 5
		retry_base_delay:   10 * time.millisecond
		min_idle_conns:     0 // No idle connections
	}

	mut p := pool.new_connection_pool(factory, config)!
	defer {
		p.close()
	}
	// Should successfully create connection after retries
	conn := p.get()!
	assert test_conns.len == 1
	assert p.stats().creation_errors == 3
}

fn test_concurrent_access() {
	mut test_conns := []&pool.ConnectionPoolable{}
	factory := create_mock_factory(mut test_conns, true, 0)
	config := pool.ConnectionPoolConfig{
		max_conns: 10
	}

	mut p := pool.new_connection_pool(factory, config)!
	defer {
		p.close()
	}
	mut wg := sync.new_waitgroup()

	for _ in 0 .. 20 {
		wg.add(1)
		spawn fn (mut p pool.ConnectionPool, mut wg sync.WaitGroup) ! {
			defer { wg.done() }
			conn := p.get()!
			time.sleep(5 * time.millisecond)
			p.put(conn)!
		}(mut p, mut wg)
	}

	wg.wait()
	stats := p.stats()
	assert stats.total_conns <= 10
	assert stats.active_conns == 0
}

fn test_pool_close() {
	mut test_conns := []&pool.ConnectionPoolable{}
	factory := create_mock_factory(mut test_conns, true, 0)

	mut p := pool.new_connection_pool(factory, pool.ConnectionPoolConfig{})!
	c := p.get()!
	p.put(c)!
	assert p.stats().active_conns == 0
	assert p.stats().idle_conns >= 5

	p.close()

	// Attempt to acquire connection after close
	p.get() or { assert err.msg().contains('closed') }
	assert p.stats().active_conns == 0
	assert p.stats().idle_conns == 0

	// Verify connection was closed
	mock_conn := test_conns[0] as MockConn
	assert mock_conn.closed == 1
}

fn test_config_update() {
	mut dummy := []&pool.ConnectionPoolable{}
	mut p := pool.new_connection_pool(create_mock_factory(mut dummy, true, 0), pool.ConnectionPoolConfig{
		max_conns:      2
		min_idle_conns: 1
	})!
	defer {
		p.close()
	}
	assert p.stats().idle_conns == 1

	// Modify configuration
	new_config := pool.ConnectionPoolConfig{
		max_conns:      5
		min_idle_conns: 3
	}

	p.update_config(new_config)!

	// Trigger idle connection replenishment
	time.sleep(100 * time.millisecond)
	assert p.stats().idle_conns >= 3
}

fn test_error_handling() {
	// Test close error handling
	mut test_conns := []&pool.ConnectionPoolable{}
	factory := create_mock_factory(mut test_conns, true, 0)
	mut p := pool.new_connection_pool(factory, pool.ConnectionPoolConfig{})!
	defer {
		p.close()
	}

	// default configuration has 5 idle_conns
	assert p.stats().idle_conns == 5

	// Bug Fix Needed! msvc generated wrong code for `mut conn := p.get()! as MockConn`
	mut connx := p.get()!
	mut conn := connx as MockConn
	assert p.stats().active_conns == 1
	// it depend on `background_maintenance` thread to keep 5 idle_conns
	assert p.stats().idle_conns >= 4
	conn.close_flag = true
	p.put(conn) or { assert err.msg().contains('simulated close error') }
	assert p.stats().active_conns == 0
	// it depend on `background_maintenance` thread to keep 5 idle_conns
	assert p.stats().idle_conns >= 4

	// Test reset error handling
	conn.reset_flag = true
	p.put(conn) or { assert err.msg().contains('reset') }
	assert p.stats().active_conns == 0
	// it depend on `background_maintenance` thread to keep 5 idle_conns
	assert p.stats().idle_conns >= 4
}