/apps/cli/src/timer.zig at 25513247531692d1154e9c20c3435896d53339c9

// 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");

const events = @import("./events.zig");

const libc = @cImport(@cInclude("time.h"));

pub const RunningTimer = struct {
    id: uuid.Uuid,
    title: []const u8,
    started_at: i64,

    pub fn deinit(self: RunningTimer, allocator: std.mem.Allocator) void {
        allocator.free(self.title);
    }
};

pub const StoppedTimer = struct {
    id: uuid.Uuid,
    title: []const u8,
    started_at: i64,
    stopped_at: i64,

    pub fn deinit(self: StoppedTimer, allocator: std.mem.Allocator) void {
        allocator.free(self.title);
    }
};

pub const PrintColumn = enum {
    id,
    title,
    status,
    started,
    stopped,

    const size = @typeInfo(PrintColumn).@"enum".fields.len;

    pub const Order = struct {
        len: usize,
        columns: [size]PrintColumn,

        pub const ParseError = error{
            UnknownColumn,
            TooManyColumns,
            DuplicatedColumns,
        };

        pub fn parse(str: []const u8) ParseError!Order {
            var len: usize = 0;
            var cols: [size]PrintColumn = undefined;

            var iter = std.mem.splitScalar(u8, str, ',');

            token_loop: while (iter.next()) |token| {
                if (len >= size) {
                    return ParseError.TooManyColumns;
                }

                inline for (@typeInfo(PrintColumn).@"enum".fields) |field| {
                    if (std.mem.eql(u8, field.name, token)) {
                        const e: PrintColumn = @enumFromInt(field.value);
                        for (cols[0..len]) |c| if (c == e) {
                            return ParseError.DuplicatedColumns;
                        };

                        cols[len] = e;
                        len += 1;
                        continue :token_loop;
                    }
                }

                return ParseError.UnknownColumn;
            }

            return .{ .len = len, .columns = cols };
        }

        test parse {
            {
                const actual = try parse("id");
                const expected: []const PrintColumn = &.{.id};
                try std.testing.expectEqualSlices(PrintColumn, expected, actual.toSlice());
            }

            {
                const actual = try parse("status,started,stopped,title");
                const expected: []const PrintColumn = &.{ .status, .started, .stopped, .title };
                try std.testing.expectEqualSlices(PrintColumn, expected, actual.toSlice());
            }

            {
                const actual = parse("version,status,started,stopped,title");
                try std.testing.expectError(ParseError.UnknownColumn, actual);
            }

            {
                const actual = parse("status, started, stopped, title");
                try std.testing.expectError(ParseError.UnknownColumn, actual);
            }

            {
                const actual = parse("id,status,status");
                try std.testing.expectError(ParseError.DuplicatedColumns, actual);
            }

            {
                const actual = parse("id,status,title,started,stopped,id");
                try std.testing.expectError(ParseError.TooManyColumns, actual);
            }
        }

        pub fn fixed(comptime columns: []const PrintColumn) Order {
            comptime {
                if (columns.len > size) {
                    @compileError("\"columns\" length cannot exceed the number of PrintColumn fields");
                }
            }

            var cols: [size]PrintColumn = undefined;
            for (columns, 0..) |c, i| {
                cols[i] = c;
            }

            return .{
                .len = columns.len,
                .columns = cols,
            };
        }

        pub fn toSlice(self: *const Order) []const PrintColumn {
            return self.columns[0..self.len];
        }

        test fixed {
            const t0 = fixed(&.{ .id, .started, .status, .title });
            try std.testing.expectEqualSlices(PrintColumn, &.{ .id, .started, .status, .title }, t0.toSlice());

            const t1 = fixed(&.{.stopped});
            try std.testing.expectEqualSlices(PrintColumn, &.{.stopped}, t1.toSlice());
        }
    };
};

test {
    _ = PrintColumn.Order;
}

pub const PrintFormat = enum {
    tsv,
    jsonl,

    pub const ParseError = error{
        UnknownFormat,
    };

    pub fn parse(str: []const u8) ParseError!PrintFormat {
        inline for (@typeInfo(PrintFormat).@"enum".fields) |field| {
            if (std.mem.eql(u8, str, field.name)) {
                return @enumFromInt(field.value);
            }
        }

        return ParseError.UnknownFormat;
    }
};

