// vtest build: started_redis?
import db.redis
import os
import rand
import time

const redis_password = os.getenv('VREDIS_PASSWORD')

// Keys and channel names used by the tests
const k_int = 'k:int'
const k_string = 'k:string'
const k_counter = 'k:counter'
const r_k_map = 'r:k:map'
const r_k_set = 'r:k:set'
const r_k_pubch = 'r:k:pubch'

// Helper publisher used by the pub/sub test. This helper swallows errors and logs
// them locally so it can be spawned safely without propagating results.
fn publish_after_delay() {
	// small delay to ensure subscriber is ready
	time.sleep(50 * time.millisecond)
	mut conn := redis.connect() or {
		eprintln('publish_after_delay: connect failed: ${err}')
		return
	}
	defer { conn.close() or { eprintln('publish_after_delay: close failed: ${err}') } }
	conn.cmd('PUBLISH', r_k_pubch, 'hello') or {
		eprintln('publish_after_delay: publish failed: ${err}')
	}
}

// -------------------- FAST / BASIC TESTS --------------------

// Basic functionality smoke test (fast)
fn test_redis_basic() {
	mut db := redis.connect(password: redis_password)!
	defer { db.close() or {} }

	// Basic health check
	assert db.ping()! == 'PONG'

	// delete all keys first
	db.cmd('FLUSHALL')!

	// test set[T]
	assert db.set('int', 123)! == 'OK'
	assert db.set('string', 'abc')! == 'OK'
	assert db.set('bin', [u8(0x00), 0x01, 0x02, 0x03])! == 'OK'

	// test get[T]
	assert db.get[i64]('int')! == 123
	assert db.get[string]('string')! == 'abc'
	assert db.get[[]u8]('bin')! == [u8(0x00), 0x01, 0x02, 0x03]

	// test incr/decr
	assert db.incr('int')! == 124
	assert db.decr('int')! == 123

	// test hset/hget/hgetall
	m := {
		'a': '1'
		'b': '2'
		'c': '3'
	}
	assert db.hset('map', m)! == m.len
	assert db.hget[string]('map', 'a')! == '1'
	assert db.hget[string]('map', 'b')! == '2'
	assert db.hget[string]('map', 'c')! == '3'
	assert db.hgetall[string]('map')! == m

	// test expire
	assert db.expire('int', 1)!
	time.sleep(2 * time.second)
	db.get[i64]('int') or {
		// tolerate server-specific message wording; ensure some message exists
		assert err.msg().len > 0
	}

	// test del
	assert db.del('string')! == 1
	db.get[string]('string') or {
		// tolerate server-specific message wording; ensure some message exists
		assert err.msg().len > 0
	}

	// test custom cmd
	assert db.cmd('SET', 'bigint', '123456')! as string == 'OK'
	assert db.cmd('GET', 'bigint')! as []u8 == [u8(49), 50, 51, 52, 53, 54]
	db.close()!
}

// A concise pipeline test that exercises correctness but remains fast
fn test_pipeline_small() {
	mut db := redis.connect(password: redis_password)!
	defer { db.close() or {} }

	assert db.ping()! == 'PONG'

	// start pipleline mode
	db.pipeline_start()
	// small pipeline of a few commands
	db.cmd('FLUSHALL') or { eprintln('FLUSHALL failed (pipeline): ${err}') }
	db.set(k_int, 1) or { eprintln('SET k_int failed (pipeline): ${err}') }
	db.set(k_string, 'p') or { eprintln('SET k_string failed (pipeline): ${err}') }
	db.get[i64](k_int) or { eprintln('GET k_int failed (pipeline): ${err}') }
	db.get[string](k_string) or { eprintln('GET k_string failed (pipeline): ${err}') }
	res := db.pipeline_execute()!

	// Expect exactly the five results we queued and validate them precisely.
	assert res.len == 5
	match res[0] {
		string { assert res[0] as string == 'OK' }
		else { assert false }
	}

	match res[1] {
		string { assert res[1] as string == 'OK' }
		else { assert false }
	}

	match res[2] {
		string { assert res[2] as string == 'OK' }
		else { assert false }
	}

	match res[3] {
		[]u8 { assert (res[3] as []u8).bytestr() == '1' }
		else { assert false }
	}

	match res[4] {
		[]u8 { assert (res[4] as []u8).bytestr() == 'p' }
		else { assert false }
	}
}

