/apps/cli/src/events.zig at 3b406c6802c58097c08ad79c1a8fb7d45e338295

// Copyright 2026 Shota FUJI
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.
//
// SPDX-License-Identifier: MPL-2.0

const std = @import("std");
const uuid = @import("uuid");

pub const EventType = enum(u8) {
    timer_deleted = 0,
    timer_started = 1,
    timer_stopped = 2,
    timer_title_changed = 3,
};

// uuid package does not define error sets.
const UrnParseError = error{
    InvalidHexChar,
    MalformedUrn,
};

const ParseError = std.mem.Allocator.Error || std.json.ParseError(std.json.Scanner) || std.json.ParseError(std.json.Reader) || UrnParseError;

pub const Manifest = struct {
    version: u64 = 1,
    tail: ?uuid.Uuid = null,
    events_dir: []const u8 = "events",
    app_dir: *const std.Io.Dir,

    const Json = struct {
        version: u64 = 1,
        tail: ?[]const u8 = null,
        @"events-dir": []const u8,
    };

    fn openFile(io: std.Io, app_dir: std.Io.Dir, opts: std.Io.File.OpenFlags) std.Io.File.OpenError!std.Io.File {
        return app_dir.openFile(io, "timetracker.manifest.json", opts) catch |err| {
            std.log.err("Failed to open manifest file: {t}", .{err});
            return err;
        };
    }

    fn openEventsDir(self: *const Manifest, io: std.Io) std.Io.Dir.OpenError!std.Io.Dir {
        return self.app_dir.openDir(io, self.events_dir, .{ .iterate = true });
    }

    pub const OpenError = std.Io.File.OpenError ||
        std.Io.Dir.OpenError ||
        std.mem.Allocator.Error ||
        UrnParseError ||
        error{
            MalformedManifest,
        };

    pub fn open(gpa: std.mem.Allocator, io: std.Io, app_dir: *const std.Io.Dir) OpenError!Manifest {
        const manifest_file = try openFile(io, app_dir.*, .{});
        defer manifest_file.close(io);

        var manifest_read_buf: [1024]u8 = undefined;
        var manifest_file_reader = manifest_file.reader(io, &manifest_read_buf);

        var manifest_reader = std.json.Reader.init(gpa, &manifest_file_reader.interface);
        defer manifest_reader.deinit();

        const manifest = std.json.parseFromTokenSource(
            Json,
            gpa,
            &manifest_reader,
            .{ .allocate = .alloc_if_needed },
        ) catch |err| {
            std.log.err("Failed to parse manifest file: {t}", .{err});
            return OpenError.MalformedManifest;
        };
        defer manifest.deinit();

        if (manifest.value.version != 1) {
            std.log.err("Unsupported manifest version: {d}", .{manifest.value.version});
            return OpenError.MalformedManifest;
        }

        const tail = if (manifest.value.tail) |t| try uuid.urn.deserialize(t) else null;

        const events_dir = try gpa.dupe(u8, manifest.value.@"events-dir");
        errdefer gpa.free(events_dir);

        return .{
            .version = manifest.value.version,
            .tail = tail,
            .events_dir = events_dir,
            .app_dir = app_dir,
        };
    }

    pub const SaveError = std.Io.File.OpenError || std.Io.Writer.Error;

    pub fn save(self: *const Manifest, io: std.Io) SaveError!void {
        const manifest_file = try openFile(io, self.app_dir.*, .{ .mode = .write_only });
        defer manifest_file.close(io);

        var write_buf: [1024]u8 = undefined;
        var writer = manifest_file.writer(io, &write_buf);

        const tail: ?[]const u8 = if (self.tail) |t| &uuid.urn.serialize(t) else null;

        var json_formatter = std.json.fmt(Json{
            .version = self.version,
            .tail = tail,
            .@"events-dir" = self.events_dir,
        }, .{ .emit_null_optional_fields = false });
        try json_formatter.format(&writer.interface);
        try writer.interface.flush();
    }

    /// `gpa` must be same to the one passed to `open`.
    pub fn deinit(self: *Manifest, gpa: std.mem.Allocator) void {
        gpa.free(self.events_dir);
    }
};

