Serveur.cpp

//
// Created by new on 9/19/2025.
//

#include "Serveur.h"

#include <algorithm>

#include "Badge.h"
#include "LecteurBadge.h"
#include <iostream>
#include <fstream>
#include <ctime>
#include <sstream>
#include <string>
#include <vector>
#include "iomanip"
#include <filesystem>
#include <unistd.h>


using namespace std;

class Serveur;

Serveur::Serveur() = default;


Serveur::Serveur(const std::string& name, const std::string &ip) : name(name),ip(ip) {
    std::cout << "Server " << name << " initialized..." << std::endl;

    // Charger la configuration des droits au démarrage, les autorisations
    gestionnaireDroits.chargerConfiguration();
}

Serveur::~Serveur() {
    std::cout << "Serveur " << name << " stopped..." << std::endl;
}

Serveur::Serveur(const Serveur& otherServeur){
    name = otherServeur.name;
    ip = otherServeur.ip;
}
Serveur& Serveur::operator=(const Serveur& other){
    if(this != &other){
        name = other.name;
        ip = other.ip;
    }
    return *this;
}


//log pour access authorized
void Serveur::ajouterLogAutorise(const string& log) {
    logsAccesAutorises.push_back(log);
}

//log pour access authorized
void Serveur::ajouterLogRefuse(const string& log) {
    logsAccesRefuses.push_back(log);
}

//ask access request Logique de vérification des droits d'accès
bool Serveur::askAccesRequest( Badge& badge,  LecteurBadge& lecteur) {
    // Obtenir l'heure actuelle
    time_t now = time(0);
    char* dt = ctime(&now);
    string heure(dt);
    heure.pop_back();

    // Créer le message de log
    ostringstream logMessage;
    logMessage << "[" << heure << "] "
               << "Personne: " << badge.getName()
               << " (" << badge.getStatus() << ") "
               << "- Lecteur: " << lecteur.getEmplacement()
               << " (" << lecteur.getTypeLecteur() << ")";

    // Vérifier d'abord si le badge est actif
    if (!badge.estActif()) {
        this->ajouterLogRefuse(logMessage.str() + " - REFUSE (Badge inactif)");
        cout << "Acces REFUSE pour " << badge.getName()
                  << " - Badge " << badge.getEtatBadge() << endl;
        //save the logs
        this->saveLogRefused();
        return false;
    }

    // Utiliser le gestionnaire de droits pour vérifier l'accès
    bool autorise = gestionnaireDroits.verifierAcces(badge, lecteur);

    // Enregistrer le log approprié
    if (autorise) {
        this->ajouterLogAutorise(logMessage.str() + " - AUTORISER");
        //save the logs on the file
        this->saveLogAutorized();
        cout << "Acces AUTORISE pour " << badge.getName()
                  << " a " << lecteur.getEmplacement() << endl;
    } else {
        this->ajouterLogRefuse(logMessage.str() + " - REFUSER");
        cout << "Acces REFUSE pour " << badge.getName()
                  << " a " << lecteur.getEmplacement() << endl;

        //save the logs on the file
        this->saveLogRefused();
    }
    return autorise;
}


void Serveur::saveLogAutorized() const {
    // Obtenir la date/heure actuelle pour le nom de fichier
    time_t now = time(0);
    struct tm* timeinfo = localtime(&now);

    char dateHeader[30];
    strftime(dateHeader, sizeof(dateHeader), "%Y-%m-%d %H:%M:%S", timeinfo);

    // Nom de fichier fixe
    string fichierAutorisesNom = "acces_autorises.log";

    // === SAUVEGARDE DES ACCÈS AUTORISÉS ===
    ofstream fichierAutorises(fichierAutorisesNom, ios::app);  // <<<<<< ajout du ios::app

    if (fichierAutorises.is_open()) {
        // Écrire un "header de session" (utile pour retrouver quand la sauvegarde a eu lieu)
        fichierAutorises << endl;
        fichierAutorises << "================================================================" << endl;
        fichierAutorises << "              LOG DES ACCÈS AUTORISES" << endl;
        fichierAutorises << "================================================================" << endl;
        fichierAutorises << "Nouvelle écriture [" << dateHeader << "]" << endl;
        fichierAutorises << "Serveur : " << name << " | Adresse IP : " << ip << endl;
        fichierAutorises << "Nombre d'entrées : " << logsAccesAutorises.size() << endl;
        fichierAutorises << "================================================================" << endl;
        fichierAutorises << endl;

        // Contenu des logs
        if (logsAccesAutorises.empty()) {
            fichierAutorises << "Aucun accès autorisé enregistré." << endl;
        } else {
            int compteur = 1;
            for (const auto& log : logsAccesAutorises) {
                fichierAutorises << "[" << setfill('0') << setw(4) << compteur << "] "
                               << log << endl;
                compteur++;
            }
        }

        // Fin du fichier
        fichierAutorises << endl;
        fichierAutorises << "================================================================" << endl;
        fichierAutorises << "Fin du fichier - Total: " << logsAccesAutorises.size() << " entrées" << endl;
        fichierAutorises << "================================================================" << endl;

        fichierAutorises.close();

        // Obtenir le chemin complet du fichier
        char chemComplet[1000];
        char* result = getcwd(chemComplet, sizeof(chemComplet));
        if (result != nullptr) {
            cout << "Logs autorises sauvegardes dans:" << endl;
            cout << "  " << chemComplet << "/" << fichierAutorisesNom << endl;
        } else {
            cout << "Logs autorises sauvegardes: " << fichierAutorisesNom << endl;
        }
        cout << "  (" << logsAccesAutorises.size() << " entrees)" << endl;

    } else {
        cerr << "ERREUR: Impossible de creer le fichier " << fichierAutorisesNom << endl;
        cerr << "  Verifiez les permissions d'ecriture du repertoire." << endl;
    }
}

