analytics_engine.h

#ifndef ANALYTICS_ENGINE_H
#define ANALYTICS_ENGINE_H

#include <iostream>
#include <vector>
#include <string>
#include <queue>
#include <unordered_map>
#include <algorithm>
#include <set>
#include <iomanip>
#include <limits> // Fix #4: Replaced magic number with professional limits

// ============================================================================
// 1. DATA CONFIGURATIONS
// ============================================================================

struct ProcessMetrics {
    int pid;
    std::string type; // "CREATE" or "REDIRECT"
    int burst_time;
    int remaining_time;
    int arrival_time;
    int waiting_time = 0;
    int turnaround_time = 0;
};

// ============================================================================
// 2. ANALYTICS ENGINE CLASS
// ============================================================================

class AnalyticsEngine {
public:
    // --- CPU SCHEDULING SIMULATION ENGINE ---
    static void computeSchedulingAlgorithms(std::vector<ProcessMetrics> processes, int quantum = 2) {
        if (processes.empty()) return;
        
        std::cout << "\n=======================================================\n";
        std::cout << "        📊 BACKEND OS SCHEDULER SIMULATION            \n";
        std::cout << "=======================================================\n";

        // 1. First-Come, First-Served (FCFS)
        auto fcfs = processes;
        std::sort(fcfs.begin(), fcfs.end(), [](const ProcessMetrics& a, const ProcessMetrics& b) {
            return a.arrival_time < b.arrival_time;
        });
        
        int clock = 0;
        double fcfs_wt = 0, fcfs_tat = 0;
        for (auto& p : fcfs) {
            if (clock < p.arrival_time) clock = p.arrival_time;
            p.waiting_time = clock - p.arrival_time;
            clock += p.burst_time;
            p.turnaround_time = p.waiting_time + p.burst_time;
            fcfs_wt += p.waiting_time;
            fcfs_tat += p.turnaround_time;
        }
        printMetricResult("FCFS", fcfs_wt / processes.size(), fcfs_tat / processes.size());

        // 2. Shortest Job First (SJF - Non-Preemptive)
        auto sjf = processes;
        clock = 0; 
        double sjf_wt = 0, sjf_tat = 0;
        std::vector<bool> finished(sjf.size(), false);
        
        for (size_t i = 0; i < sjf.size(); ++i) {
            int optimal_idx = -1;
            // Fix #4: Replaced 1e9 with professional standard limits
            int shortest_burst = std::numeric_limits<int>::max(); 
            for (size_t j = 0; j < sjf.size(); ++j) {
                if (!finished[j] && sjf[j].arrival_time <= clock) {
                    if (sjf[j].burst_time < shortest_burst) {
                        shortest_burst = sjf[j].burst_time;
                        optimal_idx = j;
                    }
                }
            }
            if (optimal_idx == -1) { 
                clock++; 
                i--; 
                continue; 
            }
            finished[optimal_idx] = true;
            sjf[optimal_idx].waiting_time = clock - sjf[optimal_idx].arrival_time;
            clock += sjf[optimal_idx].burst_time;
            sjf[optimal_idx].turnaround_time = sjf[optimal_idx].waiting_time + sjf[optimal_idx].burst_time;
            sjf_wt += sjf[optimal_idx].waiting_time;
            sjf_tat += sjf[optimal_idx].turnaround_time;
        }
        printMetricResult("SJF", sjf_wt / processes.size(), sjf_tat / processes.size());

        // 3. Round Robin (RR)
        auto rr = processes;
        // Fix #2: Explicitly ensuring remaining_time equals burst_time before starting
        for (auto& p : rr) {
            p.remaining_time = p.burst_time;
        }
        
        clock = 0; 
        double rr_wt = 0, rr_tat = 0;
        std::queue<size_t> ready_q;
        std::vector<bool> in_queue(rr.size(), false);
        
        for (size_t i = 0; i < rr.size(); ++i) {
            if (rr[i].arrival_time == 0) { ready_q.push(i); in_queue[i] = true; }
        }
        
        size_t done_count = 0;
        while (done_count < rr.size()) {
            if (ready_q.empty()) {
                clock++;
                for (size_t i = 0; i < rr.size(); ++i) {
                    if (!in_queue[i] && rr[i].arrival_time <= clock && rr[i].remaining_time > 0) {
                        ready_q.push(i); in_queue[i] = true;
                    }
                }
                continue;
            }
            size_t curr = ready_q.front(); ready_q.pop();
            int slice = std::min(rr[curr].remaining_time, quantum);
            rr[curr].remaining_time -= slice;
            clock += slice;
            
            for (size_t i = 0; i < rr.size(); ++i) {
                if (!in_queue[i] && rr[i].arrival_time <= clock && rr[i].remaining_time > 0) {
                    ready_q.push(i); in_queue[i] = true;
                }
            }
            if (rr[curr].remaining_time == 0) {
                rr[curr].turnaround_time = clock - rr[curr].arrival_time;
                rr[curr].waiting_time = rr[curr].turnaround_time - rr[curr].burst_time;
                rr_wt += rr[curr].waiting_time;
                rr_tat += rr[curr].turnaround_time;
                done_count++;
            } else {
                ready_q.push(curr);
            }
        }
        printMetricResult("Round Robin", rr_wt / processes.size(), rr_tat / processes.size());
        
        // Fix #1: Safety check against division by zero for system throughput calculation
        std::cout << " > System Execution Throughput : ";
        if (clock > 0) {
            std::cout << std::fixed << std::setprecision(4) << (double)processes.size() / clock << " requests/ms\n";
        } else {
            std::cout << "N/A\n";
        }
    }

