/**
 * ============================================================================
 * PHM Open Source — Sistemas Operacionais & Concorrência
 * Algoritmo 02: Simulador de Escalonamento de CPU Round Robin (Preemptivo)
 * Autor: Prof. Paulo Henrique Maciel · PHM Tech
 * ============================================================================
 * 
 * CONCEITO TEÓRICO DE S.O.:
 * O Round Robin (RR) é um dos algoritmos de escalonamento mais importantes em
 * sistemas operacionais de tempo compartilhado (multitarefa). A CPU é alocada
 * para cada processo por uma fatia fixa de tempo chamada Quantum.
 * 
 * SE O PROCESSO NÃO TERMINAR NO QUANTUM:
 * Ocorre preempção (interrupção por timer de hardware), o contexto é salvo e
 * o processo vai para o fim da fila de prontos.
 * 
 * MÉTRICAS COMPUTADAS:
 * 1. Tempo de Retorno (Turnaround Time): Tempo total desde a chegada até a conclusão.
 * 2. Tempo de Espera (Waiting Time): Tempo total que o processo passou na fila.
 * 
 * COMO COMPILAR E EXECUTAR:
 * gcc 02_escalonador_round_robin.c -o so_round_robin && ./so_round_robin
 * ============================================================================
 */

#include <stdio.h>
#include <stdbool.h>

#define MAX_PROCESSOS 4

typedef struct {
    char nome[10];
    int tempoBurst;       // Tempo total de CPU necessário
    int tempoRestante;    // Tempo que ainda falta executar
    int tempoEspera;      // Tempo esperando na fila
    int tempoRetorno;     // Turnaround Time
    bool concluido;
} Processo;

int main(void) {
    int quantum = 3; // Quantum de tempo da CPU (fatia de execução)
    int tempoAtual = 0;
    int processosConcluidos = 0;

    Processo fila[MAX_PROCESSOS] = {
        {"P1 (Navegador)",  10, 10, 0, 0, false},
        {"P2 (Editor Texto)", 4,  4, 0, 0, false},
        {"P3 (Compilador)",   6,  6, 0, 0, false},
        {"P4 (Reprodutor)",   2,  2, 0, 0, false}
    };

    printf("====================================================\n");
    printf(" PHM TECH — S.O. · ESCALONADOR ROUND ROBIN (CPU)     \n");
    printf(" Quantum Definido = %d unidades de tempo             \n", quantum);
    printf("====================================================\n\n");

    printf("Gantt Chart de Execucao da CPU:\n[Início] ");

    // Loop do Escalonador de CPU
    while (processosConcluidos < MAX_PROCESSOS) {
        bool executouAlgo = false;

        for (int i = 0; i < MAX_PROCESSOS; i++) {
            if (!fila[i].concluido) {
                executouAlgo = true;

                if (fila[i].tempoRestante > quantum) {
                    // Executa pelo tempo do quantum inteiro
                    printf("-> | %s (%d u.t.) | ", fila[i].nome, quantum);
                    tempoAtual += quantum;
                    fila[i].tempoRestante -= quantum;
                } else {
                    // Processo finaliza dentro desta fatia de tempo
                    printf("-> | %s (%d u.t. - FIM) | ", fila[i].nome, fila[i].tempoRestante);
                    tempoAtual += fila[i].tempoRestante;
                    fila[i].tempoRetorno = tempoAtual;
                    fila[i].tempoEspera = fila[i].tempoRetorno - fila[i].tempoBurst;
                    fila[i].tempoRestante = 0;
                    fila[i].concluido = true;
                    processosConcluidos++;
                }
            }
        }

        if (!executouAlgo) break;
    }

    printf("\n\n----------------------------------------------------------------------\n");
    printf(" Processo          | Burst Time | Tempo de Espera | Turnaround Time\n");
    printf("----------------------------------------------------------------------\n");

    float totalEspera = 0;
    float totalRetorno = 0;

    for (int i = 0; i < MAX_PROCESSOS; i++) {
        printf(" %-17s |    %2d u.t. |         %2d u.t. |         %2d u.t.\n",
            fila[i].nome,
            fila[i].tempoBurst,
            fila[i].tempoEspera,
            fila[i].tempoRetorno
        );
        totalEspera += fila[i].tempoEspera;
        totalRetorno += fila[i].tempoRetorno;
    }

    printf("----------------------------------------------------------------------\n");
    printf(" -> Tempo Medio de Espera (Waiting Time)    : %.2f u.t.\n", totalEspera / MAX_PROCESSOS);
    printf(" -> Tempo Medio de Retorno (Turnaround Time): %.2f u.t.\n", totalRetorno / MAX_PROCESSOS);

    return 0;
}