// Another small pipeline sequence test (fast)
fn test_pipeline_sequence() {
	mut db := redis.connect(password: redis_password)!
	defer { db.close() or {} }

	// keep operations minimal and deterministic
	db.cmd('FLUSHALL') or { eprintln('FLUSHALL failed: ${err}') }
	assert db.set(k_counter, '0')! == 'OK'

	// restart pipeline again
	db.pipeline_start()
	// test set[T]
	db.set('int', 123)!
	db.set('string', 'abc')!
	db.set('bin', [u8(0x00), 0x01, 0x02, 0x03])!

	// execute the queued pipeline commands and collect results
	res := db.pipeline_execute()!
	// We queued 3 SET commands above; each should return "OK"
	assert res.len == 3
	match res[0] {
		string { assert res[0] as string == 'OK' }
		else { assert false }
	}

	match res[1] {
		string { assert res[1] as string == 'OK' }
		else { assert false }
	}

	match res[2] {
		string { assert res[2] as string == 'OK' }
		else { assert false }
	}
}

// -------------------- RESP3 / PUBSUB SHAPE CHECKS (FAST) --------------------

// Quick RESP3 ping and tiny roundtrip
fn test_resp3_ping() {
	mut db := redis.connect(password: redis_password)!
	defer { db.close() or {} }

	// Basic ping and quick SET/GET roundtrip
	p := db.ping() or { panic(err) }
	assert p == 'PONG'
	db.cmd('DEL', r_k_map) or { eprintln('DEL r_k_map failed: ${err}') }
	assert db.cmd('SET', r_k_map, 'temp')! as string == 'OK'
	val := db.cmd('GET', r_k_map)!
	match val {
		[]u8 { assert val.bytestr() == 'temp' }
		string { assert val == 'temp' }
		else { assert false }
	}

	db.cmd('DEL', r_k_map) or { eprintln('cleanup DEL r_k_map failed: ${err}') }
}

// Quick RESP3 HGETALL shape check (fast)
fn test_resp3_hgetall_fast() {
	mut db := redis.connect(password: redis_password)!
	defer { db.close() or {} }

	db.cmd('DEL', r_k_map)!
	assert db.hset(r_k_map, {
		'k1': 'v1'
		'k2': 'v2'
	})! >= 1
	if db.version != 3 {
		res := db.hgetall[string](r_k_map) or { panic(err) }
		assert res['k1'] == 'v1'
		db.cmd('DEL', r_k_map)!
		return
	}
	r := db.cmd('HGETALL', r_k_map) or { panic(err) }
	match r {
		map[string]redis.RedisValue {
			v1 := r['k1']!
			v2 := r['k2']!
			assert (v1 as []u8).bytestr() == 'v1'
			assert (v2 as []u8).bytestr() == 'v2'
		}
		redis.RedisMap {
			assert (r.pairs[1] as []u8).bytestr() == 'v1'
			assert (r.pairs[3] as []u8).bytestr() == 'v2'
		}
		[]redis.RedisValue {
			assert (r[1] as []u8).bytestr() == 'v1'
			assert (r[3] as []u8).bytestr() == 'v2'
		}
		else {
			assert false
		}
	}

	db.cmd('DEL', r_k_map)!
}

// Quick RESP3 SMEMBERS shape check (fast)
fn test_resp3_smembers_fast() {
	mut db := redis.connect(password: redis_password)!
	defer { db.close() or {} }
	db.cmd('DEL', r_k_set) or { eprintln('DEL r_k_set failed: ${err}') }
	db.cmd('SADD', r_k_set, 'one', 'two') or { eprintln('SADD r_k_set failed: ${err}') }
	r := db.cmd('SMEMBERS', r_k_set) or { panic(err) }
	match r {
		redis.RedisSet {
			mut f1 := false
			mut f2 := false
			for el in r.elements {
				el_str := (el as []u8).bytestr()
				if el_str == 'one' {
					f1 = true
				}
				if el_str == 'two' {
					f2 = true
				}
			}
			assert f1 && f2
		}
		[]redis.RedisValue {
			mut f1 := false
			mut f2 := false
			for el in r {
				el_str := (el as []u8).bytestr()
				if el_str == 'one' {
					f1 = true
				}
				if el_str == 'two' {
					f2 = true
				}
			}
			assert f1 && f2
		}
		else {
			assert false
		}
	}

	db.cmd('DEL', r_k_set) or { eprintln('cleanup DEL r_k_set failed: ${err}') }
}

// Very small pub/sub smoke test (fast)
fn test_resp3_pubsub_fast() {
	mut sub := redis.connect(password: redis_password)!
	defer { sub.close() or {} }
	if sub.version != 3 {
		return
	}
	spawn publish_after_delay()
	sub.cmd('SUBSCRIBE', r_k_pubch) or { eprintln('SUBSCRIBE failed: ${err}') }
	time.sleep(200 * time.millisecond)
	sub.cmd('PING') or { eprintln('PING (pubsub) failed: ${err}') }
}

