#include <bits/stdc++.h>
using namespace std;
struct Node {
    int id;
    int arrivalTime;
    int burstTime;
    int turnaroundTime;
    int waitingTime;
    int completionTime;
    Node* next;
};
class CircularQueue {
private:
    Node* front;
    Node* rear;
public:
    CircularQueue() : front(nullptr), rear(nullptr) {}
    bool isEmpty() {
        return front == nullptr;
    }
    void enqueue(int id, int arrivalTime, int burstTime) {
        Node* newNode = new Node{id, arrivalTime, burstTime, 0, 0, 0, nullptr};
        if (isEmpty()) {
            front = rear = newNode;
            rear->next = front; // Point to itself
        } else {
            rear->next = newNode; // Link the new node
            rear = newNode;       // Update rear
            rear->next = front;   // Make it circular
        }
    }
    void dequeue() {
        if (isEmpty()) {
            cout << "queue is empty" << endl;
            return;
        }
        Node* temp = front;
        if (front == rear) {
            front = rear = nullptr;
        } else {
            front = front->next; // Move front to the next node
            rear->next = front;   // Maintain circular link
        }
        delete temp;
    }
    void display() {
        if (isEmpty()) {
            cout << "queue is empty" << endl;
            return;
        }
        Node* temp = front;
        do {
            cout << temp->id << "\t\t" << temp->arrivalTime << "\t\t" << temp->burstTime << "\t\t" << temp->completionTime << "\t\t\t" << temp->turnaroundTime << "\t\t\t" << temp->waitingTime << endl;
            temp = temp->next;
        } while (temp != front);
    }
    Node* getFront() {
        return front;
    }
};
class RoundRobinScheduler {
private:
    int timeQuantum, ids;
    void sortArrivalTime();
    bool isPending(map<int, int>& burstTimes);
    bool isAlone(map<int, int>& burstTimes);
public:
    RoundRobinScheduler(int tq) : timeQuantum(tq), ids(0) {};
    CircularQueue queue;
    void inputTime();
    void displayTime();
    void calculateTime();
};
void RoundRobinScheduler::inputTime() {
    int id = ++ids ; // Assign ID based on current queue
    cout << "\nenter for process-" << id << endl;
    
    int arrivalTime, burstTime;
    cout << "arrival-time: ";
    cin >> arrivalTime;
    
    cout << "burst-time: ";
    cin >> burstTime;
    queue.enqueue(id, arrivalTime, burstTime);
}
void RoundRobinScheduler::displayTime() {
    cout << "\n\nround robin scheduling:" << endl;
    
    cout << "process-id\tarrival-time\tburst-time\tcompletion-time\t\tturnaround-time\t\twaiting-time" << endl;
    
    queue.display();
}
void RoundRobinScheduler::sortArrivalTime() {
}
bool RoundRobinScheduler::isPending(map<int, int>& burstTimes) {
    for (auto& it : burstTimes) {
        if (it.second != 0) return true;
    }
    return false;
}
bool RoundRobinScheduler::isAlone(map<int, int>& burstTimes) {
    int count = 0;
    for (auto& it : burstTimes) {
        if (it.second != 0) count++;
    }
    return (count == 1) ? true : false;
}
void RoundRobinScheduler::calculateTime() {
    
    sortArrivalTime();
    Node* current = queue.getFront();
    // storing burstTimes
    map<int, int> burstTimes;
    do {
        
        burstTimes[current->id] = current->burstTime;
        current = current->next;
    } while(current != queue.getFront());
    // jobs scheduling
    cout << "\njobs:\t";
    current = queue.getFront();
    int timePassed = 0;
    while (isPending(burstTimes)) {
        if (burstTimes[current->id] == 0) {
            current=current->next;
            continue;
        }
        else if ((isAlone(burstTimes)) || (burstTimes[current->id] <= timeQuantum)) {
            timePassed += burstTimes[current->id];
            burstTimes[current->id] = 0;
            current->completionTime = timePassed;
        }
        else {
            burstTimes[current->id] -= timeQuantum;
            timePassed += timeQuantum;
        }
        cout << current->id << "\t";
        current = current->next;
        
    }
    // calculating other fields - turnaround and waiting time
    current = queue.getFront();
    
    do {
        
        current->turnaroundTime = current->completionTime - current->arrivalTime;
        current->waitingTime = current->turnaroundTime - current->burstTime;
        current = current->next;
    } while (current != queue.getFront());
}
int main() {
    int tq;
    cout << "\nenter time quantum: ";
    cin >> tq;
    RoundRobinScheduler obj(tq);
    int n;
    
    cout << "\nenter number of processes: ";
    cin >> n;
    for (int i = 0; i < n; i++) {
        obj.inputTime();
    }
    obj.calculateTime();
    obj.displayTime();
    return 0;
}