module http

// Tests for the synchronous HTTP/2 client connection, driven over an in-memory
// transport so no socket is required.

// MockTransport plays a fixed script of server->client bytes and records what
// the client writes.
struct MockTransport {
mut:
    inbound  []u8 // server -> client; the client reads these
    rpos     int
    outbound []u8 // client -> server; what the client wrote
}

fn (mut m MockTransport) read(mut buf []u8) !int {
    if m.rpos >= m.inbound.len {
        return error('eof')
    }
    mut n := m.inbound.len - m.rpos
    if n > buf.len {
        n = buf.len
    }
    for i in 0 .. n {
        buf[i] = m.inbound[m.rpos + i]
    }
    m.rpos += n
    return n
}

fn (mut m MockTransport) write(buf []u8) !int {
    m.outbound << buf
    return buf.len
}

// build_server_stream encodes a server-side response on stream 1: SETTINGS, an
// ACK of our SETTINGS, a HEADERS frame, and optional DATA frames.
fn build_server_stream(resp_fields []H2HeaderField, body_chunks [][]u8) []u8 {
    mut senc := H2HpackEncoder{}
    hdr := senc.encode(resp_fields)
    mut out := []u8{}
    out << H2Frame(H2SettingsFrame{}).encode()
    out << H2Frame(H2SettingsFrame{
        ack: true
    }).encode()
    last_is_headers := body_chunks.len == 0
    out << H2Frame(H2HeadersFrame{
        stream_id:   1
        fragment:    hdr
        end_headers: true
        end_stream:  last_is_headers
    }).encode()
    for i, chunk in body_chunks {
        out << H2Frame(H2DataFrame{
            stream_id:  1
            data:       chunk
            end_stream: i == body_chunks.len - 1
        }).encode()
    }
    return out
}

fn test_h2_conn_basic_get() {
    inbound := build_server_stream([
        H2HeaderField{':status', '200'},
        H2HeaderField{'content-type', 'text/plain'},
    ], [' hello'.bytes()])
    mut t := &MockTransport{
        inbound: inbound
    }
    mut c := new_h2_conn(t)
    resp := c.do(H2ClientRequest{
        method:    'GET'
        authority: 'example.com'
        path:      '/'
    })!
    assert resp.status == 200
    assert resp.body.bytestr() == ' hello'
    assert resp.headers.any(it.name == 'content-type' && it.value == 'text/plain')

    // The client must open with the connection preface.
    assert t.outbound.len > h2_client_preface.len
    assert t.outbound[..h2_client_preface.len].bytestr() == h2_client_preface

    // First client frame after the preface is its SETTINGS.
    f1, n1 := h2_read_frame(t.outbound[h2_client_preface.len..])!
    assert f1 is H2SettingsFrame

    // Next is the request HEADERS on stream 1; decode and check pseudo-headers.
    f2, _ := h2_read_frame(t.outbound[h2_client_preface.len + n1..])!
    headers := f2 as H2HeadersFrame
    assert headers.stream_id == 1
    assert headers.end_stream // GET with no body
    mut dec := H2HpackDecoder{}
    req_fields := dec.decode(headers.fragment)!
    assert req_fields.any(it.name == ':method' && it.value == 'GET')
    assert req_fields.any(it.name == ':scheme' && it.value == 'https')
    assert req_fields.any(it.name == ':authority' && it.value == 'example.com')
    assert req_fields.any(it.name == ':path' && it.value == '/')
}

fn test_h2_conn_multi_data_frames() {
    inbound := build_server_stream([H2HeaderField{':status', '200'}], [
        'foo'.bytes(),
        'bar'.bytes(),
        'baz'.bytes(),
    ])
    mut t := &MockTransport{
        inbound: inbound
    }
    mut c := new_h2_conn(t)
    resp := c.do(H2ClientRequest{ authority: 'h.example' })!
    assert resp.status == 200
    assert resp.body.bytestr() == 'foobarbaz'
}

fn test_h2_conn_post_body() {
    inbound := build_server_stream([H2HeaderField{':status', '201'}], [])
    mut t := &MockTransport{
        inbound: inbound
    }
    mut c := new_h2_conn(t)
    resp := c.do(H2ClientRequest{
        method:    'POST'
        authority: 'h.example'
        path:      '/submit'
        body:      'payload-data'.bytes()
    })!
    assert resp.status == 201

    // Walk the client's frames and confirm a DATA frame carried the body with
    // END_STREAM, after a HEADERS frame that did not end the stream.
    mut pos := h2_client_preface.len
    mut saw_headers_open := false
    mut data_payload := []u8{}
    mut data_end := false
    for pos < t.outbound.len {
        frame, n := h2_read_frame(t.outbound[pos..])!
        pos += n
        match frame {
            H2HeadersFrame {
                if frame.stream_id == 1 {
                    assert !frame.end_stream
                    saw_headers_open = true
                }
            }
            H2DataFrame {
                if frame.stream_id == 1 {
                    data_payload << frame.data
                    if frame.end_stream {
                        data_end = true
                    }
                }
            }
            else {}
        }
    }
    assert saw_headers_open
    assert data_end
    assert data_payload.bytestr() == 'payload-data'
}

