const std = @import("std");
const io = std.io;
const heap = std.heap;
const json = std.json;

const battery = @import("modules/battery.zig");
const calendar = @import("modules/calendar.zig");
const display = @import("modules/display.zig");
const uptime = @import("modules/uptime.zig");
const volume = @import("modules/volume.zig");
const memory = @import("modules/memory.zig");
const loadavg = @import("modules/loadavg.zig");
const Module = @import("module.zig");

pub fn main() !void {
    var arena = heap.ArenaAllocator.init(heap.page_allocator);
    defer arena.deinit();

    const stdout_file = std.io.getStdOut().writer();
    var bw = std.io.bufferedWriter(stdout_file);
    const stdout = bw.writer();

    try stdout.print("{{\"version\":1}}\n[\n", .{});
    try bw.flush();

    var modules = [_]Module{
        uptime.init(arena.allocator()).module,
        loadavg.init(arena.allocator()).module,
        memory.init(arena.allocator()).module,
        volume.init(arena.allocator()).module,
        display.init(arena.allocator()).module,
        battery.init(arena.allocator()).module,
        calendar.init(arena.allocator()).module,
    };

    while (true) {
        try stdout.print("[", .{});
        var bg = Color{ .r = 0.0, .g = 0.0, .b = 0.0 };
        for (modules, 0..) |module, idx| {
            _ = idx;
            var output = try module.getJson();
            output.full_text = try std.fmt.allocPrint(arena.allocator(), " {s} ", .{output.full_text});
            output.background = try bg.getString(arena.allocator());
            var color = bg.add(Color{ .r = 0.6, .g = 0.6, .b = 0.6 });
            if (output.color == null) output.color = try color.getString(arena.allocator());
            output.separator = false;
            output.separator_block_width = 0;
            try json.stringify(output, .{ .emit_null_optional_fields = false }, stdout);
            try stdout.print(",", .{});
            bg.r += 0.025;
            bg.g += 0.025;
            bg.b += 0.025;
        }
        try stdout.print("],\n", .{});

        try bw.flush();
        _ = arena.reset(.retain_capacity);
        std.time.sleep(1000_000_000);
    }
}

pub const Color = struct {
    r: f32,
    g: f32,
    b: f32,

    pub fn init(string: []const u8) !Color {
        var r = try std.fmt.parseInt(u8, string[1..2], 16);
        var g = try std.fmt.parseInt(u8, string[3..4], 16);
        var b = try std.fmt.parseInt(u8, string[5..6], 16);
        return .{
            .r = @as(f32, @floatFromInt(r)) / 255,
            .g = @as(f32, @floatFromInt(g)) / 255,
            .b = @as(f32, @floatFromInt(b)) / 255,
        };
    }

    pub fn getString(self: *const Color, allocator: std.mem.Allocator) ![]const u8 {
        const r = @as(u8, @intFromFloat(self.r * 255));
        const g = @as(u8, @intFromFloat(self.g * 255));
        const b = @as(u8, @intFromFloat(self.b * 255));
        return try std.fmt.allocPrint(allocator, "#{s}{s}{s}", .{
            std.fmt.fmtSliceHexLower(&[_]u8{r}),
            std.fmt.fmtSliceHexLower(&[_]u8{g}),
            std.fmt.fmtSliceHexLower(&[_]u8{b}),
        });
    }

    pub fn add(a: *const Color, b: Color) Color {
        return .{
            .r = std.math.clamp(a.r + b.r, 0.0, 1.0),
            .g = std.math.clamp(a.g + b.g, 0.0, 1.0),
            .b = std.math.clamp(a.b + b.b, 0.0, 1.0),
        };
    }

    pub fn mix(a: *const Color, b: Color, t: f32) Color {
        return .{
            .r = std.math.lerp(a.r, b.r, t),
            .g = std.math.lerp(a.g, b.g, t),
            .b = std.math.lerp(a.b, b.b, t),
        };
    }
};

pub fn getBgColor(idx: usize, override: ?[]const u8) []const u8 {
    if (override) |o| return o;
    return switch (idx % 2) {
        0 => "#002b36",
        1 => "#0e1b15",
        else => "#002b36",
    };
}

pub fn getFgColor(idx: usize, override: ?[]const u8) []const u8 {
    if (override) |o| return o;
    return switch (idx % 2) {
        // 0 => "#93a1a1",
        // 1 => "#d6c2d6",
        else => "#",
    };
}