ServerSelector.cpp

//
// Interactive server picker and standalone latency prober.
//

#include "ServerSelector.h"
#include "SpeedTestClient.h"

#include <algorithm>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <mutex>
#include <sstream>
#include <thread>

#include <cerrno>
#include <fcntl.h>
#include <netdb.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <sys/ioctl.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <termios.h>
#include <unistd.h>

namespace {

const int    PROBE_THREADS      = 8;
const size_t MIN_CITY_WIDTH     = 12;
const size_t MIN_SPONSOR_WIDTH  = 10;

// ---------------------------------------------------------------- text utils

std::string toLower(const std::string& in) {
    std::string out = in;
    for (size_t i = 0; i < out.size(); i++)
        out[i] = static_cast<char>(::tolower(static_cast<unsigned char>(out[i])));
    return out;
}

// Number of codepoints, so UTF-8 city names ("Montréal") are not cut in half.
size_t displayWidth(const std::string& in) {
    size_t width = 0;
    for (size_t i = 0; i < in.size(); i++)
        if ((static_cast<unsigned char>(in[i]) & 0xC0) != 0x80)
            width++;
    return width;
}

std::string truncate(const std::string& in, size_t width) {
    if (displayWidth(in) <= width)
        return in;
    if (width == 0)
        return std::string();

    size_t seen = 0, cut = in.size();
    for (size_t i = 0; i < in.size(); i++) {
        if ((static_cast<unsigned char>(in[i]) & 0xC0) != 0x80) {
            if (seen == width - 1) {
                cut = i;
                break;
            }
            seen++;
        }
    }
    return in.substr(0, cut) + "\xE2\x80\xA6"; // ellipsis
}

std::string pad(const std::string& in, size_t width) {
    std::string out = truncate(in, width);
    size_t w = displayWidth(out);
    if (w < width)
        out.append(width - w, ' ');
    return out;
}

std::string padLeft(const std::string& in, size_t width) {
    std::string out = truncate(in, width);
    size_t w = displayWidth(out);
    if (w < width)
        out.insert(0, width - w, ' ');
    return out;
}

// ------------------------------------------------------------------- colours

struct Palette {
    const char *reset, *dim, *bold, *reverse, *cyan, *green, *yellow, *red;

    Palette() {
        bool plain = ::getenv("NO_COLOR") != nullptr;
        reset   = plain ? "" : "\x1b[0m";
        dim     = plain ? "" : "\x1b[2m";
        bold    = plain ? "" : "\x1b[1m";
        reverse = plain ? "" : "\x1b[7m";
        cyan    = plain ? "" : "\x1b[36m";
        green   = plain ? "" : "\x1b[32m";
        yellow  = plain ? "" : "\x1b[33m";
        red     = plain ? "" : "\x1b[31m";
    }
};

const Palette& palette() {
    static Palette instance;
    return instance;
}

// -------------------------------------------------------------- tcp plumbing

std::pair<std::string, int> splitHostPort(const std::string& hostport) {
    size_t pos = hostport.find(':');
    if (pos == std::string::npos)
        return std::make_pair(hostport, 8080);

    int port = 8080;
    try {
        port = std::stoi(hostport.substr(pos + 1));
    } catch (...) {
        port = 8080;
    }
    return std::make_pair(hostport.substr(0, pos), port);
}

bool waitReady(int fd, bool for_write, int timeout_ms) {
    fd_set set;
    FD_ZERO(&set);
    FD_SET(fd, &set);

    struct timeval tv;
    tv.tv_sec  = timeout_ms / 1000;
    tv.tv_usec = (timeout_ms % 1000) * 1000;

    int ret = for_write ? ::select(fd + 1, nullptr, &set, nullptr, &tv)
                        : ::select(fd + 1, &set, nullptr, nullptr, &tv);
    return ret > 0;
}

int connectWithTimeout(const std::string& host, int port, int timeout_ms) {
    struct addrinfo hints;
    memset(&hints, 0, sizeof(hints));
    hints.ai_family   = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;

    char portbuf[16];
    snprintf(portbuf, sizeof(portbuf), "%d", port);

    struct addrinfo *res = nullptr;
    if (::getaddrinfo(host.c_str(), portbuf, &hints, &res) != 0 || res == nullptr)
        return -1;

    int fd = -1;
    for (struct addrinfo *p = res; p != nullptr; p = p->ai_next) {
        fd = ::socket(p->ai_family, p->ai_socktype, p->ai_protocol);
        if (fd < 0)
            continue;

        int flags = ::fcntl(fd, F_GETFL, 0);
        ::fcntl(fd, F_SETFL, flags | O_NONBLOCK);

        if (::connect(fd, p->ai_addr, p->ai_addrlen) == 0)
            break;

        if (errno == EINPROGRESS && waitReady(fd, true, timeout_ms)) {
            int err = 0;
            socklen_t len = sizeof(err);
            if (::getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &len) == 0 && err == 0)
                break;
        }

        ::close(fd);
        fd = -1;
    }
    ::freeaddrinfo(res);