pub const Envelope = struct {
    parent: ?uuid.Uuid = null,
    id: uuid.Uuid,
    event: Event,

    const Json = struct {
        parent: ?[]const u8 = null,
        id: []const u8,
        @"event-type": @typeInfo(EventType).@"enum".tag_type = @intFromEnum(EventType.timer_deleted),
        @"event-data": []const u8,
    };

    fn init(allocator: std.mem.Allocator, reader: *std.Io.Reader) ParseError!Envelope {
        var arena = std.heap.ArenaAllocator.init(allocator);
        defer arena.deinit();

        var source = std.json.Reader.init(arena.allocator(), reader);
        defer source.deinit();

        const envelope = try std.json.parseFromTokenSourceLeaky(Envelope.Json, arena.allocator(), &source, .{
            .allocate = .alloc_if_needed,
            .ignore_unknown_fields = true,
        });

        return .{
            .parent = if (envelope.parent) |parent| try uuid.urn.deserialize(parent) else null,
            .id = try uuid.urn.deserialize(envelope.id),
            .event = try Event.init(allocator, arena.allocator(), @enumFromInt(envelope.@"event-type"), envelope.@"event-data"),
        };
    }

    fn writeJson(self: *const Envelope, gpa: std.mem.Allocator, writer: *std.Io.Writer) std.Io.Writer.Error!void {
        var event_writer = std.Io.Writer.Allocating.init(gpa);
        defer event_writer.deinit();

        const event_fmt = std.json.fmt(self.event, .{ .emit_null_optional_fields = false });
        try event_fmt.format(&event_writer.writer);

        const envelope_fmt = std.json.fmt(Json{
            .parent = if (self.parent) |p| &uuid.urn.serialize(p) else null,
            .id = &uuid.urn.serialize(self.id),
            .@"event-type" = @intFromEnum(self.event),
            .@"event-data" = event_writer.written(),
        }, .{ .emit_null_optional_fields = false });
        try envelope_fmt.format(writer);
    }

    pub const AppendError = std.Io.File.OpenError || std.Io.Writer.Error || std.mem.Allocator.Error;

    pub fn append(self: *const Envelope, gpa: std.mem.Allocator, io: std.Io, manifest: *Manifest) AppendError!void {
        const filename = try std.fmt.allocPrint(gpa, "{s}.json", .{uuid.urn.serialize(self.id)});
        defer gpa.free(filename);

        var events_dir = try manifest.openEventsDir(io);
        defer events_dir.close(io);

        var file = try events_dir.createFile(io, filename, .{});
        defer file.close(io);

        var write_buf: [1024]u8 = undefined;
        var writer = file.writer(io, &write_buf);
        try self.writeJson(gpa, &writer.interface);
        try writer.interface.flush();
    }
};

test Envelope {
    const src: Envelope = .{
        .id = 0xa84841db47f8ac9b2043d152f7089191,
        .event = .{
            .timer_started = .{
                // 919108f7-52d1-4320-9bac-f847db4148a8
                .event_id = 0xa84841db47f8ac9b2043d152f7089191,
                .created_at = 1645568542,
                // 30e415df-356d-4481-a66f-4a3ab06dadde
                .timer_id = 0x30e415df356d4481a66f4a3ab06dadde,
                .title = "Sample Timer",
            },
        },
    };

    var writer = std.Io.Writer.Allocating.init(std.testing.allocator);
    defer writer.deinit();

    try src.writeJson(std.testing.allocator, &writer.writer);

    var reader = std.Io.Reader.fixed(writer.written());
    const parsed = try Envelope.init(std.testing.allocator, &reader);
    defer parsed.event.deinit(std.testing.allocator);

    try std.testing.expectEqualDeep(src, parsed);
}

