// Hermetic round-trip test for the server-side HTTP/2 driver. Uses an
// in-memory blocking ReadWriter pair so client and server share the same
// address space and no socket is required.
module http

import sync
import time

// PipeBuf is a one-way in-memory FIFO between a writer and a reader.
// `read` blocks (poll-with-sleep) until data is available, mirroring socket
// semantics so the h2 client and server can drive each other to completion.
struct PipeBuf {
mut:
	mu     &sync.Mutex = sync.new_mutex()
	data   []u8
	closed bool
}

fn (mut p PipeBuf) write(buf []u8) !int {
	p.mu.lock()
	defer {
		p.mu.unlock()
	}
	if p.closed {
		return error('pipe: write to closed pipe')
	}
	p.data << buf
	return buf.len
}

fn (mut p PipeBuf) read(mut buf []u8) !int {
	for {
		p.mu.lock()
		if p.data.len > 0 {
			mut n := p.data.len
			if n > buf.len {
				n = buf.len
			}
			for i in 0 .. n {
				buf[i] = p.data[i]
			}
			p.data = p.data[n..].clone()
			p.mu.unlock()
			return n
		}
		if p.closed {
			p.mu.unlock()
			return error('eof')
		}
		p.mu.unlock()
		time.sleep(time.millisecond)
	}
	return 0
}

// PipeEnd is one half of a bidirectional pipe: reads come from `incoming`,
// writes go to `outgoing`.
struct PipeEnd {
mut:
	incoming &PipeBuf
	outgoing &PipeBuf
}

fn (mut p PipeEnd) read(mut buf []u8) !int {
	return p.incoming.read(mut buf)!
}

fn (mut p PipeEnd) write(buf []u8) !int {
	return p.outgoing.write(buf)!
}

fn new_pipe() (&PipeEnd, &PipeEnd) {
	mut a := &PipeBuf{}
	mut b := &PipeBuf{}
	client := &PipeEnd{
		incoming: b
		outgoing: a
	}
	server := &PipeEnd{
		incoming: a
		outgoing: b
	}
	return client, server
}

struct ServerEchoHandler {
mut:
	last_method Method
	last_url    string
	last_body   string
}

fn (mut h ServerEchoHandler) handle(req Request) Response {
	h.last_method = req.method
	h.last_url = req.url
	h.last_body = req.data
	mut resp_header := new_header()
	resp_header.add_custom('content-type', 'text/plain') or {}
	// Echo the URL and body back so callers can verify end-to-end delivery
	// without depending on Handler-state mutation across goroutines.
	return Response{
		status_code: 200
		header:      resp_header
		body:        'echo: ${req.url} body=${req.data}'
	}
}

fn test_h2_server_basic_request() {
	mut client_end, mut server_end := new_pipe()

	// Spawn the server-side h2 driver against the server end of the pipe.
	mut handler := ServerEchoHandler{}
	mut handler_iface := Handler(handler)
	spawn fn [mut server_end, mut handler_iface] () {
		mut transport := H2Transport(server_end)
		serve_h2_conn(mut transport, mut handler_iface) or {}
	}()

	// Drive a client-side request through the same pipe.
	mut conn := new_h2_conn(client_end)
	resp := conn.do(H2ClientRequest{
		method:    'GET'
		authority: 'example.com'
		path:      '/hello'
	}) or {
		assert false, 'client do() failed: ${err}'
		return
	}
	assert resp.status == 200
	assert resp.body.bytestr() == 'echo: /hello body='
	assert resp.headers.any(it.name == 'content-type' && it.value == 'text/plain')
}

fn test_h2_server_post_with_body() {
	mut client_end, mut server_end := new_pipe()
	mut handler := ServerEchoHandler{}
	mut handler_iface := Handler(handler)
	spawn fn [mut server_end, mut handler_iface] () {
		mut transport := H2Transport(server_end)
		serve_h2_conn(mut transport, mut handler_iface) or {}
	}()

	mut conn := new_h2_conn(client_end)
	resp := conn.do(H2ClientRequest{
		method:    'POST'
		authority: 'svc.example'
		path:      '/upload'
		body:      'hello world'.bytes()
	}) or {
		assert false, 'client do() failed: ${err}'
		return
	}
	assert resp.status == 200
	assert resp.body.bytestr() == 'echo: /upload body=hello world'
}

struct StatusHandler {
	code int
}

