PerformanceMonitor.cpp

Go to the documentation of this file.

#include "Utils/PerformanceMonitor.h"
#include <algorithm>
#include <fstream>
#include <iomanip>
#include <sstream>
#include <wx/dc.h>
#include <wx/dcbuffer.h>
#include <wx/file.h>
#include <wx/wx.h>
 
#ifdef __linux__
#include <fstream>
#include <sys/sysinfo.h>
#include <sys/times.h>
#include <unistd.h>
#endif
 
namespace EmberForge {
 
// MetricData Implementation
MetricData::MetricData(const wxString &n, const wxColour &c, const wxString &u, size_t max_s)
    : name(n), color(c), min_value(0.0f), max_value(0.0f), current_value(0.0f), unit(u), max_samples(max_s) {}
 
void MetricData::AddValue(float value) {
    current_value = value;
    values.push_back(value);
 
    // Update min/max
    if (values.size() == 1) {
        min_value = max_value = value;
    } else {
        min_value = std::min(min_value, value);
        max_value = std::max(max_value, value);
    }
 
    // Trim to max samples
    if (values.size() > max_samples) {
        values.pop_front();
 
        // Recalculate min/max from remaining values
        if (!values.empty()) {
            auto minmax = std::minmax_element(values.begin(), values.end());
            min_value = *minmax.first;
            max_value = *minmax.second;
        }
    }
}
 
float MetricData::GetAverage() const {
    if (values.empty())
        return 0.0f;
 
    float sum = 0.0f;
    for (float value : values) {
        sum += value;
    }
    return sum / values.size();
}
 
void MetricData::Clear() {
    values.clear();
    min_value = max_value = current_value = 0.0f;
}
 
// PerformanceMonitor Implementation
PerformanceMonitor::PerformanceMonitor()
    : m_cpuUsage(0.0f), m_memoryUsageMB(0.0f), m_currentFPS(0.0f), m_enabled(true), m_frameActive(false)
#ifdef __linux__
      ,
      m_lastCpuTotal(0), m_lastCpuIdle(0)
#endif
{
    InitializeBuiltInMetrics();
    m_lastFrameTime = std::chrono::high_resolution_clock::now();
}
 
PerformanceMonitor::~PerformanceMonitor() {
    // Cleanup handled automatically
}
 
void PerformanceMonitor::InitializeBuiltInMetrics() {
    // Use default 200 samples (20 seconds), but this can be changed later via the UI
    m_frameTimeMetric = std::make_shared<MetricData>("Frame Time", wxColour(100, 200, 100), "ms", 200);
    m_fpsMetric = std::make_shared<MetricData>("FPS", wxColour(200, 100, 100), "fps", 200);
    m_cpuMetric = std::make_shared<MetricData>("CPU Usage", wxColour(100, 100, 200), "%", 200);
    m_memoryMetric = std::make_shared<MetricData>("App Memory", wxColour(200, 200, 100), "MB", 200);
}
 
void PerformanceMonitor::BeginFrame() {
    if (!m_enabled)
        return;
 
    m_frameStart = std::chrono::high_resolution_clock::now();
    m_frameActive = true;
}
 
void PerformanceMonitor::EndFrame() {
    if (!m_enabled || !m_frameActive)
        return;
 
    auto frameEnd = std::chrono::high_resolution_clock::now();
 
    // Calculate frame time
    auto frameTime = std::chrono::duration<float, std::milli>(frameEnd - m_frameStart).count();
    m_frameTimeMetric->AddValue(frameTime);
 
    // Update FPS
    UpdateFPS();
 
    // Update system metrics periodically
    static int frameCount = 0;
    if (++frameCount % 30 == 0) { // Update every 30 frames
        UpdateSystemMetrics();
    }
 
    m_frameActive = false;
    m_lastFrameTime = frameEnd;
}
 
void PerformanceMonitor::UpdateFPS() {
    auto now = std::chrono::high_resolution_clock::now();
    auto deltaTime = std::chrono::duration<float>(now - m_lastFrameTime).count();
 
    if (deltaTime > 0.0f) {
        float fps = 1.0f / deltaTime;
        m_currentFPS = fps;
        m_fpsMetric->AddValue(fps);
    }
}
 
void PerformanceMonitor::UpdateSystemMetrics() {
    m_cpuUsage = ReadCPUUsage();
    m_memoryUsageMB = ReadMemoryUsage();
 
    m_cpuMetric->AddValue(m_cpuUsage);
    m_memoryMetric->AddValue(m_memoryUsageMB);
}
 
float PerformanceMonitor::ReadCPUUsage() {
#ifdef __linux__
    std::ifstream file("/proc/stat");
    if (!file.is_open())
        return 0.0f;
 
    std::string line;
    std::getline(file, line);
 
    std::istringstream iss(line);
    std::string cpu;
    unsigned long long user, nice, system, idle, iowait, irq, softirq, steal, guest, guest_nice;
 
    iss >> cpu >> user >> nice >> system >> idle >> iowait >> irq >> softirq >> steal >> guest >> guest_nice;
 
    unsigned long long totalIdle = idle + iowait;
    unsigned long long totalNonIdle = user + nice + system + irq + softirq + steal;
    unsigned long long total = totalIdle + totalNonIdle;
 
    if (m_lastCpuTotal == 0) {
        m_lastCpuTotal = total;
        m_lastCpuIdle = totalIdle;
        return 0.0f;
    }
 
    unsigned long long totalDiff = total - m_lastCpuTotal;
    unsigned long long idleDiff = totalIdle - m_lastCpuIdle;
 
    float cpuPercent = 0.0f;
    if (totalDiff > 0) {
        cpuPercent = ((float)(totalDiff - idleDiff) / totalDiff) * 100.0f;
    }
 
    m_lastCpuTotal = total;
    m_lastCpuIdle = totalIdle;
 
    return cpuPercent;
#else
    return 0.0f; // Placeholder for other platforms
#endif
}
 
float PerformanceMonitor::ReadMemoryUsage() {
#ifdef __linux__
    // Read application's memory usage from /proc/self/status
    std::ifstream statusFile("/proc/self/status");
    if (!statusFile.is_open())
        return 0.0f;
 
    std::string line;
    float vmRSSKb = 0.0f;
 
    while (std::getline(statusFile, line)) {
        if (line.substr(0, 6) == "VmRSS:") {
            // Extract the value (in kB)
            std::istringstream iss(line);
            std::string label, unit;
            iss >> label >> vmRSSKb >> unit;
            break;
        }
    }
 
    // Convert from kB to MB
    return vmRSSKb / 1024.0f;
#else
    return 0.0f; // Placeholder for other platforms
#endif
}
 
void PerformanceMonitor::RecordMetric(const std::string &name, float value, const std::string &unit) {
    if (!m_enabled)
        return;
 
    auto it = m_customMetrics.find(name);
    if (it == m_customMetrics.end()) {
        // Create new metric with a unique color
        static int colorIndex = 0;
        wxColour colors[] = {wxColour(255, 100, 100), wxColour(100, 255, 100), wxColour(100, 100, 255),
                             wxColour(255, 255, 100), wxColour(255, 100, 255), wxColour(100, 255, 255),
                             wxColour(200, 150, 100), wxColour(150, 200, 100), wxColour(100, 150, 200)};
 
        wxColour color = colors[colorIndex % (sizeof(colors) / sizeof(colors[0]))];
        colorIndex++;
 
        m_customMetrics[name] = std::make_shared<MetricData>(name, color, unit, 120);
    }
 
    m_customMetrics[name]->AddValue(value);
}
 
void PerformanceMonitor::RecordTime(const std::string &name, double milliseconds) {
    RecordMetric(name, static_cast<float>(milliseconds), "ms");
}
 
std::shared_ptr<MetricData> PerformanceMonitor::GetMetric(const std::string &name) const {
    // Check built-in metrics first
    if (name == "Frame Time")
        return m_frameTimeMetric;
    if (name == "FPS")
        return m_fpsMetric;
    if (name == "CPU Usage")
        return m_cpuMetric;
    if (name == "App Memory")
        return m_memoryMetric;
 
    // Check custom metrics
    auto it = m_customMetrics.find(name);
    if (it != m_customMetrics.end()) {
        return it->second;
    }
 
    return nullptr;
}
 
std::vector<std::shared_ptr<MetricData>> PerformanceMonitor::GetAllMetrics() const {
    std::vector<std::shared_ptr<MetricData>> metrics;
 
    // Only add built-in metrics that we have toggles for
    metrics.push_back(m_frameTimeMetric);
    metrics.push_back(m_fpsMetric);
    metrics.push_back(m_cpuMetric);
    metrics.push_back(m_memoryMetric);
 
    // Note: Custom metrics are ignored to keep the performance tab clean
    // Only showing metrics with explicit toggle controls
 
    return metrics;
}
 
void PerformanceMonitor::Clear() {
    m_frameTimeMetric->Clear();
    m_fpsMetric->Clear();
    m_cpuMetric->Clear();
    m_memoryMetric->Clear();
 
    for (auto &pair : m_customMetrics) {
        pair.second->Clear();
    }
}
 
PerformanceMonitor &PerformanceMonitor::GetInstance() {
    static PerformanceMonitor instance;
    return instance;
}
 
// PerformancePanel Implementation
wxBEGIN_EVENT_TABLE(PerformancePanel, wxPanel) EVT_TIMER(ID_UPDATE_TIMER, PerformancePanel::OnUpdateTimer)
    EVT_PAINT(PerformancePanel::OnPaint) EVT_SIZE(PerformancePanel::OnSize)
        EVT_BUTTON(ID_TOGGLE_MONITORING, PerformancePanel::OnToggleMonitoring)
            EVT_BUTTON(ID_CLEAR_METRICS, PerformancePanel::OnClearMetrics)
                EVT_BUTTON(ID_EXPORT_METRICS, PerformancePanel::OnExportMetrics)
                    EVT_CHECKBOX(ID_TOGGLE_FRAME_TIME, PerformancePanel::OnToggleChart)
                        EVT_CHECKBOX(ID_TOGGLE_FPS, PerformancePanel::OnToggleChart)
                            EVT_CHECKBOX(ID_TOGGLE_CPU, PerformancePanel::OnToggleChart)
                                EVT_CHECKBOX(ID_TOGGLE_MEMORY, PerformancePanel::OnToggleChart)
                                    EVT_BUTTON(ID_HISTORY_MINUS, PerformancePanel::OnHistoryMinus)
                                        EVT_BUTTON(ID_HISTORY_PLUS, PerformancePanel::OnHistoryPlus) wxEND_EVENT_TABLE()
 
