module http

// Tests for the HPACK implementation (RFC 7541). The byte sequences below are
// the worked examples from RFC 7541 Appendix C; decoding them is the canonical
// correctness check for an HPACK decoder.

// hexb parses a hex string (spaces allowed) into bytes.
fn hexb(s string) []u8 {
	clean := s.replace(' ', '').replace('\n', '')
	mut out := []u8{cap: clean.len / 2}
	for i := 0; i + 1 < clean.len; i += 2 {
		hi := hex_nibble(clean[i])
		lo := hex_nibble(clean[i + 1])
		out << u8((hi << 4) | lo)
	}
	return out
}

fn hex_nibble(c u8) u8 {
	return match c {
		`0`...`9` { c - `0` }
		`a`...`f` { c - `a` + 10 }
		`A`...`F` { c - `A` + 10 }
		else { 0 }
	}
}

fn assert_fields(got []H2HeaderField, want [][]string) {
	assert got.len == want.len, 'field count: got ${got.len}, want ${want.len}'
	for i, w in want {
		assert got[i].name == w[0], 'field ${i} name: got "${got[i].name}", want "${w[0]}"'
		assert got[i].value == w[1], 'field ${i} value: got "${got[i].value}", want "${w[1]}"'
	}
}

// --- Integer representation (RFC 7541 Section 5.1) ---

fn test_hpack_integer_examples() {
	// C.1.1: encode 10 with a 5-bit prefix -> single byte 0x0a.
	mut b := []u8{}
	h2_hpack_write_int(mut b, 10, 5, 0)
	assert b == [u8(0x0a)]
	mut r := H2HpackReader{
		buf: b
	}
	assert r.read_int(5)! == 10

	// C.1.2: encode 1337 with a 5-bit prefix -> 0x1f 0x9a 0x0a.
	b = []u8{}
	h2_hpack_write_int(mut b, 1337, 5, 0)
	assert b == [u8(0x1f), 0x9a, 0x0a]
	r = H2HpackReader{
		buf: b
	}
	assert r.read_int(5)! == 1337

	// C.1.3: encode 42 with an 8-bit prefix -> single byte 0x2a.
	b = []u8{}
	h2_hpack_write_int(mut b, 42, 8, 0)
	assert b == [u8(0x2a)]
	r = H2HpackReader{
		buf: b
	}
	assert r.read_int(8)! == 42
}

fn test_hpack_integer_overflow_rejected() {
	// A run of continuation bytes with the high bit always set must not loop
	// forever or overflow; it should error.
	bad := [u8(0x1f), 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]
	mut r := H2HpackReader{
		buf: bad
	}
	r.read_int(5) or { return }
	assert false, 'expected integer overflow error'
}

// --- Huffman coding (RFC 7541 Section 5.2) ---

fn test_huffman_roundtrip() {
	samples := ['', 'www.example.com', 'no-cache', 'custom-value', '/sample/path',
		'Mon, 21 Oct 2013 20:13:21 GMT', 'https://www.example.com', 'private']
	for s in samples {
		enc := h2_huffman_encode(s.bytes())
		dec := h2_huffman_decode(enc)!
		assert dec.bytestr() == s, 'huffman roundtrip failed for "${s}"'
	}
}

fn test_huffman_known_vector() {
	// "www.example.com" Huffman-encoded, from RFC 7541 C.4.1.
	enc := hexb('f1e3c2e5f23a6ba0ab90f4ff')
	dec := h2_huffman_decode(enc)!
	assert dec.bytestr() == 'www.example.com'
}

fn test_huffman_codes_rebuilt_from_lengths() {
	// The HPACK table now ships only the bit lengths; the canonical codes are
	// rebuilt at startup via hash.huffman. Pin a few known codes from RFC 7541
	// Appendix B so a bad rebuild (or a future builder change) is caught.
	assert h2_huffman_table.codes.len == 257
	assert h2_huffman_table.lengths.len == 257
	// symbol 0 (NUL): 0x1ff8 / 13 bits
	assert h2_huffman_table.codes[0] == 0x1ff8
	assert h2_huffman_table.lengths[0] == 13
	// '0' (0x30): 0x0 / 5 bits, '1': 0x1 / 5 bits, 'a' (0x61): 0x3 / 5 bits
	assert h2_huffman_table.codes[0x30] == 0x0
	assert h2_huffman_table.lengths[0x30] == 5
	assert h2_huffman_table.codes[0x31] == 0x1
	assert h2_huffman_table.codes[0x61] == 0x3
	// EOS (256): 0x3fffffff / 30 bits
	assert h2_huffman_table.codes[256] == 0x3fffffff
	assert h2_huffman_table.lengths[256] == 30
}

fn test_huffman_rejects_padding_not_all_ones() {
	// Valid encoding of "0" is 5 bits (00000); pad the rest of the byte with
	// zeros instead of ones -> invalid per RFC 7541 Section 5.2.
	bad := [u8(0x00)] // '0' code is 00000, then 000 padding (not all ones)
	h2_huffman_decode(bad) or { return }
	assert false, 'expected invalid huffman padding error'
}

