#include <atomic>
#include <borealis.hpp>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <functional>
#include <mutex>
#include <string>
#include <thread>

extern "C" {
#include <switch.h>
#include <unistd.h>

#include "bench.h"
#include "cpu_stress.h"
#include "gpu_bw.h"
#include "gpu_stress.h"
#include "hoc_clk.h"
#include "mt_cpu.h"
#include "mt_gpu.h"
#include "run_furmark.h"
}

static std::string fstr(const char *f, double v) {
    char b[64];
    std::snprintf(b, sizeof(b), f, v);
    return b;
}
static std::string fstru(const char *f, unsigned long long v) {
    char b[64];
    std::snprintf(b, sizeof(b), f, v);
    return b;
}

static brls::Label *makeRow(brls::Box *parent, const std::string &name) {
    auto *row = new brls::Box(brls::Axis::ROW);
    row->setMarginBottom(8.0f);
    auto *n = new brls::Label();
    n->setText(name);
    n->setGrow(1.0f);
    auto *v = new brls::Label();
    v->setText("-");
    row->addView(n);
    row->addView(v);
    parent->addView(row);
    return v;
}

struct StatCells {
    brls::Label *load = nullptr, *clock = nullptr, *volt = nullptr, *vddq = nullptr, *temp = nullptr;
};

static brls::Label *statCell(brls::Box *row, float fs) {
    auto *l = new brls::Label();
    if (fs > 0.0f)
        l->setFontSize(fs);
    row->addView(l);
    return l;
}
static void statSep(brls::Box *row, float fs) {
    auto *s = new brls::Label();
    s->setText("|");
    if (fs > 0.0f)
        s->setFontSize(fs);
    s->setTextColor(nvgRGB(120, 120, 120));
    s->setMarginLeft(7.0f);
    s->setMarginRight(7.0f);
    row->addView(s);
}
static void fmtLoad(brls::Label *l, unsigned val, bool isRam) {
    char b[32];
    if (isRam)
        std::snprintf(b, sizeof b, "%u.%u GB/s", val / 1000u, (val % 1000u) / 100u);
    else
        std::snprintf(b, sizeof b, "%u%%", val);
    l->setText(b);
}
static void fmtClock1(brls::Label *l, uint32_t hz) {
    char b[32];
    std::snprintf(b, sizeof b, "%u.%u MHz", hz / 1000000u, (hz / 100000u) % 10u);
    l->setText(b);
}
static void fmtVolt(brls::Label *l, uint32_t uv) {
    char b[32];
    std::snprintf(b, sizeof b, "%u mV", uv / 1000u);
    l->setText(b);
}
static void fmtTemp(brls::Label *l, int32_t mc) {
    char b[32];
    std::snprintf(b, sizeof b, "%d°C", mc / 1000);
    l->setText(b);
}

class SysInfoTab : public brls::Box {
    public:
    SysInfoTab() {
        this->setAxis(brls::Axis::COLUMN);
        this->setGrow(1.0f);
        this->setPadding(40.0f, 60.0f, 40.0f, 60.0f);

        auto *clk = new brls::Header();
        clk->setTitle("Clocks");
        this->addView(clk);
        cpuR = makeCompRow(this, "CPU");
        gpuR = makeCompRow(this, "GPU");
        ramR = makeRamRow(this);

        auto *sys = new brls::Header();
        sys->setTitle("System");
        this->addView(sys);
        mode = makeRow(this, "Mode");
        threads = makeRow(this, "Threads");

        hocclk_init();
        refresh();
    }

    void frame(brls::FrameContext *ctx) override {
        if (++tick >= 15) {
            tick = 0;
            refresh();
        }
        brls::Box::frame(ctx);
    }

