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

struct Fichier {
    char nom[2];
    int taille;
    int debut;
};

struct Fichier fichiers[100];  // Tableau de fichiers
int disque[100] = {0}; // État du disque (0 pour vide, 1 pour réservé)

int capacite_disque = 100;  // Capacité totale du disque
int espace_libre = 100;  // Espace libre dans le disque (initialisée à la capacité)
int nb_fichiers = 0;


int verifierNomUnique(struct Fichier fichiers[], int nb_fichiers, char nom[]) {
    for (int i = 0; i < nb_fichiers; i++) {
        if (strcmp(fichiers[i].nom, nom) == 0) {
            return 0; // Le nom existe déjà
        }
    }
    return 1; // Nom unique
}

void creerFichier(struct Fichier fichiers[], int *nb_fichiers, int *espace_libre, int disque[], int capacite_disque) {
    if (*nb_fichiers < 100) {
        char nom[2];
        int nom_valide = 0;

        while (!nom_valide) {
            printf("Nom du fichier (2 caractères) : ");
            scanf("%2s", nom);

            if (verifierNomUnique(fichiers, *nb_fichiers, nom)) {
                nom_valide = 1;
            } else {
                printf("Ce nom de fichier existe déjà. Veuillez en choisir un autre.\n");
            }
        }
        strcpy(fichiers[*nb_fichiers].nom, nom);
        printf("Taille du fichier : ");
        scanf("%d", &fichiers[*nb_fichiers].taille);
        if (fichiers[*nb_fichiers].taille <= *espace_libre) {
            // Trouver un espace vide pour le nouveau fichier
            int debut_fichier = -1;
            int taille_fichier = fichiers[*nb_fichiers].taille;

            for (int i = 0; i < capacite_disque; i++) {
                if (disque[i] == 0) {
                    if (debut_fichier == -1) {
                        debut_fichier = i;
                    }
                    taille_fichier--;
                    if (taille_fichier == 0) {
                        break;
                    }
                } else {
                    debut_fichier = -1;
                    taille_fichier = fichiers[*nb_fichiers].taille;
                }
            }

            if (debut_fichier != -1) {
                // Allouer l'espace pour le fichier
                for (int i = debut_fichier; i < debut_fichier + fichiers[*nb_fichiers].taille; i++) {
                    disque[i] = 1; // Marquer les secteurs comme réservés
                }
                fichiers[*nb_fichiers].debut = debut_fichier;
                *espace_libre -= fichiers[*nb_fichiers].taille;
                printf("Fichier alloué de manière contiguë à partir du secteur %d.\n", fichiers[*nb_fichiers].debut);
                (*nb_fichiers)++;
            } else {
                printf("Espace disque insuffisant pour allouer le fichier. Cependant, une allocation est possible après une fragmentation du disque.\n");
            }
        } else {
            printf("Espace disque insuffisant pour allouer le fichier.\n");
        }
    } else {
        printf("Trop de fichiers sur le disque.\n");
    }
}


void supprimerFichier(struct Fichier fichiers[], int *nb_fichiers, int *espace_libre, int disque[], int capacite_disque) {
    char nom_fichier[2];
    printf("Nom du fichier à supprimer : ");
    scanf("%s", nom_fichier);
    int index = -1;
    for (int i = 0; i < *nb_fichiers; i++) {
        if (strcmp(nom_fichier, fichiers[i].nom) == 0) {
            index = i;
            break;
        }
    }
    if (index != -1) {
        // Libérer l'espace du fichier supprimé
        for (int i = fichiers[index].debut; i < fichiers[index].debut + fichiers[index].taille; i++) {
            disque[i] = 0; // Marquer les secteurs comme libres
        }
        *espace_libre += fichiers[index].taille;
        // Décaler les fichiers suivants vers l'arrière
        for (int i = index; i < *nb_fichiers - 1; i++) {
            fichiers[i] = fichiers[i + 1];
        }
        (*nb_fichiers)--;
        printf("Fichier \"%s\" supprimé avec succès.\n", nom_fichier);
    } else {
        printf("Fichier non trouvé ou déjà supprimé.\n");
    }
}

void lireFichier(struct Fichier fichiers[], int nb_fichiers) {
    char nom_fichier[50];
    printf("Nom du fichier à lire : ");
    scanf("%s", nom_fichier);
    int trouve = 0;
    for (int i = 0; i < nb_fichiers; i++) {
        if (strcmp(nom_fichier, fichiers[i].nom) == 0 && fichiers[i].taille > 0) {
            printf("Lecture du fichier %s de taille %d à partir du secteur %d.\n", fichiers[i].nom, fichiers[i].taille, fichiers[i].debut);
            for (int j = 0; j < fichiers[i].taille; j++) {
                printf("%s ",fichiers[i].nom);
            }
            printf("\n");
            trouve = 1;
            break;
        }
    }
    if (!trouve) {
        printf("Fichier non trouvé ou supprimé.\n");
    }
}