fn (mut h StatusHandler) handle(req Request) Response {
	return Response{
		status_code: h.code
		body:        'status ${h.code}'
	}
}

fn test_h2_server_non_200_status() {
	mut client_end, mut server_end := new_pipe()
	mut handler := StatusHandler{
		code: 404
	}
	mut handler_iface := Handler(handler)
	spawn fn [mut server_end, mut handler_iface] () {
		mut transport := H2Transport(server_end)
		serve_h2_conn(mut transport, mut handler_iface) or {}
	}()

	mut conn := new_h2_conn(client_end)
	resp := conn.do(H2ClientRequest{ authority: 'h.example' }) or {
		assert false, 'client do() failed: ${err}'
		return
	}
	assert resp.status == 404
	assert resp.body.bytestr() == 'status 404'
}

struct BigBodyHandler {
	size int
}

fn (mut h BigBodyHandler) handle(req Request) Response {
	return Response{
		status_code: 200
		body:        'x'.repeat(h.size)
	}
}

// FrameReader reads HTTP/2 frames one at a time off a PipeEnd, buffering any
// leftover bytes between frames.
struct FrameReader {
mut:
	end &PipeEnd
	buf []u8
}

fn (mut r FrameReader) next() !H2Frame {
	for {
		if r.buf.len >= h2_frame_header_len {
			hdr := h2_parse_frame_header(r.buf)!
			total := h2_frame_header_len + int(hdr.length)
			if r.buf.len >= total {
				f := h2_parse_frame(hdr, r.buf[h2_frame_header_len..total])!
				r.buf = r.buf[total..].clone()
				return f
			}
		}
		mut tmp := []u8{len: 4096}
		n := r.end.read(mut tmp)!
		r.buf << tmp[..n]
	}
	return error('unreachable')
}

fn test_h2_server_respects_send_window() {
	mut client_end, mut server_end := new_pipe()
	mut handler_iface := Handler(BigBodyHandler{
		size: 100
	})
	spawn fn [mut server_end, mut handler_iface] () {
		mut transport := H2Transport(server_end)
		serve_h2_conn(mut transport, mut handler_iface) or {}
	}()

	// Raw client: preface + SETTINGS(initial_window_size = 10) + a GET, then a
	// WINDOW_UPDATE(stream 1, +1000). The server must send at most 10 body
	// bytes before consuming the WINDOW_UPDATE, then deliver the rest.
	mut enc := H2HpackEncoder{}
	block := enc.encode([
		H2HeaderField{':method', 'GET'},
		H2HeaderField{':scheme', 'https'},
		H2HeaderField{':authority', 'h.example'},
		H2HeaderField{':path', '/big'},
	])
	mut out := []u8{}
	out << h2_client_preface.bytes()
	out << H2Frame(H2SettingsFrame{
		settings: [H2Setting{h2_settings_initial_window_size, 10}]
	}).encode()
	out << H2Frame(H2HeadersFrame{
		stream_id:   1
		fragment:    block
		end_headers: true
		end_stream:  true
	}).encode()
	out << H2Frame(H2WindowUpdateFrame{
		stream_id:             1
		window_size_increment: 1000
	}).encode()
	client_end.write(out) or {
		assert false, 'client write failed: ${err}'
		return
	}

	mut fr := FrameReader{
		end: client_end
	}
	mut body := []u8{}
	mut status := 0
	mut first_data_len := -1
	mut got_end := false
	mut dec := H2HpackDecoder{}
	for !got_end {
		f := fr.next() or {
			assert false, 'frame read failed: ${err}'
			return
		}
		match f {
			H2HeadersFrame {
				for hf in dec.decode(f.fragment) or { []H2HeaderField{} } {
					if hf.name == ':status' {
						status = hf.value.int()
					}
				}
				if f.end_stream {
					got_end = true
				}
			}
			H2DataFrame {
				if first_data_len < 0 {
					first_data_len = f.data.len
				}
				body << f.data
				if f.end_stream {
					got_end = true
				}
			}
			else {}
		}
	}
	assert status == 200
	assert body.len == 100
	// The first DATA frame must not exceed the initial 10-byte window.
	assert first_data_len <= 10
}