    private:
    static StatCells makeCompRow(brls::Box *parent, const char *name) {
        auto *row = new brls::Box(brls::Axis::ROW);
        row->setMarginBottom(10.0f);
        auto *n = new brls::Label();
        n->setText(name);
        n->setGrow(1.0f);
        row->addView(n);
        StatCells c;
        c.load = statCell(row, 0);
        statSep(row, 0);
        c.clock = statCell(row, 0);
        statSep(row, 0);
        c.volt = statCell(row, 0);
        statSep(row, 0);
        c.temp = statCell(row, 0);
        parent->addView(row);
        return c;
    }
    static StatCells makeRamRow(brls::Box *parent) {
        auto *row = new brls::Box(brls::Axis::ROW);
        row->setMarginBottom(10.0f);
        auto *n = new brls::Label();
        n->setText("RAM");
        n->setGrow(1.0f);
        row->addView(n);
        StatCells c;
        c.load = statCell(row, 0);
        statSep(row, 0);
        c.clock = statCell(row, 0);
        statSep(row, 0);
        c.volt = statCell(row, 0);
        statSep(row, 0);
        c.vddq = statCell(row, 0);
        statSep(row, 0);
        c.temp = statCell(row, 0);
        parent->addView(row);
        return c;
    }
    void setRow(StatCells &r, unsigned loadOrBw, bool isRam, uint32_t hz, uint32_t uv, int32_t mc) {
        fmtLoad(r.load, loadOrBw, isRam);
        fmtClock1(r.clock, hz);
        fmtVolt(r.volt, uv);
        fmtTemp(r.temp, mc);
    }
    void naRow(StatCells &r) {
        r.load->setText("N/A");
        r.clock->setText("-");
        r.volt->setText("-");
        r.temp->setText("-");
    }
    void refresh() {
        sysinfo_t s;
        bench_get_sysinfo(&s);
        mode->setText(s.is_4gb ? "Application" : "Applet");
        threads->setText(fstru("%llu", (unsigned long long)s.threads));

        HocClkContext c;
        if (hocclk_get(&c)) {
            setRow(cpuR, c.stable.partLoad[3] / 10, false, c.stable.freqs[0], c.stable.voltages[2], c.stable.temps[5]);
            setRow(gpuR, c.stable.partLoad[2] / 10, false, c.stable.freqs[1], c.stable.voltages[3], c.stable.temps[6]);
            setRow(ramR, c.stable.partLoad[6], true, c.stable.freqs[2], c.stable.voltages[1], c.stable.temps[7]);
            fmtVolt(ramR.vddq, c.stable.voltages[4]);
        } else {
            naRow(cpuR);
            naRow(gpuR);
            naRow(ramR);
            ramR.vddq->setText("-");
        }
    }
    StatCells cpuR, gpuR, ramR;
    brls::Label *mode, *threads;
    int tick = 0;
};

class BenchTab : public brls::Box {
    public:
    BenchTab() {
        this->setAxis(brls::Axis::COLUMN);
        this->setGrow(1.0f);
        this->setPadding(40.0f, 60.0f, 40.0f, 60.0f);

        runBtn = new brls::Button();
        runBtn->setText("Run");
        runBtn->registerClickAction([this](brls::View *) {
            start();
            return true;
        });
        this->addView(runBtn);

        status = new brls::Label();
        status->setText("Idle");
        status->setMarginTop(8.0f);
        status->setMarginBottom(6.0f);
        this->addView(status);

        bar = new brls::Box(brls::Axis::ROW);
        bar->setHeight(18.0f);
        bar->setWidthPercentage(100.0f);
        bar->setMarginBottom(14.0f);
        barFill = new brls::Rectangle();
        barFill->setColor(nvgRGB(0, 193, 210));
        barFill->setWidthPercentage(0.0f);
        barTrack = new brls::Rectangle();
        barTrack->setColor(nvgRGB(48, 48, 54));
        barTrack->setGrow(1.0f);
        bar->addView(barFill);
        bar->addView(barTrack);
        this->addView(bar);

        auto *h1 = new brls::Header();
        h1->setTitle("GPU bandwidth");
        this->addView(h1);
        gpuCopy = makeRow(this, "GPU Copy");
        gpuRead = makeRow(this, "GPU Read");
        gpuWrite = makeRow(this, "GPU Write");

        auto *h2 = new brls::Header();
        h2->setTitle("CPU bandwidth");
        this->addView(h2);
        cpuCopy = makeRow(this, "CPU Copy");
        cpuRead = makeRow(this, "CPU Read");
        cpuWrite = makeRow(this, "CPU Write");

        auto *h3 = new brls::Header();
        h3->setTitle("RAM latency");
        this->addView(h3);
        l2 = makeRow(this, "L2");
        ram = makeRow(this, "Full RAM");
    }