    // --- MEMORY PAGE REPLACEMENT SIMULATION ENGINE ---
    static void computePageReplacements(const std::vector<std::string>& memory_logs, size_t dynamic_capacity = 3) {
        if (memory_logs.empty()) return;

        std::cout << "\n=======================================================\n";
        std::cout << "        💾 VIRTUAL MEMORY MANAGEMENT SIMULATOR        \n";
        std::cout << "=======================================================\n";
        
        // Fix #3: Safety validation handling capacity = 0 boundary errors gracefully
        if (dynamic_capacity == 0) {
            std::cout << " Invalid frame size: Frame allocation pool cannot be 0.\n";
            std::cout << "=======================================================\n";
            return;
        }

        std::cout << " Cache / Memory Frame Pool Capacity: " << dynamic_capacity << " Allocations\n\n";

        // 1. FIFO Logic
        {
            std::set<std::string> pages;
            std::queue<std::string> order;
            int faults = 0;
            for (const auto& block : memory_logs) {
                if (pages.find(block) == pages.end()) {
                    if (pages.size() == dynamic_capacity) {
                        std::string front_item = order.front(); order.pop();
                        pages.erase(front_item);
                    }
                    pages.insert(block);
                    order.push(block);
                    faults++;
                }
            }
            std::cout << " [FIFO Page Replacement]    Total Page Faults: " << faults << "\n";
        }

        // 2. LRU Logic
        {
            std::set<std::string> pages;
            std::unordered_map<std::string, int> timeline;
            int faults = 0;
            for (int i = 0; i < (int)memory_logs.size(); i++) {
                if (pages.find(memory_logs[i]) == pages.end()) {
                    if (pages.size() == dynamic_capacity) {
                        // Fix #4: Replaced magic number with standard limits
                        int oldest_use = std::numeric_limits<int>::max(); 
                        std::string target_eviction;
                        for (auto cache_item : pages) {
                            if (timeline[cache_item] < oldest_use) {
                                oldest_use = timeline[cache_item];
                                target_eviction = cache_item;
                            }
                        }
                        pages.erase(target_eviction);
                    }
                    pages.insert(memory_logs[i]);
                    faults++;
                }
                timeline[memory_logs[i]] = i;
            }
            std::cout << " [LRU Page Replacement]     Total Page Faults: " << faults << "\n";
        }

        // 3. Optimal Page Replacement Logic
        {
            std::vector<std::string> frames;
            int faults = 0;
            for (size_t i = 0; i < memory_logs.size(); ++i) {
                auto it = std::find(frames.begin(), frames.end(), memory_logs[i]);
                if (it == frames.end()) {
                    if (frames.size() < dynamic_capacity) {
                        frames.push_back(memory_logs[i]);
                    } else {
                        int farthest = -1, select_idx = -1;
                        for (size_t j = 0; j < frames.size(); ++j) {
                            size_t next_use = i + 1;
                            for (; next_use < memory_logs.size(); ++next_use) {
                                if (memory_logs[next_use] == frames[j]) break;
                            }
                            if ((int)next_use > farthest) {
                                farthest = (int)next_use;
                                select_idx = (int)j;
                            }
                        }
                        frames[select_idx] = memory_logs[i];
                    }
                    faults++;
                }
            }
            std::cout << " [Optimal Replacement]      Total Page Faults: " << faults << "\n";
        }
        std::cout << "=======================================================\n";
    }

private:
    static void printMetricResult(const std::string& algo, double avg_wt, double avg_tat) {
        std::cout << " [" << std::left << std::setw(12) << algo << "] -> Avg Waiting: " 
                  << std::fixed << std::setprecision(2) << std::setw(6) << avg_wt 
                  << " ms | Avg Turnaround: " << avg_tat << " ms\n";
    }
};

#endif // ANALYTICS_ENGINE_H