module snappy

import arrays
import io

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

fn stream_round_trip(label string, input []u8) ! {
	encoded := encode_stream(input)
	decoded := decode_stream(encoded)!

	assert decoded == input, '${label}: stream round-trip mismatch (len=${input.len})'
}

// drain_decoder closes dec and returns all decoded bytes accumulated so far.
fn drain_decoder(mut dec StreamDecoder) []u8 {
	dec.close() or { panic(err) }
	mut collected := []u8{}
	mut chunk := []u8{len: 4096}
	for {
		n := dec.read(mut chunk) or { break }
		if n == 0 {
			break
		}
		collected << chunk[..n]
	}
	return collected
}

// ---------------------------------------------------------------------------
// CRC32C tests
// ---------------------------------------------------------------------------

fn test_crc32c_empty() {
	// Known value: CRC32C("") = 0x00000000
	assert crc32c([]) == u32(0x00000000)
}

fn test_crc32c_known_vector() {
	// CRC32C("123456789") = 0xE3069283 — standard test vector.
	assert crc32c('123456789'.bytes()) == u32(0xe3069283)
}

fn test_mask_unmask_roundtrip() {
	for v in [u32(0), u32(1), u32(0xdeadbeef), u32(0xffffffff)] {
		assert unmask_crc(mask_crc(v)) == v, 'mask/unmask failed for 0x${v:08x}'
	}
}

// ---------------------------------------------------------------------------
// One-shot encode / decode
// ---------------------------------------------------------------------------

fn test_stream_empty() {
	stream_round_trip('empty', []u8{}) or { panic(err) }
}

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

fn test_stream_small() {
	stream_round_trip('hello world', 'Hello, World!'.bytes()) or { panic(err) }
}

fn test_stream_compressible() {
	input := []u8{len: 8192, init: u8(index % 7)}
	stream_round_trip('compressible', input) or { panic(err) }
}

fn test_stream_incompressible() {
	mut input := []u8{len: 2048}
	mut seed := u32(0xc0ffee42)
	for i in 0 .. input.len {
		seed = seed * 1664525 + 1013904223
		input[i] = u8(seed >> 24)
	}
	stream_round_trip('incompressible', input) or { panic(err) }
}

fn test_stream_exactly_one_block() {
	// Exactly max_chunk_data_size bytes — exercises the boundary condition.
	input := []u8{len: max_chunk_data_size, init: u8(index & 0xff)}
	stream_round_trip('one-full-block', input) or { panic(err) }
}

fn test_stream_multi_block() {
	// Spans multiple 64 KiB blocks.
	input := []u8{len: max_chunk_data_size * 3 + 100, init: u8(index & 0xff)}
	stream_round_trip('multi-block', input) or { panic(err) }
}

fn test_stream_identifier_present() {
	// The encoded stream must start with the identifier chunk.
	encoded := encode_stream('test'.bytes())
	assert encoded.len >= 10, 'stream too short to contain identifier'
	assert encoded[0] == chunk_type_stream_id, 'first byte must be stream identifier type'
	// The 6-byte magic must follow the 4-byte header.
	magic := encoded[4..10]
	assert magic == stream_identifier_magic, 'stream identifier magic mismatch'
}

fn test_stream_crc_mismatch_detected() {
	mut encoded := encode_stream('hello'.bytes())
	// Corrupt a byte in the CRC field of the first data chunk (after the
	// 10-byte identifier: 4-byte header + 4-byte CRC starts at byte 14).
	if encoded.len > 14 {
		encoded[14] ^= 0xff
	}
	decode_stream(encoded) or { return } // expected error
	panic('expected decode_stream to fail on CRC mismatch')
}