int decalerFichier(struct Fichier *fichier, int premier_secteur_vide, int disque[]) {
    if (fichier->taille > 0) {
        // Sauvegarder l'ancien début du fichier
        int ancien_debut = fichier->debut;

        // Mettre à jour le début du fichier
        fichier->debut = premier_secteur_vide;

        // Mettre à jour l'état du disque pour les secteurs du fichier
        for (int i = 0; i < fichier->taille; i++) {
            disque[premier_secteur_vide + i] = 1; // Marquer les secteurs comme réservés
        }

        // Réinitialiser l'état du disque pour les anciens secteurs du fichier
        for (int i = 0; i < ancien_debut - premier_secteur_vide; i++) {
            disque[premier_secteur_vide + fichier->taille + i] = 0; // Marquer les secteurs comme vides
        }

        // Retourner la nouvelle position après le déplacement du fichier
        return premier_secteur_vide + fichier->taille;
    }

    // Si le fichier est vide, ne rien faire
    return premier_secteur_vide;
}

void defragmenterDisque(struct Fichier fichiers[], int *nb_fichiers, int *espace_libre, int disque[], int capacite_disque) {
    int secteurs_vides = 0;

    // Compter les secteurs vides et trouver la position du premier secteur vide
    int premier_secteur_vide = -1;
    for (int i = 0; i < capacite_disque; i++) {
        if (disque[i] == 0) {
            secteurs_vides++;
            if (premier_secteur_vide == -1) {
                premier_secteur_vide = i;
            }
        }
    }

    if (secteurs_vides == 0) {
        printf("Aucun secteur vide à consolider.\n");
        return;
    }

    // Trier les fichiers par leur secteur de début (du plus proche au début du disque)
    for (int i = 0; i < *nb_fichiers - 1; i++) {
        for (int j = 0; j < *nb_fichiers - i - 1; j++) {
            if (fichiers[j].debut > fichiers[j + 1].debut) {
                // Échangez les fichiers
                struct Fichier temp = fichiers[j];
                fichiers[j] = fichiers[j + 1];
                fichiers[j + 1] = temp;
            }
        }
    }

    // Parcourir les fichiers et les déplacer en consolidant les secteurs vides
    for (int i = 0; i < *nb_fichiers; i++) {
        premier_secteur_vide = decalerFichier(&fichiers[i], premier_secteur_vide, disque);
    }

    printf("Fragmentation terminée.\n");
}



void afficherEtatDisque(struct Fichier fichiers[], int nb_fichiers, int disque[], int capacite_disque, int espace_libre) {
   
    printf("État du disque avec les noms des fichiers ou # pour les secteurs vides :\n");
    
    if (capacite_disque > 0) {
        for (int i = 0; i < capacite_disque; i++) {
            if (disque[i] == 1) {
                for (int j = 0; j < nb_fichiers; j++) {
                    if (fichiers[j].debut <= i && i < fichiers[j].debut + fichiers[j].taille) {
                        printf("%s ", fichiers[j].nom);
                        break;
                    }
                }
            } else {
                printf("## ");
            }
            if (i % 10 == 9) {
                printf("\n");
            }
        } 
    } else {
        for (int i = 0; i < espace_libre; i++) {
            printf("## ");
            if (i % 10 == 9) {
                printf("\n");
            }
        }
    }
    
}


int main() {

    int choix;
    
    do {
        printf("\nMenu :\n");
        printf("1. Créer un fichier\n");
        printf("2. Lire un fichier\n");
        printf("3. Supprimer un fichier\n");
        printf("4. Fragmenter le disque\n");
        printf("5. Afficher l'état du disque\n");
        printf("6. Quitter\n");
        printf("Choix : ");
        scanf("%d", &choix);

        switch (choix) {
            case 1:
                creerFichier(fichiers, &nb_fichiers, &espace_libre, disque, capacite_disque);
                break;

            case 2:
                lireFichier(fichiers, nb_fichiers);
                break;

            case 3:
                supprimerFichier(fichiers, &nb_fichiers, &espace_libre, disque, capacite_disque);
                break;

            case 4:
                defragmenterDisque(fichiers, &nb_fichiers, &espace_libre, disque, capacite_disque);
                break;

            case 5:
                afficherEtatDisque(fichiers, nb_fichiers, disque, capacite_disque, espace_libre);
                //afficherEtatDisque(disque, capacite_disque);
                break;

            case 6:
                printf("Au revoir.\n");
                break;

            default:
                printf("Choix invalide.\n");
        }
    } while (choix != 6);

    return 0;
}