// -------------------- SLOW / HEAVY TESTS --------------------

// Large binary bulk string roundtrip (~200 KiB)
fn test_large_binary_bulk_string() ! {
	mut db := redis.connect(password: redis_password)!
	defer { db.close() or {} }

	// ensure clean DB
	db.cmd('FLUSHALL')!

	// Create a large binary payload (~200 KB) with a repeating pattern,
	// including zero bytes and CRLF sequences to exercise edge cases.
	mut data := []u8{len: 204800, init: u8(index & 0xFF)}

	// inject some CRLF and zero-byte sequences at several spots
	data[50] = `\r`
	data[51] = `\n`
	data[1000] = 0
	data[1001] = `\r`
	data[1002] = `\n`

	// store binary data
	assert db.set('bigbin', data.clone())! == 'OK'

	// retrieve as []u8 using typed get
	got := db.get[[]u8]('bigbin')!
	assert got == data

	// also test with small binary containing embedded CRLF and NUL
	small := [u8(0), `a`, `b`, `\r`, `\n`, `c`]
	assert db.set('smallbin', small)! == 'OK'
	got_small := db.get[[]u8]('smallbin')!
	assert got_small == small

	// cleanup
	db.del('bigbin')!
	db.del('smallbin')!
}

// Very large payload (~1.2 MiB) roundtrip
fn test_very_large_payload() ! {
	mut db := redis.connect(password: redis_password)!
	defer { db.close() or {} }

	// ensure clean DB
	db.cmd('FLUSHALL')!

	// Build a very large payload (> 1 MiB). Use ~1.2 MiB to be safely above 1 MiB.
	size := 1_200_000
	mut big := []u8{len: size, init: u8(index & 0xFF)}
	// Put a few sentinel checks
	big[0] = 0
	big[1023] = `\r`
	big[1024] = `\n`
	big[size - 1] = 255

	// store and retrieve
	assert db.set('hugebin', big.clone())! == 'OK'
	got := db.get[[]u8]('hugebin')!
	assert got == big

	// cleanup
	db.del('hugebin')!
}

// Many pipeline commands to exercise batching behavior
fn test_many_pipeline_commands() ! {
	mut db := redis.connect(password: redis_password)!
	defer { db.close() or {} }

	// ensure clean DB
	db.cmd('FLUSHALL')!

	// We'll queue a moderate but substantial number of commands in pipeline to test behavior.
	// Keep it reasonable for CI runtime; 300 pairs (SET, GET) should exercise pipeline thoroughly.
	count := 300
	db.pipeline_start()
	for i in 0 .. count {
		key := 'kp_${i}'
		val := 'v${i}'
		db.cmd('SET', key, val)!
		db.cmd('GET', key)!
	}
	results := db.pipeline_execute()!
	// Expect 2 * count responses
	assert results.len == count * 2
	for i in 0 .. count {
		set_idx := i * 2
		get_idx := i * 2 + 1
		// SET should return OK
		match results[set_idx] {
			string { assert (results[set_idx] as string) == 'OK' }
			else { assert false }
		}

		// GET should return the value as []u8
		expected := ('v${i}').bytes()
		match results[get_idx] {
			[]u8 { assert (results[get_idx] as []u8) == expected }
			else { assert false }
		}
	}
}

// Larger randomized binary payloads (many iterations)
fn test_fuzz_random_binary_many() ! {
	mut db := redis.connect(password: redis_password)!
	defer { db.close() or {} }

	db.cmd('FLUSHALL')!

	// LCG PRNG seed using process id
	mut x := u64(os.getpid())

	count := 50
	for iter in 0 .. count {
		// size up to ~200 KiB
		size := int((x % 200_000) + 1)
		mut data := []u8{len: size}
		for i in 0 .. size {
			data[i] = rand.u8()
		}
		key := 'fuzz_big_${iter}'
		assert db.set(key, data.clone())! == 'OK'
		got := db.get[[]u8](key)!
		assert got == data
		// clean up
		db.del(key)!

		x += u64(size) * u64(iter + 1)
	}
}

// Randomized tests that ensure CRLF sequences embedded at random locations,
// including chunk boundaries, are handled correctly.
fn test_fuzz_crlf_random_positions() ! {
	mut db := redis.connect(password: redis_password)!
	defer { db.close() or {} }

	db.cmd('FLUSHALL')!

	seed := u64(os.getpid())
	mut x := seed

	trials := 30
	for t in 0 .. trials {
		// size between 1 KiB and 32 KiB
		size := int((x % 31_744) + 1024)
		mut data := []u8{len: size}
		for i in 0 .. size {
			data[i] = rand.u8()
		}
		// place a CRLF at a pseudo-random position; sometimes force it near boundaries
		pos := int(x % u64(size - 2))
		data[pos] = `\r`
		data[pos + 1] = `\n`
		// also occasionally place CRLF at a chunk boundary (4096)
		if t % 5 == 0 && size > 4097 {
			data[4095] = `\r`
			data[4096] = `\n`
		}
		key := 'fuzz_crlf_${t}'
		assert db.set(key, data.clone())! == 'OK'
		got := db.get[[]u8](key)!
		assert got == data
		db.del(key)!
		x += u64(pos) + 1
	}
}

