fediglam/src/http/server.zig

const std = @import("std");
const util = @import("util");
const http = @import("./lib.zig");

const Request = http.Request;
const Connection = http.Connection;

const request_buf_size = 1 << 16;

pub const Context = struct {
    alloc: std.mem.Allocator,
    request: Request,
    connection: Connection,

    const Writer = http.ResponseStream(Connection.Writer);

    pub fn openResponse(self: *Context, headers: *const http.Headers, status: http.Status) !Writer {
        return try http.response_stream.open(self.alloc, self.connection.stream.writer(), headers, status);
    }

    pub fn close(self: *Context) void {
        // todo: deallocate request
        self.connection.close();
    }
};

const HttpServer = struct {
    conn_server: http.ConnectionServer,
    pub fn listen(addr: std.net.Address) !HttpServer {
        return HttpServer{
            .conn_server = try http.ConnectionServer.listen(addr),
        };
    }

    pub fn accept(self: *HttpServer, alloc: std.mem.Allocator) !Context {
        while (true) {
            const conn = try self.conn_server.accept();
            errdefer conn.close();

            const req = http.Request.parse(alloc, conn.stream.reader()) catch |err| {
                handleError(conn.stream.writer(), err) catch unreachable;
                continue;
            };

            return Context{ .connection = conn, .request = req, .alloc = alloc };
        }
    }

    pub fn shutdown(self: *HttpServer) void {
        self.conn_server.shutdown();
    }
};

// TODO: We should get more specific about what type of errors can happen
fn handleError(writer: anytype, err: anyerror) !void {
    const status: http.Status = switch (err) {
        error.BadRequest => .bad_request,
        error.UnsupportedMediaType => .unsupported_media_type,
        error.HttpVersionNotSupported => .http_version_not_supported,

        else => return err,
    };

    try writer.print("HTTP/1.1 {} {s}\r\n\r\n", .{ @enumToInt(status), status.phrase() });
}