                                            PerformancePanel::PerformancePanel(wxWindow *parent,
                                                                               PerformanceMonitor *monitor)
    : wxPanel(parent, wxID_ANY), m_monitor(monitor ? monitor : &PerformanceMonitor::GetInstance()),
      m_updateTimer(nullptr), m_monitoring(false),
      m_chartHistory(200) // Default 20 seconds (200 samples at 10 samples/sec)
      ,
      m_chartHeight(100), m_chartMargin(10) {
    SetBackgroundColour(wxColour(40, 40, 40));
    SetBackgroundStyle(wxBG_STYLE_PAINT);
 
    // Set up fonts
    m_labelFont = wxFont(8, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL);
    m_valueFont = wxFont(9, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_BOLD);
 
    // Initialize chart enabled states - all disabled by default for clean start
    m_chartEnabled["Frame Time"] = false;
    m_chartEnabled["FPS"] = false;
    m_chartEnabled["CPU Usage"] = false;
    m_chartEnabled["App Memory"] = false;
 
    CreateLayout();
 
    // Set monitor to match initial state (disabled) and clear any existing data
    if (m_monitor) {
        m_monitor->SetEnabled(m_monitoring);
        m_monitor->Clear(); // Start with clean metrics
    }
 
    // Set up update timer
    m_updateTimer = new wxTimer(this, ID_UPDATE_TIMER);
    m_updateTimer->Start(100); // Update every 100ms
}
 
PerformancePanel::~PerformancePanel() {
    if (m_updateTimer) {
        m_updateTimer->Stop();
        delete m_updateTimer;
    }
}
 
void PerformancePanel::SetMonitor(PerformanceMonitor *monitor) {
    m_monitor = monitor ? monitor : &PerformanceMonitor::GetInstance();
}
 
void PerformancePanel::CreateLayout() {
    wxBoxSizer *mainSizer = new wxBoxSizer(wxVERTICAL);
 
    // Set the sizer first before creating child components
    SetSizer(mainSizer);
 
    CreateToolbar();
    CreateCharts();
}
 
void PerformancePanel::CreateToolbar() {
    wxPanel *toolbar = new wxPanel(this, wxID_ANY);
    toolbar->SetBackgroundColour(wxColour(50, 50, 50));
 
    wxBoxSizer *toolbarSizer = new wxBoxSizer(wxHORIZONTAL);
 
    // Toggle monitoring button
    m_toggleButton = new wxButton(toolbar, ID_TOGGLE_MONITORING, "START | STOP");
    toolbarSizer->Add(m_toggleButton, 0, wxALL, 5);
 
    // Clear metrics button
    m_clearButton = new wxButton(toolbar, ID_CLEAR_METRICS, "Clear");
    toolbarSizer->Add(m_clearButton, 0, wxALL, 5);
 
    // Export button
    m_exportButton = new wxButton(toolbar, ID_EXPORT_METRICS, "Export");
    toolbarSizer->Add(m_exportButton, 0, wxALL, 5);
 
    // Add separator
    toolbarSizer->AddSpacer(20);
 
    // Chart toggle checkboxes
    wxStaticText *chartsLabel = new wxStaticText(toolbar, wxID_ANY, "Charts:");
    chartsLabel->SetForegroundColour(wxColour(200, 200, 200));
    toolbarSizer->Add(chartsLabel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
 
    m_frameTimeCheckbox = new wxCheckBox(toolbar, ID_TOGGLE_FRAME_TIME, "Frame Time");
    m_frameTimeCheckbox->SetValue(false);
    m_frameTimeCheckbox->SetForegroundColour(wxColour(200, 200, 200));
    toolbarSizer->Add(m_frameTimeCheckbox, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
 
    m_fpsCheckbox = new wxCheckBox(toolbar, ID_TOGGLE_FPS, "FPS");
    m_fpsCheckbox->SetValue(false);
    m_fpsCheckbox->SetForegroundColour(wxColour(200, 200, 200));
    toolbarSizer->Add(m_fpsCheckbox, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
 
    m_cpuCheckbox = new wxCheckBox(toolbar, ID_TOGGLE_CPU, "CPU");
    m_cpuCheckbox->SetValue(false);
    m_cpuCheckbox->SetForegroundColour(wxColour(200, 200, 200));
    toolbarSizer->Add(m_cpuCheckbox, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
 
    m_memoryCheckbox = new wxCheckBox(toolbar, ID_TOGGLE_MEMORY, "Memory");
    m_memoryCheckbox->SetValue(false);
    m_memoryCheckbox->SetForegroundColour(wxColour(200, 200, 200));
    toolbarSizer->Add(m_memoryCheckbox, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
 
    toolbarSizer->AddStretchSpacer();
 
    // Add separator
    toolbarSizer->AddSpacer(20);
 
    // Timeframe control
    wxStaticText *timeframeLabel = new wxStaticText(toolbar, wxID_ANY, "History:");
    timeframeLabel->SetForegroundColour(wxColour(200, 200, 200));
    toolbarSizer->Add(timeframeLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 8);
 
    m_historyMinusButton = new wxButton(toolbar, ID_HISTORY_MINUS, "-", wxDefaultPosition, wxSize(35, 28));
    wxFont minusFont = m_historyMinusButton->GetFont();
    minusFont.SetPointSize(14);
    minusFont.SetWeight(wxFONTWEIGHT_BOLD);
    m_historyMinusButton->SetFont(minusFont);
    toolbarSizer->Add(m_historyMinusButton, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
 
    m_historyText = new wxStaticText(toolbar, wxID_ANY, wxString::Format("%d", m_chartHistory / 10), wxDefaultPosition,
                                     wxDefaultSize, wxALIGN_CENTRE);
    m_historyText->SetForegroundColour(wxColour(200, 200, 200));
    m_historyText->SetMinSize(wxSize(40, -1));
    toolbarSizer->Add(m_historyText, 0, wxALIGN_CENTER_VERTICAL | wxALIGN_CENTER_HORIZONTAL, 0);
 
    m_historyPlusButton = new wxButton(toolbar, ID_HISTORY_PLUS, "+", wxDefaultPosition, wxSize(35, 28));
    wxFont plusFont = m_historyPlusButton->GetFont();
    plusFont.SetPointSize(14);
    plusFont.SetWeight(wxFONTWEIGHT_BOLD);
    m_historyPlusButton->SetFont(plusFont);
    toolbarSizer->Add(m_historyPlusButton, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, 5);
 
    wxStaticText *secondsLabel = new wxStaticText(toolbar, wxID_ANY, "seconds");
    secondsLabel->SetForegroundColour(wxColour(200, 200, 200));
    toolbarSizer->Add(secondsLabel, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, 8);
 
    toolbarSizer->AddStretchSpacer();
 
    // Status text
    m_statusText = new wxStaticText(toolbar, wxID_ANY, "OFF");
    m_statusText->SetForegroundColour(wxColour(255, 0, 0)); // Red for inactive
    toolbarSizer->Add(m_statusText, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
 
    toolbar->SetSizer(toolbarSizer);
 
    // Safely add to main sizer if it exists
    wxSizer *mainSizer = GetSizer();
    if (mainSizer) {
        mainSizer->Add(toolbar, 0, wxEXPAND | wxALL, 2);
    }
}
 
void PerformancePanel::CreateCharts() {
    m_chartsPanel = new wxPanel(this, wxID_ANY);
    m_chartsPanel->SetBackgroundColour(wxColour(30, 30, 30));
    m_chartsPanel->SetBackgroundStyle(wxBG_STYLE_PAINT);
    m_chartsPanel->Bind(wxEVT_PAINT, &PerformancePanel::OnPaint, this);
    m_chartsPanel->Bind(wxEVT_SIZE, &PerformancePanel::OnSize, this);
 
    // Safely add to main sizer if it exists
    wxSizer *mainSizer = GetSizer();
    if (mainSizer) {
        mainSizer->Add(m_chartsPanel, 1, wxEXPAND | wxALL, 2);
    }
}
 
void PerformancePanel::OnUpdateTimer(wxTimerEvent &event) {
    if (m_monitoring && m_monitor) {
        RefreshDisplay();
    }
}
 
void PerformancePanel::RefreshDisplay() {
    UpdateMetricDisplays();
    m_chartsPanel->Refresh();
}
 
void PerformancePanel::UpdateMetricDisplays() {
    if (!m_monitor)
        return;
 
    // Status text is now handled by the toggle button to show ON/OFF state
    // Detailed metrics are visible in the individual charts
 
    // Keep the status text as simple ON/OFF indicator
    // m_statusText shows monitoring state, not detailed metrics
}
 
void PerformancePanel::OnPaint(wxPaintEvent &event) {
    if (!m_monitor)
        return;
 
    // Get the window that received the paint event
    wxWindow *paintWindow = dynamic_cast<wxWindow *>(event.GetEventObject());
    if (!paintWindow)
        paintWindow = m_chartsPanel;
    wxAutoBufferedPaintDC dc(paintWindow);
    dc.Clear();
 
    auto allMetrics = m_monitor->GetAllMetrics();
    if (allMetrics.empty())
        return;
 
    // Filter enabled charts only - also verify metrics are valid
    std::vector<std::shared_ptr<MetricData>> enabledMetrics;
    for (const auto &metric : allMetrics) {
        if (metric && !metric->name.empty() && IsChartEnabled(metric->name.ToStdString())) {
            enabledMetrics.push_back(metric);
        }
    }
 
    if (enabledMetrics.empty())
        return;
 
    int numCharts = enabledMetrics.size();
    for (int i = 0; i < numCharts; ++i) {
        wxRect chartRect = GetChartRect(i, numCharts);
        DrawChart(dc, chartRect, enabledMetrics[i]);
    }
}
 
void PerformancePanel::DrawChart(wxDC &dc, const wxRect &rect, std::shared_ptr<MetricData> metric) {
    if (!metric || metric->values.empty())
        return;
 
    // Draw background
    dc.SetBrush(wxBrush(wxColour(25, 25, 25)));
    dc.SetPen(wxPen(wxColour(60, 60, 60)));
    dc.DrawRectangle(rect);
 
    // Draw grid
    DrawGrid(dc, rect, metric->min_value, metric->max_value);
 
    // Draw metric info
    wxRect infoRect = rect;
    infoRect.height = 25;
    DrawMetricInfo(dc, infoRect, metric);
 
    // Draw chart data
    if (metric->values.size() < 2)
        return;
 
    wxRect dataRect = rect;
    dataRect.y += 25;
    dataRect.height -= 25;
 
    float range = metric->max_value - metric->min_value;
    if (range <= 0.0f)
        range = 1.0f;
 
    // Draw line chart
    dc.SetPen(wxPen(metric->color, 2));
 
    const auto &values = metric->values;
    int numValues = values.size();
    float xStep = (float)dataRect.width / (numValues - 1);
 
    for (int i = 1; i < numValues; ++i) {
        float x1 = dataRect.x + (i - 1) * xStep;
        float y1 = dataRect.y + dataRect.height - ((values[i - 1] - metric->min_value) / range) * dataRect.height;
        float x2 = dataRect.x + i * xStep;
        float y2 = dataRect.y + dataRect.height - ((values[i] - metric->min_value) / range) * dataRect.height;
 
        dc.DrawLine(wxPoint(x1, y1), wxPoint(x2, y2));
    }
}
 
void PerformancePanel::DrawMetricInfo(wxDC &dc, const wxRect &rect, std::shared_ptr<MetricData> metric) {
    dc.SetFont(m_labelFont);
    dc.SetTextForeground(wxColour(200, 200, 200));
 
    wxString info = wxString::Format(
        "%s: %s (Avg: %s, Min: %s, Max: %s)", metric->name, FormatValue(metric->current_value, metric->unit),
        FormatValue(metric->GetAverage(), metric->unit), FormatValue(metric->min_value, metric->unit),
        FormatValue(metric->max_value, metric->unit));
 
    dc.DrawText(info, rect.x + 5, rect.y + 5);
}
 
void PerformancePanel::DrawGrid(wxDC &dc, const wxRect &rect, float minVal, float maxVal) {
    dc.SetPen(wxPen(wxColour(50, 50, 50), 1));
 
    // Horizontal grid lines
    for (int i = 1; i < 5; ++i) {
        int y = rect.y + (rect.height * i) / 5;
        dc.DrawLine(rect.x, y, rect.x + rect.width, y);
    }
 
    // Vertical grid lines
    for (int i = 1; i < 10; ++i) {
        int x = rect.x + (rect.width * i) / 10;
        dc.DrawLine(x, rect.y, x, rect.y + rect.height);
    }
}
 
wxRect PerformancePanel::GetChartRect(int index, int totalCharts) const {
    wxSize size = m_chartsPanel->GetSize();
 
    // Prevent division by zero and ensure positive dimensions
    if (totalCharts <= 0)
        totalCharts = 1;
 
    int availableHeight = size.y - (totalCharts + 1) * m_chartMargin;
    int chartHeight = std::max(50, availableHeight / totalCharts); // Minimum 50px height
    int y = m_chartMargin + index * (chartHeight + m_chartMargin);
 
    int chartWidth = std::max(100, size.x - 2 * m_chartMargin); // Minimum 100px width
 
    return wxRect(m_chartMargin, y, chartWidth, chartHeight);
}
 
wxString PerformancePanel::FormatValue(float value, const wxString &unit) const {
    if (unit == "ms") {
        return wxString::Format("%.2fms", value);
    } else if (unit == "fps") {
        return wxString::Format("%.1f", value);
    } else if (unit == "%") {
        return wxString::Format("%.1f%%", value);
    } else if (unit == "MB") {
        return wxString::Format("%.1fMB", value);
    } else {
        return wxString::Format("%.2f", value) + (unit.IsEmpty() ? "" : unit);
    }
}
 
void PerformancePanel::OnSize(wxSizeEvent &event) {
    m_chartsPanel->Refresh();
    event.Skip();
}
 
void PerformancePanel::OnToggleMonitoring(wxCommandEvent &event) {
    m_monitoring = !m_monitoring;
 
    if (m_monitor) {
        m_monitor->SetEnabled(m_monitoring);
    }
 
    // Update status text with color
    if (m_monitoring) {
        m_statusText->SetLabel("ON");
        m_statusText->SetForegroundColour(wxColour(0, 255, 0)); // Green for active
    } else {
        m_statusText->SetLabel("OFF");
        m_statusText->SetForegroundColour(wxColour(255, 0, 0)); // Red for stopped
    }
 
    // Refresh the toolbar to show color changes
    m_statusText->Refresh();
}
 
void PerformancePanel::OnClearMetrics(wxCommandEvent &event) {
    if (m_monitor) {
        m_monitor->Clear();
        RefreshDisplay();
    }
}
 
void PerformancePanel::OnExportMetrics(wxCommandEvent &event) {
    if (!m_monitor)
        return;
 
    wxFileDialog saveDialog(this, "Export Performance Data", "", "performance.csv",
                            "CSV files (*.csv)|*.csv|All files (*.*)|*.*", wxFD_SAVE | wxFD_OVERWRITE_PROMPT);
 
    if (saveDialog.ShowModal() == wxID_OK) {
        wxString path = saveDialog.GetPath();
 
        auto metrics = m_monitor->GetAllMetrics();
        if (metrics.empty())
            return;
 
        // Find maximum number of samples
        size_t maxSamples = 0;
        for (const auto &metric : metrics) {
            maxSamples = std::max(maxSamples, metric->values.size());
        }
 
        wxString content = "Sample";
        for (const auto &metric : metrics) {
            content += ",%s (" + metric->name, metric->unit + ")";
        }
        content += "\n";
 
        for (size_t i = 0; i < maxSamples; ++i) {
            content += wxString::Format("%zu", i);
            for (const auto &metric : metrics) {
                if (i < metric->values.size()) {
                    content += wxString::Format(",%.3f", metric->values[i]);
                } else {
                    content += ",";
                }
            }
            content += "\n";
        }
 
        wxFile file(path, wxFile::write);
        if (file.IsOpened()) {
            file.Write(content);
            file.Close();
 
            wxMessageBox("Performance data exported to " + path + "", "Export Complete", wxOK | wxICON_INFORMATION,
                         this);
        } else {
            wxMessageBox("Failed to save performance data", "Export Error", wxOK | wxICON_ERROR, this);
        }
    }
}
 
void PerformancePanel::SetUpdateInterval(int milliseconds) {
    if (m_updateTimer) {
        m_updateTimer->Stop();
        m_updateTimer->Start(milliseconds);
    }
}
 
void PerformancePanel::OnToggleChart(wxCommandEvent &event) {
    int id = event.GetId();
    bool enabled = static_cast<wxCheckBox *>(event.GetEventObject())->GetValue();
 
    switch (id) {
    case ID_TOGGLE_FRAME_TIME:
        SetChartEnabled("Frame Time", enabled);
        break;
    case ID_TOGGLE_FPS:
        SetChartEnabled("FPS", enabled);
        break;
    case ID_TOGGLE_CPU:
        SetChartEnabled("CPU Usage", enabled);
        break;
    case ID_TOGGLE_MEMORY:
        SetChartEnabled("App Memory", enabled);
        break;
    }
 
    RefreshDisplay();
}
 
void PerformancePanel::SetChartEnabled(const std::string &chartName, bool enabled) {
    m_chartEnabled[chartName] = enabled;
}
 
bool PerformancePanel::IsChartEnabled(const std::string &chartName) const {
    // Only allow the 4 built-in charts we have toggles for
    if (chartName != "Frame Time" && chartName != "FPS" && chartName != "CPU Usage" && chartName != "App Memory") {
        return false; // Unknown charts are disabled
    }
 
    auto it = m_chartEnabled.find(chartName);
    return it != m_chartEnabled.end() ? it->second : false; // Default to false for clean start
}
 
void PerformancePanel::SetAllChartsEnabled(bool enabled) {
    for (auto &pair : m_chartEnabled) {
        pair.second = enabled;
    }
 
    // Update checkbox states
    m_frameTimeCheckbox->SetValue(enabled);
    m_fpsCheckbox->SetValue(enabled);
    m_cpuCheckbox->SetValue(enabled);
    m_memoryCheckbox->SetValue(enabled);
 
    RefreshDisplay();
}
 
std::vector<std::string> PerformancePanel::GetAvailableCharts() const {
    std::vector<std::string> charts;
    for (const auto &pair : m_chartEnabled) {
        charts.push_back(pair.first);
    }
    return charts;
}
 
void PerformancePanel::OnHistoryMinus(wxCommandEvent &event) {
    int currentSeconds = m_chartHistory / 10;
    if (currentSeconds >= 20) { // Minimum 10 seconds (allow decrease from 20 to 10)
        currentSeconds -= 10;
        m_chartHistory = currentSeconds * 10;
 
        // Update display
        m_historyText->SetLabel(wxString::Format("%d", currentSeconds));
 
        // Update the max_samples for all metrics
        if (m_monitor) {
            auto metrics = m_monitor->GetAllMetrics();
            for (auto &metric : metrics) {
                if (metric) {
                    metric->max_samples = m_chartHistory;
 
                    // Trim existing values if necessary
                    while (metric->values.size() > static_cast<size_t>(m_chartHistory)) {
                        metric->values.pop_front();
                    }
                }
            }
        }
 
        RefreshDisplay();
    }
}
 
void PerformancePanel::OnHistoryPlus(wxCommandEvent &event) {
    int currentSeconds = m_chartHistory / 10;
    if (currentSeconds <= 990) { // Maximum 1000 seconds (ensure we don't exceed when adding 10)
        currentSeconds += 10;
        m_chartHistory = currentSeconds * 10;
 
        // Update display
        m_historyText->SetLabel(wxString::Format("%d", currentSeconds));
 
        // Update the max_samples for all metrics
        if (m_monitor) {
            auto metrics = m_monitor->GetAllMetrics();
            for (auto &metric : metrics) {
                if (metric) {
                    metric->max_samples = m_chartHistory;
                }
            }
        }
 
        RefreshDisplay();
    }
}
 
} // namespace EmberForge