NEW_PREPA

#include <stdio.h>
#include <stdlib.h>

#define PARTITION_LIBRE 0
#define PARTITION_ALLOUE 1

#define PROCESUS_NONCHARGE 0
#define PROCESUS_CHARGE 1

struct Partition {
    int numero;
    int taille;
    int state;
};


struct Processus {
    int numero;
    int taille;
    int state;
};


void lireNombreDesPartitions(int *partitionCount) {
    do {
        printf("Veuillez saisir le nombre de partitions :>>");
        scanf("%d", partitionCount);
    } while (*partitionCount < 0);

}

void lireNombreDesProcessus(int *processCount) {
    do {
        printf("\nVeuillez saisir le nombre de Processus demandant l'allocation d'une Partition :>>");
        scanf("%d", processCount);
    } while (*processCount < 0);

}

struct Partition creeNouveauPartition(int id, int size) {
    struct Partition newPartition = {id, size, PARTITION_LIBRE};
    return newPartition;
}

struct Processus creeNouveauProcessus(int id, int size) {
    struct Processus nvProcesus = {id, size, PROCESUS_NONCHARGE};
    return nvProcesus;
}

void lireLesPartitions(struct Partition partitionList[], int partitionCount) {
    for (int i = 0; i < partitionCount; i++) {
        int size;
        printf("La taille de Partition Numero %d =", i + 1);
        scanf("%d", &size);

        partitionList[i] = creeNouveauPartition(i + 1, size);
    }
}

void lireLesProcessus(struct Processus desProcessus[], int nbProcesus) {
    for (int i = 0; i < nbProcesus; i++) {
        int size;
        printf("La taille de Processus Numero %d =", i + 1);
        scanf("%d", &size);

        desProcessus[i] = creeNouveauProcessus(i + 1, size);
    }
}

void afficherLesPartitions(struct Partition desPartitions[], int nombreDesPartitions) {
    printf("%-14s %-14s %-14s\n", "Partiton N", "Size(KO)", "State");
    for (int i = 0; i < nombreDesPartitions; ++i) {
        struct Partition cePartition = desPartitions[i];
        printf("%-14d %-14d %-14d\n", cePartition.numero, cePartition.taille, cePartition.state);
    }
}

void afficherLesProcessus(struct Processus desProcessus[], int nbProcesus) {
    printf("%-14s %-14s %-14s\n", "Procesus N", "Size(KO)", "State");
    for (int i = 0; i < nbProcesus; ++i) {
        struct Processus ceProcessus = desProcessus[i];
        printf("%-14d %-14d %-14d\n", ceProcessus.numero, ceProcessus.taille, ceProcessus.state);
    }
}

struct Partition *creeAnArray(int taille) {
    struct Partition *partitionArray = malloc(taille * sizeof(*partitionArray));
    return partitionArray;
}

struct Partition *
addPartitionAt(struct Partition *partitionList, int *partitionCount, struct Partition toAdd, int index) {
    int newPartitionCount = *partitionCount + 1;
    struct Partition *newPartitionList = malloc(newPartitionCount * sizeof(*newPartitionList));
    int j = 0;
    for (int i = 0; i < *partitionCount; i++, j++) {
        if (i == index) {
            newPartitionList[i] = toAdd;
            newPartitionList[i].numero = index + 1;
            newPartitionList[i + 1] = partitionList[i];
            newPartitionList[i + 1].numero = index + 2;
            j++;
        } else {
            newPartitionList[j] = partitionList[i];
            newPartitionList[j].numero = j + 1;
        }
    }

    //when adding a partition at the end of the list
    if (index >= *partitionCount) {
        newPartitionList[index] = toAdd;
        newPartitionList[index].numero = index + 1;
    }

    *partitionCount = newPartitionCount;

    return newPartitionList;
}


struct Partition
*applyWorstFitAlgorithm(struct Partition *desPartitions, int *nbPartitons, struct Processus *desProcessus,
                        int nbProcessus) {
    printf("\n\n******************************************************* Worst Fit *******************************************************\n");
    struct Partition *partitionArray = malloc(*nbPartitons * sizeof(*partitionArray));
    for (int i = 0; i < *nbPartitons; ++i) {
        partitionArray[i] = desPartitions[i];
    }


    for (int i = 0; i < nbProcessus; ++i) {
        struct Processus ceProcessus = desProcessus[i];
        int worstFitIndex = 0;
        for (int j = 0; j < *nbPartitons; ++j) {
            struct Partition cePartition = partitionArray[j];
            if (cePartition.state == PARTITION_LIBRE && cePartition.taille >= ceProcessus.taille) {
                if (partitionArray[worstFitIndex].taille < partitionArray[j].taille) {
                    worstFitIndex = j;
                }
            }
        }

        //This condition will help when no partition can fit the process, this will prevent it from creating a new partition at the default index 0
        if (partitionArray[worstFitIndex].state == PARTITION_LIBRE &&
            partitionArray[worstFitIndex].taille >= ceProcessus.taille) {
            int partititonTaille = partitionArray[worstFitIndex].taille;
            partitionArray[worstFitIndex].taille = ceProcessus.taille;

            //cree un nouveau partition de taille part.taille - process.taille
            struct Partition partition = creeNouveauPartition(/*Le id will be assigned by addPartitionAt()*/-1,
                                                                                                            partititonTaille -
                                                                                                            ceProcessus.taille);

            partitionArray = addPartitionAt(partitionArray, nbPartitons, partition, worstFitIndex + 1);

            partitionArray[worstFitIndex].state = PARTITION_ALLOUE;
            (desProcessus + i)->state = 1;
        }
    }

    return partitionArray;
}

int main() {
    //Lire les données
    int nbPartitions, nbProcesus;

    lireNombreDesPartitions(&nbPartitions);
    struct Partition desPartitions[nbPartitions];

    lireLesPartitions(desPartitions, nbPartitions);
    afficherLesPartitions(desPartitions, nbPartitions);

    lireNombreDesProcessus(&nbProcesus);
    struct Processus desProcessus[nbProcesus];

    lireLesProcessus(desProcessus, nbProcesus);
    afficherLesProcessus(desProcessus, nbProcesus);


    //Traitement
    struct Partition *structPartition = applyWorstFitAlgorithm(desPartitions, &nbPartitions, desProcessus, nbProcesus);


    //Affichage du Resultat finale
    printf("\nEtat de la memoire a la fin de l'allocation\n");
    afficherLesPartitions(structPartition, nbPartitions);

    printf("\nEtat de processus a la fin de l'allocation\n");
    afficherLesProcessus(desProcessus, nbProcesus);


}