vpsmc.cpp

/*
    vpsmc - Virtual Private Server Master Control

    This program reads server information from a 'servers.json' file
    and displays it in a clean, scrollable, tabular format using the
    ncurses library. It provides a terminal-based dashboard for a quick
    overview of a list of servers.

    Version: v0.213

    Compilation Instruction (using the Makefile):
    make vpsmc
*/
#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <ncursesw/ncurses.h>
#include <thread>
#include <mutex>
#include <iomanip>
#include <chrono>
#include <cstring>
#include <wordexp.h>
#include <sys/stat.h>
#include <algorithm>
#include <atomic>
#include <tuple>
#include <cstdlib> // For setenv
#include <limits> // For std::numeric_limits
#include <fstream>
#include "vpsmc_lib.h" // Include the shared library header

// --- Enums and Globals ---
enum class SortKey { ID, NICKNAME, CANONICAL_NAME, IP_ADDRESS, OS, COMPANY, PURPOSE, COST, CPU, LOAD, MEM, SWAP, DISK, DISK2, DISK3, UPTIME, UPDATES, REBOOT };
SortKey current_sort_key = SortKey::ID;
bool sort_ascending = true;
std::atomic<bool> data_changed = true;
std::atomic<int> running_threads;
Config config; // Global config object
std::mutex server_mutex;

// --- UI Layout Constants ---
const int HEADER_HEIGHT = 5;
const int LIST_START_Y = HEADER_HEIGHT;
const int PANE_MIN_HEIGHT = 15;
const int SUMMARY_HEIGHT = 3;

// --- Column Layout Definitions (Single Source of Truth) ---
struct ColumnSpec {
    const char* title;
    const char* underline;
    int start_pos;
    const char* unit;
    int unit_pos;
    int arrow_pos;
    SortKey key;
};

const std::vector<ColumnSpec> COLUMNS = {
    {"ID", "---", 1, "", 0, 4, SortKey::ID},
    {"NICKNAME", "----------", 5, "", 0, 14, SortKey::NICKNAME},
    {"CANONICAL NAME", "---------------------", 16, "", 0, 31, SortKey::CANONICAL_NAME},
    {"IP ADDRESS", "---------------", 38, "", 0, 49, SortKey::IP_ADDRESS},
    {"OS", "----------", 54, "", 0, 57, SortKey::OS},
    {"CO", "--", 65, "", 0, 68, SortKey::COMPANY},
    {"PURPOSE", "----------------------", 69, "", 0, 77, SortKey::PURPOSE},
    {"COST", "------", 92, "", 0, 97, SortKey::COST},
    {"CPU", "---", 99, "", 0, 103, SortKey::CPU},
    {"LOAD", "----", 103, "%", 106, 108, SortKey::LOAD},
    {"MEM", "------", 108, "GiB", 108, 112, SortKey::MEM},
    {"SWAP", "-----", 115, "GiB", 115, 119, SortKey::SWAP},
    {"DSK1", "----", 121, "", 0, 125, SortKey::DISK},
    {"DSK2", "----", 126, "", 0, 130, SortKey::DISK2},
    {"DSK3", "----", 131, "", 0, 135, SortKey::DISK3},
    {"UPTIME", "---------------", 136, "Yr Mo Dy Hr Mn", 136, 152, SortKey::UPTIME},
    {"UPDTS", "-------", 153, "", 0, 159, SortKey::UPDATES},
    {"REBOOT", "------", 161, "", 0, 168, SortKey::REBOOT}
};
const int NUM_COLUMNS = 18;


// --- Forward Declarations ---
void redraw_dynamic_content(std::vector<Server>& servers, size_t start_row, size_t selected_row, bool draw_header = false);
void draw_static_header(int max_x);
void draw_server_list(const std::vector<Server>& servers, size_t start_row, size_t selected_row, int max_x);
void draw_details_pane(const Server& server, int max_x);
void draw_summary(const std::vector<Server>& servers, int max_y, int max_x);
bool confirm_delete_popup(const std::string& nick, std::string& reason_out);
bool get_string_input(WINDOW* win, int y, int x, char* buffer, int size);
void draw_footer(int max_y, int max_x, bool is_loading, size_t displayed, size_t total);
void update_sort_indicator();
bool edit_server(Server& server, bool is_adding = false);
void sort_servers(std::vector<Server>& servers, SortKey key, bool ascending);
void launch_all_dynamic_data_threads(Server& server);
void show_error_popup(const std::string& message);

// --- Helper Functions ---
std::string format_uptime(double total_seconds) {
    if (total_seconds < 0) {
        if (total_seconds == -1.0) return "   Fetching...";
        return "               ";
    }
    long long seconds = static_cast<long long>(total_seconds);
    if (seconds < 60) return "       < 1 min";
    const long long SEC_PER_MIN = 60, SEC_PER_HOUR = 3600, SEC_PER_DAY = 86400,
                      SEC_PER_MONTH = 2629746, SEC_PER_YEAR = 31556952;
    long long years = seconds / SEC_PER_YEAR; seconds %= SEC_PER_YEAR;
    long long months = seconds / SEC_PER_MONTH; seconds %= SEC_PER_MONTH;
    long long days = seconds / SEC_PER_DAY; seconds %= SEC_PER_HOUR;
    long long hours = seconds / SEC_PER_HOUR; seconds %= SEC_PER_HOUR;
    long long minutes = seconds / SEC_PER_MIN;
    char yr_s[4], mo_s[4], dy_s[4], hr_s[4], mn_s[4];
    snprintf(yr_s, sizeof(yr_s), "%s", (years > 0 ? std::to_string(years).c_str() : ""));
    snprintf(mo_s, sizeof(mo_s), "%s", (months > 0 ? std::to_string(months).c_str() : ""));
    snprintf(dy_s, sizeof(dy_s), "%s", (days > 0 ? std::to_string(days).c_str() : ""));
    snprintf(hr_s, sizeof(hr_s), "%s", (hours > 0 ? std::to_string(hours).c_str() : ""));
    snprintf(mn_s, sizeof(mn_s), "%s", (minutes > 0 ? std::to_string(minutes).c_str() : ""));
    char final_buffer[100];
    snprintf(final_buffer, sizeof(final_buffer), "%3s%3s%3s%3s%3s", yr_s, mo_s, dy_s, hr_s, mn_s);
    return std::string(final_buffer);
}

// --- Drawing Sub-routines ---
void draw_static_header(int max_x) {
    attron(A_BOLD | COLOR_PAIR(1));

    // Row 0: top frame border with embedded title
    move(0, 0);
    addstr("┌");
    for (int x = 1; x < max_x - 1; ++x) addstr("─");
    mvaddstr(0, max_x - 1, "┐");
    const char* title_buf = "VPS Master Control";
    int title_x = (max_x - (int)strlen(title_buf) - 2) / 2;
    mvprintw(0, title_x, " %s ", title_buf);

    // Rows 1-4: │ borders with interior cleared
    for (int y = 1; y < HEADER_HEIGHT; ++y) {
        mvaddstr(y, 0, "│");
        move(y, 1);
        for (int x = 1; x < max_x - 1; ++x) addch(' ');
        mvaddstr(y, max_x - 1, "│");
    }

    for(const auto& col : COLUMNS) {
        int title_len = strlen(col.title);
        int underline_len = strlen(col.underline);
        int title_pos = col.start_pos;

        // Right-align specific columns
        if (col.key == SortKey::COST || col.key == SortKey::CPU || col.key == SortKey::LOAD || col.key == SortKey::MEM || col.key == SortKey::SWAP) {
            title_pos = col.start_pos + underline_len - title_len;
        }

        mvprintw(2, title_pos, "%s", col.title);
        mvprintw(3, col.start_pos, "%s", col.underline);
        if (strlen(col.unit) > 0) {
            mvprintw(4, col.unit_pos, "%s", col.unit);
        }
    }

    attroff(A_BOLD | COLOR_PAIR(1));
}

