// ============================================================
// Priority Scheduling Algorithm in C++ (Non-Preemptive)
// Higher priority number = higher urgency = runs first
// All processes arrive at time 0
// ============================================================

#include <iostream>
using namespace std;

// Holds all scheduling attributes for a single process
struct Process {
    int processNo;      // Original process number (preserved after sorting)
    int arrivalTime;    // Arrival time (0 for all processes in this example)
    int burstTime;      // CPU time required to complete the process
    int priorityLevel;  // Priority value — higher number = higher urgency
    int waitingTime;    // Time the process spends waiting before execution
    int turnaroundTime; // Total time from arrival to completion
};

int main() {

    const int PROCESS_COUNT = 4;
    Process processes[PROCESS_COUNT];

    // -------------------------------------------------------
    // Step 1: Read burst time and priority for each process
    // -------------------------------------------------------
    for (int i = 0; i < PROCESS_COUNT; i++) {
        cout << "\n Enter burst time of P" << i + 1 << ": ";
        cin  >> processes[i].burstTime;
        cout << " Enter priority of P"    << i + 1 << " (higher = more urgent): ";
        cin  >> processes[i].priorityLevel;
        processes[i].processNo   = i + 1;
        processes[i].arrivalTime = 0;   // All processes arrive at time 0
    }

    // Display entered data
    cout << "\n\n Entered Data";
    cout << "\n PNO\tAT\tBT\tPriority";
    for (int i = 0; i < PROCESS_COUNT; i++) {
        cout << "\n P" << processes[i].processNo
             << "\t" << processes[i].arrivalTime
             << "\t" << processes[i].burstTime
             << "\t" << processes[i].priorityLevel;
    }

    // -------------------------------------------------------
    // Step 2: Sort processes by priority (descending — highest first)
    // -------------------------------------------------------
    for (int outer = 0; outer < PROCESS_COUNT - 1; outer++) {
        for (int inner = outer + 1; inner < PROCESS_COUNT; inner++) {
            // If outer process has lower priority, swap with inner
            if (processes[outer].priorityLevel < processes[inner].priorityLevel) {
                Process temp         = processes[outer];
                processes[outer]     = processes[inner];
                processes[inner]     = temp;
            }
        }
    }
    // After sorting: processes[0] has the highest priority

    // -------------------------------------------------------
    // Step 3: Calculate Waiting Time and Turnaround Time
    // Since all processes arrive at time 0, WT[i] = sum of all previous burst times
    // -------------------------------------------------------
    processes[0].waitingTime    = 0;
    processes[0].turnaroundTime = processes[0].burstTime;
    int totalBurstTime = processes[0].burstTime;

    for (int i = 1; i < PROCESS_COUNT; i++) {
        // With AT=0 for all, no gap correction needed
        processes[i].waitingTime =
            processes[i-1].waitingTime + processes[i-1].burstTime;

        processes[i].turnaroundTime =
            processes[i].waitingTime + processes[i].burstTime;

        totalBurstTime += processes[i].burstTime;
    }

    // -------------------------------------------------------
    // Step 4: Display results table
    // -------------------------------------------------------
    cout << "\n\n Result (sorted by priority — highest first)";
    cout << "\n PNO\tAT\tPriority\tWT\tBT\tTT";
    for (int i = 0; i < PROCESS_COUNT; i++) {
        cout << "\n P" << processes[i].processNo
             << "\t" << processes[i].arrivalTime
             << "\t" << processes[i].priorityLevel
             << "\t\t" << processes[i].waitingTime
             << "\t" << processes[i].burstTime
             << "\t" << processes[i].turnaroundTime;
    }
    cout << "\n Total Burst Time: " << totalBurstTime;

    // -------------------------------------------------------
    // Step 5: Compute averages
    // -------------------------------------------------------
    int totalWaiting = 0, totalTurnaround = 0;
    for (int i = 0; i < PROCESS_COUNT; i++) {
        totalWaiting    += processes[i].waitingTime;
        totalTurnaround += processes[i].turnaroundTime;
    }

    cout << "\n Average Waiting Time    : " << (float)totalWaiting    / PROCESS_COUNT;
    cout << "\n Average Turnaround Time : " << (float)totalTurnaround / PROCESS_COUNT;
    cout << endl;

    return 0;
}