    if (fd >= 0) {
        int one = 1;
        ::setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &one, sizeof(one));
    }
    return fd;
}

bool sendLine(int fd, const std::string& line, int timeout_ms) {
    std::string buff = line;
    if (buff.empty() || buff[buff.size() - 1] != '\n')
        buff += '\n';

    size_t sent = 0;
    while (sent < buff.size()) {
        if (!waitReady(fd, true, timeout_ms))
            return false;

        ssize_t n = ::send(fd, buff.data() + sent, buff.size() - sent, 0);
        if (n > 0)
            sent += static_cast<size_t>(n);
        else if (n < 0 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK))
            continue;
        else
            return false;
    }
    return true;
}

// Buffered line reader: a single recv() may carry more than one reply line.
struct LineReader {
    int fd;
    std::string buff;

    explicit LineReader(int socket_fd): fd(socket_fd) {}

    bool readLine(std::string& out, int timeout_ms) {
        while (true) {
            size_t pos = buff.find('\n');
            if (pos != std::string::npos) {
                out = buff.substr(0, pos);
                if (!out.empty() && out[out.size() - 1] == '\r')
                    out.erase(out.size() - 1);
                buff.erase(0, pos + 1);
                return true;
            }

            if (!waitReady(fd, false, timeout_ms))
                return false;

            char tmp[512];
            ssize_t n = ::recv(fd, tmp, sizeof(tmp), 0);
            if (n > 0)
                buff.append(tmp, static_cast<size_t>(n));
            else if (n < 0 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK))
                continue;
            else
                return false;
        }
    }
};

// --------------------------------------------------------------- table cells

std::string latencyCell(const ProbeResult& probe) {
    switch (probe.state) {
        case ProbeResult::Ok: {
            char buff[32];
            snprintf(buff, sizeof(buff), probe.latency_ms < 100.0 ? "%.1f ms" : "%.0f ms", probe.latency_ms);
            return std::string(buff);
        }
        case ProbeResult::Testing:     return "...";
        case ProbeResult::Queued:      return "\xC2\xB7\xC2\xB7\xC2\xB7"; // ···
        case ProbeResult::Failed:      return "n/a";
        case ProbeResult::Unsupported: return "old";
        default:                       return "-";
    }
}

const char* latencyColor(const ProbeResult& probe) {
    const Palette& p = palette();
    if (probe.state == ProbeResult::Ok)
        return probe.latency_ms < 20.0 ? p.green : (probe.latency_ms < 60.0 ? p.yellow : p.red);
    if (probe.state == ProbeResult::Failed || probe.state == ProbeResult::Unsupported)
        return p.red;
    return p.dim;
}

std::string distanceCell(const ServerInfo& server) {
    char buff[32];
    snprintf(buff, sizeof(buff), server.distance < 100.0f ? "%.1f km" : "%.0f km", server.distance);
    return std::string(buff);
}

struct Layout {
    size_t city, sponsor;
};

Layout layoutFor(size_t width) {
    // marker(2) + index(5) + distance(10) + latency(10) + gaps(3)
    size_t fixed = 30;
    size_t rest  = width > fixed + MIN_CITY_WIDTH + MIN_SPONSOR_WIDTH
                   ? width - fixed : MIN_CITY_WIDTH + MIN_SPONSOR_WIDTH;

    Layout layout;
    layout.city    = std::max(MIN_CITY_WIDTH, static_cast<size_t>(rest * 0.45));
    layout.sponsor = std::max(MIN_SPONSOR_WIDTH, rest - layout.city);
    return layout;
}

std::string headerRow(const Layout& layout) {
    std::ostringstream row;
    row << "   " << pad("#", 4) << ' '
        << pad("CITY", layout.city) << ' '
        << pad("SPONSOR", layout.sponsor) << ' '
        << padLeft("DISTANCE", 10) << ' '
        << padLeft("PING", 9);
    return row.str();
}

