const std = @import("std");
const Db = @import("Db.zig");

const Item = @import("Item.zig");
const Tag = @import("Tag.zig");
const json = @import("json.zig");
const request = @import("request.zig");
const util = @import("util.zig");

pub fn main() !void {
    var db = Db.open("test.tkh", true, "");
    const sock_path = "/tmp/mgtzm.sock";

    // Remove the socket file if it exists
    std.fs.deleteFileAbsolute(sock_path) catch |err| {
        switch (err) {
            // Do not error out if the file doesn't exist
            error.FileNotFound => {},
            else => unreachable,
        }
    };

    var server = std.net.StreamServer.init(.{});
    defer server.deinit();
    const addr = try std.net.Address.initUnix(sock_path);

    try server.listen(addr);

    while (true) {

        // Initialization
        // ----------------

        var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
        defer arena.deinit();
        const allocator = arena.allocator();

        const connection = try server.accept();
        defer connection.stream.close();

        // Receive and process message
        // ----------------

        const read = connection.stream.reader();

        var msg = util.readUntilDelimiterAllocZ(read, allocator, 0, 1024) catch |err| {
            std.debug.print("Failed to read from connection: {any}\n", .{err});
            continue;
        };
        defer allocator.free(msg);

        var jobj = json.Obj.newFromString(msg) catch {
            var errorObj = json.Obj.newObject();
            errorObj.objectAddString("error", "Invalid JSON request.");

            _ = connection.stream.write(errorObj.toString()) catch {};
            continue;
        };
        defer jobj.deinit();

        const answer = try request.process(&jobj, &db, allocator);
        defer allocator.free(answer);

        // Reply
        // ----------------
        _ = try connection.stream.write(answer);
    }
}