performance_monitor.cpp

#include "performance_monitor.h"

// ===== CONSTRUCTOR & DESTRUCTOR =====
PerformanceMonitor::PerformanceMonitor() 
    : startTime(0), lastUpdateTime(0), lastSpeedUpdateTime(0), 
      totalBytes(0), lastByteCount(0), currentSpeedKBps(0), 
      averageSpeedKBps(0), historyIndex(0), isActive(false),
      connectionStartTime(0), firstByteTime(0), transferStartTime(0),
      firstByteReceived(false) {
    
    // Initialize speed history array
    for (int i = 0; i < PERFORMANCE_HISTORY_SIZE; i++) {
        speedHistory[i] = 0.0;
    }
}

PerformanceMonitor::~PerformanceMonitor() {
    stopMonitoring();
}

// ===== MONITORING CONTROL =====
void PerformanceMonitor::startMonitoring() {
    resetMonitoring();
    startTime = millis();
    lastUpdateTime = startTime;
    lastSpeedUpdateTime = startTime;
    isActive = true;
    
    Serial.println("=== Performance Monitoring Started ===");
}

void PerformanceMonitor::stopMonitoring() {
    if (isActive) {
        isActive = false;
        Serial.println("=== Performance Monitoring Stopped ===");
    }
}

void PerformanceMonitor::resetMonitoring() {
    startTime = 0;
    lastUpdateTime = 0;
    lastSpeedUpdateTime = 0;
    totalBytes = 0;
    lastByteCount = 0;
    currentSpeedKBps = 0;
    averageSpeedKBps = 0;
    historyIndex = 0;
    
    // Reset enhanced timing
    connectionStartTime = 0;
    firstByteTime = 0;
    transferStartTime = 0;
    firstByteReceived = false;
    detailedTiming = DetailedTiming();
    
    for (int i = 0; i < PERFORMANCE_HISTORY_SIZE; i++) {
        speedHistory[i] = 0.0;
    }
}

// ===== ENHANCED TIMING METHODS =====
void PerformanceMonitor::startConnectionTimer() {
    connectionStartTime = millis();
    firstByteReceived = false;
}

void PerformanceMonitor::markFirstByte() {
    if (!firstByteReceived) {
        firstByteTime = millis();
        transferStartTime = millis();
        firstByteReceived = true;
        detailedTiming.connectionSetupMs = firstByteTime - connectionStartTime;
        detailedTiming.firstByteMs = firstByteTime - connectionStartTime;
    }
}

void PerformanceMonitor::stopEnhancedMonitoring() {
    unsigned long endTime = millis();
    detailedTiming.totalTimeMs = endTime - connectionStartTime;
    if (firstByteReceived) {
        detailedTiming.transferOnlyMs = endTime - transferStartTime;
    }
}

// ===== PROGRESS TRACKING =====
void PerformanceMonitor::updateProgress(size_t bytesTransferred) {
    if (!isActive) return;
    
    totalBytes = bytesTransferred;
    unsigned long currentTime = millis();
    
    // Update speed if enough time has passed
    if (currentTime - lastSpeedUpdateTime >= SPEED_UPDATE_INTERVAL_MS) {
        calculateCurrentSpeed(bytesTransferred);
        lastSpeedUpdateTime = currentTime;
    }
    
    // Update progress display
    if (currentTime - lastUpdateTime >= PROGRESS_UPDATE_INTERVAL_MS) {
        printProgress();
        lastUpdateTime = currentTime;
    }
}

void PerformanceMonitor::updateProgress(size_t current, size_t total) {
    updateProgress(current);
    
    if (total > 0 && isActive) {
        float percentage = (current * 100.0) / total;
        Serial.printf("Progress: %.1f%% (%s/%s) at %.2f KB/s\n", 
                     percentage, formatBytes(current).c_str(), 
                     formatBytes(total).c_str(), currentSpeedKBps);
    }
}

void PerformanceMonitor::printProgress() const {
    if (!isActive) return;
    
    Serial.printf("Downloaded: %s | Speed: %.2f KB/s | Time: %s\n",
                 formatBytes(totalBytes).c_str(),
                 currentSpeedKBps,
                 formatTime(getElapsedTime()).c_str());
}

void PerformanceMonitor::printProgress(size_t current, size_t total) const {
    if (total > 0) {
        float percentage = (current * 100.0) / total;
        Serial.printf("Progress: %d/%d bytes (%.1f%%) at %.2f KB/s\n", 
                     current, total, percentage, currentSpeedKBps);
    } else {
        Serial.printf("Downloaded: %d bytes at %.2f KB/s\n", current, currentSpeedKBps);
    }
}