    ~BenchTab() override {
        if (ctx)
            bench_end(ctx);
    }

    void frame(brls::FrameContext *fc) override {
        if (running) {
            if (primed) {

                primed = false;
            } else {
                const char *label = "";
                float frac = 0.0f;
                bool more = bench_step(ctx, &res, &label, &frac);
                setProgress(frac);
                if (more) {
                    status->setText(fstr("%.0f%%", frac * 100.0f) + "   " + label);
                    primed = true;
                } else {
                    showResults();
                    bench_end(ctx);
                    ctx = nullptr;
                    running = false;
                    status->setText("Done");
                    appletSetAutoSleepDisabled(false);
                }
            }
        }
        brls::Box::frame(fc);
    }

    private:
    void setProgress(float f) {
        barFill->setWidthPercentage(f * 100.0f);
    }

    void showResults() {
        gpuCopy->setText(fstr("%.1f MB/s", res.gpu_copy));
        gpuRead->setText(fstr("%.1f MB/s", res.gpu_read));
        gpuWrite->setText(fstr("%.1f MB/s", res.gpu_write));
        cpuCopy->setText(fstr("%.1f MB/s", res.cpu_copy));
        cpuRead->setText(fstr("%.1f MB/s", res.cpu_read));
        cpuWrite->setText(fstr("%.1f MB/s", res.cpu_write));
        l2->setText(fstr("%.1f ns", res.l2_ns));
        ram->setText(fstr("%.1f ns", res.ram_ns));
    }

    void start() {
        if (running)
            return;
        memset(&res, 0, sizeof(res));
        ctx = bench_begin();
        if (!ctx) {
            status->setText("Out of memory");
            return;
        }
        running = true;
        primed = true;
        setProgress(0.0f);
        status->setText("Running benchmark...");
        appletSetAutoSleepDisabled(true);
    }

    bench_ctx *ctx = nullptr;
    bool running = false;
    bool primed = false;
    bench_results_t res{};
    brls::Button *runBtn;
    brls::Label *status;
    brls::Box *bar;
    brls::Rectangle *barFill, *barTrack;
    brls::Label *gpuCopy, *gpuRead, *gpuWrite, *cpuCopy, *cpuRead, *cpuWrite, *l2, *ram;
};

struct StressShared {
    std::atomic<bool> running{ false }, stop{ false };
    std::atomic<double> gflops{ 0.0 };
    std::atomic<uint64_t> dispatches{ 0 }, mismatches{ 0 };
    std::thread worker;
};

class StressTab : public brls::Box {
    public:
    StressTab() {
        this->setAxis(brls::Axis::COLUMN);
        this->setGrow(1.0f);
        this->setPadding(40.0f, 60.0f, 40.0f, 60.0f);

        toggle = new brls::Button();
        toggle->setText("Start GPU stress");
        toggle->registerClickAction([this](brls::View *) {
            onToggle();
            return true;
        });
        this->addView(toggle);

        statusL = new brls::Label();
        statusL->setText("Stopped");
        statusL->setMarginTop(8.0f);
        statusL->setMarginBottom(8.0f);
        this->addView(statusL);

        auto *h = new brls::Header();
        h->setTitle("Info");
        this->addView(h);
        gflops = makeRow(this, "GFLOPS");
        dispatches = makeRow(this, "Dispatches");
        mismatches = makeRow(this, "Mismatches");

        auto *info = new brls::Label();
        info->setText("GPU stress test, Mismatches > 0 indicate instability.");
        info->setMarginTop(16.0f);
        this->addView(info);
    }

    ~StressTab() override {
        stopWorker();
    }

    void willDisappear(bool resetState = false) override {
        stopWorker();
        brls::Box::willDisappear(resetState);
    }