// One table line. `number` is the 1-based position shown to the user.
std::string serverRow(size_t number, const ServerInfo& server, const ProbeResult& probe,
                      const Layout& layout, bool selected, bool home_city) {
    const Palette& p = palette();
    std::ostringstream row;

    row << (selected ? p.reverse : "")
        << (selected ? " \xE2\x96\xB8 " : "   ")
        << p.dim << pad(std::to_string(number), 4) << p.reset
        << (selected ? p.reverse : "") << ' '
        << (home_city ? p.bold : "") << pad(server.name, layout.city) << (home_city ? p.reset : "")
        << (selected ? p.reverse : "") << ' '
        << pad(server.sponsor, layout.sponsor) << ' '
        << p.dim << padLeft(distanceCell(server), 10) << p.reset
        << (selected ? p.reverse : "") << ' '
        << latencyColor(probe) << padLeft(latencyCell(probe), 9) << p.reset;

    return row.str();
}

// ------------------------------------------------------------------ terminal

// Puts the terminal in raw mode and restores it on destruction.
class RawMode {
public:
    RawMode(): mActive(false) {
        if (::tcgetattr(STDIN_FILENO, &mOriginal) != 0)
            return;

        struct termios raw = mOriginal;
        raw.c_lflag &= ~(ICANON | ECHO | ISIG);
        raw.c_iflag &= ~(IXON | ICRNL);
        raw.c_cc[VMIN]  = 0;
        raw.c_cc[VTIME] = 0;
        if (::tcsetattr(STDIN_FILENO, TCSAFLUSH, &raw) == 0)
            mActive = true;
    }

    ~RawMode() {
        if (mActive)
            ::tcsetattr(STDIN_FILENO, TCSAFLUSH, &mOriginal);
    }

    bool active() const { return mActive; }

private:
    struct termios mOriginal;
    bool mActive;
};

std::pair<size_t, size_t> terminalSize() {
    struct winsize ws;
    if (::ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) == 0 && ws.ws_row > 0 && ws.ws_col > 0)
        return std::make_pair(static_cast<size_t>(ws.ws_row), static_cast<size_t>(ws.ws_col));
    return std::make_pair<size_t, size_t>(24, 80);
}

void writeOut(const std::string& data) {
    size_t written = 0;
    while (written < data.size()) {
        ssize_t n = ::write(STDOUT_FILENO, data.data() + written, data.size() - written);
        if (n > 0)
            written += static_cast<size_t>(n);
        else if (n < 0 && errno == EINTR)
            continue;
        else
            return;
    }
}

enum Key {
    KeyNone = 0, KeyUp, KeyDown, KeyPageUp, KeyPageDown, KeyHome, KeyEnd,
    KeyEnter, KeyEscape, KeyBackspace, KeyChar
};

// Reads keypresses one at a time. A single read() can carry several of them at
// once (key repeat, a paste, a piped script), so unconsumed bytes are buffered
// instead of being thrown away.
class KeyReader {
public:
    Key next(int timeout_ms, char& character) {
        character = 0;

        if (mPending.empty()) {
            if (!waitReady(STDIN_FILENO, false, timeout_ms))
                return KeyNone;

            char chunk[64];
            ssize_t n = ::read(STDIN_FILENO, chunk, sizeof(chunk));
            if (n <= 0)
                return KeyNone;
            mPending.append(chunk, static_cast<size_t>(n));
        }

        char first = mPending[0];

        if (first == '\x1b') {
            // A lone Esc is indistinguishable from an unfinished sequence: wait
            // briefly for the rest before treating it as a keypress of its own.
            if (mPending.size() == 1 && waitReady(STDIN_FILENO, false, 30)) {
                char chunk[64];
                ssize_t n = ::read(STDIN_FILENO, chunk, sizeof(chunk));
                if (n > 0)
                    mPending.append(chunk, static_cast<size_t>(n));
            }

            if (mPending.size() == 1) {
                mPending.clear();
                return KeyEscape;
            }

            if (mPending[1] == '[' && mPending.size() >= 3) {
                char code = mPending[2];
                size_t consumed = 3;
                Key key = KeyNone;

                switch (code) {
                    case 'A': key = KeyUp;    break;
                    case 'B': key = KeyDown;  break;
                    case 'H': key = KeyHome;  break;
                    case 'F': key = KeyEnd;   break;
                    case '5': key = KeyPageUp;   consumed = 4; break; // ESC [ 5 ~
                    case '6': key = KeyPageDown; consumed = 4; break;
                    default:  break;
                }
                mPending.erase(0, std::min(consumed, mPending.size()));
                return key;
            }

            mPending.erase(0, 2);
            return KeyNone;
        }

        mPending.erase(0, 1);

        if (first == '\r' || first == '\n')
            return KeyEnter;
        if (first == 127 || first == 8)
            return KeyBackspace;

        character = first;
        return KeyChar;
    }

private:
    std::string mPending;
};

