module http

// Tests for the HTTP/2 framing layer (RFC 7540 Sections 4 and 6).

fn roundtrip(f H2Frame) !H2Frame {
    encoded := f.encode()
    decoded, consumed := h2_read_frame(encoded)!
    assert consumed == encoded.len, 'consumed ${consumed} != encoded ${encoded.len}'
    return decoded
}

// --- Frame header ---

fn test_frame_header_layout() {
    // DATA frame, length 5, flags END_STREAM, stream 1, payload "hello".
    f := H2Frame(H2DataFrame{
        stream_id:  1
        data:       'hello'.bytes()
        end_stream: true
    })
    enc := f.encode()
    // 9-byte header: length(3) type(1) flags(1) stream_id(4)
    assert enc[0] == 0 && enc[1] == 0 && enc[2] == 5 // length = 5
    assert enc[3] == h2_frame_data
    assert enc[4] == h2_flag_end_stream
    assert enc[5] == 0 && enc[6] == 0 && enc[7] == 0 && enc[8] == 1 // stream 1
    assert enc[9..] == 'hello'.bytes()

    h := h2_parse_frame_header(enc)!
    assert h.length == 5
    assert h.typ == h2_frame_data
    assert h.flags == h2_flag_end_stream
    assert h.stream_id == 1
}

fn test_frame_header_clears_reserved_bit() {
    // The reserved high bit of the stream id must be ignored on read.
    raw := [u8(0), 0, 0, h2_frame_window_update, 0, 0xff, 0xff, 0xff, 0xff, 0, 0, 0, 1]
    h := h2_parse_frame_header(raw)!
    assert h.stream_id == 0x7fff_ffff
}

// --- Round-trips for each frame type ---

fn test_roundtrip_data() {
    got := roundtrip(H2DataFrame{
        stream_id:  3
        data:       'abc'.bytes()
        end_stream: true
    })!
    d := got as H2DataFrame
    assert d.stream_id == 3
    assert d.data == 'abc'.bytes()
    assert d.end_stream
}

fn test_roundtrip_headers_plain() {
    got := roundtrip(H2HeadersFrame{
        stream_id:   1
        fragment:    [u8(0x82), 0x86, 0x84]
        end_stream:  true
        end_headers: true
    })!
    h := got as H2HeadersFrame
    assert h.stream_id == 1
    assert h.fragment == [u8(0x82), 0x86, 0x84]
    assert h.end_stream
    assert h.end_headers
    assert !h.has_priority
}

fn test_roundtrip_headers_with_priority() {
    got := roundtrip(H2HeadersFrame{
        stream_id:    5
        fragment:     [u8(0x88)]
        end_headers:  true
        has_priority: true
        exclusive:    true
        stream_dep:   3
        weight:       201
    })!
    h := got as H2HeadersFrame
    assert h.has_priority
    assert h.exclusive
    assert h.stream_dep == 3
    assert h.weight == 201
    assert h.fragment == [u8(0x88)]
}

fn test_roundtrip_priority() {
    got := roundtrip(H2PriorityFrame{
        stream_id:  7
        exclusive:  false
        stream_dep: 1
        weight:     16
    })!
    p := got as H2PriorityFrame
    assert p.stream_id == 7
    assert p.stream_dep == 1
    assert p.weight == 16
    assert !p.exclusive
}

fn test_roundtrip_rst_stream() {
    got := roundtrip(H2RstStreamFrame{
        stream_id:  9
        error_code: u32(H2ErrorCode.cancel)
    })!
    r := got as H2RstStreamFrame
    assert r.stream_id == 9
    assert r.error_code == u32(H2ErrorCode.cancel)
}

fn test_roundtrip_settings() {
    got := roundtrip(H2SettingsFrame{
        settings: [
            H2Setting{h2_settings_header_table_size, 4096},
            H2Setting{h2_settings_enable_push, 0},
            H2Setting{h2_settings_initial_window_size, 65535},
        ]
    })!
    s := got as H2SettingsFrame
    assert !s.ack
    assert s.settings.len == 3
    assert s.settings[0].id == h2_settings_header_table_size
    assert s.settings[0].value == 4096
    assert s.settings[1].id == h2_settings_enable_push
    assert s.settings[1].value == 0
    assert s.settings[2].value == 65535
}

fn test_roundtrip_settings_ack() {
    got := roundtrip(H2SettingsFrame{
        ack: true
    })!
    s := got as H2SettingsFrame
    assert s.ack
    assert s.settings.len == 0
}

fn test_roundtrip_push_promise() {
    got := roundtrip(H2PushPromiseFrame{
        stream_id:          1
        promised_stream_id: 2
        fragment:           [u8(0x82), 0x84]
        end_headers:        true
    })!
    p := got as H2PushPromiseFrame
    assert p.stream_id == 1
    assert p.promised_stream_id == 2
    assert p.fragment == [u8(0x82), 0x84]
    assert p.end_headers
}

fn test_roundtrip_ping() {
    got := roundtrip(H2PingFrame{
        ack:  true
        data: [u8(1), 2, 3, 4, 5, 6, 7, 8]
    })!
    p := got as H2PingFrame
    assert p.ack
    assert p.data == [u8(1), 2, 3, 4, 5, 6, 7, 8]
}

