winfetch.cpp

#include <iostream>
#include <string>
#include <vector>
#include <set>
#include <sstream>
#include <windows.h>
#include <conio.h>

// Link necessary Windows libraries
#pragma comment(lib, "Advapi32.lib")
#pragma comment(lib, "User32.lib")

// ANSI Escape Codes for text formatting
#define RESET       "\x1b[0m"
#define BOLD        "\x1b[1m"

// Foreground colors
#define BLACK       "\x1b[30m"
#define RED         "\x1b[31m"
#define GREEN       "\x1b[32m"
#define YELLOW      "\x1b[33m"
#define BLUE        "\x1b[34m"
#define MAGENTA     "\x1b[35m"
#define CYAN        "\x1b[36m"
#define WHITE       "\x1b[37m"

// Bright foreground colors
#define BRIGHT_BLACK   "\x1b[90m"
#define BRIGHT_RED     "\x1b[91m"
#define BRIGHT_GREEN   "\x1b[92m"
#define BRIGHT_YELLOW  "\x1b[93m"
#define BRIGHT_BLUE    "\x1b[94m"
#define BRIGHT_MAGENTA "\x1b[95m"
#define BRIGHT_CYAN    "\x1b[96m"
#define BRIGHT_WHITE   "\x1b[97m"

// Background colors
#define BG_BLACK       "\x1b[40m"
#define BG_RED         "\x1b[41m"
#define BG_GREEN       "\x1b[42m"
#define BG_YELLOW      "\x1b[43m"
#define BG_BLUE        "\x1b[44m"
#define BG_MAGENTA     "\x1b[45m"
#define BG_CYAN        "\x1b[46m"
#define BG_WHITE       "\x1b[47m"
#define BG_BRIGHT_BLACK   "\x1b[100m"
#define BG_BRIGHT_RED     "\x1b[101m"
#define BG_BRIGHT_GREEN   "\x1b[102m"
#define BG_BRIGHT_YELLOW  "\x1b[103m"
#define BG_BRIGHT_BLUE    "\x1b[104m"
#define BG_BRIGHT_MAGENTA "\x1b[105m"
#define BG_BRIGHT_CYAN    "\x1b[106m"
#define BG_BRIGHT_WHITE   "\x1b[107m"

// Console control codes
#define CLEAR_SCREEN "\x1b[2J"
#define CURSOR_HOME  "\x1b[H"
#define HIDE_CURSOR  "\x1b[?25l"
#define SHOW_CURSOR  "\x1b[?25h"

using namespace std;

// ============================================================
// Enables ANSI escape sequences in the Windows console
// ============================================================
void enableANSI() {
    HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
    DWORD dwMode = 0;
    GetConsoleMode(hOut, &dwMode);
    dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
    SetConsoleMode(hOut, dwMode);
    SetConsoleOutputCP(65001);
}

// ============================================================
// Helper functions to read from the Windows Registry
// ============================================================
string getRegString(HKEY baseKey, const char* subKey, const char* valueName) {
    HKEY hKey;
    if (RegOpenKeyExA(baseKey, subKey, 0, KEY_READ, &hKey) != ERROR_SUCCESS)
        return "N/A";
    char value[512];
    DWORD valSize = sizeof(value);
    DWORD type = 0;
    if (RegQueryValueExA(hKey, valueName, NULL, &type, (LPBYTE)value, &valSize) != ERROR_SUCCESS) {
        RegCloseKey(hKey);
        return "N/A";
    }
    RegCloseKey(hKey);
    return string(value);
}

DWORD getRegDword(HKEY baseKey, const char* subKey, const char* valueName) {
    HKEY hKey;
    if (RegOpenKeyExA(baseKey, subKey, 0, KEY_READ, &hKey) != ERROR_SUCCESS)
        return 0;
    DWORD value = 0, valSize = sizeof(DWORD), type = 0;
    RegQueryValueExA(hKey, valueName, NULL, &type, (LPBYTE)&value, &valSize);
    RegCloseKey(hKey);
    return value;
}

// ============================================================
// System Information Fetchers
// ============================================================

// Fetches username and hostname (e.g., user@desktop)
string getUserHost() {
    char username[256], hostname[256];
    DWORD unSize = sizeof(username), hnSize = sizeof(hostname);
    GetUserNameA(username, &unSize);
    GetComputerNameA(hostname, &hnSize);
    return string(username) + "@" + string(hostname);
}

// Retrieves OS product name and version
string getOS() {
    string name = getRegString(HKEY_LOCAL_MACHINE,
        "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", "ProductName");
    string displayVer = getRegString(HKEY_LOCAL_MACHINE,
        "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", "DisplayVersion");
    string build = getRegString(HKEY_LOCAL_MACHINE,
        "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", "CurrentBuildNumber");
    string result = name;
    if (displayVer != "N/A" && !displayVer.empty())
        result += " " + displayVer;
    if (build != "N/A" && !build.empty())
        result += " (Build " + build + ")";
    return result;
}

