/**
 * PHM Open Source — Módulo SO: Algoritmo do Banqueiro (Prevenção de Deadlocks)
 * Implementação didática do clássico algoritmo de Edsger Dijkstra para verificação de estado seguro
 * Prof. Paulo Henrique Maciel · PHM Tech
 */

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

#define P 5 // Número de Processos (P0, P1, P2, P3, P4)
#define R 3 // Número de Tipos de Recursos (A, B, C)

// Vetor Disponível, Matriz Máxima, Matriz de Alocação
int disponivel[R] = { 3, 3, 2 };

int maximo[P][R] = {
    { 7, 5, 3 }, // P0
    { 3, 2, 2 }, // P1
    { 9, 0, 2 }, // P2
    { 2, 2, 2 }, // P3
    { 4, 3, 3 }  // P4
};

int alocacao[P][R] = {
    { 0, 1, 0 }, // P0
    { 2, 0, 0 }, // P1
    { 3, 0, 2 }, // P2
    { 2, 1, 1 }, // P3
    { 0, 0, 2 }  // P4
};

int necessidade[P][R];

void calcular_necessidade(void) {
    for (int i = 0; i < P; i++) {
        for (int j = 0; j < R; j++) {
            necessidade[i][j] = maximo[i][j] - alocacao[i][j];
        }
    }
}

bool verificar_estado_seguro(void) {
    int trabalho[R];
    bool finalizado[P] = { false };
    int sequencia_segura[P];
    int contador = 0;

    for (int i = 0; i < R; i++) trabalho[i] = disponivel[i];

    while (contador < P) {
        bool encontrado = false;
        for (int p = 0; p < P; p++) {
            if (!finalizado[p]) {
                int j;
                for (j = 0; j < R; j++) {
                    if (necessidade[p][j] > trabalho[j]) break;
                }

                if (j == R) { // Todos os recursos podem ser atendidos
                    for (int k = 0; k < R; k++) {
                        trabalho[k] += alocacao[p][k];
                    }
                    sequencia_segura[contador++] = p;
                    finalizado[p] = true;
                    encontrado = true;
                }
            }
        }

        if (!encontrado) {
            printf("\n⚠️ ALERTA: O sistema NAO esta em estado seguro! Risco iminente de DEADLOCK.\n");
            return false;
        }
    }

    printf("\n✅ O SISTEMA ESTA EM UM ESTADO SEGURO!\n");
    printf("Sequencia de Execucao Segura: < ");
    for (int i = 0; i < P; i++) {
        printf("P%d%s", sequencia_segura[i], (i < P - 1) ? " -> " : " ");
    }
    printf(">\n");
    return true;
}

int main(void) {
    printf("====================================================================\n");
    printf("  PHM OPEN SOURCE — SIMULADOR DO ALGORITMO DO BANQUEIRO (DIJKSTRA)  \n");
    printf("====================================================================\n");

    calcular_necessidade();
    verificar_estado_seguro();

    return 0;
}