fn test_h2_conn_goaway_errors() {
    mut inbound := []u8{}
    inbound << H2Frame(H2SettingsFrame{}).encode()
    inbound << H2Frame(H2GoawayFrame{
        last_stream_id: 0
        error_code:     u32(H2ErrorCode.protocol_error)
    }).encode()
    mut t := &MockTransport{
        inbound: inbound
    }
    mut c := new_h2_conn(t)
    c.do(H2ClientRequest{ authority: 'h.example' }) or {
        assert err.msg().contains('GOAWAY')
        assert err.msg().contains('PROTOCOL_ERROR')
        return
    }
    assert false, 'expected GOAWAY error'
}

fn test_h2_conn_rst_stream_errors() {
    mut senc := H2HpackEncoder{}
    mut inbound := []u8{}
    inbound << H2Frame(H2SettingsFrame{}).encode()
    inbound << H2Frame(H2HeadersFrame{
        stream_id:   1
        fragment:    senc.encode([H2HeaderField{':status', '200'}])
        end_headers: true
    }).encode()
    inbound << H2Frame(H2RstStreamFrame{
        stream_id:  1
        error_code: u32(H2ErrorCode.internal_error)
    }).encode()
    mut t := &MockTransport{
        inbound: inbound
    }
    mut c := new_h2_conn(t)
    c.do(H2ClientRequest{ authority: 'h.example' }) or {
        assert err.msg().contains('reset')
        return
    }
    assert false, 'expected RST_STREAM error'
}

fn test_h2_conn_continuation() {
    // Split the response header block across HEADERS + CONTINUATION.
    mut senc := H2HpackEncoder{}
    full := senc.encode([
        H2HeaderField{':status', '200'},
        H2HeaderField{'x-test', 'continued'},
    ])
    split := full.len / 2
    mut inbound := []u8{}
    inbound << H2Frame(H2SettingsFrame{}).encode()
    inbound << H2Frame(H2HeadersFrame{
        stream_id:   1
        fragment:    full[..split]
        end_headers: false
    }).encode()
    inbound << H2Frame(H2ContinuationFrame{
        stream_id:   1
        fragment:    full[split..]
        end_headers: true
    }).encode()
    inbound << H2Frame(H2DataFrame{
        stream_id:  1
        data:       'ok'.bytes()
        end_stream: true
    }).encode()
    mut t := &MockTransport{
        inbound: inbound
    }
    mut c := new_h2_conn(t)
    resp := c.do(H2ClientRequest{ authority: 'h.example' })!
    assert resp.status == 200
    assert resp.body.bytestr() == 'ok'
    assert resp.headers.any(it.name == 'x-test' && it.value == 'continued')
}

fn test_h2_conn_ping_ack() {
    // A server PING before the response must be answered with a PING ACK.
    mut senc := H2HpackEncoder{}
    mut inbound := []u8{}
    inbound << H2Frame(H2SettingsFrame{}).encode()
    inbound << H2Frame(H2PingFrame{
        data: [u8(1), 2, 3, 4, 5, 6, 7, 8]
    }).encode()
    inbound << H2Frame(H2HeadersFrame{
        stream_id:   1
        fragment:    senc.encode([H2HeaderField{':status', '204'}])
        end_headers: true
        end_stream:  true
    }).encode()
    mut t := &MockTransport{
        inbound: inbound
    }
    mut c := new_h2_conn(t)
    resp := c.do(H2ClientRequest{ authority: 'h.example' })!
    assert resp.status == 204

    // Find a PING ACK in the client's output carrying the same opaque data.
    mut pos := h2_client_preface.len
    mut saw_ping_ack := false
    for pos < t.outbound.len {
        frame, n := h2_read_frame(t.outbound[pos..])!
        pos += n
        if frame is H2PingFrame {
            if frame.ack && frame.data == [u8(1), 2, 3, 4, 5, 6, 7, 8] {
                saw_ping_ack = true
            }
        }
    }
    assert saw_ping_ack
}