// spawn_h2_echo_server starts the h2 server driver on the server end of a fresh
// pipe and returns the client end for raw-frame scripting.
fn spawn_h2_echo_server() &PipeEnd {
	mut client_end, mut server_end := new_pipe()
	mut handler_iface := Handler(ServerEchoHandler{})
	spawn fn [mut server_end, mut handler_iface] () {
		mut transport := H2Transport(server_end)
		serve_h2_conn(mut transport, mut handler_iface) or {}
	}()
	return client_end
}

// drive_until_rst_or_response writes `out` to the server, then reads frames back
// until it sees a RST_STREAM on stream 1 (returns the error code) or a HEADERS
// frame (a response — returns -1, meaning the request was accepted). It never
// blocks indefinitely: the server always answers a malformed request with
// RST_STREAM and a valid one with HEADERS.
fn drive_until_rst_or_response(mut client_end PipeEnd, out []u8, label string) i64 {
	client_end.write(out) or {
		assert false, '${label}: client write failed: ${err}'
		return -2
	}
	mut fr := FrameReader{
		end: client_end
	}
	for _ in 0 .. 32 {
		f := fr.next() or { break }
		match f {
			H2RstStreamFrame {
				if f.stream_id == 1 {
					return i64(f.error_code)
				}
			}
			H2HeadersFrame {
				return -1
			}
			else {}
		}
	}
	assert false, '${label}: server sent neither RST_STREAM nor a response'
	return -2
}

// malformed_headers_out builds preface + SETTINGS + a single complete HEADERS
// frame (END_HEADERS, END_STREAM) carrying `fields`.
fn malformed_headers_out(fields []H2HeaderField) []u8 {
	mut enc := H2HpackEncoder{}
	block := enc.encode(fields)
	mut out := []u8{}
	out << h2_client_preface.bytes()
	out << H2Frame(H2SettingsFrame{}).encode()
	out << H2Frame(H2HeadersFrame{
		stream_id:   1
		fragment:    block
		end_headers: true
		end_stream:  true
	}).encode()
	return out
}

fn assert_request_malformed(fields []H2HeaderField, label string) {
	mut client_end := spawn_h2_echo_server()
	code := drive_until_rst_or_response(mut client_end, malformed_headers_out(fields), label)
	assert code == i64(u32(H2ErrorCode.protocol_error)), '${label}: expected RST_STREAM(PROTOCOL_ERROR), got ${code}'
}

const valid_get_pseudo = [
	H2HeaderField{':method', 'GET'},
	H2HeaderField{':scheme', 'https'},
	H2HeaderField{':authority', 'h.example'},
	H2HeaderField{':path', '/'},
]

// RFC 9113 §8.1.2: a field name with uppercase letters is malformed.
fn test_h2_server_rejects_uppercase_header() {
	mut fields := valid_get_pseudo.clone()
	fields << H2HeaderField{'X-Test', 'v'}
	assert_request_malformed(fields, 'uppercase field name')
}

// RFC 9113 §8.1.2.1: a pseudo-header after a regular field is malformed.
fn test_h2_server_rejects_pseudo_after_regular() {
	fields := [
		H2HeaderField{'x-a', '1'},
		H2HeaderField{':method', 'GET'},
		H2HeaderField{':scheme', 'https'},
		H2HeaderField{':authority', 'h.example'},
		H2HeaderField{':path', '/'},
	]
	assert_request_malformed(fields, 'pseudo after regular')
}

// RFC 9113 §8.1.2.2: TE may only carry the value "trailers".
fn test_h2_server_rejects_te_not_trailers() {
	mut fields := valid_get_pseudo.clone()
	fields << H2HeaderField{'te', 'gzip'}
	assert_request_malformed(fields, 'TE other than trailers')
}

// RFC 9113 §8.1.2.2: connection-specific fields are forbidden.
fn test_h2_server_rejects_connection_specific_header() {
	mut fields := valid_get_pseudo.clone()
	fields << H2HeaderField{'connection', 'keep-alive'}
	assert_request_malformed(fields, 'connection-specific field')
}

// RFC 9113 §8.1.2.3: omitting :scheme is malformed.
fn test_h2_server_rejects_missing_scheme() {
	fields := [
		H2HeaderField{':method', 'GET'},
		H2HeaderField{':authority', 'h.example'},
		H2HeaderField{':path', '/'},
	]
	assert_request_malformed(fields, 'missing :scheme')
}