// Retrieves Windows Kernel version details
string getKernel() {
    string major = to_string(getRegDword(HKEY_LOCAL_MACHINE,
        "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", "CurrentMajorVersionNumber"));
    string minor = to_string(getRegDword(HKEY_LOCAL_MACHINE,
        "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", "CurrentMinorVersionNumber"));
    string build = getRegString(HKEY_LOCAL_MACHINE,
        "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", "CurrentBuildNumber");
    string ubr = to_string(getRegDword(HKEY_LOCAL_MACHINE,
        "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", "UBR"));
    return major + "." + minor + "." + build + "." + ubr;
}

// Retrieves CPU model and thread count
string getCPU() {
    string cpu = getRegString(HKEY_LOCAL_MACHINE,
        "HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0", "ProcessorNameString");
    string result;
    bool lastSpace = false;
    for (char c : cpu) {
        if (c == ' ') {
            if (!lastSpace) { result += c; lastSpace = true; }
        } else {
            result += c; lastSpace = false;
        }
    }
    SYSTEM_INFO si;
    GetSystemInfo(&si);
    result += " (" + to_string(si.dwNumberOfProcessors) + " threads)";
    return result;
}

// Retrieves GPU model(s)
string getGPU() {
    DISPLAY_DEVICEA dd;
    dd.cb = sizeof(dd);
    set<string> seen;
    vector<string> gpuList;

    for (int i = 0; EnumDisplayDevicesA(NULL, i, &dd, 0); i++) {
        if (dd.StateFlags & DISPLAY_DEVICE_MIRRORING_DRIVER) continue;
        string name(dd.DeviceString);
        if (name.empty()) continue;
        if (seen.count(name)) continue;
        seen.insert(name);
        gpuList.push_back(name);
    }

    if (gpuList.empty()) return "N/A";

    string result;
    for (size_t i = 0; i < gpuList.size(); i++) {
        if (i > 0) result += ", ";
        result += gpuList[i];
    }
    return result;
}

// Retrieves Physical RAM usage
string getRAM() {
    MEMORYSTATUSEX mem;
    mem.dwLength = sizeof(mem);
    GlobalMemoryStatusEx(&mem);
    DWORDLONG totalMB = mem.ullTotalPhys / (1024 * 1024);
    DWORDLONG usedMB = (mem.ullTotalPhys - mem.ullAvailPhys) / (1024 * 1024);
    return to_string(usedMB) + " MB / " + to_string(totalMB) + " MB ("
         + to_string(mem.dwMemoryLoad) + "%)";
}

// Calculates system uptime
string getUptime() {
    ULONGLONG ms = GetTickCount64();
    int days  = (int)(ms / (1000ULL * 60 * 60 * 24));
    int hours = (int)((ms / (1000ULL * 60 * 60)) % 24);
    int mins  = (int)((ms / (1000ULL * 60)) % 60);
    int secs  = (int)((ms / 1000ULL) % 60);
    string r;
    if (days  > 0) r += to_string(days)  + "d ";
    if (hours > 0) r += to_string(hours) + "h ";
    r += to_string(mins) + "m " + to_string(secs) + "s";
    return r;
}

// Retrieves primary display resolution and refresh rate
string getResolution() {
    int w = GetSystemMetrics(SM_CXSCREEN);
    int h = GetSystemMetrics(SM_CYSCREEN);
    DEVMODEA dm;
    memset(&dm, 0, sizeof(dm));
    dm.dmSize = sizeof(dm);
    string hz;
    if (EnumDisplaySettingsA(NULL, ENUM_CURRENT_SETTINGS, &dm))
        hz = " @ " + to_string(dm.dmDisplayFrequency) + " Hz";
    return to_string(w) + "x" + to_string(h) + hz;
}

// Retrieves the current shell environment
string getShell() {
    char* comspec = getenv("COMSPEC");
    if (comspec) return string(comspec);
    return "cmd.exe";
}

// Retrieves disk usage for fixed drives
string getDisk() {
    string result;
    DWORD drives = GetLogicalDrives();
    for (int i = 0; i < 26; i++) {
        if (!(drives & (1 << i))) continue;
        char root[] = { (char)('A' + i), ':', '\\', '\0' };
        if (GetDriveTypeA(root) != DRIVE_FIXED) continue;

        ULARGE_INTEGER freeB, totalB, totalFreeB;
        if (!GetDiskFreeSpaceExA(root, &freeB, &totalB, &totalFreeB)) continue;

        ULONGLONG totalGB = totalB.QuadPart / (1024ULL * 1024 * 1024);
        ULONGLONG usedGB  = (totalB.QuadPart - totalFreeB.QuadPart) / (1024ULL * 1024 * 1024);
        int pct = (int)(usedGB * 100 / (totalGB ? totalGB : 1));

        if (!result.empty()) result += " | ";
        result += string(root, 2) + " " + to_string(usedGB) + "G/"
                + to_string(totalGB) + "G (" + to_string(pct) + "%)";
    }
    return result.empty() ? "N/A" : result;
}