void update_sort_indicator() {
    attron(A_BOLD | COLOR_PAIR(1));
    const char* arrow = sort_ascending ? "▲" : "▼";
    
    int key_index = static_cast<int>(current_sort_key);
    int x_pos = COLUMNS[key_index].arrow_pos;
    
    mvprintw(2, x_pos, "%s", arrow);
    attroff(A_BOLD | COLOR_PAIR(1));
}


void draw_server_list(const std::vector<Server>& servers, size_t start_row, size_t selected_row, int max_x) {
    int max_y;
    getmaxyx(stdscr, max_y, max_x);
    const int SUMMARY_START_Y = max_y - PANE_MIN_HEIGHT - 1 - SUMMARY_HEIGHT;
    const int list_height = SUMMARY_START_Y - LIST_START_Y;

    for (int i = 0; i < list_height; ++i) {
        int y = LIST_START_Y + i;
        size_t server_idx = start_row + i;
        
        bool is_even_row = (i % 2 != 0);
        int base_color = is_even_row ? 6 : 5;
        
        int disk_green_pair = is_even_row ? 17 : 16;
        int disk_white_pair = is_even_row ? 34 : 33;
        int disk_magenta_pair = is_even_row ? 36 : 35;
        int disk_red_pair = is_even_row ? 21 : 20;
        int update_pair = is_even_row ? 23 : 22;
        int reboot_pair = is_even_row ? 25 : 24;

        // Frame vertical borders for every row
        attron(A_BOLD | COLOR_PAIR(1));
        mvaddstr(y, 0, "│");
        mvaddstr(y, max_x - 1, "│");
        attroff(A_BOLD | COLOR_PAIR(1));

        if(server_idx < servers.size()) {
            const auto& s = servers[server_idx];

            int current_row_color = (server_idx == selected_row) ? 3 : base_color;
            attron(COLOR_PAIR(current_row_color));

            for (int j = 1; j < max_x - 1; ++j) { mvaddch(y, j, ' '); }
            
            mvprintw(y, 1, "%-3d", s.id);
            mvprintw(y, 5, "%-10.10s", s.nick.c_str());
            mvprintw(y, 16, "%-21.21s", s.canonical_name.c_str());
            mvprintw(y, 38, "%-15s", s.network.ipv4.c_str());
            std::string os_str = s.os.name.empty()
                ? "?"
                : s.os.name.substr(0, 2) + " " + s.os.version;
            mvprintw(y, 54, "%-10.10s", os_str.c_str());
            mvprintw(y, 65, "%-2s", s.hpa.c_str());
            mvprintw(y, 69, "%-22.22s", s.purpose.c_str());
            if (s.monthly_cost_cents > 0)
                mvprintw(y, 92, "%6.2f", (s.monthly_cost_cents / 100.0));
            else
                mvprintw(y, 92, "     ?");
            if (s.specs.cpu_cores > 0)
                mvprintw(y, 99, "%3d", s.specs.cpu_cores);
            else
                mvprintw(y, 99, "  ?");
            if (s.cpu_load_percent >= 0) {
                mvprintw(y, 103, "%4.1f", s.cpu_load_percent);
            }
            mvprintw(y, 108, "%6.3f", s.specs.memory_gb);
            mvprintw(y, 115, "%5.1f", s.specs.swap_gb);
            
            auto draw_disk_col = [&](int col, double pct) {
                if (pct < 0.0) return;
                std::stringstream ds;
                ds << std::fixed << std::setprecision(0) << pct << "%";
                std::string str = ds.str();
                int color = 0;
                if      (pct >= 95.0) color = disk_red_pair;
                else if (pct >= 80.0) color = disk_magenta_pair;
                else if (pct >= 70.0) color = disk_white_pair;
                else if (pct >= 0.0)  color = disk_green_pair;
                if (color > 0) {
                    attron(COLOR_PAIR(color));
                    mvprintw(y, col, "%4s", str.c_str());
                    attron(COLOR_PAIR(current_row_color));
                }
            };
            draw_disk_col(121, s.specs.disk_used_percent);
            draw_disk_col(126, s.specs.disk2_used_percent);
            draw_disk_col(131, s.specs.disk3_used_percent);

            mvprintw(y, 136, "%-15s", format_uptime(s.uptime_seconds).c_str());

            if (s.updates.count > 0) {
                attron(COLOR_PAIR(update_pair));
                mvprintw(y, 153, "(%d)", s.updates.count);
                attron(COLOR_PAIR(current_row_color));
            }

            if (s.reboot_required) {
                attron(COLOR_PAIR(reboot_pair));
                mvprintw(y, 161, "RBT");
                attron(COLOR_PAIR(current_row_color));
            }
        }
        attroff(COLOR_PAIR(base_color));
    }
}

