module bzip2

import encoding.hex

fn must_decode_hex(s string) []u8 {
	return hex.decode(s) or { panic(err) }
}

fn test_roundtrip_empty_input() {
	src := []u8{}
	compressed := compress(src) or { panic(err) }
	decompressed := decompress(compressed) or { panic(err) }
	assert decompressed == src
}

fn test_roundtrip_small_text() {
	src := 'hello world\n'.bytes()
	compressed := compress(src) or { panic(err) }
	decompressed := decompress(compressed) or { panic(err) }
	assert decompressed == src
}

fn test_roundtrip_binary_data() {
	mut src := []u8{len: 4096}
	for i in 0 .. src.len {
		src[i] = u8((i * 17 + 13) & 0xff)
	}
	compressed := compress(src, block_size: 1) or { panic(err) }
	decompressed := decompress(compressed) or { panic(err) }
	assert decompressed == src
}

fn test_roundtrip_long_runs() {
	src := 'a'.repeat(2000).bytes()
	compressed := compress(src) or { panic(err) }
	decompressed := decompress(compressed) or { panic(err) }
	assert decompressed == src
}

fn test_decompress_known_python_vector_empty() {
	bz2 := must_decode_hex('425a683917724538509000000000')
	plain := decompress(bz2) or { panic(err) }
	assert plain == []u8{}
}

fn test_decompress_known_python_vector_hello() {
	bz2 :=
		must_decode_hex('425a68393141592653594eece83600000251800010400006449080200031064c4101a7a9a580bb9431f8bb9229c28482776741b0')
	plain := decompress(bz2) or { panic(err) }
	assert plain.bytestr() == 'hello world\n'
}

fn test_decompress_known_python_vector_text() {
	bz2 :=
		must_decode_hex('425a6839314159265359dc01b0d8000002d9800010410120080a00cc20200021a4d3688cd0806800e28a3de49f0b16b10d177245385090dc01b0d8')
	plain := decompress(bz2) or { panic(err) }
	assert plain.bytestr() == '1.test\ncopy ©\n'
}

fn test_decompress_known_python_vector_repeated_a() {
	bz2 :=
		must_decode_hex('425a6839314159265359ca3d8dfb000000010420000400200021008283177245385090ca3d8dfb')
	plain := decompress(bz2) or { panic(err) }
	assert plain == 'a'.repeat(200).bytes()
}

fn test_decompress_rejects_invalid_header() {
	_ := decompress('not-bzip2'.bytes()) or {
		assert err.msg().contains('invalid header')
		return
	}
	assert false
}

fn test_decompress_rejects_crc_mismatch() {
	mut bz2 :=
		must_decode_hex('425a68393141592653594eece83600000251800010400006449080200031064c4101a7a9a580bb9431f8bb9229c28482776741b0')
	// Corrupt the stored block CRC field (bytes 10..13 in a single-block stream).
	bz2[10] ^= 0x01
	_ := decompress(bz2) or {
		assert err.msg().contains('crc mismatch')
		return
	}
	assert false
}

fn test_selector_count_limit_boundaries() {
	below_limit := selector_count_from_symbol_count(900050) or { panic(err) }
	at_limit := selector_count_from_symbol_count(900100) or { panic(err) }
	assert below_limit == 18001
	assert at_limit == 18002

	_ := selector_count_from_symbol_count(900101) or {
		assert err.msg().contains('invalid selector count')
		return
	}
	assert false
}

fn test_block_output_limit_guard() {
	ensure_block_output_limit(0, 100000, 100000) or { panic(err) }
	ensure_block_output_limit(99999, 1, 100000) or { panic(err) }

	ensure_block_output_limit(100000, 1, 100000) or {
		assert err.msg().contains('block output exceeds declared block size')
		return
	}
	assert false
}

fn test_find_rle1_block_end_for_four_byte_runs() {
	mut src := []u8{cap: 100000}
	for i in 0 .. 25000 {
		b := u8(i & 0xff)
		for _ in 0 .. 4 {
			src << b
		}
	}
	end := find_rle1_block_end(src, 0, 100000)
	assert end == 80000
	assert rle1_encode(src[0..end]).len == 100000
	assert rle1_encode(src[0..end + 4]).len > 100000
}

fn test_roundtrip_block_size_1_four_byte_runs() {
	mut src := []u8{cap: 100000}
	for i in 0 .. 25000 {
		b := u8(i & 0xff)
		for _ in 0 .. 4 {
			src << b
		}
	}
	compressed := compress(src, block_size: 1) or { panic(err) }
	decompressed := decompress(compressed) or { panic(err) }
	assert decompressed == src
}