/**
 * PHM Open Source — Módulo SO: Algoritmos de Alocação Contígua de Memória
 * Simulação comparativa de First Fit, Best Fit e Worst Fit
 * Prof. Paulo Henrique Maciel · PHM Tech
 */

#include <stdio.h>
#include <string.h>

#define NUM_BLOCOS 5
#define NUM_PROCESSOS 4

void simular_first_fit(int blocos_orig[], int proc_orig[]) {
    int blocos[NUM_BLOCOS];
    int alocacao[NUM_PROCESSOS];
    for (int i = 0; i < NUM_BLOCOS; i++) blocos[i] = blocos_orig[i];
    for (int i = 0; i < NUM_PROCESSOS; i++) alocacao[i] = -1;

    for (int i = 0; i < NUM_PROCESSOS; i++) {
        for (int j = 0; j < NUM_BLOCOS; j++) {
            if (blocos[j] >= proc_orig[i]) {
                alocacao[i] = j;
                blocos[j] -= proc_orig[i];
                break;
            }
        }
    }

    printf("\n--- 1. FIRST FIT (PRIMEIRO ESPACO COMPATIVEL) ---\n");
    printf("Processo\tTamanho\tBloco Alocado\n");
    for (int i = 0; i < NUM_PROCESSOS; i++) {
        printf("P%d\t\t%d KB\t", i + 1, proc_orig[i]);
        if (alocacao[i] != -1) printf("Bloco %d\n", alocacao[i] + 1);
        else printf("Nao Alocado (Sem Espaco)\n");
    }
}

void simular_best_fit(int blocos_orig[], int proc_orig[]) {
    int blocos[NUM_BLOCOS];
    int alocacao[NUM_PROCESSOS];
    for (int i = 0; i < NUM_BLOCOS; i++) blocos[i] = blocos_orig[i];
    for (int i = 0; i < NUM_PROCESSOS; i++) alocacao[i] = -1;

    for (int i = 0; i < NUM_PROCESSOS; i++) {
        int melhor_idx = -1;
        for (int j = 0; j < NUM_BLOCOS; j++) {
            if (blocos[j] >= proc_orig[i]) {
                if (melhor_idx == -1 || blocos[j] < blocos[melhor_idx]) {
                    melhor_idx = j;
                }
            }
        }
        if (melhor_idx != -1) {
            alocacao[i] = melhor_idx;
            blocos[melhor_idx] -= proc_orig[i];
        }
    }

    printf("\n--- 2. BEST FIT (MENOR ESPACO SUFICIENTE) ---\n");
    printf("Processo\tTamanho\tBloco Alocado\n");
    for (int i = 0; i < NUM_PROCESSOS; i++) {
        printf("P%d\t\t%d KB\t", i + 1, proc_orig[i]);
        if (alocacao[i] != -1) printf("Bloco %d\n", alocacao[i] + 1);
        else printf("Nao Alocado (Sem Espaco)\n");
    }
}

int main(void) {
    printf("====================================================================\n");
    printf("  PHM OPEN SOURCE — SIMULADOR DE ALOCACAO DE MEMORIA (FIRST/BEST)   \n");
    printf("====================================================================\n");

    int blocos[NUM_BLOCOS] = { 100, 500, 200, 300, 600 }; // KB
    int processos[NUM_PROCESSOS] = { 212, 417, 112, 426 }; // KB

    printf("Blocos de Memoria Disponiveis: [ 100K, 500K, 200K, 300K, 600K ]\n");
    printf("Requisicoes de Processos:      [ P1: 212K, P2: 417K, P3: 112K, P4: 426K ]\n");

    simular_first_fit(blocos, processos);
    simular_best_fit(blocos, processos);

    return 0;
}