oxwm

const std = @import("std");

const format_util = @import("format.zig");

pub const Battery = struct {

    format_charging: []const u8,

    format_discharging: []const u8,

    format_full: []const u8,

    battery_name: []const u8,

    interval_secs: u64,

    color: c_ulong,

    pub fn init(

        format_charging: []const u8,

        format_discharging: []const u8,

        format_full: []const u8,

        battery_name: []const u8,

        interval_secs: u64,

        color: c_ulong,

    ) Battery {

        return .{

            .format_charging = format_charging,

            .format_discharging = format_discharging,

            .format_full = format_full,

            .battery_name = if (battery_name.len > 0) battery_name else "BAT0",

            .interval_secs = interval_secs,

            .color = color,

        };

    }

    pub fn content(self: *Battery, buffer: []u8) []const u8 {

        var path_buf: [128]u8 = undefined;

        const capacity = self.read_battery_file(&path_buf, "capacity") orelse return buffer[0..0];

        const status = self.read_battery_status(&path_buf) orelse return buffer[0..0];

        const format = switch (status) {

            .charging => self.format_charging,

            .discharging => self.format_discharging,

            .full => self.format_full,

        };

        var cap_buf: [8]u8 = undefined;

        const cap_str = std.fmt.bufPrint(&cap_buf, "{d}", .{capacity}) catch return buffer[0..0];

        return format_util.substitute(format, cap_str, buffer);

    }

    const Status = enum { charging, discharging, full };

    fn read_battery_status(self: *Battery, path_buf: *[128]u8) ?Status {

        const path = std.fmt.bufPrint(path_buf, "/sys/class/power_supply/{s}/status", .{self.battery_name}) catch return null;

        const file = std.fs.openFileAbsolute(path, .{}) catch return null;

        defer file.close();

        var buf: [32]u8 = undefined;

        const len = file.read(&buf) catch return null;

        const status_str = std.mem.trim(u8, buf[0..len], " \n\r\t");

        if (std.mem.eql(u8, status_str, "Charging")) return .charging;

        if (std.mem.eql(u8, status_str, "Discharging")) return .discharging;

        if (std.mem.eql(u8, status_str, "Full")) return .full;

        if (std.mem.eql(u8, status_str, "Not charging")) return .full;

        return .discharging;

    }

    fn read_battery_file(self: *Battery, path_buf: *[128]u8, file_name: []const u8) ?u8 {

        const path = std.fmt.bufPrint(path_buf, "/sys/class/power_supply/{s}/{s}", .{ self.battery_name, file_name }) catch return null;

        const file = std.fs.openFileAbsolute(path, .{}) catch return null;

        defer file.close();

        var buf: [16]u8 = undefined;

        const len = file.read(&buf) catch return null;

        const value_str = std.mem.trim(u8, buf[0..len], " \n\r\t");

        return std.fmt.parseInt(u8, value_str, 10) catch null;

    }

    pub fn interval(self: *Battery) u64 {

        return self.interval_secs;

    }

    pub fn get_color(self: *Battery) c_ulong {

        return self.color;

    }

};