pub const DateTimeFormat = enum {
    /// Format using the current locale and timezone.
    system,

    /// Unix seconds.
    unix,

    pub const ParseError = error{
        UnknownFormat,
    };

    pub fn parse(str: []const u8) ParseError!DateTimeFormat {
        inline for (@typeInfo(DateTimeFormat).@"enum".fields) |field| {
            if (std.mem.eql(u8, str, field.name)) {
                return @enumFromInt(field.value);
            }
        }

        return ParseError.UnknownFormat;
    }

    pub fn print(self: DateTimeFormat, writer: *std.Io.Writer, unix_sec: i64) std.Io.Writer.Error!void {
        switch (self) {
            .unix => try writer.printInt(unix_sec, 10, .lower, .{}),
            .system => {
                libc.tzset();

                var tm: libc.tm = undefined;
                _ = libc.localtime_r(&unix_sec, &tm);

                // Reasonable size, I guess.
                var buf: [256:0]u8 = undefined;
                @memset(&buf, 0);
                const wrote = libc.strftime(&buf, buf.len, "%c", &tm);

                try writer.writeAll(buf[0..wrote]);
            },
        }
    }
};

test {
    _ = DateTimeFormat;
}

pub const State = enum {
    running,
    stopped,
};

pub const Timer = union(State) {
    running: RunningTimer,
    stopped: StoppedTimer,

    pub fn deinit(self: *const Timer, allocator: std.mem.Allocator) void {
        switch (self.*) {
            .running => |t| t.deinit(allocator),
            .stopped => |t| t.deinit(allocator),
        }
    }

    pub const PrintOptions = struct {
        format: PrintFormat,
        order: PrintColumn.Order,
        datetime: DateTimeFormat,
    };

    pub fn print(self: *const Timer, writer: *std.Io.Writer, opts: PrintOptions) std.Io.Writer.Error!void {
        switch (opts.format) {
            .tsv => {
                for (opts.order.toSlice(), 0..) |column, i| {
                    if (i > 0) {
                        try writer.writeInt(u8, '\t', .native);
                    }

                    switch (column) {
                        .id => try writer.writeAll(&uuid.urn.serialize(switch (self.*) {
                            .running => |t| t.id,
                            .stopped => |t| t.id,
                        })),
                        // User can't input title containing newline or tab character via GUI.
                        // This is fine.
                        .title => try writer.writeAll(switch (self.*) {
                            .running => |t| t.title,
                            .stopped => |t| t.title,
                        }),
                        .status => try writer.writeAll(@tagName(self.*)),
                        .started => try opts.datetime.print(writer, switch (self.*) {
                            .running => |t| t.started_at,
                            .stopped => |t| t.started_at,
                        }),
                        .stopped => switch (self.*) {
                            .running => {},
                            .stopped => |t| try opts.datetime.print(writer, t.stopped_at),
                        },
                    }
                }
            },
            .jsonl => {
                var stringify: std.json.Stringify = .{
                    .writer = writer,
                    .options = .{ .emit_null_optional_fields = false, .whitespace = .minified },
                };

                try stringify.beginObject();

                for (opts.order.toSlice()) |column| {
                    switch (column) {
                        .id => {
                            try stringify.objectField("id");
                            try stringify.write(uuid.urn.serialize(switch (self.*) {
                                .running => |t| t.id,
                                .stopped => |t| t.id,
                            }));
                        },
                        .title => {
                            try stringify.objectField("title");
                            try stringify.write(switch (self.*) {
                                .running => |t| t.title,
                                .stopped => |t| t.title,
                            });
                        },
                        .status => {
                            try stringify.objectField("status");
                            try stringify.write(@tagName(self.*));
                        },
                        .started => {
                            const started_at = switch (self.*) {
                                .running => |t| t.started_at,
                                .stopped => |t| t.started_at,
                            };

                            try stringify.objectField("started");
                            switch (opts.datetime) {
                                .unix => try stringify.write(started_at),
                                .system => {
                                    try stringify.beginWriteRaw();
                                    try stringify.writer.writeInt(u8, '"', .native);
                                    try opts.datetime.print(writer, started_at);
                                    try stringify.writer.writeInt(u8, '"', .native);
                                    stringify.endWriteRaw();
                                },
                            }
                        },
                        .stopped => switch (self.*) {
                            .stopped => |t| {
                                try stringify.objectField("stopped");
                                switch (opts.datetime) {
                                    .unix => try stringify.write(t.stopped_at),
                                    .system => {
                                        try stringify.beginWriteRaw();
                                        try stringify.writer.writeInt(u8, '"', .native);
                                        try opts.datetime.print(writer, t.stopped_at);
                                        try stringify.writer.writeInt(u8, '"', .native);
                                        stringify.endWriteRaw();
                                    },
                                }
                            },
                            .running => {},
                        },
                    }
                }

                try stringify.endObject();
            },
        }

        try writer.writeInt(u8, '\n', .native);
    }

    test "TSV single" {
        var alloc = std.Io.Writer.Allocating.init(std.testing.allocator);
        defer alloc.deinit();

        try print(&.{
            .running = .{
                .id = 0xa84841db47f8ac9b2043d152f7089191,
                .title = "Foo",
                .started_at = 1,
            },
        }, &alloc.writer, .{
            .datetime = .unix,
            .format = .tsv,
            .order = PrintColumn.Order.fixed(&.{.id}),
        });

        try std.testing.expectEqualSlices(
            u8,
            "919108f7-52d1-4320-9bac-f847db4148a8\n",
            alloc.written(),
        );
    }

    test "TSV running full" {
        var alloc = std.Io.Writer.Allocating.init(std.testing.allocator);
        defer alloc.deinit();

        try print(&.{
            .running = .{
                .id = 0xa84841db47f8ac9b2043d152f7089191,
                .title = "Foo",
                .started_at = 1,
            },
        }, &alloc.writer, .{
            .datetime = .unix,
            .format = .tsv,
            .order = PrintColumn.Order.fixed(&.{ .status, .title, .id, .started, .stopped }),
        });

        try std.testing.expectEqualSlices(
            u8,
            "running\tFoo\t919108f7-52d1-4320-9bac-f847db4148a8\t1\t\n",
            alloc.written(),
        );
    }

    test "TSV stopped" {
        var alloc = std.Io.Writer.Allocating.init(std.testing.allocator);
        defer alloc.deinit();

        try print(&.{
            .stopped = .{
                .id = 0xa84841db47f8ac9b2043d152f7089191,
                .title = "Foo",
                .started_at = 1,
                .stopped_at = 2,
            },
        }, &alloc.writer, .{
            .datetime = .unix,
            .format = .tsv,
            .order = PrintColumn.Order.fixed(&.{ .status, .title, .id, .started, .stopped }),
        });

        try std.testing.expectEqualSlices(
            u8,
            "stopped\tFoo\t919108f7-52d1-4320-9bac-f847db4148a8\t1\t2\n",
            alloc.written(),
        );
    }

    test "JSONL single" {
        var alloc = std.Io.Writer.Allocating.init(std.testing.allocator);
        defer alloc.deinit();

        try print(&.{
            .running = .{
                .id = 0xa84841db47f8ac9b2043d152f7089191,
                .title = "Foo",
                .started_at = 1,
            },
        }, &alloc.writer, .{
            .datetime = .unix,
            .format = .jsonl,
            .order = PrintColumn.Order.fixed(&.{.id}),
        });

        try std.testing.expectEqualSlices(
            u8,
            \\{"id":"919108f7-52d1-4320-9bac-f847db4148a8"}
            \\
        ,
            alloc.written(),
        );
    }

    test "JSONL running full" {
        var alloc = std.Io.Writer.Allocating.init(std.testing.allocator);
        defer alloc.deinit();

        try print(&.{
            .running = .{
                .id = 0xa84841db47f8ac9b2043d152f7089191,
                .title = "Foo",
                .started_at = 1,
            },
        }, &alloc.writer, .{
            .datetime = .unix,
            .format = .jsonl,
            .order = PrintColumn.Order.fixed(&.{ .status, .title, .id, .started, .stopped }),
        });

        try std.testing.expectEqualSlices(
            u8,
            \\{"status":"running","title":"Foo","id":"919108f7-52d1-4320-9bac-f847db4148a8","started":1}
            \\
        ,
            alloc.written(),
        );
    }

    test "JSONL stopped" {
        var alloc = std.Io.Writer.Allocating.init(std.testing.allocator);
        defer alloc.deinit();

        try print(&.{
            .stopped = .{
                .id = 0xa84841db47f8ac9b2043d152f7089191,
                .title = "Foo",
                .started_at = 1,
                .stopped_at = 2,
            },
        }, &alloc.writer, .{
            .datetime = .unix,
            .format = .jsonl,
            .order = PrintColumn.Order.fixed(&.{ .status, .title, .id, .started, .stopped }),
        });

        try std.testing.expectEqualSlices(
            u8,
            \\{"status":"stopped","title":"Foo","id":"919108f7-52d1-4320-9bac-f847db4148a8","started":1,"stopped":2}
            \\
        ,
            alloc.written(),
        );
    }
};