fn test_h2_conn_splits_large_request_headers() {
    inbound := build_server_stream([H2HeaderField{':status', '200'}], [])
    mut t := &MockTransport{
        inbound: inbound
    }
    mut c := new_h2_conn(t)
    // A header value larger than the default 16 KiB max frame size forces the
    // request header block to be split across HEADERS + CONTINUATION frames.
    big := 'x'.repeat(20000)
    resp := c.do(H2ClientRequest{
        authority: 'h.example'
        headers:   [H2HeaderField{'x-big', big}]
    })!
    assert resp.status == 200

    mut pos := h2_client_preface.len
    mut headers_open := false
    mut continuation_end := false
    mut block := []u8{}
    for pos < t.outbound.len {
        frame, n := h2_read_frame(t.outbound[pos..])!
        pos += n
        match frame {
            H2HeadersFrame {
                if frame.stream_id == 1 {
                    assert !frame.end_headers // split, so END_HEADERS not on HEADERS
                    headers_open = true
                    block << frame.fragment
                }
            }
            H2ContinuationFrame {
                if frame.stream_id == 1 {
                    block << frame.fragment
                    if frame.end_headers {
                        continuation_end = true
                    }
                }
            }
            else {}
        }
    }
    assert headers_open
    assert continuation_end
    // The reassembled block must decode back to the original header.
    mut dec := H2HpackDecoder{}
    fields := dec.decode(block)!
    assert fields.any(it.name == 'x-big' && it.value == big)
}

fn test_h2_conn_large_body_flow_control() {
    // Body larger than the initial 64 KiB window: the client sends up to the
    // window, waits, then resumes once the peer grows both the connection and
    // stream windows.
    body := 'a'.repeat(70000)
    mut inbound := []u8{}
    inbound << H2Frame(H2SettingsFrame{}).encode()
    inbound << H2Frame(H2WindowUpdateFrame{
        stream_id:             0
        window_size_increment: 70000
    }).encode()
    inbound << H2Frame(H2WindowUpdateFrame{
        stream_id:             1
        window_size_increment: 70000
    }).encode()
    mut senc := H2HpackEncoder{}
    inbound << H2Frame(H2HeadersFrame{
        stream_id:   1
        fragment:    senc.encode([H2HeaderField{':status', '200'}])
        end_headers: true
        end_stream:  true
    }).encode()
    mut t := &MockTransport{
        inbound: inbound
    }
    mut c := new_h2_conn(t)
    resp := c.do(H2ClientRequest{
        method:    'POST'
        authority: 'h.example'
        path:      '/upload'
        body:      body.bytes()
    })!
    assert resp.status == 200

    // The client must have sent the entire body, ending with END_STREAM, and no
    // single DATA frame may exceed the max frame size.
    mut pos := h2_client_preface.len
    mut sent := 0
    mut ended := false
    for pos < t.outbound.len {
        frame, n := h2_read_frame(t.outbound[pos..])!
        pos += n
        if frame is H2DataFrame {
            if frame.stream_id == 1 {
                assert frame.data.len <= int(h2_default_max_frame_size)
                sent += frame.data.len
                if frame.end_stream {
                    ended = true
                }
            }
        }
    }
    assert sent == body.len
    assert ended
}

fn test_h2_fetch_glue_roundtrip() {
    // Drive the full conversion glue (Request -> H2 -> Response) over the mock
    // transport, without a socket.
    inbound := build_server_stream([
        H2HeaderField{':status', '200'},
        H2HeaderField{'content-type', 'text/plain'},
    ], [' world'.bytes()])
    mut t := &MockTransport{
        inbound: inbound
    }
    req := Request{
        user_agent: 'v.http'
    }
    h2req := req.to_h2_request(.get, 'example.com', '/', '', new_header())
    mut c := new_h2_conn(t)
    h2resp := c.do(h2req)!
    resp := h2_response_to_http(h2resp)
    assert resp.status_code == 200
    assert resp.version() == .v2_0
    assert resp.body == ' world'
    assert (resp.header.get_custom('content-type') or { '' }) == 'text/plain'
}

// build_streamed_response builds a server stream that delivers the response
// body in fixed-size chunks, useful for streaming tests.
fn build_streamed_response(status string, content_length string, chunks [][]u8) []u8 {
    mut senc := H2HpackEncoder{}
    mut fields := [H2HeaderField{':status', status}]
    if content_length != '' {
        fields << H2HeaderField{'content-length', content_length}
    }
    hdr := senc.encode(fields)
    mut out := []u8{}
    out << H2Frame(H2SettingsFrame{}).encode()
    out << H2Frame(H2SettingsFrame{
        ack: true
    }).encode()
    last_is_headers := chunks.len == 0
    out << H2Frame(H2HeadersFrame{
        stream_id:   1
        fragment:    hdr
        end_headers: true
        end_stream:  last_is_headers
    }).encode()
    for i, chunk in chunks {
        out << H2Frame(H2DataFrame{
            stream_id:  1
            data:       chunk
            end_stream: i == chunks.len - 1
        }).encode()
    }
    return out
}

