#!/usr/bin/env bash 
set -euo pipefail

# Script de lancement du service Vision Skull Pi
# Utilisation: /opt/Skull/bin/skull-vision.sh

# Variables d'environnement
export PYTHONPATH="/opt/Skull/apps:${PYTHONPATH:-}"
export PYTHONUNBUFFERED=1

# Répertoires
SKULL_ROOT="/opt/Skull"
VENV_PATH="${SKULL_ROOT}/venv"
APPS_PATH="${SKULL_ROOT}/apps"
LOGS_PATH="${SKULL_ROOT}/logs"

# Fichiers de log
LOG_FILE="${LOGS_PATH}/vision.log"
PID_FILE="${LOGS_PATH}/vision.pid"

# Couleurs pour output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color

# Fonction d'affichage avec couleur
log_info() {
    echo -e "${GREEN}[INFO]${NC} $1"
}

log_warn() {
    echo -e "${YELLOW}[WARN]${NC} $1"
}

log_error() {
    echo -e "${RED}[ERROR]${NC} $1"
}

# Vérifications préalables
check_prerequisites() {
    log_info "Vérification des prérequis..."
    
    # Vérifier utilisateur
    if [[ $EUID -eq 0 ]]; then
        log_error "Ne pas exécuter en tant que root"
        exit 1
    fi
    
    # Vérifier environnement virtuel
    if [[ ! -d "$VENV_PATH" ]]; then
        log_error "Environnement virtuel non trouvé: $VENV_PATH"
        exit 1
    fi
    
    # Vérifier module vision
    if [[ ! -d "$APPS_PATH/vision" ]]; then
        log_error "Module vision non trouvé: $APPS_PATH/vision"
        exit 1
    fi
    
    # Créer répertoire logs si nécessaire
    mkdir -p "$LOGS_PATH"
    
    # Vérifier permissions caméra (si Pi)
    if [[ -e "/dev/video0" ]] && [[ ! -r "/dev/video0" ]]; then
        log_warn "Permissions caméra limitées, mode mock possible"
    fi
    
    log_info "Prérequis OK"
}

# Activation environnement virtuel
activate_venv() {
    log_info "Activation environnement virtuel..."
    
    if [[ ! -f "$VENV_PATH/bin/activate" ]]; then
        log_error "Script d'activation non trouvé: $VENV_PATH/bin/activate"
        exit 1
    fi
    
    # shellcheck source=/dev/null
    source "$VENV_PATH/bin/activate"
    
    # Vérifier activation
    if [[ -z "${VIRTUAL_ENV:-}" ]]; then
        log_error "Échec activation environnement virtuel"
        exit 1
    fi
    
    log_info "Environnement virtuel activé: $VIRTUAL_ENV"
}

# Test connectivité MQTT
test_mqtt() {
    log_info "Test connectivité MQTT..."
    
    # Vérifier si mosquitto-clients est installé
    if ! command -v mosquitto_pub >/dev/null 2>&1; then
        log_warn "mosquitto-clients non installé, skip test MQTT"
        return 0
    fi
    
    # Test simple pub/sub local
    if mosquitto_pub -h 127.0.0.1 -p 1883 -t "skull/test" -m "vision-startup" -q 1 2>/dev/null; then
        log_info "MQTT broker accessible"
    else
        log_warn "MQTT broker inaccessible, service peut échouer"
    fi
}

# Détection mode d'exécution
detect_mode() {
    local mode_args=""
    
    # Détecter Pi Zero (ARM)
    if grep -q "Raspberry Pi" /proc/cpuinfo 2>/dev/null; then
        log_info "Raspberry Pi détecté"
        
        # Vérifier caméra
        if [[ ! -e "/dev/video0" ]] || [[ ! -r "/dev/video0" ]]; then
            log_warn "Caméra non accessible, passage en mode mock"
            mode_args="--mock"
        fi
    else
        log_info "Plateforme non-Pi, mode mock recommandé"
        # Ne pas forcer mock sur autres plateformes
    fi
    
    # Variables d'environnement pour mode mock
    if [[ "$mode_args" == "--mock" ]]; then
        export VISION_MOCK_MODE=1
    fi
    
    echo "$mode_args"
}

# Nettoyage à l'arrêt
cleanup() {
    local exit_code=$?
    
    log_info "Nettoyage en cours..."
    
    # Supprimer PID file si existant
    if [[ -f "$PID_FILE" ]]; then
        rm -f "$PID_FILE"
    fi
    
    log_info "Nettoyage terminé"
    exit $exit_code
}

# Configuration trap pour nettoyage
trap cleanup EXIT INT TERM

# Fonction principale
main() {
    log_info "Démarrage service Vision Skull Pi"
    log_info "Working directory: $(pwd)"
    log_info "Python path: $PYTHONPATH"
    
    # Vérifications
    check_prerequisites
    activate_venv
    test_mqtt
    
    # Détecter mode
    local mode_args
    mode_args=$(detect_mode)
    
    # Changer vers répertoire de travail
    cd "$APPS_PATH/vision" || {
        log_error "Impossible de changer vers $APPS_PATH/vision"
        exit 1
    }
    
    # Sauvegarder PID
    echo $$ > "$PID_FILE"
    
    # Variables d'environnement par défaut
    export VISION_RES="${VISION_RES:-320x240}"
    export VISION_FPS="${VISION_FPS:-15}"
    export VISION_MIN_DET_CONF="${VISION_MIN_DET_CONF:-0.6}"
    export VISION_MIN_TRACK_CONF="${VISION_MIN_TRACK_CONF:-0.5}"
    
    log_info "Configuration:"
    log_info "  Résolution: $VISION_RES"
    log_info "  FPS: $VISION_FPS"
    log_info "  Confidence détection: $VISION_MIN_DET_CONF"
    log_info "  Confidence tracking: $VISION_MIN_TRACK_CONF"
    log_info "  Mode args: ${mode_args:-aucun}"
    
    # Lancement du service Python
    log_info "Lancement du service..."
    
    # shellcheck disable=SC2086
    exec python -m vision.main ${mode_args}
}

# Point d'entrée
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
    main "$@"
fi