const std = @import("std");
const assert = std.debug.assert;
const testing = std.testing;
const Allocator = std.mem.Allocator;

pub fn main() !void {
    const argv = std.os.argv;
    if (argv.len != 2) {
        std.debug.print("Usage: {s} FILE\n", .{argv[0]});
        std.os.exit(2);
    }

    const file = try std.fs.cwd().openFileZ(argv[1], .{});
    defer file.close();
    const data = try std.os.mmap(
        null,
        try file.getEndPos(),
        std.os.PROT.READ,
        std.os.MAP.PRIVATE,
        file.handle,
        0,
    );
    defer std.os.munmap(data);

    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer arena.deinit();
    var wrap = std.heap.ThreadSafeAllocator{ .child_allocator = arena.allocator() };
    try process(wrap.allocator(), data);
}

const Measurement = struct {
    min: i32,
    max: i32,
    sum: i32,
    count: u32 = 1,
};

const Result = std.StringHashMap(Measurement);
const pre_alloc_capacity: usize = 2 << 14;

fn process(allocator: Allocator, data: []const u8) !void {
    const chunks = try getChunks(allocator, data);
    defer allocator.free(chunks);

    var results = try std.ArrayList(Result).initCapacity(allocator, chunks.len);
    defer {
        for (results.items) |*result| {
            result.deinit();
        }
        results.deinit();
    }
    var threads = try std.ArrayList(std.Thread).initCapacity(allocator, chunks.len);
    defer threads.deinit();

    for (0..chunks.len) |idx| {
        try results.append(blk: {
            var m = Result.init(allocator);
            try m.ensureTotalCapacity(pre_alloc_capacity);
            break :blk m;
        });
        try threads.append(try std.Thread.spawn(
            .{},
            worker,
            .{
                data[(if (idx == 0) 0 else chunks[idx - 1])..chunks[idx]],
                &results.items[results.items.len - 1],
            },
        ));
    }
    for (threads.items) |thread| {
        thread.join();
    }

    var merged = Result.init(allocator);
    defer merged.deinit();
    try merged.ensureTotalCapacity(pre_alloc_capacity);
    for (results.items) |result| {
        var iter = result.iterator();
        while (iter.next()) |entry| {
            if (merged.getPtr(entry.key_ptr.*)) |m| {
                m.*.min = @min(m.*.min, entry.value_ptr.*.min);
                m.*.max = @max(m.*.max, entry.value_ptr.*.max);
                m.*.sum += entry.value_ptr.*.sum;
                m.*.count += entry.value_ptr.*.count;
            } else {
                try merged.put(entry.key_ptr.*, entry.value_ptr.*);
            }
        }
    }

    var ids = try std.ArrayList([]const u8).initCapacity(allocator, merged.count());
    defer ids.deinit();
    var iter = merged.keyIterator();
    while (iter.next()) |key| {
        try ids.append(key.*);
    }
    std.sort.pdq([]const u8, ids.items, {}, struct {
        fn lessThan(context: void, lhs: []const u8, rhs: []const u8) bool {
            _ = context;
            return std.mem.order(u8, lhs, rhs) == .lt;
        }
    }.lessThan);

    const stdout = std.io.getStdOut();
    var buf = std.io.bufferedWriter(stdout.writer());
    var writer = buf.writer();
    try writer.writeByte('{');
    for (ids.items, 0..) |id, i| {
        if (i != 0) _ = try writer.write(", ");
        const measurement = merged.get(id).?;
        try writer.print(
            "{s}={d:.1}/{d:.1}/{d:.1}",
            .{
                id,
                @as(f64, @floatFromInt(measurement.min)) / 10,
                @round(@as(f64, @floatFromInt(measurement.sum)) / @as(f64, @floatFromInt(measurement.count))) / 10,
                @as(f64, @floatFromInt(measurement.max)) / 10,
            },
        );
    }
    _ = try writer.write("}\n");
    try buf.flush();
}

fn worker(data: []const u8, result: *Result) !void {
    var offset: usize = 0;
    var semi: usize = undefined;
    var lf: usize = undefined;
    var v: i32 = undefined;
    while (true) {
        semi = std.mem.indexOfScalarPos(u8, data, offset, ';') orelse break;
        lf = semi + 1;

        v = unsafeParseNumber(data, &lf);
        if (result.getPtr(data[offset..semi])) |m| {
            m.*.min = @min(m.*.min, v);
            m.*.max = @max(m.*.max, v);
            m.*.sum += v;
            m.*.count += 1;
        } else {
            try result.put(data[offset..semi], .{
                .min = v,
                .max = v,
                .sum = v,
            });
        }

        offset = lf + 1;
    }
}

inline fn unsafeParseNumber(data: []const u8, offset: *usize) i32 {
    var sign: i32 = 1;
    var res: i32 = 0;
    if (data[offset.*] == '-') {
        sign = -1;
        offset.* += 1;
    }
    while (offset.* < data.len and data[offset.*] != '\n') : (offset.* += 1) {
        if (data[offset.*] == '.') continue;
        res = res * 10 + (data[offset.*] - '0');
    }
    return sign * res;
}

test "unsafeParseNumber" {
    var offset: usize = 0;
    try testing.expectEqual(@as(i32, 123), unsafeParseNumber("12.3", &offset));
    try testing.expectEqual(@as(usize, 4), offset);
    offset = 0;
    try testing.expectEqual(@as(i32, 12), unsafeParseNumber("1.2", &offset));
    try testing.expectEqual(@as(usize, 3), offset);
}

fn getChunks(allocator: Allocator, data: []const u8) ![]usize {
    const cpu_count = try std.Thread.getCpuCount();
    const chunk_size = data.len / cpu_count;
    assert(chunk_size > 0);

    var chunks = try std.ArrayList(usize).initCapacity(allocator, cpu_count);
    defer chunks.deinit();
    var offset: usize = 0;
    while (offset < data.len) {
        offset += chunk_size;
        if (offset >= data.len) {
            try chunks.append(data.len);
            break;
        }

        if (std.mem.indexOfScalarPos(u8, data, offset, '\n')) |idx| {
            offset = idx + 1;
        } else {
            offset = data.len;
        }
        try chunks.append(offset);
    }

    return try chunks.toOwnedSlice();
}