pub const Iterator = struct {
    events_dir: std.Io.Dir,
    cursor: ?uuid.Uuid,

    pub const InitError = Manifest.OpenError;

    /// Caller has to call `deinit` after use.
    pub fn init(io: std.Io, manifest: *const Manifest) InitError!Iterator {
        return .{
            .events_dir = try manifest.openEventsDir(io),
            .cursor = manifest.tail,
        };
    }

    pub const IterateError = std.Io.File.OpenError || std.mem.Allocator.Error || ParseError;

    /// Caller must call `deinit` on the returned event after use.
    pub fn next(self: *Iterator, gpa: std.mem.Allocator, io: std.Io) IterateError!?Event {
        const cursor = self.cursor orelse return null;

        const filename = try std.fmt.allocPrint(gpa, "{s}.json", .{uuid.urn.serialize(cursor)});
        defer gpa.free(filename);

        const file = self.events_dir.openFile(io, filename, .{}) catch |err| {
            std.log.err("Unable to open event file {s}.json: {t}", .{ filename, err });
            return err;
        };
        defer file.close(io);

        var read_buf: [1024]u8 = undefined;
        var reader = file.reader(io, &read_buf);

        const envelope = try Envelope.init(gpa, &reader.interface);

        self.cursor = envelope.parent;
        return envelope.event;
    }
};

pub const TimerDeleted = struct {
    event_id: uuid.Uuid,
    created_at: i64,
    timer_id: uuid.Uuid,

    const Json = struct {
        @"event-id": []const u8,
        @"created-at": i64,
        @"timer-id": []const u8,
    };

    fn init(json: Json) UrnParseError!TimerDeleted {
        return .{
            .event_id = try uuid.urn.deserialize(json.@"event-id"),
            .created_at = json.@"created-at",
            .timer_id = try uuid.urn.deserialize(json.@"timer-id"),
        };
    }

    pub fn jsonStringify(value: @This(), jws: *std.json.Stringify) !void {
        try jws.beginObject();

        try jws.objectField("event-id");
        try jws.write(uuid.urn.serialize(value.event_id));

        try jws.objectField("created-at");
        try jws.write(value.created_at);

        try jws.objectField("timer-id");
        try jws.write(uuid.urn.serialize(value.timer_id));

        try jws.endObject();
    }
};

pub const TimerStarted = struct {
    event_id: uuid.Uuid,
    created_at: i64,
    timer_id: uuid.Uuid,
    title: []const u8,

    const Json = struct {
        @"event-id": []const u8,
        @"created-at": i64,
        @"timer-id": []const u8,
        title: []const u8,
    };

    fn init(allocator: std.mem.Allocator, json: Json) (std.mem.Allocator.Error || UrnParseError)!TimerStarted {
        return .{
            .event_id = try uuid.urn.deserialize(json.@"event-id"),
            .created_at = json.@"created-at",
            .timer_id = try uuid.urn.deserialize(json.@"timer-id"),
            .title = try allocator.dupe(u8, json.title),
        };
    }

    /// `allocator` should be the same one passed to `init`.
    fn deinit(self: TimerStarted, allocator: std.mem.Allocator) void {
        allocator.free(self.title);
    }

    pub fn jsonStringify(value: @This(), jws: *std.json.Stringify) !void {
        try jws.beginObject();

        try jws.objectField("event-id");
        try jws.write(uuid.urn.serialize(value.event_id));

        try jws.objectField("created-at");
        try jws.write(value.created_at);

        try jws.objectField("timer-id");
        try jws.write(uuid.urn.serialize(value.timer_id));

        try jws.objectField("title");
        try jws.write(value.title);

        try jws.endObject();
    }
};

pub const TimerStopped = struct {
    event_id: uuid.Uuid,
    created_at: i64,
    timer_id: uuid.Uuid,

    const Json = struct {
        @"event-id": []const u8,
        @"created-at": i64,
        @"timer-id": []const u8,
    };

    fn init(json: Json) UrnParseError!TimerStopped {
        return .{
            .event_id = try uuid.urn.deserialize(json.@"event-id"),
            .created_at = json.@"created-at",
            .timer_id = try uuid.urn.deserialize(json.@"timer-id"),
        };
    }

    pub fn jsonStringify(value: @This(), jws: *std.json.Stringify) !void {
        try jws.beginObject();

        try jws.objectField("event-id");
        try jws.write(uuid.urn.serialize(value.event_id));

        try jws.objectField("created-at");
        try jws.write(value.created_at);

        try jws.objectField("timer-id");
        try jws.write(uuid.urn.serialize(value.timer_id));

        try jws.endObject();
    }
};

