<?php
// Configuration de la base de données
$host = 'localhost';
$dbname = 'cpn';
$username = 'root';
$password = '';

try {
    $pdo = new PDO("mysql:host=$host;dbname=$dbname;charset=utf8", $username, $password);
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    $pdo->setAttribute(PDO::ATTR_DEFAULT_FETCH_MODE, PDO::FETCH_ASSOC);
} catch(PDOException $e) {
    die("Erreur de connexion : " . $e->getMessage());
}

/**
 * Récupère les informations de l'utilisateur connecté
 * @param PDO $pdo
 * @return array
 */
function getUserInfo($pdo) {
    if (!isset($_SESSION['id_user'])) {
        return [
            'nom' => 'Utilisateur',
            'prenom' => '',
            'role' => $_SESSION['user_role'] ?? 'visiteur'
        ];
    }
    
    try {
        $stmt = $pdo->prepare("SELECT nom, prenom, role, email, login FROM utilisateur WHERE id_user = ?");
        $stmt->execute([$_SESSION['id_user']]);
        $user = $stmt->fetch();
        
        if ($user) {
            return $user;
        }
    } catch(Exception $e) {
        error_log("Erreur getUserInfo: " . $e->getMessage());
    }
    
    return [
        'nom' => $_SESSION['user_nom'] ?? 'Utilisateur',
        'prenom' => '',
        'role' => $_SESSION['user_role'] ?? 'visiteur'
    ];
}

/**
 * Récupère l'emploi du temps d'un enseignant
 * @param PDO $pdo
 * @param int $id_enseignant
 * @return array
 */
function getEmploiTempsEnseignant($pdo, $id_enseignant) {
    $emploi = [];
    
    if (!$id_enseignant) {
        error_log("getEmploiTempsEnseignant: ID enseignant non fourni");
        return $emploi;
    }
    
    try {
        $sql = "SELECT 
                    s.*, 
                    COALESCE(m.nom_matiere, 'Matière inconnue') as nom_matiere,
                    COALESCE(g.nom_groupe, CONCAT('Groupe ', s.id_groupe)) as nom_groupe,
                    COALESCE(sal.nom_salle, CONCAT('Salle ', s.id_salle)) as nom_salle,
                    s.jour,
                    s.heure_debut,
                    s.heure_fin,
                    m.nbr_heure_semaine
                FROM seance s
                LEFT JOIN matieres m ON s.id_matiere = m.id_matiere
                LEFT JOIN groupe g ON s.id_groupe = g.id_groupe
                LEFT JOIN salle sal ON s.id_salle = sal.id_salle
                WHERE s.id_enseignant = :id_enseignant
                ORDER BY FIELD(s.jour, 'Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi', 'Samedi'), 
                         s.heure_debut";
        
        $stmt = $pdo->prepare($sql);
        $stmt->execute([':id_enseignant' => $id_enseignant]);
        $emploi = $stmt->fetchAll(PDO::FETCH_ASSOC);
        
        error_log("getEmploiTempsEnseignant: " . count($emploi) . " cours trouvés pour l'enseignant " . $id_enseignant);
        
    } catch(Exception $e) {
        error_log("Erreur getEmploiTempsEnseignant: " . $e->getMessage());
    }
    
    return $emploi;
}

/**
 * Récupère les absences des étudiants
 * @param PDO $pdo
 * @return array
 */
function getAbsencesEnseignant($pdo) {
    try {
        $sql = "SELECT a.*, 
                       e.nom as etudiant_nom,
                       e.prenom as etudiant_prenom,
                       e.id_groupe as groupe_id,
                       g.nom_groupe as groupe_nom,
                       m.nom_matiere as matiere_nom,
                       s.date_seance,
                       s.heure_debut,
                       s.heure_fin
                FROM absence_etudiant a
                JOIN etudiants e ON a.id_etudiant = e.id_etudiant
                LEFT JOIN seance s ON a.id_seance = s.id_seance
                LEFT JOIN matieres m ON s.id_matiere = m.id_matiere
                LEFT JOIN groupe g ON e.id_groupe = g.id_groupe
                ORDER BY a.date_absence DESC";
        
        $stmt = $pdo->query($sql);
        return $stmt->fetchAll(PDO::FETCH_ASSOC);
    } catch(Exception $e) {
        error_log("Erreur getAbsencesEnseignant: " . $e->getMessage());
        return [];
    }
}

/**
 * Récupère les notes des étudiants
 * @param PDO $pdo
 * @return array
 */
