<?php

/**
 * @file User.php
 * @brief Entité utilisateur pour le systeme d'authentification Symfony
 *
 * Represente un utilisateur de l'application ServerControl.
 * Implémente UserInterface et PasswordAuthenticatedUserInterface
 * pour s'intégrer avec le systeme de securité de Symfony.
 *
 * @package App\Entity
 * @author Yasser
 */

namespace App\Entity;

use App\Repository\UserRepository;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
use Symfony\Component\Security\Core\User\UserInterface;

/**
 * @class User
 * @brief Entité Doctrine representant un utilisateur de l'application
 *
 * Gere les 3 niveaux de roles : ROLE_USER (compte en attente),
 * ROLE_OPERATOR (acces aux serveurs assignés) et ROLE_ADMIN (acces total).
 * Le champ email est unique et sert d'identifiant de connexion.
 * Un utilisateur peut etre desactivé par un admin sans suppression.
 */
#[ORM\Entity(repositoryClass: UserRepository::class)]
#[ORM\Table(name: 'app_user')]
#[UniqueEntity(fields: ['email'], message: 'There is already an account with this email')]
class User implements UserInterface, PasswordAuthenticatedUserInterface
{
    /**
     * @var int|null Identifiant unique auto-incrementé de l'utilisateur
     */
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column(name: 'user_id')]
    private ?int $id = null;

    /**
     * @var string|null Adresse email unique, utilisée comme identifiant de connexion
     */
    #[ORM\Column(name: 'email', length: 180, unique: true)]
    private ?string $email = null;

    /**
     * @var string|null Pseudo affiché dans l'interface (nom d'affichage)
     */
    #[ORM\Column(name: 'pseudo', length: 50)]
    private ?string $pseudo = null;

    /**
     * @var array Tableau des roles Symfony (ex: ['ROLE_ADMIN'])
     * ROLE_USER est toujours ajouté automatiquement par getRoles()
     */
    #[ORM\Column(name: 'roles', type: 'json')]
    private array $roles = [];

    /**
     * @var string|null Mot de passe hashé par Symfony PasswordHasher
     */
    #[ORM\Column(name: 'password', length: 255)]
    private ?string $password = null;

    /**
     * @var bool Indique si le compte est actif, permet de bloquer un utilisateur
     */
    #[ORM\Column(name: 'is_active')]
    private bool $isActive = true;

    /**
     * @var \DateTimeImmutable|null Date d'inscription de l'utilisateur
     */
    #[ORM\Column(name: 'created_at')]
    private ?\DateTimeImmutable $createdAt = null;

    /**
     * @var string|null Token temporaire pour la reinitialisation de mot de passe
     */
    #[ORM\Column(name: 'reset_token', length: 100, nullable: true)]
    private ?string $resetToken = null;

    /**
     * @var \DateTimeImmutable|null Date d'expiration du token de reset, null si aucun token actif
     */
    #[ORM\Column(name: 'reset_token_expires_at', nullable: true)]
    private ?\DateTimeImmutable $resetTokenExpiresAt = null;

    /**
     * @var Collection Serveurs dont cet utilisateur est proprietaire
     */
    #[ORM\OneToMany(targetEntity: Server::class, mappedBy: 'owner')]
    private Collection $servers;

    /**
     * @var Collection Logs de toutes les actions effectué par cet utilisateur
     */
    #[ORM\OneToMany(targetEntity: ActionLog::class, mappedBy: 'user')]
    private Collection $actionLogs;

    /**
     * @var Collection Acces aux serveurs assignés a cet utilisateur par un admin
     */
    #[ORM\OneToMany(targetEntity: ServerAccess::class, mappedBy: 'user', cascade: ['remove'])]
    private Collection $serverAccesses;

    /**
     * @brief Constructeur - initialise les collections et la date de creation
     */
    public function __construct()
    {
        $this->createdAt = new \DateTimeImmutable();
        $this->servers = new ArrayCollection();
        $this->actionLogs = new ArrayCollection();
        $this->serverAccesses = new ArrayCollection();
    }

    /**
     * @brief Retourne l'identifiant de l'utilisateur
     * @return int|null L'id, null si pas encore persisté en base
     */
    public function getId(): ?int { return $this->id; }

    /** @return string|null Email de l'utilisateur */
    public function getEmail(): ?string { return $this->email; }
    /** @param string $email @return static */
    public function setEmail(string $email): static { $this->email = $email; return $this; }

    /** @return string|null Pseudo de l'utilisateur */
    public function getPseudo(): ?string { return $this->pseudo; }
    /** @param string $pseudo @return static */
    public function setPseudo(string $pseudo): static { $this->pseudo = $pseudo; return $this; }

    /**
     * @brief Retourne l'identifiant de connexion (email) pour Symfony Security
     * @return string L'email comme identifiant unique
     */
    public function getUserIdentifier(): string { return (string) $this->email; }

    /**
     * @brief Retourne les roles de l'utilisateur
     *
     * ROLE_USER est toujours inclus automatiquement pour garantir
     * que tout les utilisateurs aient au moin un role de base.
     *
     * @return array Tableau de roles uniques
     */
    public function getRoles(): array
    {
        $roles = $this->roles;
        $roles[] = 'ROLE_USER';
        return array_unique($roles);
    }

    /**
     * @param array $roles Les roles a assigner (ex: ['ROLE_OPERATOR'])
     * @return static
     */
    public function setRoles(array $roles): static { $this->roles = $roles; return $this; }

    /** @return string|null Mot de passe hashé */
    public function getPassword(): ?string { return $this->password; }
    /** @param string $password Le hash du mot de passe @return static */
    public function setPassword(string $password): static { $this->password = $password; return $this; }

    /**
     * @brief Verifie si le compte est actif
     * @return bool true si actif, false si désactivé par un admin
     */
    public function isActive(): bool { return $this->isActive; }
    /** @param bool $isActive @return static */
    public function setIsActive(bool $isActive): static { $this->isActive = $isActive; return $this; }

    /** @return \DateTimeImmutable|null Date d'inscription */
    public function getCreatedAt(): ?\DateTimeImmutable { return $this->createdAt; }

    /** @return string|null Token de reinitialisation de mot de passe */
    public function getResetToken(): ?string { return $this->resetToken; }
    /** @param string|null $resetToken null pour effacer le token @return static */
    public function setResetToken(?string $resetToken): static { $this->resetToken = $resetToken; return $this; }

    /** @return \DateTimeImmutable|null Date d'expiration du token */
    public function getResetTokenExpiresAt(): ?\DateTimeImmutable { return $this->resetTokenExpiresAt; }

    /**
     * @param \DateTimeImmutable|null $resetTokenExpiresAt
     * @return static
     */
    public function setResetTokenExpiresAt(?\DateTimeImmutable $resetTokenExpiresAt): static
    {
        $this->resetTokenExpiresAt = $resetTokenExpiresAt;
        return $this;
    }

    /**
     * @brief Efface les données sensibles de l'utilisateur apres authentification
     * Requis par l'interface UserInterface, on laisse vide car on utilise pas plainPassword
     */
    public function eraseCredentials(): void {}

    /** @return Collection Serveurs propriéte de cet utilisateur */
    public function getServers(): Collection { return $this->servers; }
    /** @return Collection Logs des actions de cet utilisateur */
    public function getActionLogs(): Collection { return $this->actionLogs; }
    /** @return Collection Accès aux serveurs assignés */
    public function getServerAccesses(): Collection { return $this->serverAccesses; }

    /**
     * @brief Vérifie si l'utilisateur a le role admin
     * @return bool true si ROLE_ADMIN est dans les roles
     */
    public function isAdmin(): bool { return in_array('ROLE_ADMIN', $this->getRoles()); }

    /**
     * @brief Vérifie si l'utilisateur est au moins opérateur
     * @return bool true si ROLE_OPERATOR ou ROLE_ADMIN
     */
    public function isOperator(): bool { return $this->isAdmin() || in_array('ROLE_OPERATOR', $this->getRoles()); }
}