import hash.crc64

fn test_crc64_basic() {
	b1 := 'testing crc64'.bytes()
	sum1 := crc64.sum(b1)
	// Verify it's not zero for non-empty input
	assert sum1 != u64(0)

	c := crc64.new(crc64.ecma)
	b2 := 'testing crc64 again'.bytes()
	sum2 := c.checksum(b2)
	// Different input should yield different checksum (with high probability)
	assert sum2 != sum1
}

fn test_crc64_empty() {
	empty := ''.bytes()
	assert crc64.sum(empty) == u64(0)

	c := crc64.new(crc64.ecma)
	assert c.checksum(empty) == u64(0)
}

fn test_crc64_single_byte() {
	a := 'a'.bytes()
	c := crc64.new(crc64.ecma)
	sum_a := c.checksum(a)
	assert sum_a != u64(0)

	b := 'b'.bytes()
	sum_b := c.checksum(b)
	assert sum_b != sum_a
}

fn test_crc64_roundtrip_known_vector() {
	// Standard test vector: "123456789"
	data := '123456789'.bytes()
	c := crc64.new(crc64.ecma)
	result := c.checksum(data)
	// CRC-64-ECMA-182 check value
	assert result == u64(0x6c40df5f0b497347)

	// Verify consistency
	assert crc64.sum(data) == result
	assert crc64.sum_with_poly(crc64.ecma, data) == result
}

fn test_crc64_binary_input() {
	// Test with all byte values
	data := [u8(0), 1, 2, 255, 128, 42, 0x00, 0xff]
	c := crc64.new(crc64.ecma)
	result := c.checksum(data)
	assert result != u64(0)
}

fn test_crc64_update() {
	data := '123456789'.bytes()
	part1 := data[..4]
	part2 := data[4..]

	c := crc64.new(crc64.ecma)
	mut acc := u64(0)
	acc = c.update(acc, part1)
	acc = c.update(acc, part2)

	assert acc == c.checksum(data)
}

fn test_crc64_streaming_chunk_sizes() {
	data := ('streaming data block '.repeat(64)).bytes()
	c := crc64.new(crc64.ecma)
	expected := c.checksum(data)

	for chunk_size in [1, 2, 3, 5, 7, 16, 31, 64, 128] {
		mut state := u64(0)
		mut start := 0
		for start < data.len {
			end := if start + chunk_size < data.len { start + chunk_size } else { data.len }
			state = c.update_state(state, data[start..end])
			start = end
		}
		assert state == expected
	}
}

fn test_crc64_update_state() {
	data := 'stateful streaming'.bytes()
	part1 := data[..5]
	part2 := data[5..]
	c := crc64.new(crc64.ecma)

	mut state := u64(0)
	state = c.update_state(state, part1)
	state = c.update_state(state, part2)

	assert state == c.checksum(data)
}

fn test_crc64_sum_with_poly() {
	data := 'variant helper'.bytes()
	c := crc64.new(crc64.ecma)
	assert c.checksum(data) == crc64.sum_with_poly(crc64.ecma, data)
	assert crc64.sum(data) == crc64.sum_with_poly(crc64.ecma, data)
}

fn test_crc64_sum_with_poly_custom() {
	data := 'custom poly checksum'.bytes()
	// Use a different polynomial to verify custom path
	poly := u64(0xa6fd4db2ef0b0da9)

	assert crc64.sum_with_poly(poly, data) == crc64.new(poly).checksum(data)
}

fn test_crc64_large_input() {
	// Test with large repetitive data
	large_data := ('large repetitive input '.repeat(1000)).bytes()
	c := crc64.new(crc64.ecma)
	result := c.checksum(large_data)
	assert result != u64(0)

	// Verify consistency with streaming
	mut state := u64(0)
	for i := 0; i < large_data.len; i += 512 {
		end := if i + 512 < large_data.len { i + 512 } else { large_data.len }
		state = c.update_state(state, large_data[i..end])
	}
	assert state == result
}

fn test_crc64_all_bytes() {
	// Create data with all possible byte values
	mut all_bytes := []u8{}
	for b in 0 .. 256 {
		all_bytes << u8(b)
	}
	c := crc64.new(crc64.ecma)
	result := c.checksum(all_bytes)
	assert result != u64(0)

	// Verify it's consistent
	assert crc64.sum(all_bytes) == result
}

fn test_crc64_deterministic() {
	data := 'deterministic test'.bytes()
	c := crc64.new(crc64.ecma)

	result1 := c.checksum(data)
	result2 := c.checksum(data)
	result3 := crc64.sum(data)

	assert result1 == result2
	assert result1 == result3
}

fn test_crc64_prefix_sensitivity() {
	// Verify that different prefixes produce different results
	base := 'test'.bytes()
	c := crc64.new(crc64.ecma)

	sum_base := c.checksum(base)
	sum_t := c.checksum('test_extended'.bytes())
	sum_prefix := c.checksum('prefix_test'.bytes())

	assert sum_base != sum_t
	assert sum_base != sum_prefix
	assert sum_t != sum_prefix
}

fn test_crc64_consistency_across_polys() {
	// If only one poly is defined, at least verify the path works
	data := 'poly path test'.bytes()
	direct := crc64.sum(data)
	via_poly := crc64.sum_with_poly(crc64.ecma, data)
	via_new := crc64.new(crc64.ecma).checksum(data)

	assert direct == via_poly
	assert direct == via_new
}