// --- C.2: Header field representations ---

fn test_hpack_c_2_1_literal_incremental() {
	mut d := H2HpackDecoder{}
	fields := d.decode(hexb('400a 6375 7374 6f6d 2d6b 6579 0d63 7573 746f 6d2d 6865 6164 6572'))!
	assert_fields(fields, [['custom-key', 'custom-header']])
	// Added to the dynamic table: size = 10 + 13 + 32 = 55.
	assert d.dyn_table.entries.len == 1
	assert d.dyn_table.cur_size == 55
	assert d.dyn_table.entries[0].name == 'custom-key'
}

fn test_hpack_c_2_2_literal_without_indexing() {
	mut d := H2HpackDecoder{}
	fields := d.decode(hexb('040c 2f73 616d 706c 652f 7061 7468'))!
	assert_fields(fields, [[':path', '/sample/path']])
	assert d.dyn_table.entries.len == 0
}

fn test_hpack_c_2_3_never_indexed() {
	mut d := H2HpackDecoder{}
	fields := d.decode(hexb('1008 7061 7373 776f 7264 0673 6563 7265 74'))!
	assert_fields(fields, [['password', 'secret']])
	assert d.dyn_table.entries.len == 0
}

fn test_hpack_c_2_4_indexed() {
	mut d := H2HpackDecoder{}
	fields := d.decode(hexb('82'))!
	assert_fields(fields, [[':method', 'GET']])
}

// --- C.3: Request sequence without Huffman, shared decoder ---

fn test_hpack_c_3_request_sequence() {
	mut d := H2HpackDecoder{}

	f1 := d.decode(hexb('8286 8441 0f77 7777 2e65 7861 6d70 6c65 2e63 6f6d'))!
	assert_fields(f1, [[':method', 'GET'], [':scheme', 'http'],
		[':path', '/'], [':authority', 'www.example.com']])
	assert d.dyn_table.cur_size == 57

	f2 := d.decode(hexb('8286 84be 5808 6e6f 2d63 6163 6865'))!
	assert_fields(f2, [[':method', 'GET'], [':scheme', 'http'],
		[':path', '/'], [':authority', 'www.example.com'], ['cache-control', 'no-cache']])

	f3 :=
		d.decode(hexb('8287 85bf 400a 6375 7374 6f6d 2d6b 6579 0c63 7573 746f 6d2d 7661 6c75 65'))!
	assert_fields(f3, [[':method', 'GET'], [':scheme', 'https'],
		[':path', '/index.html'], [':authority', 'www.example.com'],
		['custom-key', 'custom-value']])
}

// --- C.4: Request sequence with Huffman, shared decoder ---

fn test_hpack_c_4_request_sequence_huffman() {
	mut d := H2HpackDecoder{}

	f1 := d.decode(hexb('8286 8441 8cf1 e3c2 e5f2 3a6b a0ab 90f4 ff'))!
	assert_fields(f1, [[':method', 'GET'], [':scheme', 'http'],
		[':path', '/'], [':authority', 'www.example.com']])

	f2 := d.decode(hexb('8286 84be 5886 a8eb 1064 9cbf'))!
	assert_fields(f2, [[':method', 'GET'], [':scheme', 'http'],
		[':path', '/'], [':authority', 'www.example.com'], ['cache-control', 'no-cache']])

	f3 := d.decode(hexb('8287 85bf 4088 25a8 49e9 5ba9 7d7f 8925 a849 e95b b8e8 b4bf'))!
	assert_fields(f3, [[':method', 'GET'], [':scheme', 'https'],
		[':path', '/index.html'], [':authority', 'www.example.com'],
		['custom-key', 'custom-value']])
}

// --- Dynamic table eviction (RFC 7541 Sections 4.3, 4.4) ---

fn test_dyn_table_eviction_on_add() {
	// Mirrors python-hpack's eviction test: a 66-byte table holds only one of
	// these two entries at a time.
	mut t := H2DynTable{
		max_size: 66
	}
	t.add('a', 'b') // size = 1 + 1 + 32 = 34
	assert t.entries.len == 1
	assert t.cur_size == 34
	t.add('long-custom-header', 'longish value') // size = 18 + 13 + 32 = 63
	assert t.entries.len == 1
	assert t.entries[0].name == 'long-custom-header'
	assert t.cur_size == 63
}

fn test_dyn_table_oversized_entry_empties_table() {
	mut t := H2DynTable{
		max_size: 64
	}
	t.add('a', 'b')
	assert t.entries.len == 1
	// An entry larger than the whole table empties it and is not added.
	t.add('x'.repeat(100), '')
	assert t.entries.len == 0
	assert t.cur_size == 0
}

