"""
Utilitaires pour le service Motion
"""

import json
import logging
import time
from pathlib import Path
from typing import Any, Dict
from logging.handlers import RotatingFileHandler


def setup_json_logger(log_file: Path, level: int = logging.INFO) -> logging.Logger:
    """Configure un logger JSON avec rotation"""
    logger = logging.getLogger("skull.motion")
    logger.setLevel(level)

    # Éviter les doublons de handlers
    if logger.handlers:
        return logger

    # Handler avec rotation (5MB max, 5 fichiers)
    handler = RotatingFileHandler(
        log_file, maxBytes=5 * 1024 * 1024, backupCount=5, encoding="utf-8"  # 5MB
    )

    # Formatter JSON
    class JsonFormatter(logging.Formatter):
        def format(self, record):
            log_entry = {
                "timestamp": time.time(),
                "level": record.levelname,
                "module": record.module,
                "message": record.getMessage(),
                "service": "motion",
            }
            if record.exc_info:
                log_entry["exception"] = self.formatException(record.exc_info)
            return json.dumps(log_entry)

    handler.setFormatter(JsonFormatter())
    logger.addHandler(handler)

    # Console handler pour debug
    console = logging.StreamHandler()
    console.setLevel(logging.WARNING)
    console.setFormatter(
        logging.Formatter("%(asctime)s [%(levelname)s] motion.%(module)s: %(message)s")
    )
    logger.addHandler(console)

    return logger


def clamp(value: float, min_val: float, max_val: float) -> float:
    """Clamp une valeur entre min et max"""
    return max(min_val, min(max_val, value))


def get_monotonic_ms() -> int:
    """Retourne le temps monotonique en millisecondes"""
    return int(time.monotonic() * 1000)