// ChunkCapture records on_data invocations via a reference captured by the
// returned closure.
struct ChunkCapture {
mut:
    chunks   [][]u8
    running  []u64
    expected []u64
    status   []int
}

fn make_capture_fn(cap &ChunkCapture) H2DataFn {
    return fn [cap] (chunk []u8, body_so_far u64, body_expected u64, status int) ! {
        unsafe {
            cap.chunks << chunk.clone()
            cap.running << body_so_far
            cap.expected << body_expected
            cap.status << status
        }
    }
}

fn test_h2_on_data_fires_per_chunk() {
    mut cap := &ChunkCapture{}
    inbound := build_streamed_response('200', '12', [
        'foo'.bytes(),
        'bar'.bytes(),
        'baz quux'.bytes(),
    ])
    mut t := &MockTransport{
        inbound: inbound
    }
    mut c := new_h2_conn(t)
    resp := c.do(H2ClientRequest{
        authority: 'h.example'
        on_data:   make_capture_fn(cap)
    })!
    assert resp.status == 200
    assert resp.body.bytestr() == 'foobarbaz quux'
    // Three DATA frames -> three callback invocations.
    assert cap.chunks.len == 3
    assert cap.chunks[0].bytestr() == 'foo'
    assert cap.chunks[1].bytestr() == 'bar'
    assert cap.chunks[2].bytestr() == 'baz quux'
    // body_so_far is cumulative including the current chunk.
    assert cap.running == [u64(3), u64(6), u64(14)]
    // content-length is reported.
    assert cap.expected == [u64(12), u64(12), u64(12)]
    // Status was known by the first callback (headers arrived first).
    assert cap.status == [200, 200, 200]
}

fn test_h2_stop_copying_limit_caps_body_but_keeps_callback() {
    mut cap := &ChunkCapture{}
    inbound := build_streamed_response('200', '', [
        'AAAA'.bytes(),
        'BBBB'.bytes(),
        'CCCC'.bytes(),
    ])
    mut t := &MockTransport{
        inbound: inbound
    }
    mut c := new_h2_conn(t)
    resp := c.do(H2ClientRequest{
        authority:          'h.example'
        on_data:            make_capture_fn(cap)
        stop_copying_limit: 6
    })!
    // Body is capped at 6 bytes (4 from first chunk + 2 from second).
    assert resp.body.bytestr() == 'AAAABB'
    // All three chunks still produced callbacks.
    assert cap.chunks.len == 3
    assert cap.chunks[0].bytestr() == 'AAAA'
    assert cap.chunks[1].bytestr() == 'BBBB'
    assert cap.chunks[2].bytestr() == 'CCCC'
    // body_so_far still reports the true cumulative size.
    assert cap.running == [u64(4), u64(8), u64(12)]
}

fn test_h2_stop_receiving_limit_breaks_early() {
    mut cap := &ChunkCapture{}
    inbound := build_streamed_response('200', '', [
        'XXXX'.bytes(),
        'YYYY'.bytes(),
        'ZZZZ'.bytes(), // should never be delivered
    ])
    mut t := &MockTransport{
        inbound: inbound
    }
    mut c := new_h2_conn(t)
    resp := c.do(H2ClientRequest{
        authority:            'h.example'
        on_data:              make_capture_fn(cap)
        stop_receiving_limit: 6
    })!
    // Loop breaks after the second DATA frame (8 bytes >= limit 6); body
    // contains both chunks delivered so far.
    assert resp.body.bytestr() == 'XXXXYYYY'
    assert cap.chunks.len == 2
    assert cap.chunks[1].bytestr() == 'YYYY'

    // On early termination the client must send RST_STREAM(CANCEL) on the
    // stream, and the connection must refuse further requests.
    mut saw_cancel := false
    mut pos := h2_client_preface.len
    for pos < t.outbound.len {
        frame, n := h2_read_frame(t.outbound[pos..])!
        pos += n
        if frame is H2RstStreamFrame {
            if frame.stream_id == 1 && frame.error_code == u32(H2ErrorCode.cancel) {
                saw_cancel = true
            }
        }
    }
    assert saw_cancel, 'expected RST_STREAM(CANCEL) on early termination'
    c.do(H2ClientRequest{ authority: 'h.example' }) or {
        assert err.msg().contains('no longer usable')
        return
    }
    assert false, 'expected error on reuse after early termination'
}