test {
    _ = Timer;
}

pub const Aggregation = struct {
    pub const RunningOnly = struct {
        running: []RunningTimer,

        pub fn deinit(self: RunningOnly, allocator: std.mem.Allocator) void {
            for (self.running) |t| t.deinit(allocator);
            allocator.free(self.running);
        }
    };

    pub const Full = struct {
        running: []RunningTimer,
        stopped: []StoppedTimer,

        pub fn deinit(self: Full, allocator: std.mem.Allocator) void {
            for (self.running) |t| t.deinit(allocator);
            allocator.free(self.running);

            for (self.stopped) |t| t.deinit(allocator);
            allocator.free(self.stopped);
        }
    };
};

pub const AggregateError = std.mem.Allocator.Error || events.Iterator.IterateError;

/// Caller is responsible for calling `deinit` on the returned struct after use.
pub fn aggregate(Type: type, gpa: std.mem.Allocator, io: std.Io, iterator: *events.Iterator) AggregateError!Type {
    if (Type != Aggregation.RunningOnly and Type != Aggregation.Full) {
        @compileError("Type parameter of \"aggregate\" must be either one of \"State.RunningOnly\" or \"State.Full\"");
    }

    var event_list = std.ArrayList(events.Event).empty;
    defer event_list.deinit(gpa);
    defer for (event_list.items) |event| event.deinit(gpa);

    while (try iterator.next(gpa, io)) |event| {
        try event_list.append(gpa, event);
    }

    var running_timers = std.array_hash_map.Auto(uuid.Uuid, RunningTimer).empty;
    defer running_timers.deinit(gpa);
    errdefer for (running_timers.values()) |timer| timer.deinit(gpa);

    var stopped_timers = if (Type == Aggregation.Full) std.array_hash_map.Auto(uuid.Uuid, StoppedTimer).empty else std.array_hash_map.Auto(void, void).empty;
    defer if (Type == Aggregation.Full) stopped_timers.deinit(gpa);
    errdefer if (Type == Aggregation.Full) for (stopped_timers.values()) |timer| timer.deinit(gpa);

    for (0..event_list.items.len) |i| {
        const event = event_list.items[event_list.items.len - i - 1];

        switch (event) {
            .timer_started => |started| {
                try running_timers.put(gpa, started.timer_id, .{
                    .id = started.timer_id,
                    .title = try gpa.dupe(u8, started.title),
                    .started_at = started.created_at,
                });
            },
            .timer_stopped => |stopped| {
                const found = running_timers.fetchOrderedRemove(stopped.timer_id) orelse {
                    std.log.warn("Detected stopping non-existing timer ID ({s}), skipping", .{uuid.urn.serialize(stopped.timer_id)});
                    continue;
                };

                if (Type == Aggregation.Full) {
                    try stopped_timers.put(gpa, stopped.timer_id, .{
                        .id = found.value.id,
                        .title = found.value.title,
                        .started_at = found.value.started_at,
                        .stopped_at = stopped.created_at,
                    });
                } else {
                    found.value.deinit(gpa);
                }
            },
            .timer_deleted => |deleted| {
                if (running_timers.fetchOrderedRemove(deleted.timer_id)) |timer| {
                    timer.value.deinit(gpa);
                }

                if (Type == Aggregation.Full) {
                    if (stopped_timers.fetchOrderedRemove(deleted.timer_id)) |timer| {
                        timer.value.deinit(gpa);
                    }
                }
            },
            .timer_title_changed => |title_changed| {
                if (running_timers.getPtr(title_changed.timer_id)) |timer| {
                    gpa.free(timer.title);
                    timer.title = try gpa.dupe(u8, title_changed.new_title);
                }

                if (Type == Aggregation.Full) {
                    if (stopped_timers.getPtr(title_changed.timer_id)) |timer| {
                        gpa.free(timer.title);
                        timer.title = try gpa.dupe(u8, title_changed.new_title);
                    }
                }
            },
        }
    }

    if (Type == Aggregation.RunningOnly) {
        return .{
            .running = try gpa.dupe(RunningTimer, running_timers.values()),
        };
    } else {
        const running = try gpa.dupe(RunningTimer, running_timers.values());
        errdefer gpa.free(running);

        const stopped = try gpa.dupe(StoppedTimer, stopped_timers.values());
        errdefer gpa.free(stopped);

        return .{
            .running = running,
            .stopped = stopped,
        };
    }
}