void draw_details_pane(const Server& server, int max_x) {
    int max_y;
    getmaxyx(stdscr, max_y, max_x);
    const int PANE_START_Y = max_y - PANE_MIN_HEIGHT - 1;
    const int PANE_END_Y   = max_y - 2;

    // Disk sub-section box geometry (right 1/3)
    const int box_x  = 2 * max_x / 3;   // left border column of box
    const int box_rx = max_x - 1;        // right border column of box
    // Inner width (between the two border chars)
    const int inner_w = box_rx - box_x - 1;
    // Column widths inside the box: label + device + mount + pct
    const int label_w = 4;
    const int pct_w   = 4;
    const int gap     = 2;   // spaces between each field
    const int flex    = inner_w - label_w - pct_w - gap * 3 - 2; // 2 = leading space + trailing space
    const int dev_w   = std::max(8, flex / 2);
    const int mnt_w   = std::max(5, flex - dev_w);

    // ── Title row (section separator) ────────────────────────────────────────
    attron(A_BOLD | COLOR_PAIR(1));
    mvprintw(PANE_START_Y, 0, "├── DETAILS ");
    move(PANE_START_Y, 12);
    for (int i = 12; i < max_x - 1; ++i) addstr("─");
    mvaddstr(PANE_START_Y, max_x - 1, "┤");
    attroff(A_BOLD | COLOR_PAIR(1));

    // ── Clear content rows with frame borders ────────────────────────────────
    for (int y = PANE_START_Y + 1; y <= PANE_END_Y; ++y) {
        attron(A_BOLD | COLOR_PAIR(1));
        mvaddstr(y, 0, "│");
        mvaddstr(y, max_x - 1, "│");
        attroff(A_BOLD | COLOR_PAIR(1));
        for (int x = 1; x < max_x - 1; ++x)
            mvaddch(y, x, ' ');
    }

    // ── Left section: server info ─────────────────────────────────────────────
    char cost_buf[64];
    if (server.monthly_cost_cents > 0)
        snprintf(cost_buf, sizeof(cost_buf), "%.2f %s/mo",
                 server.monthly_cost_cents / 100.0, server.cost_currency.c_str());
    else
        snprintf(cost_buf, sizeof(cost_buf), "?");

    mvprintw(PANE_START_Y + 2, 2,  "  Nickname      : %-20s", server.nick.c_str());
    mvprintw(PANE_START_Y + 2, 46, "  Canonical Name: %s",    server.canonical_name.c_str());
    mvprintw(PANE_START_Y + 3, 2,  "  IP Address    : %-20s", server.network.ipv4.c_str());
    mvprintw(PANE_START_Y + 3, 46, "  Purpose       : %s",    server.purpose.c_str());
    mvprintw(PANE_START_Y + 4, 2,  "  OS            : %s %s", server.os.name.c_str(), server.os.version.c_str());
    mvprintw(PANE_START_Y + 4, 46, "  Reboot Req    : %s",    server.reboot_required ? "Yes" : "No");
    mvprintw(PANE_START_Y + 5, 2,  "  ISP           : %-20s", server.provider.c_str());
    mvprintw(PANE_START_Y + 5, 46, "  HPA Code      : %s",    server.hpa.c_str());
    mvprintw(PANE_START_Y + 6, 2,  "  Cost          : %s",    cost_buf);
    mvprintw(PANE_START_Y + 7, 2,  "  CPU Cores     : %d",    server.specs.cpu_cores);
    mvprintw(PANE_START_Y + 7, 46, "  Memory        : %.3f GB", server.specs.memory_gb);
    mvprintw(PANE_START_Y + 8, 2,  "  Swap          : %.3f GB", server.specs.swap_gb);

    // ── DISK SPACE sub-section (right 1/3, no box) ───────────────────────────
    const int DISK_HDR = PANE_START_Y + 2;

    attron(A_BOLD | COLOR_PAIR(1));
    mvprintw(DISK_HDR, box_x + 1, "DISK SPACE");
    attroff(A_BOLD | COLOR_PAIR(1));

    // ── Disk rows: label | pct | device | mount ───────────────────────────────
    struct DiskSlot {
        const char*        label;
        double             pct;
        const std::string* device;
        const std::string* mount;
    };
    const DiskSlot slots[3] = {
        { "DSK1", server.specs.disk_used_percent,  &server.specs.disk1_device, &server.specs.disk1_mount },
        { "DSK2", server.specs.disk2_used_percent, &server.specs.disk2_device, &server.specs.disk2_mount },
        { "DSK3", server.specs.disk3_used_percent, &server.specs.disk3_device, &server.specs.disk3_mount },
    };

    for (int d = 0; d < 3; ++d) {
        const int row    = DISK_HDR + 1 + d;
        const auto& slot = slots[d];
        int cx           = box_x + 1;

        // Label (bold)
        attron(A_BOLD);
        mvprintw(row, cx, " %-*s", label_w, slot.label);
        attroff(A_BOLD);
        cx += 1 + label_w + gap;

        if (slot.pct < 0.0 || slot.device->empty()) {
            mvprintw(row, cx, "%-*s", dev_w, "(none)");
            continue;
        }

        // Percentage: color-coded, immediately after label
        int dcolor = 0;
        if      (slot.pct >= 95.0) dcolor = 15;
        else if (slot.pct >= 80.0) dcolor = 13;
        else if (slot.pct >= 70.0) dcolor = 14;
        else if (slot.pct >= 0.0)  dcolor = 12;

        char pct_str[8];
        snprintf(pct_str, sizeof(pct_str), "%3.0f%%", slot.pct);
        if (dcolor) attron(COLOR_PAIR(dcolor) | A_BOLD);
        mvprintw(row, cx, "%-*s", pct_w, pct_str);
        if (dcolor) attroff(COLOR_PAIR(dcolor) | A_BOLD);
        cx += pct_w + gap;

        // Device name (truncated)
        mvprintw(row, cx, "%-*.*s", dev_w, dev_w, slot.device->c_str());
        cx += dev_w + gap;

        // Mount point (truncated)
        mvprintw(row, cx, "%-*.*s", mnt_w, mnt_w, slot.mount->c_str());
    }
}

void draw_summary(const std::vector<Server>& servers, int max_y, int max_x) {
    const int y0 = max_y - PANE_MIN_HEIGHT - 1 - SUMMARY_HEIGHT;  // separator row
    const int y1 = y0 + 1;                                          // data row
    const int y2 = y0 + 2;                                          // blank spacer

    // Sum only servers with a known cost
    long total_cents = 0;
    bool any_cost_known = false;
    for (const auto& s : servers) {
        if (s.monthly_cost_cents > 0) {
            total_cents += s.monthly_cost_cents;
            any_cost_known = true;
        }
    }

    attron(A_BOLD | COLOR_PAIR(1));

    // y0: section separator
    mvprintw(y0, 0, "├── COST TOTAL ");
    move(y0, 15);
    for (int x = 15; x < max_x - 1; ++x) addstr("─");
    mvaddstr(y0, max_x - 1, "┤");

    // y1, y2: clear interior with frame borders
    for (int y = y1; y <= y2; ++y) {
        mvaddstr(y, 0, "│");
        move(y, 1);
        for (int x = 1; x < max_x - 1; ++x) addch(' ');
        mvaddstr(y, max_x - 1, "│");
    }

    // Total value right-aligned at column 97 (matching individual cost cells: %6.2f at col 92)
    if (any_cost_known)
        mvprintw(y1, 92, "%6.2f /mo", total_cents / 100.0);
    else
        mvprintw(y1, 92, "     ? /mo");

    attroff(A_BOLD | COLOR_PAIR(1));
}

void draw_footer(int max_y, int max_x, bool is_loading, size_t displayed, size_t total) {
    attron(A_BOLD | COLOR_PAIR(1));

    // Bottom frame border: └ ... ┘
    move(max_y - 1, 0);
    addstr("└");
    for (int i = 1; i < max_x - 1; ++i) addch(' ');
    mvaddstr(max_y - 1, max_x - 1, "┘");

    const char* help_text = " ENTER: Edit | A/+: Add | d: Delete | s: Sort | r/R: Check | ARROWS: Navigate | q: Quit";
    const char* version_text = "vpsmc v0.213";

    char count_buf[20];
    snprintf(count_buf, sizeof(count_buf), "[%zu/%zu]", displayed, total);

    mvprintw(max_y - 1, 1, "%s", help_text);

    int version_pos = max_x - strlen(version_text) - 6;
    mvprintw(max_y - 1, version_pos, "%s", version_text);

    int count_pos = version_pos - strlen(count_buf) - 2;
    mvprintw(max_y - 1, count_pos, "%s", count_buf);

    if (is_loading) {
        attron(COLOR_PAIR(11)); // Orange foreground
        mvaddwstr(max_y - 1, max_x - 3, L"🟠");
        attroff(COLOR_PAIR(11));
    } else {
        attron(COLOR_PAIR(12)); // Green foreground
        mvaddwstr(max_y - 1, max_x - 3, L"✅");
        attroff(COLOR_PAIR(12));
    }

    // Redraw closing corner in case emoji rendering advanced past it
    attron(A_BOLD | COLOR_PAIR(1));
    mvaddstr(max_y - 1, max_x - 1, "┘");

    attroff(A_BOLD | COLOR_PAIR(1));
    refresh();
}

// --- MAIN DRAW FUNCTION ---
// draw_header: only needed on startup, sort change, or terminal resize
void redraw_dynamic_content(std::vector<Server>& servers, size_t start_row, size_t selected_row,
                            bool draw_header) {
    int max_x;
    getmaxyx(stdscr, max_x, max_x);

    for(auto& s : servers) {
        if (s.uptime_seconds > 0 && s.specs.cpu_cores > 0) {
            double total_time = s.uptime_seconds * s.specs.cpu_cores;
            double busy_time = total_time - s.idle_seconds;
            s.cpu_load_percent = (busy_time / total_time) * 100.0;
        } else {
            s.cpu_load_percent = -1.0;
        }
    }

    if (draw_header) {
        draw_static_header(max_x);
        update_sort_indicator();
    }

    int max_y;
    getmaxyx(stdscr, max_y, max_x);

    draw_server_list(servers, start_row, selected_row, max_x);
    draw_summary(servers, max_y, max_x);
    // Details pane is NOT drawn here — the main loop draws it only when the
    // input queue is empty so rapid navigation never triggers a details redraw.
    refresh();
}