    void frame(brls::FrameContext *ctx) override {
        if (sh.running.load()) {
            gflops->setText(fstr("%.1f", sh.gflops.load()));
            dispatches->setText(fstru("%llu", (unsigned long long)sh.dispatches.load()));
            mismatches->setText(fstru("%llu", (unsigned long long)sh.mismatches.load()));
        }
        brls::Box::frame(ctx);
    }

    private:
    void onToggle() {
        if (sh.running.load())
            stopWorker();
        else
            startWorker();
    }
    void startWorker() {
        if (sh.worker.joinable())
            sh.worker.join();
        sh.stop.store(false);
        sh.running.store(true);
        toggle->setText("Stop GPU stress");
        statusL->setText("Running...");
        sh.worker = std::thread([this] {
            appletSetAutoSleepDisabled(true);
            uint64_t totD = 0, totM = 0;
            while (!sh.stop.load()) {
                double g = 0;
                uint64_t d = 0, m = 0;
                if (!gpu_stress_run(&g, &d, &m))
                    break;
                totD += d;
                totM += m;
                sh.gflops.store(g);
                sh.dispatches.store(totD);
                sh.mismatches.store(totM);
            }
            appletSetAutoSleepDisabled(false);
            sh.running.store(false);
        });
    }
    void stopWorker() {
        sh.stop.store(true);
        if (sh.worker.joinable())
            sh.worker.join();
        gpu_stress_shutdown();
        sh.running.store(false);
        if (toggle)
            toggle->setText("Start GPU stress");
        if (statusL)
            statusL->setText("Stopped");
    }
    StressShared sh;
    brls::Button *toggle;
    brls::Label *statusL, *gflops, *dispatches, *mismatches;
};

class FurmarkTab : public brls::Box {
    public:
    FurmarkTab(int which, const char *desc) : which(which) {
        this->setAxis(brls::Axis::COLUMN);
        this->setGrow(1.0f);
        this->setPadding(40.0f, 60.0f, 40.0f, 60.0f);

        toggle = new brls::Button();
        toggle->setText("Start");
        toggle->registerClickAction([this](brls::View *) {
            onToggle();
            return true;
        });
        this->addView(toggle);

        statusL = new brls::Label();
        statusL->setText("Stopped");
        statusL->setMarginTop(8.0f);
        statusL->setMarginBottom(12.0f);
        this->addView(statusL);

        auto *info = new brls::Label();
        info->setText(desc);
        info->setMarginBottom(8.0f);
        this->addView(info);

        auto *h = new brls::Header();
        h->setTitle("Info");
        this->addView(h);
        if (which == 3) {
            gpuFpsL = makeRow(this, "GPU FPS");
            cpuFpsL = makeRow(this, "CPU FPS");
        } else {
            gpuFpsL = makeRow(this, "FPS");
        }
    }

    ~FurmarkTab() override {
        if (run_furmark_running())
            run_furmark_stop();
    }

    void willDisappear(bool resetState = false) override {
        if (run_furmark_running())
            run_furmark_stop();
        brls::Box::willDisappear(resetState);
    }

    void frame(brls::FrameContext *fc) override {
        bool r = run_furmark_running() != 0;
        if (r != shown) {
            shown = r;
            toggle->setText(r ? "Stop" : "Start");
            statusL->setText(r ? "Running..." : "Stopped");
            if (!r) {
                gpuFpsL->setText("-");
                if (cpuFpsL)
                    cpuFpsL->setText("-");
            }
        }
        if (r) {
            gpuFpsL->setText(fstr("%.1f", run_furmark_fps()));
            if (cpuFpsL)
                cpuFpsL->setText(fstr("%.1f", run_furmark_cpu_fps()));
        }
        brls::Box::frame(fc);
    }

    private:
    void onToggle() {
        if (run_furmark_running())
            run_furmark_stop();
        else
            run_furmark_start(which);
    }
    int which;
    bool shown = false;
    brls::Button *toggle;
    brls::Label *statusL;
    brls::Label *gpuFpsL = nullptr;
    brls::Label *cpuFpsL = nullptr;
};