// ============================================================
// UI Rendering & Color Palette
// ============================================================
string makeColorBlock(const char* bgColor, int width = 3) {
    string spaces(width, ' ');
    return string(bgColor) + spaces + RESET;
}

string getPaletteLine1() {
    return makeColorBlock(BG_BLACK)   + makeColorBlock(BG_RED)
         + makeColorBlock(BG_GREEN)   + makeColorBlock(BG_YELLOW)
         + makeColorBlock(BG_BLUE)    + makeColorBlock(BG_MAGENTA)
         + makeColorBlock(BG_CYAN)    + makeColorBlock(BG_WHITE);
}

string getPaletteLine2() {
    return makeColorBlock(BG_BRIGHT_BLACK)   + makeColorBlock(BG_BRIGHT_RED)
         + makeColorBlock(BG_BRIGHT_GREEN)   + makeColorBlock(BG_BRIGHT_YELLOW)
         + makeColorBlock(BG_BRIGHT_BLUE)    + makeColorBlock(BG_BRIGHT_MAGENTA)
         + makeColorBlock(BG_BRIGHT_CYAN)    + makeColorBlock(BG_BRIGHT_WHITE);
}

// ============================================================
// Draws the ASCII logo and system information side-by-side
// ============================================================
void drawFrame(const vector<string>& logo) {
    string userHost  = getUserHost();
    string separator(userHost.length(), '-');

    vector<string> info = {
        CYAN BOLD + userHost + RESET,
        CYAN + separator + RESET,
        CYAN BOLD "OS:         " RESET + getOS(),
        CYAN BOLD "Kernel:     " RESET + getKernel(),
        CYAN BOLD "Uptime:     " RESET + getUptime(),
        CYAN BOLD "Shell:      " RESET + getShell(),
        CYAN BOLD "Resolution: " RESET + getResolution(),
        CYAN BOLD "CPU:        " RESET + getCPU(),
        CYAN BOLD "GPU:        " RESET + getGPU(),
        CYAN BOLD "Memory:     " RESET + getRAM(),
        CYAN BOLD "Disk:       " RESET + getDisk(),
        "",
        getPaletteLine1(),
        getPaletteLine2(),
        "",
        BRIGHT_BLACK "[Press Q or Ctrl+C to exit]" RESET
    };

    size_t maxLines = max(logo.size(), info.size());

    cout << CURSOR_HOME;
    cout << "\n";
    for (size_t i = 0; i < maxLines; i++) {
        if (i < logo.size())
            cout << " " << logo[i];

        cout << "\x1b[42G";

        if (i < info.size())
            cout << info[i];

        cout << "\x1b[K";
        cout << RESET << "\n";
    }

    cout << "\x1b[J";
    cout.flush();
}

// ============================================================
//  MAIN
// ============================================================
int main() {
    enableANSI();

    cout << HIDE_CURSOR;
    cout << CLEAR_SCREEN;

    vector<string> logo = {
        RED    "        ,.=:!!t3Z3z.,                ",
        RED    "       :tt:::tt333EE3                 ",
        RED    "       Et:::ztt33EEEL" GREEN " @Ee.,      .., ",
        RED    "      ;tt:::tt333EE7" GREEN " ;EEEEEEttttt33# ",
        RED    "     :Et:::zt333EEQ." GREEN " $EEEEEttttt33QL ",
        RED    "     it::::tt333EEF"  GREEN " @EEEEEEttttt33F ",
        RED    "    ;3=*^```\"*4EEV"  GREEN " :EEEEEEttttt33@.",
        BLUE   "    ,.=::::!t=., "   RED "`" GREEN " @EEEEEEtttz33QF",
        BLUE   "   ;::::::::zt33)   " GREEN "\"4EEEtttji3P*   ",
        BLUE   "  :t::::::::tt33." YELLOW ":Z3z..  " GREEN "``" YELLOW " ,..g.  ",
        BLUE   "  i::::::::zt33F" YELLOW " AEEEtttt::::ztF  ",
        BLUE   " ;:::::::::t33V"  YELLOW " ;EEEttttt::::t3  ",
        BLUE   " E::::::::zt33L"  YELLOW " @EEEtttt::::z3F  ",
        BLUE   "{3=*^```\"*4E3)"   YELLOW " ;EEEtttt:::::tZ` ",
        BLUE   "             `"    YELLOW " :EEEEtttt::::z7  ",
        YELLOW "                 \"VEzjt:;;z>*`      "
    };

    while (true) {
        drawFrame(logo);

        for (int tick = 0; tick < 20; tick++) {
            Sleep(50);
            if (_kbhit()) {
                int ch = _getch();
                if (ch == 'q' || ch == 'Q' || ch == 27) {
                    cout << SHOW_CURSOR << RESET;
                    return 0;
                }
            }
        }
    }

    cout << SHOW_CURSOR << RESET;
    return 0;
}