void show_error_popup(const std::string& message) {
    int max_y, max_x;
    getmaxyx(stdscr, max_y, max_x);
    int height = 5, width = message.length() + 6;
    int start_y = (max_y - height) / 2;
    int start_x = (max_x - width) / 2;

    WINDOW* win = newwin(height, width, start_y, start_x);
    wbkgd(win, COLOR_PAIR(2)); // Use error color scheme
    box(win, 0, 0);
    mvwprintw(win, 2, 3, "%s", message.c_str());
    wrefresh(win);
    timeout(-1);
    getch();
    timeout(200);
    delwin(win);
}

// Returns true if confirmed; sets reason_out to the entered reason (empty = none given).
// ESC or empty+Enter without 'y' confirmation cancels.
bool confirm_delete_popup(const std::string& nick, std::string& reason_out) {
    int max_y, max_x;
    getmaxyx(stdscr, max_y, max_x);
    const int width = 56, height = 10;
    int start_y = (max_y - height) / 2;
    int start_x = (max_x - width) / 2;

    WINDOW* win = newwin(height, width, start_y, start_x);
    keypad(win, TRUE);
    wbkgd(win, COLOR_PAIR(2));
    box(win, 0, 0);

    wattron(win, A_BOLD | COLOR_PAIR(2));
    mvwprintw(win, 1, (width - 14) / 2, "DELETE SERVER");
    wattroff(win, A_BOLD | COLOR_PAIR(2));

    mvwprintw(win, 3, 3, "Remove '%s' from the list?", nick.c_str());
    mvwprintw(win, 5, 3, "Reason: ");
    mvwprintw(win, 8, 3, "ENTER to confirm,  ESC to cancel");
    wrefresh(win);

    char reason_buf[80] = {};
    bool confirmed = get_string_input(win, 5, 11, reason_buf, sizeof(reason_buf));

    delwin(win);
    touchwin(stdscr);

    if (confirmed) reason_out = reason_buf;
    return confirmed;
}

void show_sort_popup(SortKey& key, bool& ascending) {
    int max_y, max_x;
    getmaxyx(stdscr, max_y, max_x);
    int height = 18, width = 54;
    int start_y = (max_y - height) / 2;
    int start_x = (max_x - width) / 2;

    WINDOW* win = newwin(height, width, start_y, start_x);
    wbkgd(win, COLOR_PAIR(1));
    box(win, 0, 0);

    wattron(win, A_BOLD | COLOR_PAIR(1));
    mvwprintw(win, 1, (width - 17) / 2, "Select Sort Key");
    wattroff(win, A_BOLD | COLOR_PAIR(1));
    
    const std::vector<std::tuple<const char*, char, SortKey>> sort_options = {
        {"ID", 'I', SortKey::ID}, {"Nickname", 'N', SortKey::NICKNAME},
        {"Canonical Name", 'L', SortKey::CANONICAL_NAME}, {"IP Address", 'A', SortKey::IP_ADDRESS},
        {"OS", 'O', SortKey::OS}, {"Company/HPC", 'G', SortKey::COMPANY},
        {"Purpose", 'M', SortKey::PURPOSE}, {"Cost", 'C', SortKey::COST},
        {"CPU Cores", 'U', SortKey::CPU}, {"Processor Load", 'P', SortKey::LOAD},
        {"Memory", 'R', SortKey::MEM}, {"Swap", 'W', SortKey::SWAP},
        {"Disk", 'D', SortKey::DISK}, {"Uptime", 'T', SortKey::UPTIME},
        {"Updates", 'S', SortKey::UPDATES}, {"Reboot", 'B', SortKey::REBOOT}
    };

    for(size_t i=0; i < 8; ++i) { // Loop for 8 rows
        int row_color = (i % 2 != 0) ? 9 : 10;
        wattron(win, COLOR_PAIR(row_color));
        int row = 3 + i;
        mvwprintw(win, row, 1, "%*s", width - 2, ""); 

        if (i < sort_options.size()) {
            char left_buf[30];
            snprintf(left_buf, sizeof(left_buf), "%2ld. %s (%c)", i+1, std::get<0>(sort_options[i]), std::get<1>(sort_options[i]));
            mvwprintw(win, row, 2, "%-25s", left_buf);
        }
        
        if (i + 8 < sort_options.size()) {
            char right_buf[30];
            snprintf(right_buf, sizeof(right_buf), "%2ld. %s (%c)", i+9, std::get<0>(sort_options[i+8]), std::get<1>(sort_options[i+8]));
            mvwprintw(win, row, 28, "%-25s", right_buf);
        }
        wattroff(win, COLOR_PAIR(row_color));
    }
    
    wattron(win, A_BOLD | COLOR_PAIR(1));
    mvwprintw(win, height - 2, 2, "Press letter or number & ENTER, or q to close.");
    wattroff(win, A_BOLD | COLOR_PAIR(1));

    wrefresh(win);

    int ch;
    std::string num_buffer;
    while(true) {
        ch = wgetch(win);
        if (isdigit(ch)) {
            if (num_buffer.length() < 2) {
                num_buffer += ch;
                wattron(win, A_BOLD | COLOR_PAIR(1));
                mvwprintw(win, height - 2, 48, "[%-2s]", num_buffer.c_str());
                wattroff(win, A_BOLD | COLOR_PAIR(1));
                wrefresh(win);
            }
            continue;
        }

        SortKey new_key = key;
        bool key_found = false;

        if (ch == '\n' || ch == KEY_ENTER) {
            if (!num_buffer.empty()) {
                int num = std::stoi(num_buffer);
                if (num >= 1 && (size_t)num <= sort_options.size()) {
                    new_key = std::get<2>(sort_options[num - 1]);
                    key_found = true;
                }
            }
        } else if (isalpha(ch)) {
            ch = toupper(ch);
            for(const auto& opt : sort_options) {
                if(std::get<1>(opt) == ch) {
                    new_key = std::get<2>(opt);
                    key_found = true;
                    break;
                }
            }
        } else if (ch == 'q' || ch == 's') {
             delwin(win); touchwin(stdscr); refresh(); return;
        }

        if (key_found) {
            if (new_key == key) {
                ascending = !ascending;
            } else {
                key = new_key;
                switch (new_key) {
                    case SortKey::COST:
                    case SortKey::CPU:
                    case SortKey::LOAD:
                    case SortKey::MEM:
                    case SortKey::SWAP:
                    case SortKey::DISK:
                    case SortKey::DISK2:
                    case SortKey::DISK3:
                    case SortKey::UPTIME:
                    case SortKey::UPDATES:
                        ascending = false; // Default to descending for these
                        break;
                    default:
                        ascending = true; // Default to ascending for others
                        break;
                }
            }
        }
        delwin(win); touchwin(stdscr); refresh();
        return;
    }
}

// --- First-Run Wizard (shown when servers.json is missing or empty) ---

struct SshConfigHost {
    std::string nick;
    std::string hostname;
    std::string user;
    int port = 22;
};