function getNotesEnseignant($pdo) {
    try {
        $sql = "SELECT n.*, 
                       e.nom as etudiant_nom, 
                       e.prenom as etudiant_prenom, 
                       e.id_groupe as groupe_id,
                       g.nom_groupe as groupe_nom,
                       m.nom_matiere as matiere_nom
                FROM notes n
                JOIN etudiants e ON n.id_etudiant = e.id_etudiant
                JOIN matieres m ON n.id_matiere = m.id_matiere
                LEFT JOIN groupe g ON e.id_groupe = g.id_groupe
                ORDER BY e.nom, m.nom_matiere";
        
        $stmt = $pdo->query($sql);
        return $stmt->fetchAll(PDO::FETCH_ASSOC);
    } catch(Exception $e) {
        error_log("Erreur getNotesEnseignant: " . $e->getMessage());
        return [];
    }
}

/**
 * Récupère les examens
 * @param PDO $pdo
 * @return array
 */
function getExamensEnseignant($pdo) {
    try {
        $sql = "SELECT e.*, 
                       m.nom_matiere AS matiere_nom,
                       g.nom_groupe AS groupe_nom,
                       s.nom_salle AS salle_nom,
                       CASE 
                           WHEN e.type_examen = 'test1' THEN 'Test 1'
                           WHEN e.type_examen = 'test2' THEN 'Test 2'
                           WHEN e.type_examen = 'examen' THEN 'Examen final'
                           ELSE e.type_examen
                       END as type_label
                FROM examen e
                JOIN matieres m ON e.id_matieres = m.id_matiere
                JOIN groupe g ON e.id_groupe = g.id_groupe
                LEFT JOIN salle s ON e.id_salle = s.id_salle
                ORDER BY e.date_examen DESC";
        
        $stmt = $pdo->query($sql);
        return $stmt->fetchAll(PDO::FETCH_ASSOC);
    } catch(Exception $e) {
        error_log("Erreur getExamensEnseignant: " . $e->getMessage());
        return [];
    }
}

/**
 * Récupère la liste des étudiants
 * @param PDO $pdo
 * @return array
 */
function getEtudiants($pdo) {
    try {
        return $pdo->query("SELECT id_etudiant, nom, prenom, id_groupe FROM etudiants ORDER BY nom, prenom")->fetchAll(PDO::FETCH_ASSOC);
    } catch(Exception $e) {
        error_log("Erreur getEtudiants: " . $e->getMessage());
        return [];
    }
}

/**
 * Récupère la liste des matières
 * @param PDO $pdo
 * @return array
 */
function getMatieres($pdo) {
    try {
        return $pdo->query("SELECT id_matiere, nom_matiere, code, nbr_heure_semaine FROM matieres ORDER BY nom_matiere")->fetchAll(PDO::FETCH_ASSOC);
    } catch(Exception $e) {
        error_log("Erreur getMatieres: " . $e->getMessage());
        return [];
    }
}

/**
 * Récupère la liste des groupes
 * @param PDO $pdo
 * @return array
 */
function getGroupes($pdo) {
    try {
        return $pdo->query("SELECT id_groupe, nom_groupe FROM groupe ORDER BY nom_groupe")->fetchAll(PDO::FETCH_ASSOC);
    } catch(Exception $e) {
        error_log("Erreur getGroupes: " . $e->getMessage());
        return [];
    }
}

/**
 * Récupère la liste des salles
 * @param PDO $pdo
 * @return array
 */
function getSalles($pdo) {
    try {
        return $pdo->query("SELECT id_salle, nom_salle, capacite FROM salle ORDER BY nom_salle")->fetchAll(PDO::FETCH_ASSOC);
    } catch(Exception $e) {
        error_log("Erreur getSalles: " . $e->getMessage());
        return [];
    }
}

/**
 * Récupère les absences d'un étudiant
 * @param PDO $pdo
 * @param int $id_etudiant
 * @return array
 */
