// Copyright (c) 2019-2024 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module http

// This file converts between net.http's Request/Response and the HTTP/2
// client types in h2_conn.v. The actual transport wiring (ALPN negotiation on
// the TLS socket) lives in backend.c.v; these helpers are pure and backend
// agnostic, so they can be tested without a socket.

// h2_hop_by_hop are header names that must not be forwarded on HTTP/2
// (RFC 7540 Section 8.1.2.2), plus `host` (replaced by the :authority
// pseudo-header) and `cookie` (handled specially below).
const h2_hop_by_hop = ['connection', 'keep-alive', 'proxy-connection', 'transfer-encoding', 'upgrade',
    'host', 'cookie']

// h2_authority returns the :authority value for a host and port, omitting the
// port for the default HTTPS port.
fn h2_authority(host string, port int) string {
    if port == 443 || port == 0 {
        return host
    }
    return '${host}:${port}'
}

// to_h2_request builds an HTTP/2 request from this request. Header names are
// lowercased, hop-by-hop headers are dropped, the Host header becomes the
// :authority pseudo-header, and cookies are collapsed into a single field.
fn (req &Request) to_h2_request(method Method, authority string, path string, data string, header Header) H2ClientRequest {
    // An explicit Host header overrides the URL host, matching the HTTP/1.1
    // path (used for virtual-host / host-override requests).
    mut auth := authority
    if host := header.get(.host) {
        if host != '' {
            auth = host
        }
    }
    mut extra := []H2HeaderField{}
    if !header.contains(.user_agent) && req.user_agent != '' {
        extra << H2HeaderField{'user-agent', req.user_agent}
    }
    if data.len > 0 && !header.contains(.content_length) {
        extra << H2HeaderField{'content-length', data.len.str()}
    }
    for key in header.keys() {
        lkey := key.to_lower()
        if lkey in h2_hop_by_hop {
            continue
        }
        for val in header.custom_values(key) {
            // RFC 9113 §8.2.2: TE may be sent on an HTTP/2 request, but MUST NOT
            // carry any value other than 'trailers'. Drop a non-conformant TE
            // rather than generate a malformed request.
            if lkey == 'te' && val.trim_space().to_lower() != 'trailers' {
                continue
            }
            extra << H2HeaderField{lkey, val}
        }
    }
    // Cookies: the request's own cookie map plus any Cookie header values,
    // joined into one field (RFC 7540 Section 8.1.2.5 also allows splitting).
    mut cookie_parts := []string{}
    for k, v in req.cookies {
        cookie_parts << '${k}=${v}'
    }
    for cv in header.values(.cookie) {
        cookie_parts << cv
    }
    if cookie_parts.len > 0 {
        extra << H2HeaderField{'cookie', cookie_parts.join('; ')}
    }
    return H2ClientRequest{
        method:    method.str()
        scheme:    'https'
        authority: auth
        path:      path
        headers:   extra
        body:      data.bytes()
    }
}

// h2_response_to_http converts an HTTP/2 response into a net.http Response,
// decoding any Content-Encoding the same way the HTTP/1.1 path does.
fn h2_response_to_http(h2resp H2ClientResponse) Response {
    mut h := new_header()
    for f in h2resp.headers {
        h.add_custom(f.name, f.value) or {}
    }
    body := decode_response_body(h2resp.body.bytestr(), h.get(.content_encoding) or { '' })
    status := status_from_int(h2resp.status)
    return Response{
        http_version: '2.0'
        status_code:  h2resp.status
        status_msg:   status.str()
        header:       h
        body:         body
    }
}