<?php

/**
 * Classe session
 * 
 * Cette classe gère les sessions utilisateur, y compris la création, la récupération,
 * la modification et la suppression des données de session.
 */
class session
{
    /**
     * Crée une session avec les données fournies.
     *
     * @param array $_array Données de la session.
     * @param string $_type Type de session (par défaut "user").
     */
    public static function createSession(array $_array, string $_type = "user")
    {
        $_SESSION[$_type] = $_array;
    }

    /**
     * Récupère l'identifiant de la session.
     *
     * @param string $_type Type de session (par défaut "user").
     * @return mixed Identifiant de la session.
     */
    public static function getId(string $_type = "user")
    {
        return $_SESSION[$_type]["id"];
    }

    /**
     * Récupère une valeur spécifique de la session.
     *
     * @param string $_val Clé de la valeur à récupérer.
     * @param string $_type Type de session (par défaut "user").
     * @return mixed Valeur correspondante dans la session.
     */
    public static function getValue(string $_val, string $_type = "user")
    {
        return $_SESSION[$_type][$_val];
    }

    /**
     * Définit une valeur spécifique dans la session.
     *
     * @param mixed $_vl Valeur à définir.
     * @param string $_val Clé de la valeur à définir.
     * @param string $_type Type de session (par défaut "user").
     */
    public static function setValue($_vl, string $_val, string $_type = "user")
    {
        $_SESSION[$_type][$_val] = $_vl;
    }

    /**
     * Récupère le nom complet de l'utilisateur dans la session.
     *
     * @param string $_type Type de session (par défaut "user").
     * @return string Nom complet de l'utilisateur.
     */
    public static function getName(string $_type = "user")
    {
        return $_SESSION[$_type]["prenom"] . " " . $_SESSION[$_type]["nom"];
    }

    /**
     * Récupère le type d'utilisateur dans la session.
     *
     * @param string $_type Type de session (par défaut "user").
     * @return mixed Type d'utilisateur.
     */
    public static function getType(string $_type = "user")
    {
        return $_SESSION[$_type]["idType"];
    }

    /**
     * Vérifie si l'utilisateur est connecté.
     *
     * @param string $_type Type de session (par défaut "user").
     * @return bool Vrai si l'utilisateur est connecté, faux sinon.
     */
    public static function isConnect(string $_type = "user")
    {
        return (isset($_SESSION[$_type]["id"])) ? TRUE : FALSE;
    }

    /**
     * Vérifie si l'utilisateur a accès à un type spécifique.
     *
     * @param array $_type Types d'accès autorisés.
     * @return bool Vrai si l'utilisateur a accès, faux sinon.
     */
    public static function access(array $_type)
    {
        return (in_array($_SESSION["user"]["idType"], $_type)) ? TRUE : FALSE;
    }

    /**
     * Vérifie si l'utilisateur est dans l'espace des contrôleurs.
     *
     * @return bool Vrai si l'utilisateur est dans l'espace des contrôleurs, faux sinon.
     */
    public static function isEspaceControleurs()
    {
        return ($_SERVER['HTTP_HOST'] == DOMAIN_CONTROL) ? TRUE : FALSE;
    }

    /**
     * Vérifie si l'utilisateur est dans l'espace des salariés.
     *
     * @return bool Vrai si l'utilisateur est dans l'espace des salariés, faux sinon.
     */
    public static function isEspaceSalaries()
    {
        return ($_SERVER['HTTP_HOST'] == DOMAIN_EVENTS) ? TRUE : FALSE;
    }

    /**
     * Définit des données temporaires dans la session.
     *
     * @param array $_array Données temporaires à définir.
     * @param string|null $_name Nom de la clé temporaire (par défaut "tmp").
     */
    public static function setTemp(array $_array, ?string $_name = NULL)
    {
        if ($_name == NULL) {
            $_SESSION["TEMP"]["tmp"] = $_array;
        } else {
            $_SESSION["TEMP"][$_name] = $_array;
        }
    }

    /**
     * Récupère des données temporaires de la session.
     *
     * @param string|null $_name Nom de la clé temporaire (par défaut "tmp").
     * @return mixed Données temporaires récupérées.
     */
    public static function getTemp(?string $_name = NULL)
    {
        if (empty($_SESSION["TEMP"])) {
            return NULL;
        } elseif ($_name == NULL) {
            $return = $_SESSION["TEMP"]["tmp"];
        } else {
            $return = $_SESSION["TEMP"][$_name];
        }
        self::resetTemp();
        return $return;
    }

    /**
     * Réinitialise les données temporaires dans la session.
     *
     * @param string|null $_name Nom de la clé temporaire à réinitialiser (par défaut toutes).
     */
    public static function resetTemp(?string $_name = NULL)
    {
        unset($_SESSION["TEMP"]);
    }

    /**
     * Déconnexion sécurisée de l'utilisateur.
     * Détruit la session et régénère l'ID pour éviter la fixation de session.
     *
     * @param string $_type Type de session à détruire (par défaut "user").
     * @return bool True si la déconnexion a réussi.
     */
    public static function logout(string $_type = "user"): bool
    {
        // Supprimer les données de session de l'utilisateur
        if (isset($_SESSION[$_type])) {
            unset($_SESSION[$_type]);
        }

        // Si aucune autre donnée de session n'existe, détruire complètement la session
        $hasOtherSessions = false;
        foreach ($_SESSION as $key => $value) {
            if (!in_array($key, ['_session_created', '_session_ip', '_session_user_agent', '_session_last_activity', 'TEMP'])) {
                $hasOtherSessions = true;
                break;
            }
        }

        // Si pas d'autres sessions actives, détruire complètement
        if (!$hasOtherSessions) {
            return secureSession::destroy();
        }

        // Sinon, régénérer l'ID de session pour sécurité
        return secureSession::regenerateId();
    }

    /**
     * Force le timeout d'inactivité de la session.
     * À appeler au début de chaque requête pour vérifier l'activité.
     *
     * @param int $minutes Nombre de minutes d'inactivité avant expiration (par défaut 30).
     * @return bool True si la session est toujours valide, False si elle a expiré.
     */
    public static function checkTimeout(int $minutes = 30): bool
    {
        return secureSession::setInactivityTimeout($minutes);
    }
}