function getAbsencesEtudiant($pdo, $id_etudiant) {
    $absences = [];
    
    try {
        $sql = "
            SELECT 
                a.id_absence,
                a.id_etudiant,
                a.id_seance,
                a.date_absence,
                a.justifie,
                COALESCE(
                    m.nom_matiere,
                    (SELECT nom_matiere FROM matieres WHERE id_matiere = s.id_matiere),
                    'Matière non spécifiée'
                ) as matiere_nom,
                COALESCE(
                    a.date_absence,
                    s.date_seance,
                    CURDATE()
                ) as date_affichage,
                COALESCE(
                    s.heure_debut,
                    '08:00:00'
                ) as heure_debut,
                COALESCE(
                    s.heure_fin,
                    '10:00:00'
                ) as heure_fin,
                s.jour as jour_seance,
                CASE 
                    WHEN a.justifie = 'oui' THEN 'Oui'
                    ELSE 'Non'
                END as justifie_texte
            FROM absence_etudiant a
            LEFT JOIN seance s ON a.id_seance = s.id_seance
            LEFT JOIN matieres m ON s.id_matiere = m.id_matiere
            WHERE a.id_etudiant = :id_etudiant
            ORDER BY COALESCE(a.date_absence, s.date_seance, '1900-01-01') DESC, a.id_absence DESC
        ";
        
        $stmt = $pdo->prepare($sql);
        $stmt->execute([':id_etudiant' => $id_etudiant]);
        $absences = $stmt->fetchAll(PDO::FETCH_ASSOC);
        
        // Post-traitement des données
        foreach ($absences as &$absence) {
            if (empty($absence['matiere_nom'])) {
                $absence['matiere_nom'] = 'Matière inconnue';
            }
            if (empty($absence['date_affichage']) || $absence['date_affichage'] == '0000-00-00') {
                $absence['date_affichage'] = date('Y-m-d');
            }
            $absence['justifie_class'] = ($absence['justifie'] ?? 'non') == 'oui' ? 'justifie-oui' : 'justifie-non';
        }
        
    } catch(Exception $e) {
        error_log("Erreur getAbsencesEtudiant: " . $e->getMessage());
        $absences = [];
    }
    
    return $absences;
}

/**
 * Récupère les notes d'un étudiant
 * @param PDO $pdo
 * @param int $id_etudiant
 * @return array
 */
function getNotesEtudiant($pdo, $id_etudiant) {
    $notes = [];
    
    try {
        $sql = "
            SELECT n.*, 
                   COALESCE(m.nom_matiere, 'Matière inconnue') as matiere_nom
            FROM notes n
            LEFT JOIN matieres m ON n.id_matiere = m.id_matiere
            WHERE n.id_etudiant = :id_etudiant
            ORDER BY m.nom_matiere
        ";
        
        $stmt = $pdo->prepare($sql);
        $stmt->execute([':id_etudiant' => $id_etudiant]);
        $notes = $stmt->fetchAll(PDO::FETCH_ASSOC);
        
    } catch(Exception $e) {
        error_log("Erreur getNotesEtudiant: " . $e->getMessage());
        $notes = [];
    }
    
    return $notes;
}

/**
 * Récupère les informations d'un étudiant
 * @param PDO $pdo
 * @param int $id_etudiant
 * @return array|null
 */
function getInfosEtudiant($pdo, $id_etudiant) {
    try {
        $sql = "
            SELECT e.*, 
                   COALESCE(g.nom_groupe, 'Groupe non assigné') as groupe_nom,
                   g.id_groupe,
                   COALESCE(f.nom_formation, 'Formation non spécifiée') as nom_formation
            FROM etudiants e 
            LEFT JOIN groupe g ON e.id_groupe = g.id_groupe
            LEFT JOIN formation f ON g.id_formation = f.id_formation
            WHERE e.id_etudiant = :id_etudiant
        ";
        
        $stmt = $pdo->prepare($sql);
        $stmt->execute([':id_etudiant' => $id_etudiant]);
        $etudiant = $stmt->fetch(PDO::FETCH_ASSOC);
        
        if (!$etudiant && isset($_SESSION['id_user'])) {
            $sql = "
                SELECT e.*, 
                       COALESCE(g.nom_groupe, 'Groupe non assigné') as groupe_nom,
                       g.id_groupe,
                       COALESCE(f.nom_formation, 'Formation non spécifiée') as nom_formation
                FROM etudiants e 
                LEFT JOIN groupe g ON e.id_groupe = g.id_groupe
                LEFT JOIN formation f ON g.id_formation = f.id_formation
                WHERE e.id_user = :id_user
            ";
            $stmt = $pdo->prepare($sql);
            $stmt->execute([':id_user' => $_SESSION['id_user']]);
            $etudiant = $stmt->fetch(PDO::FETCH_ASSOC);
        }
        
        return $etudiant;
        
    } catch(Exception $e) {
        error_log("Erreur getInfosEtudiant: " . $e->getMessage());
        return null;
    }
}

/**
 * Récupère l'emploi du temps d'un étudiant
 * @param PDO $pdo
 * @param int $id_groupe
 * @return array
 */
