main.cpp

#include <iostream>
#include "Serveur.h"
#include "Badge.h"
#include "LecteurBadge.h"
#include "TypeAcces.h"
#include "Personne.h"
#include <fstream>
#include <memory>
#include "Enseignant.h"
#include "Etudiant.h"
#include "PersonnelSecurite.h"
#include "Scheduler.h"


using namespace  std;

class Serveur;
class Badge;
class LecteurBadge;


int main() {

    std::cout << "=== Simulateur de systeme de badges ===" << std::endl;

    Serveur* serveur = new Serveur("Serveur-UTBM", "192.168.10.100");
    Scheduler* scheduler = new Scheduler(serveur);

    serveur->showConfiguration();


    // 2. Créer des personnes
    cout << "\n=== CREATION DES PERSONNES ===" << endl;

    // Vecteur polymorphe de Personne*
    vector<shared_ptr<Personne>> personnes;
    // Étudiants
    auto etudiant1 = make_shared<Etudiant>("Faullereau", "Jean", "L3",
                                  "jean.Faullereau@utbm.fr", "Informatique");
    auto etudiant2 = make_shared<Etudiant>("Bernard", "Sophie", "M1",
                                           "sophie.bernard@utbm.fr", "Informatique");
    auto doctorant = make_shared<Etudiant>("Petit", "Thomas", "Doctorant",
                                           "thomas.petit@utbm.fr", "Energie");

    // Enseignants
    auto enseignant1 = make_shared<Enseignant>("Martin", "Marie", "Maîtresse de conférence",
                                               "marie.martin@utbm.fr", "Mathématiques");
    enseignant1->ajouterStatutChercheur("LORIA");

    auto enseignant2 = make_shared<Enseignant>("Lacaille", "Nicolas", "Professeur",
                                               "nicolas.lacaille@utbm.fr", "Informatique");

    // Personnel de sécurité
    auto securite1 = make_shared<PersonnelSecurite>("Fontaine", "Pierre", "Agent de sécurité",
                                                     "pierre.fontaine@utbm.fr", "Sécurité");
    auto securite2 = make_shared<PersonnelSecurite>("Leroy", "Marc", "Chef d'équipe",
                                                     "marc.leroy@univ.fr", "Sécurité");

    // Ajouter toutes les personnes au vecteur polymorphe
    personnes.push_back(etudiant1);
    personnes.push_back(etudiant2);
    personnes.push_back(doctorant);
    personnes.push_back(enseignant1);
    personnes.push_back(enseignant2);
    personnes.push_back(securite1);
    personnes.push_back(securite2);

    // 3. Créer des badges associés aux personnes
    cout << "\n=== CREATION DES BADGES ===" << endl;

    // Créer les badges en passant les shared_ptr de Personne
    const auto badge1 = make_shared<Badge>(etudiant1, "actif");
    const auto badge2 = make_shared<Badge>(etudiant2, "desactive");
    const auto badge3 = make_shared<Badge>(doctorant, "actif");
    const auto badge4 = make_shared<Badge>(enseignant1, "suspendu");
    const auto badge5 = make_shared<Badge>(enseignant2, "actif");
    const auto badge6 = make_shared<Badge>(securite1, "actif");
    const auto badge7 = make_shared<Badge>(securite2, "actif", "2026-12-31");

    // 4. Créer des lecteurs
    cout << "\n=== CREATION DES LECTEURS DE BADGE ===" << endl;

    const auto lecteur1 = make_shared<LecteurBadge>(serveur,"Batiment A - Entree principale", "batiment",
                         TypeAcces::BATIMENT, NiveauAcces::STANDARD);
    const auto lecteur2 = make_shared<LecteurBadge>(serveur,"Laboratoire de Recherche", "laboratoire",
                         TypeAcces::LABORATOIRE, NiveauAcces::PRIORITAIRE);
    const auto lecteur3 = make_shared<LecteurBadge>(serveur,"Salle Securite", "securite",
                         TypeAcces::SALLE_SECURITE, NiveauAcces::PRIORITAIRE);

    const auto lecteur4 = make_shared<LecteurBadge>(serveur,"Salle TP Informatique", "salle",
                                                 TypeAcces::SALLE_TP, NiveauAcces::STANDARD);

    // ajouter les instances des entites crees au scheduler
    cout << "\n=== AJOUT DES ENTITES AU SCHEDULER ===" << endl;

    // Ajouter toutes les personnes
    for (const auto& personne : personnes) {
        scheduler->ajouterPersonne(personne);
    }
    // Ajouter tous les badges
    scheduler->ajouterBadge(badge1);
    scheduler->ajouterBadge(badge2);
    scheduler->ajouterBadge(badge3);
    scheduler->ajouterBadge(badge4);
    scheduler->ajouterBadge(badge5);
    scheduler->ajouterBadge(badge6);
    scheduler->ajouterBadge(badge7);

    // Ajouter tous les lecteurs de badges
    scheduler->ajouterLecteur(lecteur1);
    scheduler->ajouterLecteur(lecteur2);
    scheduler->ajouterLecteur(lecteur3);
    scheduler->ajouterLecteur(lecteur4);


    // 5. Affichage des informations
    cout << "\n=== INFORMATIONS DES PERSONNES ===" << endl;
    for (const auto& personne : personnes) {
        personne->afficherInfos();
        cout << endl;
    }
    cout << "\n=== INFORMATIONS DES BADGES ===" << endl;
    badge1->afficherInfosBadge();
    cout << endl;
    badge2->afficherInfosBadge();
    cout << endl;
    badge3->afficherInfosBadge();
    cout << endl;
    badge4->afficherInfosBadge();
    cout << endl;
    badge5->afficherInfosBadge();
    cout << endl;
    badge6->afficherInfosBadge();

    // 6. Tests d'accès
    cout << "\n=== TESTS D'ACCES ===" << endl;

    scheduler->simulation();

    // 7. Test de suspension de badge
    cout << "\n=== TEST DE GESTION DES BADGES ===" << endl;

    cout << "\n--- Suspension du badge etudiant ---" << endl;
    badge1->suspendreBadge();
    badge1->afficherInfosBadge();

    scheduler->simulation();

    cout << "\n--- Reactivation du badge ---" << endl;
    badge1->activerBadge();

    scheduler->simulation();

    // 8. Nettoyage
    cout << "\n=== ARRET DU SYSTEME ===" << endl;
    delete serveur;

    //liberer la memoire -> supprime touts les objets qui sont reliés au scheduler
    delete scheduler;

    cout << "\n=== PROGRAMME TERMINE ===" << endl;

    return 0;
}