"""
Point d'entrée unique pour héberger le serveur de signalisation depuis
l'interface, sans terminal — masque la différence entre Windows (Planificateur
de tâches + exécutable détaché) et Linux (`systemd --user`) derrière une API
commune :

    status() -> ServiceStatus
    start() / stop()
    set_autostart(enabled)
    recent_logs(lines) -> str

Le reste du projet n'a jamais besoin de savoir sur quel OS il tourne.

Pourquoi ça compte : le seul avantage architectural réel de Meshamoto face aux
outils gratuits concurrents est qu'on peut héberger sa propre signalisation
plutôt que dépendre de l'infrastructure d'un éditeur. Tant que ça exige un
terminal, cet avantage n'existe que sur le papier.

**Aucune de ces opérations ne demande de privilège élevé sur Linux** : le port
de signalisation est supérieur à 1024, donc une unité `systemd --user` suffit —
ni polkit, ni composant privilégié, ni invite (voir CLAUDE.md point 1ter-a).
"""

from __future__ import annotations

import logging
import sys

from server_service_common import ServiceStatus

logger = logging.getLogger("meshamoto-client.server_service")

# Sélection du backend au chargement du module, une seule fois.
if sys.platform == "win32":
    import server_service_backend_windows as _backend
elif sys.platform.startswith("linux"):
    import server_service_backend_linux as _backend
else:
    raise RuntimeError(
        f"Plateforme non supportée : {sys.platform}. "
        "Seuls Windows et Linux sont pris en charge par ce client."
    )

__all__ = [
    "ServiceStatus", "status", "start", "stop", "set_autostart", "recent_logs",
]


def status() -> ServiceStatus:
    """État courant de l'hébergement. Lecture seule, sans privilège, sûre à
    appeler périodiquement pour rafraîchir l'affichage."""
    return _backend.status()


def start() -> None:
    """Démarre le serveur maintenant. Sans effet s'il tourne déjà : deux
    instances se disputeraient le même port, et la seconde mourrait avec un
    message trompeur (la première continuant de répondre)."""
    _backend.start()


def stop() -> None:
    """Arrête le serveur. Sans effet s'il ne tourne pas."""
    _backend.stop()


def set_autostart(enabled: bool) -> None:
    """
    Active ou coupe le redémarrage automatique après un redémarrage de la
    machine.

    C'est délibérément séparé de `start()` : héberger le temps d'une soirée de
    jeu et faire de sa machine un point d'accès permanent sont deux intentions
    différentes, et la seconde a des conséquences (la machine reste joignable
    depuis Internet) qu'on ne doit pas activer par surprise.
    """
    _backend.set_autostart(enabled)


def recent_logs(lines: int = 40) -> str:
    """Dernières lignes du journal du serveur, pour affichage direct. Renvoie un
    message explicatif plutôt qu'une exception si le journal est indisponible :
    c'est un confort de diagnostic, jamais une raison de faire échouer l'écran."""
    return _backend.recent_logs(lines)