// ===== SPEED CALCULATION =====
void PerformanceMonitor::calculateCurrentSpeed(size_t newBytes) {
    if (!isActive || startTime == 0) return;
    
    unsigned long currentTime = millis();
    unsigned long timeDiff = currentTime - lastSpeedUpdateTime;
    
    if (timeDiff > 0) {
        size_t bytesDiff = newBytes - lastByteCount;
        currentSpeedKBps = calculateSpeedKBps(bytesDiff, timeDiff);
        
        // Update speed history
        updateSpeedHistory();
        
        // Calculate average speed
        unsigned long totalTime = currentTime - startTime;
        if (totalTime > 0) {
            averageSpeedKBps = calculateSpeedKBps(newBytes, totalTime);
        }
        
        lastByteCount = newBytes;
    }
}

void PerformanceMonitor::updateSpeedHistory() {
    speedHistory[historyIndex] = currentSpeedKBps;
    historyIndex = (historyIndex + 1) % PERFORMANCE_HISTORY_SIZE;
}

float PerformanceMonitor::getPeakSpeed() const {
    float peak = 0.0;
    for (int i = 0; i < PERFORMANCE_HISTORY_SIZE; i++) {
        if (speedHistory[i] > peak) {
            peak = speedHistory[i];
        }
    }
    return peak;
}

// ===== TIMING METHODS =====
unsigned long PerformanceMonitor::getElapsedTime() const {
    if (!isActive || startTime == 0) return 0;
    return millis() - startTime;
}

float PerformanceMonitor::getElapsedTimeSeconds() const {
    return getElapsedTime() / 1000.0;
}

// ===== RESULTS AND REPORTING =====
void PerformanceMonitor::printDetailedResults(size_t totalBytesTransferred) const {
    Serial.println("\n=== DETAILED PERFORMANCE RESULTS ===");
    Serial.println("Total bytes: " + formatBytes(totalBytesTransferred));
    Serial.println("Total time: " + formatTime(getElapsedTime()));
    Serial.printf("Average speed: %.2f KB/s (%.2f MB/s)\n", averageSpeedKBps, averageSpeedKBps / 1024.0);
    Serial.printf("Peak speed: %.2f KB/s (%.2f MB/s)\n", getPeakSpeed(), getPeakSpeed() / 1024.0);
    Serial.printf("Current speed: %.2f KB/s\n", currentSpeedKBps);
    Serial.println("Target achieved: " + String(hasAchievedTarget() ? "YES" : "NO"));
    Serial.println("Performance rating: " + getPerformanceRating(averageSpeedKBps));
    Serial.println("====================================");
}

void PerformanceMonitor::printEnhancedResults(size_t totalBytesTransferred) const {
    Serial.println("\n=== ENHANCED PERFORMANCE ANALYSIS ===");
    Serial.println("File size: " + formatBytes(totalBytesTransferred));
    Serial.println("Connection setup: " + String(detailedTiming.connectionSetupMs) + " ms");
    Serial.println("Transfer time: " + String(detailedTiming.transferOnlyMs) + " ms");
    Serial.println("Total time: " + String(detailedTiming.totalTimeMs) + " ms");
    Serial.println("");
    
    float pureSpeed = detailedTiming.getPureTransferSpeedKBps(totalBytesTransferred);
    float overallSpeed = detailedTiming.getOverallSpeedKBps(totalBytesTransferred);
    float efficiency = detailedTiming.getEfficiencyPercent();
    
    Serial.println("Pure transfer speed: " + String(pureSpeed, 2) + " KB/s");
    Serial.println("Overall speed: " + String(overallSpeed, 2) + " KB/s");
    Serial.println("Transfer efficiency: " + String(efficiency, 1) + "%");
    
    // File size analysis
    if (totalBytesTransferred < 10240) {  // < 10KB
        Serial.println("Analysis: Small file - Speed dominated by connection overhead");
        Serial.println("Recommendation: Use files >100KB for accurate speed testing");
    } else if (totalBytesTransferred < 102400) {  // < 100KB
        Serial.println("Analysis: Medium file - Some overhead impact on speed");
        Serial.println("Recommendation: Use files >1MB for best speed accuracy");
    } else {
        Serial.println("Analysis: Large file - Speed measurement is accurate");
        Serial.println("Recommendation: This speed represents true performance");
    }
    
    // Performance rating based on pure transfer speed
    String pureSpeedRating = getPerformanceRating(pureSpeed);
    Serial.println("Pure speed rating: " + pureSpeedRating);
    Serial.println("Target achieved: " + String(pureSpeed >= TARGET_SPEED_KBPS ? "YES" : "NO"));
    Serial.println("=======================================");
}

void PerformanceMonitor::printSpeedSummary() const {
    Serial.println("=== SPEED SUMMARY ===");
    printSpeedInAllUnits(averageSpeedKBps);
    Serial.println("=====================");
}

void PerformanceMonitor::printPerformanceAnalysis() const {
    Serial.println("=== PERFORMANCE ANALYSIS ===");
    Serial.println(getSpeedAnalysisReport());
    Serial.println("=============================");
}