class MemtesterTab : public brls::Box {
    public:
    MemtesterTab() {
        this->setAxis(brls::Axis::COLUMN);
        this->setGrow(1.0f);
        this->setPadding(40.0f, 60.0f, 40.0f, 60.0f);

        auto *modeRow = new brls::Box(brls::Axis::ROW);
        modeRow->setMarginBottom(10.0f);
        auto *ml = new brls::Label();
        ml->setText("Mode");
        ml->setGrow(1.0f);
        modeRow->addView(ml);
        modeVal = new brls::Label();
        modeVal->setText(modeName(mode));
        modeRow->addView(modeVal);
        this->addView(modeRow);

        auto *hint = new brls::Label();
        hint->setText("Use L / R to select the memtester mode. Press A to run.");
        hint->setFontSize(15.0f);
        hint->setTextColor(nvgRGB(150, 150, 150));
        hint->setMarginBottom(14.0f);
        this->addView(hint);

        toggle = new brls::Button();
        toggle->setText("Start");
        toggle->registerClickAction([this](brls::View *) {
            onToggle();
            return true;
        });
        this->addView(toggle);

        this->registerAction("Prev mode", brls::ControllerButton::BUTTON_LB, [this](brls::View *) {
            cycle(-1);
            return true;
        });
        this->registerAction("Next mode", brls::ControllerButton::BUTTON_RB, [this](brls::View *) {
            cycle(1);
            return true;
        });

        statusL = new brls::Label();
        statusL->setText("Stopped");
        statusL->setMarginTop(10.0f);
        statusL->setMarginBottom(8.0f);
        this->addView(statusL);

        bar = new brls::Box(brls::Axis::ROW);
        bar->setHeight(18.0f);
        bar->setWidthPercentage(100.0f);
        bar->setMarginBottom(14.0f);
        barFill = new brls::Rectangle();
        barFill->setColor(nvgRGB(0, 193, 210));
        barFill->setWidthPercentage(0.0f);
        barTrack = new brls::Rectangle();
        barTrack->setColor(nvgRGB(48, 48, 54));
        barTrack->setGrow(1.0f);
        bar->addView(barFill);
        bar->addView(barTrack);
        this->addView(bar);

        auto *h = new brls::Header();
        h->setTitle("Info");
        this->addView(h);
        rowA = makeRow(this, "Loops");
        rowB = makeRow(this, "Mismatches");
        rowC = makeRow(this, "Detail");

        updateBar();
    }

    void setProgress(float f) {
        barFill->setWidthPercentage(f * 100.0f);
    }

    void updateBar() {
        bar->setVisibility(isGpu() ? brls::Visibility::GONE : brls::Visibility::VISIBLE);
    }

    ~MemtesterTab() override {
        stopAny();
    }

    void willDisappear(bool resetState = false) override {
        stopAny();
        brls::Box::willDisappear(resetState);
    }

    void frame(brls::FrameContext *ctx) override {
        if (isGpu()) {
            mt_gpu_status_t s;
            mt_gpu_get(&s);
            if (s.running || lastRunning) {
                rowA->setText(fstru("%llu", (unsigned long long)s.loop));
                rowB->setText(fstru("%llu", (unsigned long long)s.mismatches));
                rowC->setText(fstru("%llu MB tested", (unsigned long long)s.size_mb));
                statusL->setText(s.error ? std::string("Error: ") + s.status : std::string(s.status));
            }
            syncToggle(s.running != 0);
        } else {
            mt_cpu_status_t s;
            mt_cpu_get(&s);
            if (mt_cpu_running() || lastRunning) {
                rowA->setText(fstru("%llu", (unsigned long long)s.loop));
                rowB->setText(fstru("%llu", (unsigned long long)s.mismatches));
                char d[96];
                if (mode == 1)
                    std::snprintf(d, sizeof d, "%llu MB, burn-in x%llu",
                                  (unsigned long long)s.total_mb, (unsigned long long)s.burnin_iters);
                else
                    std::snprintf(d, sizeof d, "%llu MB, %d threads",
                                  (unsigned long long)s.total_mb, s.threads);
                rowC->setText(d);
                setProgress(mt_cpu_running() ? s.progress : 0.0f);
                if (mt_cpu_running())
                    statusL->setText(std::string(s.mismatches ? "Errors found! Running - " : "Running - ") +
                                     (s.test ? s.test : ""));
            }
            syncToggle(mt_cpu_running() != 0);
        }
        brls::Box::frame(ctx);
    }