pub const TimerTitleChanged = struct {
    event_id: uuid.Uuid,
    created_at: i64,
    timer_id: uuid.Uuid,
    new_title: []const u8,

    const Json = struct {
        @"event-id": []const u8,
        @"created-at": i64,
        @"timer-id": []const u8,
        @"new-title": []const u8,
    };

    fn init(allocator: std.mem.Allocator, json: Json) (std.mem.Allocator.Error || UrnParseError)!TimerTitleChanged {
        return .{
            .event_id = try uuid.urn.deserialize(json.@"event-id"),
            .created_at = json.@"created-at",
            .timer_id = try uuid.urn.deserialize(json.@"timer-id"),
            .new_title = try allocator.dupe(u8, json.@"new-title"),
        };
    }

    /// `allocator` should be the same one passed to `init`.
    fn deinit(self: TimerTitleChanged, allocator: std.mem.Allocator) void {
        allocator.free(self.new_title);
    }

    pub fn jsonStringify(value: @This(), jws: *std.json.Stringify) !void {
        try jws.beginObject();

        try jws.objectField("event-id");
        try jws.write(uuid.urn.serialize(value.event_id));

        try jws.objectField("created-at");
        try jws.write(value.created_at);

        try jws.objectField("timer-id");
        try jws.write(uuid.urn.serialize(value.timer_id));

        try jws.objectField("new-title");
        try jws.write(value.new_title);

        try jws.endObject();
    }
};

pub const Event = union(EventType) {
    timer_deleted: TimerDeleted,
    timer_started: TimerStarted,
    timer_stopped: TimerStopped,
    timer_title_changed: TimerTitleChanged,

    fn init(allocator: std.mem.Allocator, arena: std.mem.Allocator, event_type: EventType, event_data: []const u8) ParseError!Event {
        return switch (event_type) {
            EventType.timer_deleted => .{
                .timer_deleted = try TimerDeleted.init(
                    try std.json.parseFromSliceLeaky(TimerDeleted.Json, arena, event_data, .{
                        .allocate = .alloc_if_needed,
                        .ignore_unknown_fields = true,
                    }),
                ),
            },
            EventType.timer_started => .{
                .timer_started = try TimerStarted.init(
                    allocator,
                    try std.json.parseFromSliceLeaky(TimerStarted.Json, arena, event_data, .{
                        .allocate = .alloc_if_needed,
                        .ignore_unknown_fields = true,
                    }),
                ),
            },
            EventType.timer_stopped => .{
                .timer_stopped = try TimerStopped.init(
                    try std.json.parseFromSliceLeaky(TimerStopped.Json, arena, event_data, .{
                        .allocate = .alloc_if_needed,
                        .ignore_unknown_fields = true,
                    }),
                ),
            },
            EventType.timer_title_changed => .{
                .timer_title_changed = try TimerTitleChanged.init(
                    allocator,
                    try std.json.parseFromSliceLeaky(TimerTitleChanged.Json, arena, event_data, .{
                        .allocate = .alloc_if_needed,
                        .ignore_unknown_fields = true,
                    }),
                ),
            },
        };
    }

    pub fn deinit(self: Event, allocator: std.mem.Allocator) void {
        switch (self) {
            .timer_started => |ev| ev.deinit(allocator),
            .timer_title_changed => |ev| ev.deinit(allocator),
            else => {},
        }
    }

    pub fn jsonStringify(value: Event, jws: *std.json.Stringify) !void {
        switch (value) {
            .timer_deleted => |ev| try jws.write(ev),
            .timer_started => |ev| try jws.write(ev),
            .timer_stopped => |ev| try jws.write(ev),
            .timer_title_changed => |ev| try jws.write(ev),
        }
    }
};