// CRLF crossing a read-chunk boundary
fn test_crlf_at_chunk_boundary() {
	mut db := redis.connect(password: redis_password)!
	defer { db.close() or {} }

	// ensure clean DB
	db.cmd('FLUSHALL')!

	// The driver's read buffer reads in 4096-byte chunks. Create a payload where CRLF
	// crosses the 4096-byte boundary: place '\r' at index 4095 and '\n' at 4096.
	chunk := 4096
	size := chunk * 3 // a few chunks
	mut data := []u8{len: size, init: u8((index * 37) % 256)}
	if size > chunk + 1 {
		data[chunk - 1] = `\r` // index 4095
		data[chunk] = `\n` // index 4096
	}
	// store and retrieve
	assert db.set('crlf_boundary', data.clone())! == 'OK'
	got := db.get[[]u8]('crlf_boundary')!
	assert got.len == data.len
	// ensure boundary bytes preserved
	assert got[chunk - 1] == `\r`
	assert got[chunk] == `\n`
	// cleanup
	db.del('crlf_boundary')!
}

// Small randomized binary payloads (many repetitions).
fn test_fuzz_random_binary_small() {
	mut db := redis.connect(password: redis_password)!
	defer { db.close() or {} }

	db.cmd('FLUSHALL')!

	// Simple LCG PRNG seeded from process id
	seed := u64(os.getpid())
	mut x := seed
	for iter := 0; iter < 20; iter++ {
		// pseudo-random size in [1, 4096]
		size := int((x % 4096) + 1)
		mut data := []u8{len: size}
		for i in 0 .. size {
			data[i] = rand.u8()
		}
		k := 'fuzz_small_${iter}'
		assert db.set(k, data.clone())! == 'OK'
		got := db.get[[]u8](k)!
		assert got == data
		// mutate seed slightly so sizes vary
		x += u64(size)
	}

	db.pipeline_start()

	// ensure we have a small map to use here (define inline to avoid depending on outer scope)
	db.hset('map', {
		'a': '1'
		'b': '2'
		'c': '3'
	})!
	db.hget[string]('map', 'a')!
	db.hget[string]('map', 'b')!
	db.hget[string]('map', 'c')!
	db.hgetall[string]('map')!

	// test custom cmd
	db.cmd('SET', 'bigint', '123456')!
	db.cmd('GET', 'bigint')!

	b := db.pipeline_execute()!

	// Validate elements individually to accommodate server-shape differences.
	assert b.len == 7

	match b[0] {
		i64 { assert (b[0] as i64) == 3 }
		else { assert false }
	}

	match b[1] {
		[]u8 { assert (b[1] as []u8) == [u8(49)] }
		else { assert false }
	}

	match b[2] {
		[]u8 { assert (b[2] as []u8) == [u8(50)] }
		else { assert false }
	}

	match b[3] {
		[]u8 { assert (b[3] as []u8) == [u8(51)] }
		else { assert false }
	}

	// HGETALL may arrive as map[string]RedisValue, RedisMap, or array - accept common shapes.
	match b[4] {
		map[string]redis.RedisValue {
			m := b[4] as map[string]redis.RedisValue
			v := m['a'] or { panic('hgetall: missing a') }
			assert (v as []u8) == [u8(49)]
		}
		redis.RedisMap {
			rm := b[4] as redis.RedisMap
			// pairs are interleaved key/value; expect at least 2 pairs and check the first value
			assert rm.pairs.len >= 2
			assert (rm.pairs[1] as []u8) == [u8(49)]
		}
		[]redis.RedisValue {
			arr := b[4] as []redis.RedisValue
			// RESP2-style interleaved array; ensure element 1 (second item) is the value for 'a'
			assert arr.len > 1
			assert (arr[1] as []u8) == [u8(49)]
		}
		else {
			assert false
		}
	}

	match b[5] {
		string { assert b[5] as string == 'OK' }
		else { assert false }
	}

	match b[6] {
		[]u8 { assert (b[6] as []u8) == [u8(49), 50, 51, 52, 53, 54] }
		else { assert false }
	}

	db.close()!
}