    private:
    static const char *modeName(int m) {
        switch (m) {
            case 0: return "CPU - Memtester";
            case 1: return "CPU - Memtester + BW Burn-in";
            case 2: return "GPU - Memtester (Fast)";
            case 3: return "GPU - Memtester (Full)";
        }
        return "";
    }
    bool isGpu() const {
        return mode >= 2;
    }
    bool anyRunning() {
        return mt_cpu_running() || mt_gpu_running();
    }
    void cycle(int dir) {
        if (anyRunning())
            return;
        mode = (mode + dir + 4) % 4;
        modeVal->setText(modeName(mode));
        updateBar();
    }
    void onToggle() {
        if (anyRunning())
            stopAny();
        else
            startAny();
    }
    void startAny() {
        rowA->setText("-");
        rowB->setText("-");
        rowC->setText("-");
        switch (mode) {
            case 0: mt_cpu_start(0); break;
            case 1: mt_cpu_start(1); break;
            case 2: mt_gpu_start(0); break;
            case 3: mt_gpu_start(1); break;
        }
    }
    void stopAny() {
        if (mt_cpu_running())
            mt_cpu_stop();
        if (mt_gpu_running())
            mt_gpu_stop();
    }
    void syncToggle(bool running) {
        if (running == lastRunning)
            return;
        lastRunning = running;
        toggle->setText(running ? "Stop" : "Start");
        if (!running)
            statusL->setText("Stopped");
    }
    int mode = 0;
    bool lastRunning = false;
    brls::Label *modeVal, *statusL, *rowA, *rowB, *rowC;
    brls::Button *toggle;
    brls::Box *bar;
    brls::Rectangle *barFill, *barTrack;
};

class CpuStressTab : public brls::Box {
    public:
    CpuStressTab() {
        this->setAxis(brls::Axis::COLUMN);
        this->setGrow(1.0f);
        this->setPadding(40.0f, 60.0f, 40.0f, 60.0f);

        auto *modeRow = new brls::Box(brls::Axis::ROW);
        modeRow->setMarginBottom(10.0f);
        auto *ml = new brls::Label();
        ml->setText("Mode");
        ml->setGrow(1.0f);
        modeRow->addView(ml);
        modeVal = new brls::Label();
        modeVal->setText(modeName(mode));
        modeRow->addView(modeVal);
        this->addView(modeRow);

        auto *hint = new brls::Label();
        hint->setText("Use L / R to select the CPU stress mode. Press A to run.");
        hint->setFontSize(15.0f);
        hint->setTextColor(nvgRGB(150, 150, 150));
        hint->setMarginBottom(14.0f);
        this->addView(hint);

        toggle = new brls::Button();
        toggle->setText("Start");
        toggle->registerClickAction([this](brls::View *) {
            onToggle();
            return true;
        });
        this->addView(toggle);

        this->registerAction("Prev mode", brls::ControllerButton::BUTTON_LB, [this](brls::View *) {
            cycle(-1);
            return true;
        });
        this->registerAction("Next mode", brls::ControllerButton::BUTTON_RB, [this](brls::View *) {
            cycle(1);
            return true;
        });

        statusL = new brls::Label();
        statusL->setText("Stopped");
        statusL->setMarginTop(10.0f);
        statusL->setMarginBottom(8.0f);
        this->addView(statusL);

        auto *h = new brls::Header();
        h->setTitle("Info");
        this->addView(h);
        rowA = makeRow(this, "Iterations");
        rowB = makeRow(this, "Mismatches");
        rowC = makeRow(this, "Threads");
    }

    ~CpuStressTab() override {
        if (cpu_stress_running())
            cpu_stress_stop();
    }

