const std = @import("std");
const c_unistd = @cImport(@cInclude("unistd.h"));
const c_statvfs = @cImport(@cInclude("sys/statvfs.h"));
const c_libpci = @cImport(@cInclude("pci/pci.h"));

/// Struct representing CPU informations
pub const CpuInfo = struct {
    cpu_name: []u8,
    cpu_cores: i32,
    cpu_max_freq: f32,
};

/// Struct representing GPU informations
pub const GpuInfo = struct {
    gpu_name: []u8,
    gpu_cores: i32,
    gpu_freq: f64,
};

/// Struct representing RAM usage informations
pub const RamInfo = struct {
    ram_size: f64,
    ram_usage: f64,
    ram_usage_percentage: u8,
};

/// Struct representing Swap usage informations
pub const SwapInfo = struct {
    swap_size: f64,
    swap_usage: f64,
    swap_usage_percentage: u8,
};

/// Struct representing Disk usage informations
pub const DiskInfo = struct {
    disk_path: []const u8,
    disk_size: f64,
    disk_usage: f64,
    disk_usage_percentage: u8,
};

pub fn getCpuInfo(allocator: std.mem.Allocator) !CpuInfo {
    const cpu_cores = c_unistd.sysconf(c_unistd._SC_NPROCESSORS_ONLN);

    // Reads /proc/cpuinfo
    const cpuinfo_path = "/proc/cpuinfo";
    var file = try std.fs.cwd().openFile(cpuinfo_path, .{});
    defer file.close();
    const cpuinfo_data = try file.readToEndAlloc(allocator, std.math.maxInt(usize));
    defer allocator.free(cpuinfo_data);

    // Parsing /proc/cpuinfo
    var model_name: ?[]const u8 = null;

    var lines = std.mem.splitScalar(u8, cpuinfo_data, '\n');
    while (lines.next()) |line| {
        const trimmed = std.mem.trim(u8, line, " \t");
        if (std.mem.startsWith(u8, trimmed, "model name") and model_name == null) {
            var parts = std.mem.splitScalar(u8, trimmed, ':');
            _ = parts.next(); // discards the key
            if (parts.next()) |value| {
                model_name = std.mem.trim(u8, value, " ");
                break;
            }
        }
    }

    // Reads /sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq
    const cpuinfo_max_freq_path = "/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq";
    var file2 = try std.fs.cwd().openFile(cpuinfo_max_freq_path, .{});
    defer file2.close();
    const cpuinfo_max_freq_data = try file2.readToEndAlloc(allocator, std.math.maxInt(usize));
    defer allocator.free(cpuinfo_max_freq_data);

    // Parsing /sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq
    const trimmed = std.mem.trim(u8, cpuinfo_max_freq_data, " \n\r");
    const cpu_max_freq_khz: f32 = try std.fmt.parseFloat(f32, trimmed);
    const cpu_max_freq: f32 = cpu_max_freq_khz / 1_000_000;

    return CpuInfo{
        .cpu_name = try allocator.dupe(u8, model_name orelse "Unknown"),
        .cpu_cores = @as(i32, @intCast(cpu_cores)),
        .cpu_max_freq = cpu_max_freq,
    };
}

pub fn getGpuInfo(allocator: std.mem.Allocator) !std.ArrayList(GpuInfo) {
    var gpu_info_list = std.ArrayList(GpuInfo).init(allocator);

    const display_controller = 0x03;

    const pacc = c_libpci.pci_alloc();
    defer c_libpci.pci_cleanup(pacc);
    c_libpci.pci_init(pacc);
    c_libpci.pci_scan_bus(pacc);

    var devices = pacc.*.devices;
    while (devices != null) : (devices = devices.*.next) {
        // NOTE: for references: https://github.com/pciutils/pciutils/blob/3ec74c71c01878f92e751f15bb8febe720c3ab40/lib/access.c#L194
        const known_fields = c_libpci.pci_fill_info(devices, c_libpci.PCI_FILL_IDENT | c_libpci.PCI_FILL_CLASS);
        if (known_fields <= 0) {
            return error.NoLibpciFieldsFound;
        }

        if ((devices.*.device_class >> 8) == display_controller) {
            var name_buffer: [256]u8 = undefined;

            const name = c_libpci.pci_lookup_name(
                pacc,
                &name_buffer,
                name_buffer.len,
                c_libpci.PCI_LOOKUP_VENDOR | c_libpci.PCI_LOOKUP_DEVICE,
                devices.*.vendor_id,
                devices.*.device_id,
            );

            try gpu_info_list.append(GpuInfo{
                .gpu_name = try allocator.dupe(u8, std.mem.span(name)),
                .gpu_cores = 0,
                .gpu_freq = 0.0,
            });
        }
    }

    if (gpu_info_list.items.len == 0) {
        return GpuInfo{
            .gpu_name = undefined,
            .gpu_cores = 0,
            .gpu_freq = 0.0,
        };
    }

    return gpu_info_list;
}