fn test_dyn_table_resize_evicts() {
	mut t := H2DynTable{}
	t.add('a', 'b')
	t.add('c', 'd')
	assert t.entries.len == 2
	t.set_max_size(34) // room for exactly one 34-byte entry (the newest)
	assert t.entries.len == 1
	assert t.entries[0].name == 'c'
	t.set_max_size(0)
	assert t.entries.len == 0
	assert t.cur_size == 0
}

// A "size update then re-add" sequence exercised through the decoder: an
// indexed reference to an evicted entry must fail.
fn test_decoder_dynamic_indexing_and_eviction() {
	mut d := H2HpackDecoder{}
	// Literal incremental indexing of custom-key: custom-header (size 55).
	_ := d.decode(hexb('400a 6375 7374 6f6d 2d6b 6579 0d63 7573 746f 6d2d 6865 6164 6572'))!
	assert d.dyn_table.entries.len == 1
	// Index 62 now refers to that entry.
	f := d.decode([u8(0xbe)])!
	assert_fields(f, [['custom-key', 'custom-header']])
	// Shrinking the table to 0 evicts it; index 62 is then out of range.
	d.decode([u8(0x20)])! // dynamic table size update to 0
	assert d.dyn_table.entries.len == 0
	d.decode([u8(0xbe)]) or { return }
	assert false, 'expected out-of-range error after eviction'
}

// --- Encoder + round-trip ---

fn test_hpack_encode_indexed_static() {
	mut e := H2HpackEncoder{}
	// :method GET is static index 2 -> single byte 0x82.
	out := e.encode([H2HeaderField{':method', 'GET'}])
	assert out == [u8(0x82)]
}

fn test_hpack_roundtrip() {
	fields := [
		H2HeaderField{':method', 'GET'},
		H2HeaderField{':scheme', 'https'},
		H2HeaderField{':authority', 'example.com'},
		H2HeaderField{':path', '/index.html'},
		H2HeaderField{'user-agent', 'v.http/0.1'},
		H2HeaderField{'accept', '*/*'},
		H2HeaderField{'cookie', 'session=abc123'},
	]
	mut e := H2HpackEncoder{}
	mut d := H2HpackDecoder{}
	encoded := e.encode(fields)
	decoded := d.decode(encoded)!
	assert_fields(decoded, [[':method', 'GET'], [':scheme', 'https'],
		[':authority', 'example.com'], [':path', '/index.html'],
		['user-agent', 'v.http/0.1'], ['accept', '*/*'], ['cookie', 'session=abc123']])
}

// --- Decoder error handling ---

fn test_hpack_rejects_zero_index() {
	mut d := H2HpackDecoder{}
	d.decode([u8(0x80)]) or { return } // indexed header field, index 0
	assert false, 'expected error for index 0'
}

fn test_hpack_rejects_out_of_range_index() {
	mut d := H2HpackDecoder{}
	d.decode([u8(0xff), 0x00]) or { return } // index 62, dynamic table empty
	assert false, 'expected error for out-of-range index'
}

fn test_hpack_rejects_size_update_after_field() {
	mut d := H2HpackDecoder{}
	// Indexed field (0x82) followed by a dynamic table size update (0x20).
	d.decode([u8(0x82), 0x20]) or { return }
	assert false, 'expected error for size update after field'
}

fn test_hpack_rejects_size_update_over_limit() {
	mut d := H2HpackDecoder{}
	d.set_max_dynamic_size(4096)
	// 0x3f e0 0f = dynamic table size update to 4096+... well over 4096.
	// Dynamic table size update to 8192 (> 4096 limit).
	d.decode([u8(0x3f), 0xe1, 0x3f]) or { return }
	assert false, 'expected error for size update over limit'
}

fn test_hpack_rejects_truncating_index() {
	mut d := H2HpackDecoder{}
	// Insert one dynamic entry, so dynamic index 1 (HPACK index 62) is valid.
	_ := d.decode(hexb('400a 6375 7374 6f6d 2d6b 6579 0d63 7573 746f 6d2d 6865 6164 6572'))!
	// Indexed representation with idx = 2^32 + 62: it truncates to 62 (a valid
	// dynamic index) when narrowed to a 32-bit int, but must be rejected.
	mut block := []u8{}
	h2_hpack_write_int(mut block, u64(0x1_0000_0000) + 62, 7, 0x80)
	d.decode(block) or { return }
	assert false, 'expected out-of-range error for truncating index'
}

fn test_hpack_rejects_truncating_string_length() {
	mut d := H2HpackDecoder{}
	mut block := []u8{}
	block << 0x00 // literal without indexing, name index 0
	block << 0x00 // empty name (H=0, length 0)
	// Value string length = 2^32 + 5, which truncates to 5 in a 32-bit int.
	h2_hpack_write_int(mut block, u64(0x1_0000_0000) + 5, 7, 0x00)
	// No value bytes follow; the oversized length must be rejected cleanly.
	d.decode(block) or { return }
	assert false, 'expected length-exceeds-buffer error for truncating string length'
}