    void willDisappear(bool resetState = false) override {
        if (cpu_stress_running())
            cpu_stress_stop();
        brls::Box::willDisappear(resetState);
    }

    void frame(brls::FrameContext *ctx) override {
        cpu_stress_status_t s;
        cpu_stress_get(&s);
        if (cpu_stress_running() || lastRunning) {
            rowA->setText(fstru("%llu", (unsigned long long)s.iters));
            rowB->setText(fstru("%llu", (unsigned long long)s.mismatches));
            rowC->setText(fstru("%llu", (unsigned long long)s.threads));
            if (cpu_stress_running())
                statusL->setText(s.mismatches ? "Errors found! Running..." : "Running...");
        }
        syncToggle(cpu_stress_running() != 0);
        brls::Box::frame(ctx);
    }

    private:
    static const char *modeName(int m) {
        switch (m) {
            case 0: return "Matrixprod";
            case 1: return "Hanoi (verify)";
        }
        return "";
    }
    void cycle(int dir) {
        if (cpu_stress_running())
            return;
        mode = (mode + dir + 2) % 2;
        modeVal->setText(modeName(mode));
    }
    void onToggle() {
        if (cpu_stress_running())
            cpu_stress_stop();
        else {
            rowA->setText("-");
            rowB->setText("-");
            rowC->setText("-");
            cpu_stress_start(mode);
        }
    }
    void syncToggle(bool running) {
        if (running == lastRunning)
            return;
        lastRunning = running;
        toggle->setText(running ? "Stop" : "Start");
        if (!running)
            statusL->setText("Stopped");
    }
    int mode = 0;
    bool lastRunning = false;
    brls::Label *modeVal, *statusL, *rowA, *rowB, *rowC;
    brls::Button *toggle;
};

class CreditsTab : public brls::Box {
    public:
    CreditsTab() {
        this->setAxis(brls::Axis::COLUMN);
        this->setGrow(1.0f);
        this->setPadding(40.0f, 60.0f, 40.0f, 60.0f);

        auto *title = new brls::Label();
        title->setText("Benchmark Toolbox");
        title->setFontSize(26.0f);
        this->addView(title);

        auto *by = new brls::Label();
        by->setText("by Souldbminer and Lightos_, licensed under the GPLv2");
        by->setFontSize(16.0f);
        by->setTextColor(nvgRGB(150, 150, 150));
        this->addView(by);

        auto *h = new brls::Header();
        h->setTitle("Credits");
        this->addView(h);

        makeRow(this, "Memtester")->setText("Simon Kirby, Charles Cazabon, KazushiMe & CTCaer");
        makeRow(this, "FurMark")->setText("StanislavPetrovV & AnxietyTimmy");
        makeRow(this, "GPU Test")->setText("NaGaa95");
        makeRow(this, "Membench")->setText("Siarhei Siamashka, KazushiMe & Lineon");
        makeRow(this, "Stress-ng")->setText("ColinIanKing & Lineon");

        auto *note = new brls::Label();
        note->setText("Thanks to all the original authors.");
        note->setFontSize(15.0f);
        note->setTextColor(nvgRGB(150, 150, 150));
        note->setMarginTop(18.0f);
        this->addView(note);
    }
};

class AppFrame : public brls::TabFrame {
    public:
    AppFrame() {
        box = dynamic_cast<brls::Box *>(this->getView("brls/applet_frame/header_stats"));
        if (box) {
            box->setJustifyContent(brls::JustifyContent::FLEX_END);
            box->setAlignItems(brls::AlignItems::CENTER);
            const float fs = 13.0f;
            for (int i = 0; i < 3; i++) {
                grp[i].load = statCell(box, fs);
                if (i)
                    grp[i].load->setMarginLeft(18.0f);
                statSep(box, fs);
                grp[i].clock = statCell(box, fs);
                statSep(box, fs);
                grp[i].temp = statCell(box, fs);
            }
        }
        hocclk_init();
        update();
    }

    void frame(brls::FrameContext *ctx) override {
        if (box && ++tick >= 12) {
            tick = 0;
            update();
        }
        brls::TabFrame::frame(ctx);
    }