pub fn getRamInfo(allocator: std.mem.Allocator) !RamInfo {
    // Reads /proc/meminfo
    const meminfo_path = "/proc/meminfo";
    const file = try std.fs.cwd().openFile(meminfo_path, .{});
    defer file.close();
    const meminfo_data = try file.readToEndAlloc(allocator, std.math.maxInt(usize));
    defer allocator.free(meminfo_data);

    // Parsing /proc/meminfo
    var total_mem: f64 = 0.0;
    var free_mem: f64 = 0.0; // remove?
    var available_mem: f64 = 0.0;

    var total_mem_str: ?[]const u8 = null;
    var free_mem_str: ?[]const u8 = null;
    var available_mem_str: ?[]const u8 = null;

    var lines = std.mem.splitScalar(u8, meminfo_data, '\n');
    while (lines.next()) |line| {
        const trimmed = std.mem.trim(u8, line, " \t");
        if (std.mem.startsWith(u8, trimmed, "MemTotal")) {
            var parts = std.mem.splitScalar(u8, trimmed, ':');
            _ = parts.next(); // discards the key
            if (parts.next()) |value| {
                total_mem_str = std.mem.trim(u8, value[0..(value.len - 3)], " ");
                total_mem = try std.fmt.parseFloat(f64, total_mem_str.?);
            }
        } else if (std.mem.startsWith(u8, trimmed, "MemFree")) {
            var parts = std.mem.splitScalar(u8, trimmed, ':');
            _ = parts.next(); // discards the key
            if (parts.next()) |value| {
                free_mem_str = std.mem.trim(u8, value[0..(value.len - 3)], " ");
                free_mem = try std.fmt.parseFloat(f64, free_mem_str.?);
            }
        } else if (std.mem.startsWith(u8, trimmed, "MemAvailable")) {
            var parts = std.mem.splitScalar(u8, trimmed, ':');
            _ = parts.next(); // discards the key
            if (parts.next()) |value| {
                available_mem_str = std.mem.trim(u8, value[0..(value.len - 3)], " ");
                available_mem = try std.fmt.parseFloat(f64, available_mem_str.?);
            }
        }

        if ((total_mem_str != null) and (free_mem_str != null) and (available_mem_str != null)) {
            break;
        }
    }

    var used_mem = total_mem - available_mem;

    // Converts KB in GB
    total_mem /= (1024 * 1024);
    used_mem /= (1024 * 1024);
    const ram_usage_percentage: u8 = @as(u8, @intFromFloat((used_mem * 100) / total_mem));

    return RamInfo{
        .ram_size = total_mem,
        .ram_usage = used_mem,
        .ram_usage_percentage = ram_usage_percentage,
    };
}

pub fn getSwapInfo(allocator: std.mem.Allocator) !?SwapInfo {
    // Reads /proc/meminfo
    const meminfo_path = "/proc/meminfo";
    const file = try std.fs.cwd().openFile(meminfo_path, .{});
    defer file.close();
    const meminfo_data = try file.readToEndAlloc(allocator, std.math.maxInt(usize));
    defer allocator.free(meminfo_data);

    // Parsing /proc/meminfo
    var total_swap: f64 = 0.0;
    var free_swap: f64 = 0.0;

    var total_swap_str: ?[]const u8 = null;
    var free_swap_str: ?[]const u8 = null;

    var lines = std.mem.splitScalar(u8, meminfo_data, '\n');
    while (lines.next()) |line| {
        const trimmed = std.mem.trim(u8, line, " \t");
        if (std.mem.startsWith(u8, trimmed, "SwapTotal")) {
            var parts = std.mem.splitScalar(u8, trimmed, ':');
            _ = parts.next(); // discards the key
            if (parts.next()) |value| {
                total_swap_str = std.mem.trim(u8, value[0..(value.len - 3)], " ");
                total_swap = try std.fmt.parseFloat(f64, total_swap_str.?);
            }
        } else if (std.mem.startsWith(u8, trimmed, "SwapFree")) {
            var parts = std.mem.splitScalar(u8, trimmed, ':');
            _ = parts.next(); // discards the key
            if (parts.next()) |value| {
                free_swap_str = std.mem.trim(u8, value[0..(value.len - 3)], " ");
                free_swap = try std.fmt.parseFloat(f64, free_swap_str.?);
            }
        }

        if ((total_swap_str != null) and (free_swap_str != null)) {
            break;
        }
    }

    var used_swap = total_swap - free_swap;

    // Converts KB in GB
    total_swap /= (1024 * 1024);
    used_swap /= (1024 * 1024);

    if (used_swap == 0) {
        return null;
    }

    const swap_usage_percentage: u8 = @as(u8, @intFromFloat((used_swap * 100) / total_swap));

    return SwapInfo{
        .swap_size = total_swap,
        .swap_usage = used_swap,
        .swap_usage_percentage = swap_usage_percentage,
    };
}

pub fn getDiskSize(disk_path: []const u8) !DiskInfo {
    var stat: c_statvfs.struct_statvfs = undefined;
    if (c_statvfs.statvfs(disk_path.ptr, &stat) != 0) {
        return error.StatvfsFailed;
    }

    const total_size = stat.f_blocks * stat.f_frsize;
    const free_size = stat.f_bavail * stat.f_frsize;
    const used_size = total_size - free_size;

    const used_size_percentage = (used_size * 100) / total_size;

    return DiskInfo{
        .disk_path = disk_path,
        .disk_size = @as(f64, @floatFromInt(total_size)) / 1e9,
        .disk_usage = @as(f64, @floatFromInt(used_size)) / 1e9,
        .disk_usage_percentage = @as(u8, @intCast(used_size_percentage)),
    };
}