static std::vector<SshConfigHost> parse_ssh_config() {
    std::vector<SshConfigHost> hosts;
    std::ifstream file(expand_path("~/.ssh/config"));
    if (!file.is_open()) return hosts;

    SshConfigHost current;
    bool in_host = false;
    std::string line;

    while (std::getline(file, line)) {
        size_t start = line.find_first_not_of(" \t");
        if (start == std::string::npos || line[start] == '#') continue;
        line = line.substr(start);

        size_t sp = line.find_first_of(" \t=");
        std::string key = (sp == std::string::npos) ? line : line.substr(0, sp);
        std::string val;
        if (sp != std::string::npos) {
            size_t vs = line.find_first_not_of(" \t=", sp);
            if (vs != std::string::npos) {
                val = line.substr(vs);
                size_t ve = val.find_last_not_of(" \t\r");
                if (ve != std::string::npos) val = val.substr(0, ve + 1);
            }
        }
        std::string lkey = key;
        std::transform(lkey.begin(), lkey.end(), lkey.begin(), ::tolower);

        if (lkey == "host") {
            // Save previous host if it was a plain alias (no wildcards or spaces)
            if (in_host && current.nick.find_first_of("*? ") == std::string::npos)
                hosts.push_back(current);
            current = SshConfigHost();
            current.nick = val;
            in_host = true;
        } else if (in_host) {
            if      (lkey == "hostname") current.hostname = val;
            else if (lkey == "user")     current.user = val;
            else if (lkey == "port")     { try { current.port = std::stoi(val); } catch (...) {} }
        }
    }
    if (in_host && current.nick.find_first_of("*? ") == std::string::npos)
        hosts.push_back(current);
    return hosts;
}

// Scrollable checklist of SSH config hosts. Returns indices of selected entries.
static std::vector<int> show_ssh_host_selector(const std::vector<SshConfigHost>& hosts) {
    int max_y, max_x;
    getmaxyx(stdscr, max_y, max_x);

    const int list_max = (int)hosts.size();
    const int h        = std::min(list_max + 7, max_y - 4);
    const int w        = std::min(70, max_x - 4);
    const int list_h   = h - 6;
    WINDOW* win = newwin(h, w, (max_y - h) / 2, (max_x - w) / 2);
    keypad(win, TRUE);
    wbkgd(win, COLOR_PAIR(1));

    std::vector<bool> selected(hosts.size(), false);
    int cursor = 0, scroll_off = 0;

    while (true) {
        box(win, 0, 0);
        wattron(win, A_BOLD | COLOR_PAIR(1));
        const char* title = "Import from ~/.ssh/config";
        mvwprintw(win, 1, (w - (int)strlen(title)) / 2, "%s", title);
        wattroff(win, A_BOLD | COLOR_PAIR(1));
        mvwprintw(win, 2, 2, "SPACE:toggle  j/k:move  a:all  ENTER:import  ESC:cancel");

        for (int i = 0; i < list_h; ++i) {
            int idx = scroll_off + i;
            int row = 4 + i;
            mvwprintw(win, row, 1, "%*s", w - 2, "");
            if (idx >= list_max) continue;
            bool cur = (idx == cursor);
            if (cur) wattron(win, COLOR_PAIR(3) | A_BOLD);
            const char* hname = hosts[idx].hostname.empty()
                                    ? hosts[idx].nick.c_str()
                                    : hosts[idx].hostname.c_str();
            mvwprintw(win, row, 2, "[%c] %-16.16s  %-28.28s",
                      selected[idx] ? 'x' : ' ', hosts[idx].nick.c_str(), hname);
            if (cur) wattroff(win, COLOR_PAIR(3) | A_BOLD);
        }

        int sel_count = (int)std::count(selected.begin(), selected.end(), true);
        mvwprintw(win, h - 2, 2, "%d of %d selected   ", sel_count, list_max);
        wrefresh(win);

        int ch = wgetch(win);
        switch (ch) {
            case KEY_DOWN: case 'j':
                if (cursor < list_max - 1) { ++cursor; if (cursor >= scroll_off + list_h) ++scroll_off; }
                break;
            case KEY_UP: case 'k':
                if (cursor > 0) { --cursor; if (cursor < scroll_off) --scroll_off; }
                break;
            case ' ':
                selected[cursor] = !selected[cursor];
                break;
            case 'a': case 'A': {
                bool all = std::all_of(selected.begin(), selected.end(), [](bool b){ return b; });
                std::fill(selected.begin(), selected.end(), !all);
                break;
            }
            case '\n': case KEY_ENTER: {
                std::vector<int> result;
                for (int i = 0; i < list_max; ++i)
                    if (selected[i]) result.push_back(i);
                delwin(win); touchwin(stdscr); refresh();
                return result;
            }
            case 27: case 'q': case 'Q':
                delwin(win); touchwin(stdscr); refresh();
                return {};
        }
    }
}

// Welcome dialog loop. Returns servers to use; empty means the user chose to quit.
static std::vector<Server> run_first_run_wizard(const Config& config) {
    std::vector<Server> servers;
    int max_y, max_x;

    while (servers.empty()) {
        getmaxyx(stdscr, max_y, max_x);
        const int h = 14, w = 62;
        WINDOW* win = newwin(h, w, (max_y - h) / 2, (max_x - w) / 2);
        wbkgd(win, COLOR_PAIR(1));
        box(win, 0, 0);

        wattron(win, A_BOLD | COLOR_PAIR(1));
        const char* title = "VPS Master Control";
        mvwprintw(win, 1, (w - (int)strlen(title)) / 2, "%s", title);
        wattroff(win, A_BOLD | COLOR_PAIR(1));

        mvwprintw(win, 3, 3, "No server data found at:");
        mvwprintw(win, 4, 5, "%-52.52s", config.servers_json_path.c_str());
        mvwprintw(win, 6, 3, "How would you like to get started?");

        wattron(win, A_BOLD | COLOR_PAIR(1));
        mvwprintw(win,  8, 5, "i");
        mvwprintw(win,  9, 5, "a");
        mvwprintw(win, 11, 5, "q");
        wattroff(win, A_BOLD | COLOR_PAIR(1));
        mvwprintw(win,  8, 8, "Import hosts from ~/.ssh/config");
        mvwprintw(win,  9, 8, "Add a server manually");
        mvwprintw(win, 11, 8, "Quit");

        wrefresh(win);
        int ch = wgetch(win);
        delwin(win);
        touchwin(stdscr);
        refresh();

        if (ch == 'q' || ch == 'Q' || ch == 27) return servers; // empty = quit

        if (ch == 'i' || ch == 'I') {
            auto ssh_hosts = parse_ssh_config();
            if (ssh_hosts.empty()) {
                show_error_popup("No Host entries found in ~/.ssh/config.");
            } else {
                auto idxs = show_ssh_host_selector(ssh_hosts);
                int next_id = 1;
                for (int idx : idxs) {
                    const auto& h = ssh_hosts[idx];
                    Server s;
                    s.id   = next_id++;
                    s.nick = h.nick;
                    // If HostName looks like an IPv4 address, store it as the IP.
                    // Otherwise use it as the canonical name (fetch_canonical_name will
                    // verify/overwrite it from the server itself on first connect).
                    bool is_ip = !h.hostname.empty()
                                 && h.hostname.find_first_not_of("0123456789.") == std::string::npos
                                 && h.hostname.find('.') != std::string::npos;
                    if (is_ip)
                        s.network.ipv4 = h.hostname;
                    else
                        s.canonical_name = h.hostname.empty() ? h.nick : h.hostname;
                    s.status            = "unknown";
                    s.reboot_required   = false;
                    s.uptime_seconds    = -1.0;
                    s.idle_seconds      = -1.0;
                    s.cpu_load_percent  = -1.0;
                    s.is_checking       = false;
                    s.specs.disk_used_percent  = -1.0;
                    s.specs.disk2_used_percent = -1.0;
                    s.specs.disk3_used_percent = -1.0;
                    servers.push_back(s);
                }
            }
        } else if (ch == 'a' || ch == 'A') {
            Server s;
            s.id                = 1;
            s.uptime_seconds    = -1.0;
            s.idle_seconds      = -1.0;
            s.cpu_load_percent  = -1.0;
            s.is_checking       = false;
            s.specs.disk_used_percent  = -1.0;
            s.specs.disk2_used_percent = -1.0;
            s.specs.disk3_used_percent = -1.0;
            if (edit_server(s, true)) servers.push_back(s);
            // If cancelled, loop back to welcome screen
        }
    }
    return servers;
}