// ------------------------------------------------------------------- picker

enum SortMode { SortDistance = 0, SortPing, SortCity, SortSponsor, SortModeCount };

const char* sortName(SortMode mode) {
    switch (mode) {
        case SortPing:    return "ping";
        case SortCity:    return "city";
        case SortSponsor: return "sponsor";
        default:          return "distance";
    }
}

class Picker {
public:
    Picker(const std::vector<ServerInfo>& servers, const IPInfo& client,
           const std::string& filter, const std::string& min_version):
            mServers(servers),
            mClient(client),
            mResults(servers.size()),
            mFilter(filter),
            mMinVersion(min_version),
            mSort(SortDistance),
            mFilterMode(false),
            mCursor(0),
            mOffset(0),
            mDirty(true),
            mStop(false) {}

    bool run(ServerInfo& chosen) {
        RawMode raw;
        if (!raw.active()) {
            std::cerr << "Unable to switch the terminal into raw mode." << std::endl;
            return false;
        }

        rebuildView();
        selectHomeCity();
        startWorkers();

        writeOut("\x1b[?1049h\x1b[?25l"); // alternate screen, hidden cursor

        KeyReader keys;
        bool picked = false;
        while (true) {
            queueVisible();
            render();

            char character = 0;
            Key key = keys.next(120, character);

            if (key == KeyNone) {
                std::lock_guard<std::mutex> lock(mMutex);
                if (mDirty && mSort == SortPing)
                    mResort = true;
                continue;
            }

            if (mFilterMode && key == KeyChar && character >= ' ' && character != 127) {
                mFilter += character;
                rebuildView();
                continue;
            }

            if (key == KeyBackspace) {
                if (!mFilter.empty()) {
                    mFilter.erase(mFilter.size() - 1);
                    rebuildView();
                }
                continue;
            }

            switch (key) {
                case KeyUp:       moveCursor(-1); break;
                case KeyDown:     moveCursor(1);  break;
                case KeyPageUp:   moveCursor(-static_cast<long>(pageSize())); break;
                case KeyPageDown: moveCursor(static_cast<long>(pageSize()));  break;
                case KeyHome:     mCursor = 0; break;
                case KeyEnd:      mCursor = mView.empty() ? 0 : mView.size() - 1; break;
                case KeyEnter:
                    if (mFilterMode) {
                        mFilterMode = false;
                    } else if (!mView.empty()) {
                        chosen = mServers[mView[mCursor]];
                        picked = true;
                    }
                    break;
                case KeyEscape:
                    if (mFilterMode || !mFilter.empty()) {
                        mFilterMode = false;
                        mFilter.clear();
                        rebuildView();
                    } else {
                        picked = false;
                        goto done;
                    }
                    break;
                case KeyChar:
                    switch (character) {
                        case 'q': case 3: /* Ctrl-C */ picked = false; goto done;
                        case '/': mFilterMode = true; break;
                        case 'j': moveCursor(1);  break;
                        case 'k': moveCursor(-1); break;
                        case 'g': mCursor = 0; break;
                        case 'G': mCursor = mView.empty() ? 0 : mView.size() - 1; break;
                        case 's': mSort = static_cast<SortMode>((mSort + 1) % SortModeCount); rebuildView(); break;
                        case 'r': requeueVisible(); break;
                        case 'a': queueAll(); break;
                        default: break;
                    }
                    break;
                default: break;
            }

            if (picked)
                break;
        }

    done:
        stopWorkers();
        writeOut("\x1b[?25h\x1b[?1049l"); // show cursor, back to the normal screen
        return picked;
    }

private:
    size_t pageSize() const {
        std::pair<size_t, size_t> size = terminalSize();
        size_t chrome = 6; // 2 header lines, blank line, 2 footer lines, margin
        return size.first > chrome + 1 ? size.first - chrome : 1;
    }