fn test_stream_missing_identifier() {
	// A stream that starts with a compressed chunk instead of the identifier.
	bad := [u8(chunk_type_compressed), 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
	decode_stream(bad) or { return }
	panic('expected decode_stream to fail without identifier chunk')
}

fn test_stream_unskippable_reserved_chunk() {
	mut s := encode_stream('hello'.bytes())
	// Inject a reserved unskippable chunk (type=0x02) before the data.
	injected := [u8(0x02), 0x01, 0x00, 0x00, u8(0x00)] // type + 3-byte len=1 + 1 payload byte
	// Insert after the 10-byte stream identifier.
	s = arrays.reduce([s[..10], injected, s[10..]], fn (acc []u8, x []u8) []u8 {
		mut out := acc.clone()
		out << x
		return out
	})!
	decode_stream(s) or { return }
	panic('expected decode_stream to fail on unskippable reserved chunk')
}

fn test_stream_padding_skipped() {
	// Build a stream manually: identifier + padding + compressed data.
	mut s := []u8{}
	// Stream identifier
	s << chunk_type_stream_id
	write_u24le(mut s, stream_identifier_magic.len)
	s << stream_identifier_magic
	// Padding chunk (type=0xfe, length=4, 4 zero bytes)
	s << chunk_type_padding
	write_u24le(mut s, 4)
	s << [u8(0), 0, 0, 0]
	// A real data chunk
	inner := encode_stream('after padding'.bytes())
	// Skip the inner identifier (first 10 bytes) and append the data chunk.
	s << inner[10..]

	decoded := decode_stream(s) or { panic(err) }
	assert decoded == 'after padding'.bytes(), 'padding chunk should be silently skipped'
}

// ---------------------------------------------------------------------------
// Incremental encoder
// ---------------------------------------------------------------------------

fn test_incremental_encoder_matches_oneshot() {
	input := []u8{len: max_chunk_data_size + 500, init: u8(index & 0xff)}

	// One-shot
	oneshot := encode_stream(input)

	// Incremental: feed in 1000-byte pieces via write/close/peek.
	mut enc := StreamEncoder{}
	mut pos := 0
	for pos < input.len {
		end := if pos + 1000 < input.len { pos + 1000 } else { input.len }
		enc.write(input[pos..end]) or { panic(err) }
		pos = end
	}
	enc.close()
	incremental := enc.peek()

	assert incremental == oneshot, 'incremental encoder output differs from one-shot'
}

fn test_incremental_encoder_decodable() {
	input := 'Streaming is fun!'.bytes().repeat(3000)

	mut enc := StreamEncoder{}
	enc.write(input[..input.len / 2]) or { panic(err) }
	enc.write(input[input.len / 2..]) or { panic(err) }
	enc.close()
	stream := enc.peek()

	decoded := decode_stream(stream) or { panic(err) }
	assert decoded == input, 'incremental encoder produced undecodable stream'
}

fn test_incremental_encoder_write_after_close_errors() {
	// write() on a closed encoder must return an error.
	mut enc := StreamEncoder{}
	enc.write('hello'.bytes()) or { panic(err) }
	enc.close()
	enc.write('world'.bytes()) or { return } // expected error
	panic('expected write on closed encoder to fail')
}

fn test_incremental_encoder_read_drains_output() {
	// read() should drain bytes from the encoded output incrementally.
	input := []u8{len: max_chunk_data_size + 100, init: u8(index & 0xff)}
	mut enc := StreamEncoder{}
	enc.write(input) or { panic(err) }
	enc.close()

	// Drain via read() in small pieces and reassemble.
	mut collected := []u8{}
	mut chunk := []u8{len: 256}
	for {
		n := enc.read(mut chunk) or { break }
		if n == 0 {
			break
		}
		collected << chunk[..n]
	}

	expected := encode_stream(input)
	assert collected == expected, 'read() did not produce the same bytes as encode_stream'
}

// ---------------------------------------------------------------------------
// Incremental decoder
// ---------------------------------------------------------------------------

fn test_incremental_decoder_byte_by_byte() {
	input := 'Byte by byte delivery'.bytes().repeat(500)
	stream := encode_stream(input)

	mut dec := StreamDecoder{}
	for b in stream {
		dec.write([b]) or { panic(err) }
	}
	assert drain_decoder(mut dec) == input, 'incremental decoder failed (byte-by-byte)'
}

fn test_incremental_decoder_large_chunks() {
	input := []u8{len: max_chunk_data_size * 2 + 99, init: u8(index % 13)}
	stream := encode_stream(input)

	mut dec := StreamDecoder{}
	mut pos := 0
	for pos < stream.len {
		end := if pos + 8192 < stream.len { pos + 8192 } else { stream.len }
		dec.write(stream[pos..end]) or { panic(err) }
		pos = end
	}
	assert drain_decoder(mut dec) == input, 'incremental decoder failed (large chunks)'
}

fn test_incremental_decoder_read_drains_output() {
	// A first read() call should return all decoded bytes; a second call on a
	// closed decoder with no remaining output should return io.Eof.
	stream := encode_stream('hello world'.bytes())
	mut dec := StreamDecoder{}
	dec.write(stream) or { panic(err) }
	dec.close() or { panic(err) }

	mut buf := []u8{len: 4096}

	// First read — should yield the decoded payload.
	n := dec.read(mut buf) or { panic(err) }
	assert buf[..n] == 'hello world'.bytes(), 'first read should return decoded bytes'

	// Second read — decoder is closed and output is empty; expect Eof.
	dec.read(mut buf) or {
		assert err is io.Eof, 'expected io.Eof after output is drained, got: ${err}'
		return
	}
	panic('expected io.Eof on second read after output is drained')
}

fn test_incremental_decoder_write_after_close_errors() {
	// write() on a closed decoder must return an error.
	stream := encode_stream('hello'.bytes())
	mut dec := StreamDecoder{}
	dec.write(stream) or { panic(err) }
	dec.close() or { panic(err) }
	dec.write(stream) or { return } // expected error
	panic('expected write on closed decoder to fail')
}