int main(int argc, char* argv[]) {
    setenv("TERM", "xterm-256color", 1);
    setlocale(LC_ALL, "en_US.UTF-8");

    if (!load_config(config)) {
        return 1;
    }

    if (argc > 1 && (strcmp(argv[1], "-v") == 0 || strcmp(argv[1], "--version") == 0)) {
        std::cout << "vpsmc v0.213" << std::endl;
        return 0;
    }
    
    mkdir(config.log_directory_path.c_str(), 0755);

    initscr();
    cbreak();
    noecho();
    keypad(stdscr, TRUE);
    set_escdelay(25);     // reduce ESC recognition lag (default is 1000ms)
    curs_set(0);          
    
    if (has_colors()) {
        start_color();
        init_pair(1, 255, 24); init_pair(2, 255, 196); init_pair(3, 16, 226);
        init_pair(4, 255, 16); init_pair(5, 0, 81); init_pair(6, 0, 51);
        init_pair(7, 16, 208); init_pair(8, 0, 244); 
        init_pair(9, 0, 230); init_pair(10, 0, 251);
        use_default_colors();
        init_pair(11, 208, -1); // Orange foreground
        init_pair(12,  46, -1); // Green foreground (disk ok)
        init_pair(13, 198, -1); // Magenta (disk high)
        init_pair(14, 255, -1); // Bright white (disk moderate)
        init_pair(15, 196, -1); // Red (disk critical)
        init_pair(16, 22, 81); // Dark Green on light
        init_pair(17, 22, 51); // Dark Green on dark
        init_pair(20, 196, 81); // Red on light
        init_pair(21, 196, 51); // Red on dark
        init_pair(22, 16, 81); // Yellow on light
        init_pair(23, 16, 51); // Yellow on dark
        init_pair(24, 255, 196); // White on Red
        init_pair(25, 255, 196); 
        init_pair(33, 255, 81); // White on light
        init_pair(34, 255, 51); // White on dark
        init_pair(35, 198, 81); // Magenta on light
        init_pair(36, 198, 51); // Magenta on dark
    }
    
    int max_y, max_x;
    getmaxyx(stdscr, max_y, max_x);
    
    draw_static_header(max_x);
    update_sort_indicator();
    draw_footer(max_y, max_x, true, 0, 0);
    
    auto servers = loadServers(config.servers_json_path);
    if (servers.empty()) {
        servers = run_first_run_wizard(config);
        if (servers.empty()) {
            endwin();
            return 0;
        }
        save_servers(config.servers_json_path, servers);
    }
    
    sort_servers(servers, current_sort_key, sort_ascending);
    redraw_dynamic_content(servers, 0, 0);
    
    for (auto& server : servers) {
        launch_all_dynamic_data_threads(server);
    }
    
    size_t start_row = 0;
    size_t selected_row = 0;
    bool header_dirty = true;  // draw header on first frame

    // Key handler lambda — updates state, returns false on quit
    const int display_rows = max_y - PANE_MIN_HEIGHT - 1 - SUMMARY_HEIGHT - LIST_START_Y;

    auto handle_key = [&](int ch) -> bool {
        data_changed = true;
        switch (ch) {
            case 'j': case KEY_DOWN:
                if (selected_row < servers.size() - 1) {
                    selected_row++;
                    if (selected_row >= start_row + display_rows)
                        start_row = selected_row - display_rows + 1;
                }
                break;
            case 'k': case KEY_UP:
                if (selected_row > 0) {
                    selected_row--;
                    if (selected_row < start_row)
                        start_row = selected_row;
                }
                break;
            case KEY_ENTER: case '\n':
                if(edit_server(servers[selected_row]))
                    save_servers(config.servers_json_path, servers);
                touchwin(stdscr);
                header_dirty = true;
                break;
            case 'd': case KEY_DC:
                if (!servers.empty() && selected_row < servers.size()) {
                    std::string reason;
                    const Server& del_srv = servers[selected_row];
                    if (confirm_delete_popup(del_srv.nick, reason)) {
                        std::string log_msg = "DELETED server '" + del_srv.nick +
                            "' (" + del_srv.canonical_name + ", " + del_srv.network.ipv4 + ")";
                        if (!reason.empty()) log_msg += " -- Reason: " + reason;
                        log_message(config.log_directory_path, "ADMIN", log_msg);
                        {
                            std::lock_guard<std::mutex> lock(server_mutex);
                            servers.erase(servers.begin() + selected_row);
                        }
                        if (selected_row >= servers.size() && selected_row > 0)
                            selected_row = servers.size() - 1;
                        if (start_row > selected_row)
                            start_row = selected_row;
                        save_servers(config.servers_json_path, servers);
                    }
                    touchwin(stdscr);
                    header_dirty = true;
                }
                break;
            case 'a': case 'A': case '+':
                {
                    Server new_server;
                    if(edit_server(new_server, true)) {
                        std::lock_guard<std::mutex> lock(server_mutex);
                        int max_id = 0;
                        for(const auto& s : servers) {
                            if (s.id > max_id) max_id = s.id;
                        }
                        new_server.id = max_id + 1;
                        servers.push_back(new_server);
                        save_servers(config.servers_json_path, servers);
                        launch_all_dynamic_data_threads(servers.back());
                    }
                    touchwin(stdscr);
                    header_dirty = true;
                }
                break;
            case 's': case 'S':
                show_sort_popup(current_sort_key, sort_ascending);
                sort_servers(servers, current_sort_key, sort_ascending);
                header_dirty = true;
                break;
            case 'r':
                if (selected_row < servers.size())
                    launch_all_dynamic_data_threads(servers[selected_row]);
                touchwin(stdscr);
                break;
            case 'R':
                {
                    std::lock_guard<std::mutex> lock(server_mutex);
                    for (auto& server : servers)
                        launch_all_dynamic_data_threads(server);
                }
                break;
            case KEY_RESIZE:
                clear();
                getmaxyx(stdscr, max_y, max_x);
                header_dirty = true;
                break;
            case 'q': case 'Q':
                endwin();
                return false;
        }
        return true;
    };

    bool details_dirty = true;  // details pane needs a draw

    while (true) {
        // --- List redraw (cheap: header + rows + summary, NO details pane) ---
        if (data_changed) {
            std::lock_guard<std::mutex> lock(server_mutex);
            redraw_dynamic_content(servers, start_row, selected_row, header_dirty);
            draw_footer(max_y, max_x, (running_threads > 0), servers.size(), servers.size());
            header_dirty = false;
            data_changed = false;
            details_dirty = true;
        }

        // --- Drain all queued keypresses in one pass ---
        nodelay(stdscr, TRUE);
        int ch;
        while ((ch = getch()) != ERR) {
            if (!handle_key(ch)) return 0;
        }
        nodelay(stdscr, FALSE);

        if (data_changed) continue;  // key(s) changed state; redraw list first

        // --- Idle: input queue empty, now draw the details pane ---
        // This is the expensive draw (~2700 chars). We only reach here when the
        // user has stopped pressing keys, so navigation feels instant.
        if (details_dirty && selected_row < servers.size()) {
            {
                std::lock_guard<std::mutex> lock(server_mutex);
                draw_details_pane(servers[selected_row], max_x);
                refresh();
            }
            details_dirty = false;

            // The details draw can take ~50 ms. Drain any keys that arrived
            // during it so they are not delayed by the idle wait below.
            nodelay(stdscr, TRUE);
            while ((ch = getch()) != ERR) {
                if (!handle_key(ch)) return 0;
            }
            nodelay(stdscr, FALSE);
            if (data_changed) continue;
        }

        // --- Wait up to 25 ms for next event (background data updates) ---
        // 25 ms is imperceptible to users but ensures "Fetching" labels and
        // other live data clear as soon as the background thread finishes.
        timeout(25);
        ch = getch();
        timeout(-1);
        if (ch != ERR) {
            if (!handle_key(ch)) return 0;
        }
    }
    
    endwin();
    return 0;
}