pub const FindError = std.mem.Allocator.Error || events.Iterator.IterateError;

/// Caller is responsible for calling `deinit` on the returned struct after use.
pub fn findById(gpa: std.mem.Allocator, io: std.Io, iterator: *events.Iterator, id: uuid.Uuid) FindError!?Timer {
    var stopped_at: ?i64 = null;
    var latest_title: ?[]const u8 = null;
    errdefer if (latest_title) |str| gpa.free(str);

    while (try iterator.next(gpa, io)) |event| {
        defer event.deinit(gpa);

        switch (event) {
            .timer_deleted => |deleted| {
                if (deleted.timer_id == id) {
                    return null;
                }
            },
            .timer_started => |started| {
                if (started.timer_id == id) {
                    const title = latest_title orelse try gpa.dupe(u8, started.title);

                    if (stopped_at) |s| {
                        return .{
                            .stopped = .{
                                .id = id,
                                .title = title,
                                .started_at = started.created_at,
                                .stopped_at = s,
                            },
                        };
                    } else {
                        return .{
                            .running = .{
                                .id = id,
                                .title = title,
                                .started_at = started.created_at,
                            },
                        };
                    }
                }
            },
            .timer_stopped => |stopped| {
                if (stopped.timer_id == id) {
                    stopped_at = stopped.created_at;
                }
            },
            .timer_title_changed => |changed| {
                if (changed.timer_id == id and latest_title == null) {
                    latest_title = try gpa.dupe(u8, changed.new_title);
                }
            },
        }
    }

    return null;
}