    void moveCursor(long delta) {
        if (mView.empty()) {
            mCursor = 0;
            return;
        }
        long target = static_cast<long>(mCursor) + delta;
        if (target < 0)
            target = 0;
        if (target > static_cast<long>(mView.size()) - 1)
            target = static_cast<long>(mView.size()) - 1;
        mCursor = static_cast<size_t>(target);
    }

    // Rebuilds the filtered/sorted view, keeping the cursor on the same server.
    void rebuildView() {
        int keep = mView.empty() || mCursor >= mView.size() ? -1 : static_cast<int>(mView[mCursor]);

        mView.clear();
        for (size_t i = 0; i < mServers.size(); i++)
            if (mFilter.empty() || serverMatches(mServers[i], mFilter))
                mView.push_back(i);

        sortView();

        mCursor = 0;
        if (keep >= 0) {
            for (size_t i = 0; i < mView.size(); i++) {
                if (static_cast<int>(mView[i]) == keep) {
                    mCursor = i;
                    break;
                }
            }
        }
        mOffset = 0;
    }

    void sortView() {
        std::lock_guard<std::mutex> lock(mMutex);
        const std::vector<ProbeResult>& results = mResults;
        SortMode mode = mSort;
        const std::vector<ServerInfo>& servers = mServers;

        std::stable_sort(mView.begin(), mView.end(), [&](size_t a, size_t b) -> bool {
            switch (mode) {
                case SortPing: {
                    bool oka = results[a].state == ProbeResult::Ok;
                    bool okb = results[b].state == ProbeResult::Ok;
                    if (oka != okb)
                        return oka; // untested and unreachable sink to the bottom
                    if (oka && results[a].latency_ms != results[b].latency_ms)
                        return results[a].latency_ms < results[b].latency_ms;
                    return servers[a].distance < servers[b].distance;
                }
                case SortCity: {
                    std::string ca = toLower(servers[a].name), cb = toLower(servers[b].name);
                    if (ca != cb)
                        return ca < cb;
                    return servers[a].distance < servers[b].distance;
                }
                case SortSponsor: {
                    std::string sa = toLower(servers[a].sponsor), sb = toLower(servers[b].sponsor);
                    if (sa != sb)
                        return sa < sb;
                    return servers[a].distance < servers[b].distance;
                }
                default:
                    return servers[a].distance < servers[b].distance;
            }
        });
    }

    // Puts the cursor on the first server sitting in the same city as the client.
    void selectHomeCity() {
        if (mClient.city.empty())
            return;
        std::string home = toLower(mClient.city);
        for (size_t i = 0; i < mView.size(); i++) {
            if (toLower(mServers[mView[i]].name).find(home) != std::string::npos) {
                mCursor = i;
                return;
            }
        }
    }

    bool isHomeCity(const ServerInfo& server) const {
        if (mClient.city.empty())
            return false;
        return toLower(server.name).find(toLower(mClient.city)) != std::string::npos;
    }

    // ---- probing

    void startWorkers() {
        for (int i = 0; i < PROBE_THREADS; i++)
            mWorkers.push_back(std::thread(&Picker::worker, this));
    }

    void stopWorkers() {
        {
            std::lock_guard<std::mutex> lock(mMutex);
            mStop = true;
            mQueue.clear();
        }
        mCv.notify_all();
        for (size_t i = 0; i < mWorkers.size(); i++)
            mWorkers[i].join();
        mWorkers.clear();
    }

    void worker() {
        while (true) {
            size_t index;
            {
                std::unique_lock<std::mutex> lock(mMutex);
                mCv.wait(lock, [this] { return mStop || !mQueue.empty(); });
                if (mStop)
                    return;
                index = mQueue.front();
                mQueue.pop_front();
                mResults[index].state = ProbeResult::Testing;
                mDirty = true;
            }

            ProbeResult probe = probeServer(mServers[index]);
            if (probe.state == ProbeResult::Ok && !SpeedTestClient::versionAtLeast(probe.version, mMinVersion))
                probe.state = ProbeResult::Unsupported;

            std::lock_guard<std::mutex> lock(mMutex);
            mResults[index] = probe;
            mDirty = true;
        }
    }