bool PerformanceMonitor::hasAchievedTarget() const {
    return averageSpeedKBps >= TARGET_SPEED_KBPS;
}

// ===== UTILITY METHODS =====
void PerformanceMonitor::printSpeedInAllUnits(float speedKBps) const {
    float speedBps = speedKBps * 1024.0;
    float speedMBps = speedKBps / 1024.0;
    float speedMbps = speedKBps * 8.0 / 1024.0; // Megabits per second
    
    Serial.printf("Speed: %.0f B/s | %.2f KB/s | %.3f MB/s | %.2f Mbps\n", 
                 speedBps, speedKBps, speedMBps, speedMbps);
}

String PerformanceMonitor::getPerformanceRating(float speedKBps) const {
    if (speedKBps >= 1000.0) return "EXCELLENT";
    else if (speedKBps >= 500.0) return "VERY GOOD";
    else if (speedKBps >= 400.0) return "GOOD";
    else if (speedKBps >= 200.0) return "AVERAGE";
    else if (speedKBps >= 100.0) return "BELOW AVERAGE";
    else return "POOR";
}

String PerformanceMonitor::getSpeedAnalysisReport() const {
    String report = "Average: " + formatSpeed(averageSpeedKBps);
    report += " | Peak: " + formatSpeed(getPeakSpeed());
    report += " | Rating: " + getPerformanceRating(averageSpeedKBps);
    report += " | Target: " + String(hasAchievedTarget() ? "ACHIEVED" : "NOT ACHIEVED");
    return report;
}

// ===== STATIC UTILITY METHODS =====
float PerformanceMonitor::convertBytesToKB(size_t bytes) {
    return (float)bytes / 1024.0;
}

float PerformanceMonitor::convertBytesToMB(size_t bytes) {
    return (float)bytes / (1024.0 * 1024.0);
}

float PerformanceMonitor::calculateSpeedKBps(size_t bytes, unsigned long timeMs) {
    if (timeMs == 0) return 0.0;
    return (convertBytesToKB(bytes) * 1000.0) / (float)timeMs;
}

String PerformanceMonitor::formatSpeed(float speedKBps) {
    if (speedKBps >= 1024.0) {
        return String(speedKBps / 1024.0, 2) + " MB/s";
    } else {
        return String(speedKBps, 2) + " KB/s";
    }
}

String PerformanceMonitor::formatTime(unsigned long timeMs) {
    if (timeMs < 1000) {
        return String(timeMs) + "ms";
    } else if (timeMs < 60000) {
        return String(timeMs / 1000.0, 1) + "s";
    } else {
        int minutes = timeMs / 60000;
        int seconds = (timeMs % 60000) / 1000;
        return String(minutes) + "m " + String(seconds) + "s";
    }
}

String PerformanceMonitor::formatBytes(size_t bytes) {
    if (bytes < 1024) {
        return String(bytes) + " B";
    } else if (bytes < 1024 * 1024) {
        return String(bytes / 1024.0, 1) + " KB";
    } else if (bytes < 1024 * 1024 * 1024) {
        return String(bytes / (1024.0 * 1024.0), 1) + " MB";
    } else {
        return String(bytes / (1024.0 * 1024.0 * 1024.0), 2) + " GB";
    }
}

// ===== C-STYLE FUNCTIONS =====
PerformanceResults analyzePerformance(size_t bytes, unsigned long timeMs) {
    PerformanceResults results;
    
    results.success = true;
    results.totalBytes = bytes;
    results.totalTimeMs = timeMs;
    results.averageSpeedKBps = PerformanceMonitor::calculateSpeedKBps(bytes, timeMs);
    results.peakSpeedKBps = results.averageSpeedKBps; // Simplified for static analysis
    results.targetAchieved = results.averageSpeedKBps >= TARGET_SPEED_KBPS;
    
    PerformanceMonitor monitor;
    results.performanceRating = monitor.getPerformanceRating(results.averageSpeedKBps);
    results.analysisReport = "Speed: " + PerformanceMonitor::formatSpeed(results.averageSpeedKBps) + 
                            " | Rating: " + results.performanceRating +
                            " | Target: " + String(results.targetAchieved ? "ACHIEVED" : "NOT ACHIEVED");
    
    return results;
}

void printPerformanceReport(const PerformanceResults& results) {
    Serial.println("\n=== PERFORMANCE REPORT ===");
    Serial.println("Bytes: " + PerformanceMonitor::formatBytes(results.totalBytes));
    Serial.println("Time: " + PerformanceMonitor::formatTime(results.totalTimeMs));
    Serial.println("Speed: " + PerformanceMonitor::formatSpeed(results.averageSpeedKBps));
    Serial.println("Rating: " + results.performanceRating);
    Serial.println("Target: " + String(results.targetAchieved ? "ACHIEVED" : "NOT ACHIEVED"));
    Serial.println("==========================");
}