// RFC 9113 §8.1.2.3: a duplicated request pseudo-header is malformed.
fn test_h2_server_rejects_duplicate_pseudo() {
	for dup in [
		H2HeaderField{':method', 'GET'},
		H2HeaderField{':path', '/'},
		H2HeaderField{':scheme', 'https'},
	] {
		mut fields := valid_get_pseudo.clone()
		fields << dup
		assert_request_malformed(fields, 'duplicate ${dup.name}')
	}
}

// RFC 9113 §8.2.1: a field value containing NUL/CR/LF is malformed (and would be
// a header-injection vector if forwarded to an HTTP/1.x peer).
fn test_h2_server_rejects_control_char_in_value() {
	mut fields := valid_get_pseudo.clone()
	fields << H2HeaderField{'x-evil', 'a\r\nInjected: 1'}
	assert_request_malformed(fields, 'CR/LF in field value')
}

// RFC 9113 §8.3.1: an empty :path pseudo-header is malformed for http/https.
fn test_h2_server_rejects_empty_path() {
	fields := [
		H2HeaderField{':method', 'GET'},
		H2HeaderField{':scheme', 'https'},
		H2HeaderField{':authority', 'h.example'},
		H2HeaderField{':path', ''},
	]
	assert_request_malformed(fields, 'empty :path')
}

// RFC 9113 §8.1.2.6: content-length must equal the DATA payload length.
fn test_h2_server_rejects_content_length_mismatch() {
	mut enc := H2HpackEncoder{}
	mut fields := [
		H2HeaderField{':method', 'POST'},
		H2HeaderField{':scheme', 'https'},
		H2HeaderField{':authority', 'h.example'},
		H2HeaderField{':path', '/upload'},
		H2HeaderField{'content-length', '5'},
	]
	block := enc.encode(fields)
	mut out := []u8{}
	out << h2_client_preface.bytes()
	out << H2Frame(H2SettingsFrame{}).encode()
	out << H2Frame(H2HeadersFrame{
		stream_id:   1
		fragment:    block
		end_headers: true
		end_stream:  false
	}).encode()
	// Two DATA frames totalling 2 bytes, not the declared 5 (covers the
	// "sum of multiple DATA frames" variant too).
	out << H2Frame(H2DataFrame{
		stream_id:  1
		data:       'h'.bytes()
		end_stream: false
	}).encode()
	out << H2Frame(H2DataFrame{
		stream_id:  1
		data:       'i'.bytes()
		end_stream: true
	}).encode()
	mut client_end := spawn_h2_echo_server()
	code := drive_until_rst_or_response(mut client_end, out, 'content-length mismatch')
	assert code == i64(u32(H2ErrorCode.protocol_error)), 'content-length mismatch: expected RST_STREAM(PROTOCOL_ERROR), got ${code}'
}

// RFC 9110 §8.6: conflicting duplicate content-length fields are malformed —
// every occurrence is validated, not just the last.
fn test_h2_server_rejects_conflicting_content_length() {
	mut enc := H2HpackEncoder{}
	block := enc.encode([
		H2HeaderField{':method', 'POST'},
		H2HeaderField{':scheme', 'https'},
		H2HeaderField{':authority', 'h.example'},
		H2HeaderField{':path', '/upload'},
		H2HeaderField{'content-length', '5'},
		H2HeaderField{'content-length', '0'},
	])
	mut out := []u8{}
	out << h2_client_preface.bytes()
	out << H2Frame(H2SettingsFrame{}).encode()
	out << H2Frame(H2HeadersFrame{
		stream_id:   1
		fragment:    block
		end_headers: true
		end_stream:  true
	}).encode()
	mut client_end := spawn_h2_echo_server()
	code := drive_until_rst_or_response(mut client_end, out, 'conflicting content-length')
	assert code == i64(u32(H2ErrorCode.protocol_error)), 'conflicting content-length: expected RST_STREAM(PROTOCOL_ERROR), got ${code}'
}