// --- Sorting Logic ---
std::string trim_string(const std::string& str) {
    const auto strBegin = str.find_first_not_of(" \t");
    if (strBegin == std::string::npos)
        return ""; // no content
    const auto strEnd = str.find_last_not_of(" \t");
    const auto strRange = strEnd - strBegin + 1;
    return str.substr(strBegin, strRange);
}

std::vector<std::string> split_purpose(const std::string& purpose_str) {
    std::vector<std::string> purposes;
    std::stringstream ss(purpose_str);
    std::string item;
    while (std::getline(ss, item, ',')) {
        purposes.push_back(trim_string(item));
    }
    return purposes;
}

unsigned long ip_to_long(const std::string& ip_str) {
    unsigned long res = 0;
    std::stringstream ss(ip_str);
    std::string segment;
    int shift = 24;
    while(std::getline(ss, segment, '.')) {
        try {
            res |= std::stoi(segment) << shift;
        } catch (...) { /* ignore invalid segments */ }
        shift -= 8;
    }
    return res;
}

void sort_servers(std::vector<Server>& servers, SortKey key, bool ascending) {
    std::stable_sort(servers.begin(), servers.end(), [&](const Server& a, const Server& b) {
        bool result = false;
        
        auto ci_less = [](const std::string& s1, const std::string& s2) {
            std::string s1_lower = s1;
            std::string s2_lower = s2;
            std::transform(s1_lower.begin(), s1_lower.end(), s1_lower.begin(),
                           [](unsigned char c){ return std::tolower(c); });
            std::transform(s2_lower.begin(), s2_lower.end(), s2_lower.begin(),
                           [](unsigned char c){ return std::tolower(c); });
            return s1_lower < s2_lower;
        };

        switch(key) {
            case SortKey::ID:             result = a.id < b.id; break;
            case SortKey::NICKNAME:       result = ci_less(a.nick, b.nick); break;
            case SortKey::CANONICAL_NAME: result = ci_less(a.canonical_name, b.canonical_name); break;
            case SortKey::PURPOSE:
                {
                    auto purposes_a = split_purpose(a.purpose);
                    auto purposes_b = split_purpose(b.purpose);
                    result = std::lexicographical_compare(purposes_a.begin(), purposes_a.end(),
                                                          purposes_b.begin(), purposes_b.end());
                }
                break;
            case SortKey::COMPANY:        result = a.hpa < b.hpa; break;
            case SortKey::COST:           result = a.monthly_cost_cents < b.monthly_cost_cents; break;
            case SortKey::CPU:            result = a.specs.cpu_cores < b.specs.cpu_cores; break;
            case SortKey::LOAD:           result = a.cpu_load_percent < b.cpu_load_percent; break;
            case SortKey::MEM:            result = a.specs.memory_gb < b.specs.memory_gb; break;
            case SortKey::SWAP:           result = a.specs.swap_gb < b.specs.swap_gb; break;
            case SortKey::DISK:           result = a.specs.disk_used_percent  < b.specs.disk_used_percent;  break;
            case SortKey::DISK2:          result = a.specs.disk2_used_percent < b.specs.disk2_used_percent; break;
            case SortKey::DISK3:          result = a.specs.disk3_used_percent < b.specs.disk3_used_percent; break;
            case SortKey::IP_ADDRESS:     result = ip_to_long(a.network.ipv4) < ip_to_long(b.network.ipv4); break;
            case SortKey::OS:             result = (a.os.name + a.os.version) < (b.os.name + b.os.version); break;
            case SortKey::UPDATES:        result = a.updates.count < b.updates.count; break;
            case SortKey::REBOOT:         result = a.reboot_required < b.reboot_required; break;
            case SortKey::UPTIME:
                {
                    double uptime_a = (a.uptime_seconds < 0) ? std::numeric_limits<double>::max() : a.uptime_seconds;
                    double uptime_b = (b.uptime_seconds < 0) ? std::numeric_limits<double>::max() : b.uptime_seconds;
                    result = uptime_a < uptime_b;
                }
                break;
        }
        return ascending ? result : !result;
    });
}


// --- Other Function Implementations ---

void launch_all_dynamic_data_threads(Server& server) {
    if (server.is_checking) return;
    server.is_checking = true;

    running_threads++;
    std::thread([&](){ fetch_ssh_user(&server, &server_mutex); running_threads--; data_changed = true; }).detach();
    running_threads++;
    std::thread([&](){ fetch_uptime(&server, &server_mutex); running_threads--; data_changed = true; }).detach();
    running_threads++;
    std::thread([&](){ fetch_cpu_cores(&server, &server_mutex); running_threads--; data_changed = true; }).detach();
    running_threads++;
    std::thread([&](){ fetch_os_info(&server, &server_mutex); running_threads--; data_changed = true; }).detach();
    running_threads++;
    std::thread([&](){ check_server_status(&server, &server_mutex, config); running_threads--; data_changed = true; }).detach();
    running_threads++;
    std::thread([&](){ fetch_canonical_name(&server, &server_mutex); running_threads--; data_changed = true; }).detach();
    running_threads++;
    std::thread([&](){ fetch_swap_info(&server, &server_mutex); running_threads--; data_changed = true; }).detach();
    running_threads++;
    std::thread([&](){ fetch_disk_info(&server, &server_mutex); running_threads--; data_changed = true; }).detach();
}


// Returns true if input was confirmed (Enter), false if cancelled (ESC).
// Uses per-character mvwaddch updates so only ~1 byte is sent to the terminal
// per keystroke instead of rewriting the entire field.
bool get_string_input(WINDOW* win, int y, int x, char* buffer, int size) {
    curs_set(1);
    keypad(win, TRUE);

    int len = (int)strnlen(buffer, size - 1);
    // Initial full display of any pre-existing value, then park cursor
    mvwprintw(win, y, x, "%-40s", buffer);
    wmove(win, y, x + len);
    wrefresh(win);

    bool confirmed = false;
    while (true) {
        int ch = wgetch(win);
        if (ch == 27) {
            break;
        } else if (ch == KEY_ENTER || ch == '\n') {
            confirmed = true;
            break;
        } else if (ch == KEY_BACKSPACE || ch == 127 || ch == '\b') {
            if (len > 0) {
                --len;
                buffer[len] = '\0';
                // Erase the one character that was deleted, reposition cursor
                mvwaddch(win, y, x + len, ' ');
                wmove(win, y, x + len);
                wrefresh(win);
            }
        } else if (ch >= 32 && ch < 127 && len < size - 1) {
            buffer[len] = (char)ch;
            buffer[++len] = '\0';
            // Write the one new character, cursor advances automatically
            mvwaddch(win, y, x + len - 1, (chtype)ch);
            wmove(win, y, x + len);
            wrefresh(win);
        }
    }

    curs_set(0);
    return confirmed;
}