pub const TimerIterator = struct {
    events_iter: *events.Iterator,
    title_changes: std.hash_map.AutoHashMapUnmanaged(uuid.Uuid, []const u8) = .empty,
    stopped_timestamps: std.hash_map.AutoHashMapUnmanaged(uuid.Uuid, i64) = .empty,
    deleted_timer_ids: std.hash_map.AutoHashMapUnmanaged(uuid.Uuid, void) = .empty,

    pub fn deinit(self: *TimerIterator, gpa: std.mem.Allocator) void {
        var changes_iter = self.title_changes.iterator();
        while (changes_iter.next()) |entry| {
            gpa.free(entry.value_ptr.*);
        }

        self.title_changes.deinit(gpa);
        self.stopped_timestamps.deinit(gpa);
        self.deleted_timer_ids.deinit(gpa);
    }

    pub const Error = events.Iterator.IterateError || std.mem.Allocator.Error;

    /// Caller is responsible for calling `deinit` on the returned struct after use.
    pub fn next(self: *TimerIterator, gpa: std.mem.Allocator, io: std.Io) Error!?Timer {
        while (try self.events_iter.next(gpa, io)) |event| {
            defer event.deinit(gpa);

            switch (event) {
                .timer_deleted => |deleted| {
                    try self.deleted_timer_ids.put(gpa, deleted.timer_id, {});
                },
                .timer_stopped => |stopped| if (!self.deleted_timer_ids.contains(stopped.timer_id)) {
                    try self.stopped_timestamps.put(gpa, stopped.timer_id, stopped.created_at);
                },
                .timer_title_changed => |changed| if (!self.deleted_timer_ids.contains(changed.timer_id)) {
                    const new_title = try gpa.dupe(u8, changed.new_title);
                    errdefer gpa.free(new_title);

                    if (try self.title_changes.fetchPut(gpa, changed.timer_id, new_title)) |prev| {
                        gpa.free(prev.value);
                    }
                },
                .timer_started => |started| if (!self.deleted_timer_ids.contains(started.timer_id)) {
                    const stopped_at = if (self.stopped_timestamps.fetchRemove(started.timer_id)) |entry| entry.value else null;
                    const title = if (self.title_changes.fetchRemove(started.timer_id)) |entry| entry.value else try gpa.dupe(u8, started.title);

                    if (stopped_at) |ts| {
                        return .{
                            .stopped = .{
                                .id = started.timer_id,
                                .title = title,
                                .started_at = started.created_at,
                                .stopped_at = ts,
                            },
                        };
                    } else {
                        return .{
                            .running = .{
                                .id = started.timer_id,
                                .title = title,
                                .started_at = started.created_at,
                            },
                        };
                    }
                },
            }
        }

        return null;
    }
};