// RFC 9113 §4.3: an HPACK decoding error is a CONNECTION error
// (GOAWAY COMPRESSION_ERROR), not a stream reset — the decoder's dynamic table is
// desynced, so the whole connection must close.
fn test_h2_server_hpack_error_closes_connection() {
	mut out := []u8{}
	out << h2_client_preface.bytes()
	out << H2Frame(H2SettingsFrame{}).encode()
	// HEADERS with an invalid HPACK block: indexed header field with index 0
	// (0x80), which RFC 7541 §6.1 forbids -> decode error.
	out << H2Frame(H2HeadersFrame{
		stream_id:   1
		fragment:    [u8(0x80)]
		end_headers: true
		end_stream:  true
	}).encode()
	mut client_end := spawn_h2_echo_server()
	client_end.write(out) or {
		assert false, 'hpack error: client write failed: ${err}'
		return
	}
	mut fr := FrameReader{
		end: client_end
	}
	mut code := i64(-1)
	for _ in 0 .. 32 {
		f := fr.next() or { break }
		match f {
			H2GoawayFrame {
				code = i64(f.error_code)
				break
			}
			H2RstStreamFrame {
				// Wrong scope: a per-stream reset for an HPACK error.
				code = -2
				break
			}
			else {}
		}
	}
	assert code == i64(u32(H2ErrorCode.compression_error)), 'HPACK decode error must be GOAWAY(COMPRESSION_ERROR), got ${code}'
}

// RFC 9113 §8.1: a trailer section that does not carry END_STREAM is malformed.
// It must be a STREAM error (RST_STREAM) — the connection stays up — not a GOAWAY.
fn test_h2_server_rejects_trailers_without_end_stream() {
	mut enc := H2HpackEncoder{}
	req_block := enc.encode([
		H2HeaderField{':method', 'POST'},
		H2HeaderField{':scheme', 'https'},
		H2HeaderField{':authority', 'h.example'},
		H2HeaderField{':path', '/upload'},
	])
	trailer_block := enc.encode([
		H2HeaderField{'x-checksum', 'abc123'},
	])
	mut out := []u8{}
	out << h2_client_preface.bytes()
	out << H2Frame(H2SettingsFrame{}).encode()
	out << H2Frame(H2HeadersFrame{
		stream_id:   1
		fragment:    req_block
		end_headers: true
		end_stream:  false
	}).encode()
	out << H2Frame(H2DataFrame{
		stream_id:  1
		data:       'hi'.bytes()
		end_stream: false
	}).encode()
	// Trailer HEADERS missing END_STREAM.
	out << H2Frame(H2HeadersFrame{
		stream_id:   1
		fragment:    trailer_block
		end_headers: true
		end_stream:  false
	}).encode()
	mut client_end := spawn_h2_echo_server()
	code := drive_until_rst_or_response(mut client_end, out, 'trailers without END_STREAM')
	assert code == i64(u32(H2ErrorCode.protocol_error)), 'trailers without END_STREAM: expected RST_STREAM(PROTOCOL_ERROR), got ${code}'
}

// RFC 9113 §8.1: a POST with a trailer section (a 2nd HEADERS block ending the
// stream) is accepted and dispatched.
fn test_h2_server_accepts_post_with_trailers() {
	mut enc := H2HpackEncoder{}
	req_block := enc.encode([
		H2HeaderField{':method', 'POST'},
		H2HeaderField{':scheme', 'https'},
		H2HeaderField{':authority', 'h.example'},
		H2HeaderField{':path', '/upload'},
	])
	trailer_block := enc.encode([
		H2HeaderField{'x-checksum', 'abc123'},
	])
	mut out := []u8{}
	out << h2_client_preface.bytes()
	out << H2Frame(H2SettingsFrame{}).encode()
	out << H2Frame(H2HeadersFrame{
		stream_id:   1
		fragment:    req_block
		end_headers: true
		end_stream:  false
	}).encode()
	out << H2Frame(H2DataFrame{
		stream_id:  1
		data:       'hi'.bytes()
		end_stream: false
	}).encode()
	out << H2Frame(H2HeadersFrame{
		stream_id:   1
		fragment:    trailer_block
		end_headers: true
		end_stream:  true
	}).encode()

	mut client_end := spawn_h2_echo_server()
	client_end.write(out) or {
		assert false, 'trailers POST: client write failed: ${err}'
		return
	}
	mut fr := FrameReader{
		end: client_end
	}
	mut dec := H2HpackDecoder{}
	mut status := 0
	for _ in 0 .. 32 {
		f := fr.next() or { break }
		if f is H2HeadersFrame {
			for hf in dec.decode(f.fragment) or { []H2HeaderField{} } {
				if hf.name == ':status' {
					status = hf.value.int()
				}
			}
			break
		}
	}
	assert status == 200, 'trailers POST should succeed, got status ${status}'
}