void Serveur::saveLogRefused() const{
    // Obtenir la date/heure actuelle pour le nom de fichier
    time_t now = time(0);
    struct tm* timeinfo = localtime(&now);

    char dateHeader[30];
    strftime(dateHeader, sizeof(dateHeader), "%Y-%m-%d %H:%M:%S", timeinfo);
    string fichierRefusesNom = "acces_refuses.log";

    // === SAUVEGARDE DES ACCÈS REFUSÉS ===
    std::ofstream fichierRefuses(fichierRefusesNom, ios::app);//mode append
    if (fichierRefuses.is_open()) {
        // En-tête du fichier
        fichierRefuses << endl;
        fichierRefuses << "================================================================" << endl;
        fichierRefuses << "              LOG DES ACCÈS REFUSÉS" << endl;
        fichierRefuses << "================================================================" << endl;
        fichierRefuses << "Nouvelle écriture [" << dateHeader << "]" << endl;
        fichierRefuses << "Serveur : " << name << " | Adresse IP : " << ip << endl;
        fichierRefuses << "Nombre d'entrées : " << logsAccesRefuses.size() << endl;
        fichierRefuses << "================================================================" << endl;
        fichierRefuses << endl;

        // Contenu des logs
        if (logsAccesRefuses.empty()) {
            fichierRefuses << "Aucun accès refusé enregistré." << endl;
        } else {
            int compteur = 1;
            for (const auto& log : logsAccesRefuses) {
                fichierRefuses << "[" << setfill('0') << setw(4) << compteur << "] "
                             << log << endl;
                compteur++;
            }
        }

        // Fin du fichier
        fichierRefuses << endl;
        fichierRefuses << "================================================================" << endl;
        fichierRefuses << "Fin du fichier - Total: " << logsAccesRefuses.size() << " entrées" << endl;
        fichierRefuses << "================================================================" << endl;

        fichierRefuses.close();

        // Obtenir le chemin complet du fichier
        char chemComplet[1000];
        char* result = getcwd(chemComplet, sizeof(chemComplet));
        if (result != nullptr) {
            cout << "Logs refuses sauvegardes dans:" << endl;
            cout << "  " << chemComplet << "/" << fichierRefusesNom << endl;
        } else {
            cout << "Logs refuses sauvegardes: " << fichierRefusesNom << endl;
        }
        cout << "  (" << logsAccesRefuses.size() << " entrees)" << endl;

    } else {
        cerr << "ERREUR: Impossible de creer le fichier " << fichierRefusesNom << endl;
        cerr << "  Verifiez les permissions d'ecriture du repertoire." << endl;
    }
}


void Serveur::saveLogs() const {
    ofstream fichierAutorises("acces_autorises.log");
    if (fichierAutorises.is_open()) {
        for (const auto& log : logsAccesAutorises) {
            fichierAutorises << log << endl;
        }
        fichierAutorises.close();
        cout << "Logs autorises sauvegardes (" << logsAccesAutorises.size() << " entrees)" << endl;
    }

    ofstream fichierRefuses("acces_refuses.log");
    if (fichierRefuses.is_open()) {
        for (const auto& log : logsAccesRefuses) {
            fichierRefuses << log << endl;
        }
        fichierRefuses.close();
        cout << "Logs refuses sauvegardes (" << logsAccesRefuses.size() << " entrees)" << endl;
    }
}

//affiche les configurations initales
void Serveur::showConfiguration() const {
    gestionnaireDroits.afficherConfiguration();
}

ostream& operator<<(ostream& os, const Serveur& serveur) {
    os << "Serveur name: " << serveur.name
       << " @" << serveur.ip
       << " - Logs autorises: " << serveur.logsAccesAutorises.size()
       << " - Logs refuses: " << serveur.logsAccesRefuses.size();
    return os;
}