bool edit_server(Server& server, bool is_adding) {
    int max_y, max_x;
    getmaxyx(stdscr, max_y, max_x);
    int height = 22, width = 70;
    int start_y = (max_y - height) / 2, start_x = (max_x - width) / 2;
    WINDOW* edit_win = newwin(height, width, start_y, start_x);
    keypad(edit_win, TRUE);
    wbkgd(edit_win, COLOR_PAIR(1));

    std::vector<std::string> labels = {
        "Nickname:", "Canonical Name:", "IP Address:", "Purpose:", "OS Name:", "OS Version:",
        "ISP:", "HPA Code:", "Cost (cents):", "Currency:", "CPU Cores:", "Memory (GB):", "Swap (GB):",
        "Disk 1 (% Used):", "Disk 2 (% Used):", "Disk 3 (% Used):", "Reboot? (y/n):"
    };
    size_t current_field = 0;
    Server temp_server = server;

    auto draw_form = [&]() {
        box(edit_win, 0, 0);
        const char* title = is_adding ? "--- Add Server Details ---" : "--- Edit Server Details ---";
        wattron(edit_win, A_BOLD | COLOR_PAIR(1));
        mvwprintw(edit_win, 1, (width - strlen(title)) / 2, "%s", title);
        wattroff(edit_win, A_BOLD | COLOR_PAIR(1));
        
        std::stringstream mem_ss, swap_ss, disk_ss, disk2_ss, disk3_ss, cost_ss;
        cost_ss << temp_server.monthly_cost_cents;
        mem_ss.precision(3);  mem_ss  << std::fixed << temp_server.specs.memory_gb;
        swap_ss.precision(3); swap_ss << std::fixed << temp_server.specs.swap_gb;
        disk_ss.precision(0); disk_ss << std::fixed << temp_server.specs.disk_used_percent;
        if (temp_server.specs.disk2_used_percent >= 0.0) { disk2_ss.precision(0); disk2_ss << std::fixed << temp_server.specs.disk2_used_percent; } else disk2_ss << "-";
        if (temp_server.specs.disk3_used_percent >= 0.0) { disk3_ss.precision(0); disk3_ss << std::fixed << temp_server.specs.disk3_used_percent; } else disk3_ss << "-";

        std::vector<std::string> values = {
            temp_server.nick, temp_server.canonical_name, temp_server.network.ipv4, temp_server.purpose, temp_server.os.name,
            temp_server.os.version, temp_server.provider, temp_server.hpa, cost_ss.str(), temp_server.cost_currency,
            std::to_string(temp_server.specs.cpu_cores), mem_ss.str(), swap_ss.str(),
            disk_ss.str(), disk2_ss.str(), disk3_ss.str(),
            (temp_server.reboot_required ? "y" : "n")
        };

        for (size_t i = 0; i < labels.size(); ++i) {
            int row_color = (i % 2 == 0) ? 9 : 10;
            wattron(edit_win, COLOR_PAIR(row_color));
            mvwprintw(edit_win, i + 3, 1, "%*s", width - 2, ""); 
            mvwprintw(edit_win, i + 3, 2, "%-16s", labels[i].c_str());
            mvwprintw(edit_win, i + 3, 20, "%-40s", values[i].c_str());
             if (i == current_field) { 
                wattron(edit_win, A_REVERSE);
                mvwprintw(edit_win, i + 3, 2, "%-16s", labels[i].c_str());
                wattroff(edit_win, A_REVERSE);
            }
            wattroff(edit_win, COLOR_PAIR(row_color));
        }
        
        const char* help = is_adding ? "s: Save & Add | q: Quit" : "s: Save Changes | q: Quit";
        mvwprintw(edit_win, height - 2, 2, "%s", help);
        wrefresh(edit_win);
    };

    while(true) {
        draw_form();
        int ch = wgetch(edit_win);
        char buffer[100];

        switch(ch) {
            case KEY_UP: if (current_field > 0) current_field--; break;
            case KEY_DOWN: if (current_field < labels.size() - 1) current_field++; break;
            case KEY_ENTER:
            case '\n': {
                // Pre-populate buffer with the current field value so the
                // user can see and edit it, and ESC leaves it unchanged.
                std::stringstream pre_ss;
                switch(current_field) {
                    case 0:  strncpy(buffer, temp_server.nick.c_str(), 99); break;
                    case 1:  strncpy(buffer, temp_server.canonical_name.c_str(), 99); break;
                    case 2:  strncpy(buffer, temp_server.network.ipv4.c_str(), 99); break;
                    case 3:  strncpy(buffer, temp_server.purpose.c_str(), 99); break;
                    case 4:  strncpy(buffer, temp_server.os.name.c_str(), 99); break;
                    case 5:  strncpy(buffer, temp_server.os.version.c_str(), 99); break;
                    case 6:  strncpy(buffer, temp_server.provider.c_str(), 99); break;
                    case 7:  strncpy(buffer, temp_server.hpa.c_str(), 99); break;
                    case 8:  snprintf(buffer, 100, "%d", temp_server.monthly_cost_cents); break;
                    case 9:  strncpy(buffer, temp_server.cost_currency.c_str(), 99); break;
                    case 10: snprintf(buffer, 100, "%d", temp_server.specs.cpu_cores); break;
                    case 11: snprintf(buffer, 100, "%.3f", temp_server.specs.memory_gb); break;
                    case 12: snprintf(buffer, 100, "%.3f", temp_server.specs.swap_gb); break;
                    case 13: snprintf(buffer, 100, "%.0f", temp_server.specs.disk_used_percent); break;
                    case 14: snprintf(buffer, 100, temp_server.specs.disk2_used_percent >= 0.0 ? "%.0f" : "-", temp_server.specs.disk2_used_percent); break;
                    case 15: snprintf(buffer, 100, temp_server.specs.disk3_used_percent >= 0.0 ? "%.0f" : "-", temp_server.specs.disk3_used_percent); break;
                    case 16: strncpy(buffer, (temp_server.reboot_required ? "y" : "n"), 99); break;
                    default: buffer[0] = '\0'; break;
                }
                buffer[99] = '\0';

                if (get_string_input(edit_win, current_field + 3, 20, buffer, 100)) {
                    switch(current_field) {
                        case 0:  temp_server.nick = buffer; break;
                        case 1:  temp_server.canonical_name = buffer; break;
                        case 2:  temp_server.network.ipv4 = buffer; break;
                        case 3:  temp_server.purpose = buffer; break;
                        case 4:  temp_server.os.name = buffer; break;
                        case 5:  temp_server.os.version = buffer; break;
                        case 6:  temp_server.provider = buffer; break;
                        case 7:  temp_server.hpa = buffer; break;
                        case 8:  temp_server.monthly_cost_cents = atoi(buffer); break;
                        case 9:  temp_server.cost_currency = buffer; break;
                        case 10: temp_server.specs.cpu_cores = atoi(buffer); break;
                        case 11: temp_server.specs.memory_gb = atof(buffer); break;
                        case 12: temp_server.specs.swap_gb = atof(buffer); break;
                        case 13: temp_server.specs.disk_used_percent  = atof(buffer); break;
                        case 14: temp_server.specs.disk2_used_percent = (buffer[0] == '-') ? -1.0 : atof(buffer); break;
                        case 15: temp_server.specs.disk3_used_percent = (buffer[0] == '-') ? -1.0 : atof(buffer); break;
                        case 16: temp_server.reboot_required = (buffer[0] == 'y' || buffer[0] == 'Y'); break;
                    }
                }
                break;
            }
            case 's':
            case 'S': 
                if (temp_server.nick.empty() || temp_server.network.ipv4.empty()) {
                    show_error_popup("Nickname and IP Address cannot be empty.");
                    continue;
                }
                server = temp_server; 
                delwin(edit_win); 
                return true;
            case 27:             // ESC — discard changes and close
            case 'q':
            case 'Q': delwin(edit_win); return false;
        }
    }
}