const std = @import("std");
const builtin = @import("builtin");
const smi_info = @import("zml-smi/info");
const DeviceInfo = smi_info.device_info.DeviceInfo;
const ProcessInfo = smi_info.process_info.ProcessInfo;
const ProcessDoubleBuffer = @import("zml-smi/double_buffer").DoubleBuffer(std.ArrayList(ProcessInfo));
const json = @import("zml-smi/json");
const ProcessEnricher = if (builtin.os.tag == .macos)
    @import("zml-smi/platforms/macos").process.ProcessEnricher
else
    @import("zml-smi/platforms/linux").process.ProcessEnricher;

pub const Server = struct {
    allocator: std.mem.Allocator,
    io: std.Io,
    devices: []const *DeviceInfo,
    process_lists: []const *const ProcessDoubleBuffer,
    enricher: *ProcessEnricher,
    tcp: std.Io.net.Server,
    connection_group: std.Io.Group = .init,

    pub fn init(allocator: std.mem.Allocator, io: std.Io, port: u16, devices: []const *DeviceInfo, process_lists: []const *const ProcessDoubleBuffer, enricher: *ProcessEnricher) !Server {
        const address: std.Io.net.IpAddress = .{ .ip4 = .{
            .bytes = .{ 0, 0, 0, 0 },
            .port = port,
        } };
        var tcp = try address.listen(io, .{ .reuse_address = true });
        errdefer tcp.deinit(io);

        return .{
            .allocator = allocator,
            .io = io,
            .devices = devices,
            .process_lists = process_lists,
            .enricher = enricher,
            .tcp = tcp,
        };
    }

    pub fn run(allocator: std.mem.Allocator, io: std.Io, port: u16, devices: []const *DeviceInfo, process_lists: []const *const ProcessDoubleBuffer, enricher: *ProcessEnricher) void {
        var self = init(allocator, io, port, devices, process_lists, enricher) catch |err| {
            std.log.err("api server failed to start: {s}", .{@errorName(err)});
            return;
        };
        defer self.deinit();
        self.serve();
    }

    pub fn deinit(self: *Server) void {
        self.connection_group.await(self.io) catch {};
        self.tcp.deinit(self.io);
    }

    pub fn serve(self: *Server) void {
        while (true) {
            const stream = self.tcp.accept(self.io) catch break;
            self.connection_group.concurrent(self.io, Server.onConnection, .{ self, stream }) catch break;
        }
    }

    fn onConnection(self: *Server, stream: std.Io.net.Stream) std.Io.Cancelable!void {
        defer stream.close(self.io);
        self.handleConn(stream) catch {};
    }

    fn handleConn(self: *Server, stream: std.Io.net.Stream) !void {
        var read_buf: [8192]u8 = undefined;
        var reader = stream.reader(self.io, &read_buf);

        var write_buf: [4096]u8 = undefined;
        var writer = stream.writer(self.io, &write_buf);

        var http_server: std.http.Server = .init(&reader.interface, &writer.interface);

        var procs: std.ArrayList(ProcessInfo) = .empty;
        defer procs.deinit(self.allocator);

        while (true) {
            var request = http_server.receiveHead() catch |err| switch (err) {
                error.HttpConnectionClosing => return,
                else => return err,
            };

            procs.clearRetainingCapacity();
            for (self.process_lists) |pl| {
                procs.appendSlice(self.allocator, pl.front().items) catch {};
            }
            self.enricher.enrich(self.io, procs.items);

            var body_buf: [4096]u8 = undefined;
            var body_writer = try request.respondStreaming(&body_buf, .{
                .respond_options = .{
                    .status = .ok,
                    .extra_headers = &.{
                        .{ .name = "content-type", .value = "application/json" },
                        .{ .name = "access-control-allow-origin", .value = "*" },
                    },
                },
            });

            try json.write(&body_writer.writer, self.devices, procs.items);
            try body_writer.end();
        }
    }
};