    void enqueue(const std::vector<size_t>& indices, bool force) {
        {
            std::lock_guard<std::mutex> lock(mMutex);
            for (size_t i = 0; i < indices.size(); i++) {
                ProbeResult::State state = mResults[indices[i]].state;
                bool pending = state == ProbeResult::Queued || state == ProbeResult::Testing;
                if (pending || (!force && state != ProbeResult::Untested))
                    continue;
                mResults[indices[i]].state = ProbeResult::Queued;
                mQueue.push_back(indices[i]);
            }
            mDirty = true;
        }
        mCv.notify_all();
    }

    std::vector<size_t> visibleIndices() {
        std::vector<size_t> visible;
        size_t page = pageSize();
        for (size_t row = mOffset; row < mView.size() && row < mOffset + page; row++)
            visible.push_back(mView[row]);
        return visible;
    }

    void queueVisible()   { enqueue(visibleIndices(), false); }
    void requeueVisible() { enqueue(visibleIndices(), true);  }

    void queueAll() {
        std::vector<size_t> all(mView.begin(), mView.end());
        enqueue(all, false);
    }

    // ---- rendering

    void render() {
        std::pair<size_t, size_t> size = terminalSize();
        size_t cols = size.second;
        size_t page = pageSize();

        if (mResort) {
            sortView();
            mResort = false;
        }

        // Keep the cursor inside the viewport.
        if (mCursor < mOffset)
            mOffset = mCursor;
        else if (mCursor >= mOffset + page)
            mOffset = mCursor - page + 1;
        if (mView.size() <= page)
            mOffset = 0;

        Layout layout = layoutFor(cols);
        const Palette& p = palette();
        std::ostringstream out;
        out << "\x1b[H"; // home

        std::ostringstream head;
        head << "SpeedTest++ \xC2\xB7 " << mClient.ip_address << " (" << mClient.isp << ")";
        if (!mClient.city.empty())
            head << " \xC2\xB7 " << mClient.city;
        out << p.bold << p.cyan << truncate(head.str(), cols) << p.reset << "\x1b[K\r\n";

        std::ostringstream status;
        status << mView.size() << "/" << mServers.size() << " servers \xC2\xB7 sorted by "
               << sortName(mSort);
        if (!mFilter.empty())
            status << " \xC2\xB7 filter: \"" << mFilter << "\"";
        out << p.dim << truncate(status.str(), cols) << p.reset << "\x1b[K\r\n";

        out << p.bold << truncate(headerRow(layout), cols) << p.reset << "\x1b[K\r\n";

        {
            std::lock_guard<std::mutex> lock(mMutex);
            mDirty = false;

            size_t printed = 0;
            for (size_t row = mOffset; row < mView.size() && printed < page; row++, printed++) {
                size_t index = mView[row];
                out << serverRow(row + 1, mServers[index], mResults[index], layout,
                                 row == mCursor, isHomeCity(mServers[index]))
                    << p.reset << "\x1b[K\r\n";
            }

            if (mView.empty())
                out << p.red << "  Nothing matches \"" << mFilter << "\" \xE2\x80\x94 Esc clears the filter"
                    << p.reset << "\x1b[K\r\n";
            else
                for (; printed < page; printed++)
                    out << "\x1b[K\r\n";
        }

        std::string hint = mFilterMode
            ? "filter: " + mFilter + "_   (Enter keeps it \xC2\xB7 Esc clears \xC2\xB7 Backspace deletes)"
            : "\xE2\x86\x91\xE2\x86\x93 move \xC2\xB7 Enter select \xC2\xB7 / filter \xC2\xB7 s sort \xC2\xB7 r re-ping \xC2\xB7 a ping all \xC2\xB7 q quit";
        out << (mFilterMode ? p.bold : p.dim) << truncate(hint, cols) << p.reset << "\x1b[K";

        out << "\x1b[J"; // wipe anything below
        writeOut(out.str());
    }

    const std::vector<ServerInfo>& mServers;
    const IPInfo mClient;
    std::vector<ProbeResult> mResults;
    std::vector<size_t> mView;
    std::string mFilter;
    std::string mMinVersion;
    SortMode mSort;
    bool mFilterMode;
    size_t mCursor;
    size_t mOffset;
    bool mDirty;
    bool mResort = false;

    std::vector<std::thread> mWorkers;
    std::deque<size_t> mQueue;
    std::mutex mMutex;
    std::condition_variable mCv;
    bool mStop;
};

} // namespace

// ------------------------------------------------------------------ public API

