module snappy

// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------

fn round_trip(label string, input []u8) ! {
	compressed := compress(input)
	decompressed := decompress(compressed)!
	assert decompressed == input, '${label}: round-trip mismatch (input len=${input.len})'
	bound := max_compressed_length(input.len)
	assert compressed.len <= bound, '${label}: compressed size ${compressed.len} exceeds bound ${bound}'
}

// ---------------------------------------------------------------------------
// Tests
// ---------------------------------------------------------------------------

fn test_empty() {
	round_trip('empty', []u8{}) or { panic(err) }
}

fn test_single_byte() {
	round_trip('single byte', [u8(0x42)]) or { panic(err) }
}

fn test_two_bytes() {
	round_trip('two bytes', [u8(0xde), 0xad]) or { panic(err) }
}

fn test_all_zeros() {
	// Highly compressible — long run of the same byte.
	input := []u8{len: 4096, init: 0}
	compressed := compress(input)
	decompressed := decompress(compressed) or { panic(err) }
	assert decompressed == input, 'all-zeros round-trip failed'
	// Should compress to much less than input.
	assert compressed.len < input.len / 4, 'all-zeros should compress well'
}

fn test_all_same_nonzero() {
	input := []u8{len: 1024, init: u8(0xff)}
	round_trip('all-0xff', input) or { panic(err) }
}

fn test_incompressible() {
	// Pseudo-random bytes — poor compressibility.
	mut input := []u8{len: 512}
	mut seed := u32(0xdeadbeef)
	for i in 0 .. input.len {
		seed = seed * 1664525 + 1013904223 // LCG
		input[i] = u8(seed >> 24)
	}
	round_trip('pseudo-random', input) or { panic(err) }
}

fn test_repeated_pattern() {
	// Short repeating pattern — exercises the copy back-reference paths.
	pattern := 'abcdefgh'.bytes()
	mut input := []u8{cap: pattern.len * 200}
	for _ in 0 .. 200 {
		input << pattern
	}
	compressed := compress(input)
	decompressed := decompress(compressed) or { panic(err) }
	assert decompressed == input, 'repeated-pattern round-trip failed'
	assert compressed.len < input.len / 2, 'repeated pattern should compress well'
}

fn test_lorem_ipsum() {
	lorem := 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. ' +
		'Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. ' +
		'Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris ' +
		'nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in ' +
		'reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla ' +
		'pariatur. Excepteur sint occaecat cupidatat non proident, sunt in ' +
		'culpa qui officia deserunt mollit anim id est laborum.'
	mut input := []u8{cap: lorem.len * 50}
	for _ in 0 .. 50 {
		input << lorem.bytes()
	}
	round_trip('lorem-ipsum-x50', input) or { panic(err) }
}

fn test_multi_block() {
	// Larger than one 64 KiB block to exercise the block-splitting path.
	mut input := []u8{len: 200_000, init: u8(index & 0xff)}
	round_trip('multi-block', input) or { panic(err) }
}

fn test_max_compressed_length_bound() {
	for n in [0, 1, 100, 1000, 65536, 200_000] {
		bound := max_compressed_length(n)
		mut input := []u8{len: n, init: u8(index & 0xff)}
		compressed := compress(input)
		assert compressed.len <= bound, 'max_compressed_length(${n})=${bound} exceeded by ${compressed.len}'
	}
}

fn test_decompress_invalid_varint() {
	// A stream that never terminates the varint (all bytes have MSB set).
	bad := [u8(0xff), 0xff, 0xff, 0xff, 0xff, 0xff]
	decompress(bad) or { return } // expected — an error is correct
	panic('expected decompress to fail on invalid varint')
}

fn test_decompress_truncated_literal() {
	// Header says 10 bytes uncompressed; literal tag claims 10 bytes
	// but the data is truncated.
	bad := [u8(10), u8(9 << 2), u8(0x41)] // varint(10) + tag + 1 byte
	decompress(bad) or { return }
	panic('expected decompress to fail on truncated literal')
}

fn test_decompress_bad_offset() {
	// A COPY_2 that references before the start of output.
	//   varint(5)  tag=COPY_2(len=5, _)  offset=999 (past output)
	bad := [u8(5), u8(2 | ((5 - 1) << 2)), u8(0xe7), u8(0x03)]
	decompress(bad) or { return }
	panic('expected decompress to fail on out-of-range offset')
}