fn test_roundtrip_goaway() {
    got := roundtrip(H2GoawayFrame{
        last_stream_id: 7
        error_code:     u32(H2ErrorCode.protocol_error)
        debug_data:     'oops'.bytes()
    })!
    g := got as H2GoawayFrame
    assert g.last_stream_id == 7
    assert g.error_code == u32(H2ErrorCode.protocol_error)
    assert g.debug_data == 'oops'.bytes()
}

fn test_roundtrip_window_update() {
    got := roundtrip(H2WindowUpdateFrame{
        stream_id:             0
        window_size_increment: 65535
    })!
    w := got as H2WindowUpdateFrame
    assert w.stream_id == 0
    assert w.window_size_increment == 65535
}

fn test_roundtrip_continuation() {
    got := roundtrip(H2ContinuationFrame{
        stream_id:   3
        fragment:    [u8(0x40), 0x88]
        end_headers: true
    })!
    c := got as H2ContinuationFrame
    assert c.stream_id == 3
    assert c.fragment == [u8(0x40), 0x88]
    assert c.end_headers
}

// --- Padding ---

fn test_data_padding_decode() {
    // Hand-built padded DATA frame: pad length 3, data "hi", 3 pad bytes.
    mut payload := [u8(3)] // pad length
    payload << 'hi'.bytes()
    payload << [u8(0), 0, 0] // padding
    raw := h2_frame_bytes(h2_frame_data, h2_flag_padded, 1, payload)
    frame, _ := h2_read_frame(raw)!
    d := frame as H2DataFrame
    assert d.data == 'hi'.bytes()
}

fn test_padding_length_exceeds_frame_rejected() {
    // pad length 5 but only 2 bytes of payload after it -> error.
    payload := [u8(5), 0x61, 0x62]
    raw := h2_frame_bytes(h2_frame_data, h2_flag_padded, 1, payload)
    h2_read_frame(raw) or { return }
    assert false, 'expected pad-length error'
}

// --- Unknown frames ---

fn test_unknown_frame_preserved() {
    // Type 0x16 is not defined; it must be preserved, not rejected.
    raw := h2_frame_bytes(0x16, 0x0, 0, [u8(0xde), 0xad, 0xbe, 0xef])
    frame, consumed := h2_read_frame(raw)!
    assert consumed == raw.len
    u := frame as H2UnknownFrame
    assert u.header.typ == 0x16
    assert u.payload == [u8(0xde), 0xad, 0xbe, 0xef]
    // And it round-trips back to the same bytes.
    assert frame.encode() == raw
}

// --- Structural validation ---

fn test_read_frame_truncated_payload() {
    // Header claims 10 bytes of payload but none follow.
    raw := [u8(0), 0, 10, h2_frame_data, 0, 0, 0, 0, 1]
    h2_read_frame(raw) or { return }
    assert false, 'expected truncated payload error'
}

fn test_settings_bad_length_rejected() {
    // SETTINGS payload not a multiple of 6.
    raw := h2_frame_bytes(h2_frame_settings, 0, 0, [u8(0), 1, 0, 0, 0])
    h2_read_frame(raw) or { return }
    assert false, 'expected SETTINGS length error'
}

fn test_settings_ack_with_payload_rejected() {
    raw := h2_frame_bytes(h2_frame_settings, h2_flag_ack, 0, [u8(0), 1, 0, 0, 0x10, 0])
    h2_read_frame(raw) or { return }
    assert false, 'expected SETTINGS ACK payload error'
}

fn test_window_update_bad_length_rejected() {
    raw := h2_frame_bytes(h2_frame_window_update, 0, 0, [u8(0), 0, 1])
    h2_read_frame(raw) or { return }
    assert false, 'expected WINDOW_UPDATE length error'
}

fn test_ping_bad_length_rejected() {
    raw := h2_frame_bytes(h2_frame_ping, 0, 0, [u8(1), 2, 3, 4])
    h2_read_frame(raw) or { return }
    assert false, 'expected PING length error'
}

fn test_data_on_stream_zero_rejected() {
    raw := h2_frame_bytes(h2_frame_data, 0, 0, 'x'.bytes())
    h2_read_frame(raw) or { return }
    assert false, 'expected DATA-on-stream-0 error'
}

fn test_settings_on_nonzero_stream_rejected() {
    raw := h2_frame_bytes(h2_frame_settings, 0, 1, [])
    h2_read_frame(raw) or { return }
    assert false, 'expected SETTINGS-on-stream-1 error'
}

// --- Multiple frames back to back ---

fn test_read_consecutive_frames() {
    mut buf := []u8{}
    buf << H2Frame(H2SettingsFrame{}).encode()
    buf << H2Frame(H2DataFrame{
        stream_id: 1
        data:      'one'.bytes()
    }).encode()
    buf << H2Frame(H2PingFrame{
        data: [u8(0), 0, 0, 0, 0, 0, 0, 9]
    }).encode()

    mut pos := 0
    f1, c1 := h2_read_frame(buf[pos..])!
    pos += c1
    f2, c2 := h2_read_frame(buf[pos..])!
    pos += c2
    f3, c3 := h2_read_frame(buf[pos..])!
    pos += c3
    assert pos == buf.len
    assert f1 is H2SettingsFrame
    d := f2 as H2DataFrame
    assert d.data == 'one'.bytes()
    p := f3 as H2PingFrame
    assert p.data[7] == 9
}