bool serverMatches(const ServerInfo& server, const std::string& needle) {
    if (needle.empty())
        return true;

    std::string what = toLower(needle);
    return toLower(server.name).find(what) != std::string::npos
        || toLower(server.sponsor).find(what) != std::string::npos
        || toLower(server.country).find(what) != std::string::npos
        || toLower(server.country_code).find(what) != std::string::npos
        || toLower(server.host).find(what) != std::string::npos;
}

std::vector<ServerInfo> filterServers(const std::vector<ServerInfo>& servers, const std::string& needle) {
    std::vector<ServerInfo> matching;
    for (size_t i = 0; i < servers.size(); i++)
        if (serverMatches(servers[i], needle))
            matching.push_back(servers[i]);
    return matching;
}

ProbeResult probeServer(const ServerInfo& server, int samples, int timeout_ms) {
    ProbeResult probe;
    probe.state = ProbeResult::Failed;

    std::pair<std::string, int> hostport = splitHostPort(server.host);
    int fd = connectWithTimeout(hostport.first, hostport.second, timeout_ms);
    if (fd < 0)
        return probe;

    LineReader reader(fd);
    std::string reply;

    if (sendLine(fd, "HI", timeout_ms) && reader.readLine(reply, timeout_ms)) {
        std::istringstream stream(reply);
        std::string hello, version;
        stream >> hello >> version;

        if (hello == "HELLO") {
            probe.version = version;
            double best = -1.0;

            for (int i = 0; i < samples; i++) {
                std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();

                std::ostringstream cmd;
                cmd << "PING " << std::chrono::duration_cast<std::chrono::milliseconds>(
                                      start.time_since_epoch()).count();

                if (!sendLine(fd, cmd.str(), timeout_ms) || !reader.readLine(reply, timeout_ms))
                    break;
                if (reply.compare(0, 5, "PONG ") != 0)
                    break;

                double ms = std::chrono::duration_cast<std::chrono::duration<double, std::milli> >(
                                std::chrono::steady_clock::now() - start).count();
                if (best < 0.0 || ms < best)
                    best = ms;
            }

            if (best >= 0.0) {
                probe.state      = ProbeResult::Ok;
                probe.latency_ms = best;
            }
        }
    }

    sendLine(fd, "QUIT", 200);
    ::close(fd);
    return probe;
}

std::vector<ProbeResult> probeServers(const std::vector<ServerInfo>& servers, const std::string& minVersion) {
    std::vector<ProbeResult> results(servers.size());
    if (servers.empty())
        return results;

    std::atomic<size_t> next(0);
    size_t worker_count = std::min<size_t>(servers.size(), PROBE_THREADS);
    std::vector<std::thread> workers;

    for (size_t w = 0; w < worker_count; w++) {
        workers.push_back(std::thread([&servers, &results, &next, &minVersion] {
            for (size_t i = next++; i < servers.size(); i = next++) {
                ProbeResult probe = probeServer(servers[i]);
                if (probe.state == ProbeResult::Ok && !SpeedTestClient::versionAtLeast(probe.version, minVersion))
                    probe.state = ProbeResult::Unsupported;
                results[i] = probe;
            }
        }));
    }
    for (size_t w = 0; w < workers.size(); w++)
        workers[w].join();

    return results;
}

bool selectServerInteractive(const std::vector<ServerInfo>& servers, const IPInfo& client,
                             const std::string& initialFilter, const std::string& minVersion, ServerInfo& chosen) {
    if (servers.empty())
        return false;

    Picker picker(servers, client, initialFilter, minVersion);
    return picker.run(chosen);
}

void printServerTable(const std::vector<ServerInfo>& servers, const std::vector<ProbeResult>& results,
                      const IPInfo& client) {
    const Palette& p = palette();
    Layout layout = layoutFor(terminalSize().second);

    if (!client.city.empty())
        std::cout << p.dim << "Your location: " << client.city << p.reset << std::endl;

    std::cout << p.bold << headerRow(layout) << p.reset << std::endl;

    for (size_t i = 0; i < servers.size(); i++) {
        ProbeResult probe = i < results.size() ? results[i] : ProbeResult();
        bool home = !client.city.empty()
                    && toLower(servers[i].name).find(toLower(client.city)) != std::string::npos;
        std::cout << serverRow(i + 1, servers[i], probe, layout, false, home) << std::endl;
    }
}

bool stdinIsInteractive() {
    return ::isatty(STDIN_FILENO) == 1 && ::isatty(STDOUT_FILENO) == 1;
}