#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <queue>
#include <iomanip>

using namespace std;

struct Process {
    int pid;
    int arrival_time;
    vector<int> burst_times;
    int current_burst_index;
    int completion_time;
    int waiting_time;
    int turnaround_time;
    bool in_cpu;
};

vector<Process> processes;

void fifo() {
    queue<Process*> ready_queue;
    int current_time = 0;
    int completed_processes = 0;
    int process_count = processes.size();

    while (completed_processes < process_count) {
        // Add processes to the ready queue based on arrival time
        for (auto& process : processes) {
            if (process.arrival_time <= current_time && !process.in_cpu) {
                ready_queue.push(&process);
                process.in_cpu = true;
            }
        }

        if (!ready_queue.empty()) {
            Process* current_process = ready_queue.front();
            ready_queue.pop();

            // Simulate CPU execution
            for (int i = current_process->current_burst_index; i < current_process->burst_times.size(); i += 2) {
                int cpu_burst = current_process->burst_times[i];
                current_time += cpu_burst; // Advance time by CPU burst duration
                current_process->current_burst_index++;

                // Handle I/O burst if there's one
                if (i + 1 < current_process->burst_times.size()) {
                    int io_burst = current_process->burst_times[i + 1];
                    current_time += io_burst; // Advance time by I/O burst duration
                }
            }

            current_process->completion_time = current_time;
            current_process->turnaround_time = current_process->completion_time - current_process->arrival_time;
            current_process->waiting_time = current_process->turnaround_time - (current_process->burst_times.size() / 2);
            completed_processes++;
        } else {
            // No process is ready; advance time
            current_time++;
        }
    }

    // Calculate averages
    int total_waiting_time = 0, total_turnaround_time = 0;
    for (const auto& process : processes) {
        total_waiting_time += process.waiting_time;
        total_turnaround_time += process.turnaround_time;
    }
    
    double avg_waiting_time = static_cast<double>(total_waiting_time) / process_count;
    double avg_turnaround_time = static_cast<double>(total_turnaround_time) / process_count;

    // Output results
    cout << "FIFO Scheduling Results:\n";
    cout << "Processes:\n";
    for (const auto& process : processes) {
        cout << "Process ID: " << process.pid 
             << ", Completion Time: " << process.completion_time
             << ", Waiting Time: " << process.waiting_time
             << ", Turnaround Time: " << process.turnaround_time << endl;
    }

    cout << "Average Waiting Time: " << fixed << setprecision(2) << avg_waiting_time << endl;
    cout << "Average Turnaround Time: " << fixed << setprecision(2) << avg_turnaround_time << endl;
}

int main(int argc, char** argv) {
    if (argc != 3) {
        cout << "Usage: ./scheduler.out <path-to-workload-file> <scheduler_algorithm>\n";
        return -1;
    }

    ifstream file(argv[1]);
    string line;
    int pid = 0;

    while (getline(file, line)) {
        if (line.empty()) continue;
        Process process;
        process.pid = pid++;
        process.current_burst_index = 0;
        process.in_cpu = false;

        istringstream iss(line);
        iss >> process.arrival_time;
        
        int burst_time;
        while (iss >> burst_time && burst_time != -1) {
            process.burst_times.push_back(burst_time);
        }
        processes.push_back(process);
    }

    string algorithm = argv[2];
    if (algorithm == "fifo") {
        fifo();
    } else {
        cout << "Invalid scheduling algorithm. Please use 'fifo'.\n";
    }

    return 0;
}