function getEmploiTempsEtudiant($pdo, $id_groupe) {
    $emploi_temps = [];
    
    if (empty($id_groupe)) {
        return $emploi_temps;
    }
    
    try {
        $sql = "
            SELECT s.*, 
                   COALESCE(m.nom_matiere, 'Matière inconnue') as matiere_nom,
                   COALESCE(sal.nom_salle, 'Salle non assignée') as salle_nom,
                   COALESCE(CONCAT(ens.nom, ' ', ens.prenom), 'Enseignant non assigné') as enseignant_nom
            FROM seance s
            LEFT JOIN matieres m ON s.id_matiere = m.id_matiere
            LEFT JOIN salle sal ON s.id_salle = sal.id_salle
            LEFT JOIN enseignant ens ON s.id_enseignant = ens.id_enseignant
            WHERE s.id_groupe = :id_groupe
            ORDER BY FIELD(s.jour, 'Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi', 'Samedi'), 
                     s.heure_debut
        ";
        
        $stmt = $pdo->prepare($sql);
        $stmt->execute([':id_groupe' => $id_groupe]);
        $emploi_temps = $stmt->fetchAll(PDO::FETCH_ASSOC);
        
    } catch(Exception $e) {
        error_log("Erreur getEmploiTempsEtudiant: " . $e->getMessage());
        $emploi_temps = [];
    }
    
    return $emploi_temps;
}

/**
 * Récupère les examens d'un étudiant
 * @param PDO $pdo
 * @param int $id_groupe
 * @return array
 */
function getExamensEtudiant($pdo, $id_groupe) {
    $examens = [];
    
    if (empty($id_groupe)) {
        return $examens;
    }
    
    try {
        $sql = "
            SELECT e.*, 
                   COALESCE(m.nom_matiere, 'Matière inconnue') as matiere_nom,
                   COALESCE(s.nom_salle, 'Salle non assignée') as salle_nom,
                   CASE 
                       WHEN e.type_examen = 'test1' THEN 'Test 1'
                       WHEN e.type_examen = 'test2' THEN 'Test 2'
                       WHEN e.type_examen = 'examen' THEN 'Examen final'
                       ELSE COALESCE(e.type_examen, 'Examen')
                   END as type_label
            FROM examen e
            LEFT JOIN matieres m ON e.id_matieres = m.id_matiere
            LEFT JOIN salle s ON e.id_salle = s.id_salle
            WHERE e.id_groupe = :id_groupe
            ORDER BY e.date_examen ASC, e.heure_debut
        ";
        
        $stmt = $pdo->prepare($sql);
        $stmt->execute([':id_groupe' => $id_groupe]);
        $examens = $stmt->fetchAll(PDO::FETCH_ASSOC);
        
    } catch(Exception $e) {
        error_log("Erreur getExamensEtudiant: " . $e->getMessage());
        $examens = [];
    }
    
    return $examens;
}

/**
 * Calcule les statistiques d'absences
 * @param array $absences
 * @return array
 */
function calculerStatsAbsences($absences) {
    $total = count($absences);
    $non_justifiees = 0;
    $justifiees = 0;
    
    foreach ($absences as $a) {
        if (($a['justifie'] ?? 'non') == 'oui') {
            $justifiees++;
        } else {
            $non_justifiees++;
        }
    }
    
    return [
        'total' => $total,
        'non_justifiees' => $non_justifiees,
        'justifiees' => $justifiees,
        'pourcentage_justifie' => $total > 0 ? round(($justifiees / $total) * 100, 2) : 0
    ];
}

/**
 * Calcule la moyenne générale d'un étudiant
 * @param array $notes
 * @return array
 */
function calculerMoyenneGenerale($notes) {
    $somme = 0;
    $count = 0;
    
    foreach ($notes as $n) {
        if (!empty($n['moyenne']) && $n['moyenne'] > 0) {
            $somme += floatval($n['moyenne']);
            $count++;
        }
    }
    
    return [
        'moyenne' => $count > 0 ? $somme / $count : 0,
        'nb_matieres' => $count,
        'total_matieres' => count($notes)
    ];
}

/**
 * Calcule la moyenne à partir des notes individuelles
 * @param float|null $test1
 * @param float|null $test2
 * @param float|null $examen
 * @return float|null
 */
function calculerMoyenne($test1, $test2, $examen) {
    $coefficients = 0;
    $somme = 0;
    
    if ($test1 !== null && $test1 !== '' && floatval($test1) > 0) {
        $somme += floatval($test1);
        $coefficients += 1;
    }
    if ($test2 !== null && $test2 !== '' && floatval($test2) > 0) {
        $somme += floatval($test2);
        $coefficients += 1;
    }
    if ($examen !== null && $examen !== '' && floatval($examen) > 0) {
        $somme += floatval($examen) * 2;
        $coefficients += 2;
    }
    
    if ($coefficients > 0) {
        return round($somme / $coefficients, 2);
    }
    return null;
}

/**
 * Fonction de debug (active seulement si ?debug=1 dans l'URL)
 * @param mixed $data
 * @param string $message
 */
function debug_log($message, $data = null) {
    if (isset($_GET['debug']) && $_GET['debug'] == 1) {
        echo "<!-- DEBUG: $message - " . print_r($data, true) . " -->";
    }
    error_log("DEBUG: $message - " . print_r($data, true));
}
?>