    private:
    void setGrp(StatCells &g, const char *name, unsigned loadOrBw, bool isRam, uint32_t hz, int32_t mc) {
        char b[48];
        if (isRam)
            std::snprintf(b, sizeof b, "%s %u.%u GB/s", name, loadOrBw / 1000u, (loadOrBw % 1000u) / 100u);
        else
            std::snprintf(b, sizeof b, "%s %u%%", name, loadOrBw);
        g.load->setText(b);
        fmtClock1(g.clock, hz);
        fmtTemp(g.temp, mc);
    }
    void update() {
        if (!box)
            return;
        HocClkContext c;
        if (!hocclk_get(&c)) {
            grp[0].load->setText("hoc:clk N/A");
            grp[0].clock->setText("-");
            grp[0].temp->setText("-");
            grp[1].load->setText("-");
            grp[1].clock->setText("-");
            grp[1].temp->setText("-");
            grp[2].load->setText("-");
            grp[2].clock->setText("-");
            grp[2].temp->setText("-");
            return;
        }
        setGrp(grp[0], "CPU", c.stable.partLoad[3] / 10, false, c.stable.realFreqs[0], c.stable.temps[5]);
        setGrp(grp[1], "GPU", c.stable.partLoad[2] / 10, false, c.stable.realFreqs[1], c.stable.temps[6]);
        setGrp(grp[2], "RAM", c.stable.partLoad[6], true, c.stable.realFreqs[2], c.stable.temps[7]);
    }
    brls::Box *box = nullptr;
    StatCells grp[3];
    int tick = 0;
};

class MainActivity : public brls::Activity {
    public:
    brls::View *createContentView() override {
        auto *tab = new AppFrame();
        tab->setTitle("Benchmark Toolbox");
        tab->setIconFromRes("img/logo.png");
        tab->addTab("System Info", [] { return new SysInfoTab(); });

        tab->addHeader("Combined");
        tab->addTab("Black Hole", [] { return new FurmarkTab(3, "CPU+GPU black-hole."); });

        tab->addHeader("CPU");
        tab->addTab("CPU Stress", [] { return new CpuStressTab(); });
        tab->addTab("CPU Ray Trace", [] { return new FurmarkTab(4, "CPU Path Tracer"); });

        tab->addHeader("GPU");
        tab->addTab("GPU Test", [] { return new StressTab(); });
        tab->addTab("Furmark", [] { return new FurmarkTab(0, "FurMark for Switch (48 step)"); });
        tab->addTab("GPU Path Trace", [] { return new FurmarkTab(2, "GPU Path Tracer"); });

        tab->addHeader("RAM");
        tab->addTab("Memtester", [] { return new MemtesterTab(); });
        tab->addTab("Membench", [] { return new BenchTab(); });
        tab->addTab("Furmark RAM", [] { return new FurmarkTab(1, "FurMark with extra ram stress"); });
        tab->addTab("CPU RAM", [] { return new FurmarkTab(5, "CPU RT with extra RAM stress"); });

        tab->addSeparator();
        tab->addTab("Credits", [] { return new CreditsTab(); });
        return tab;
    }
};

int main(int argc, char *argv[]) {
    (void)argc;
    (void)argv;

    brls::Logger::setLogLevel(brls::LogLevel::INFO);

    if (!brls::Application::init()) {
        brls::Logger::error("Unable to init borealis application");
        return EXIT_FAILURE;
    }

    brls::Application::createWindow("Benchmark Toolbox");
    brls::Application::setGlobalQuit(true);
    brls::Application::pushActivity(new MainActivity());

    while (brls::Application::mainLoop())
        ;

    // Global quit (+) can return from the main loop without destroying the
    // activity, leaving background workers (and their threads / large RAM
    // allocations) live across _exit. Tear them down first.
    if (run_furmark_running())
        run_furmark_stop();
    if (mt_gpu_running())
        mt_gpu_stop();
    if (mt_cpu_running())
        mt_cpu_stop();
    if (cpu_stress_running())
        cpu_stress_stop();

    _exit(EXIT_SUCCESS);
}