#!/usr/bin/env bash
# Wrapper pour le service ASR Skull Pi

set -euo pipefail

# Configuration
SKULL_ROOT="/opt/Skull"
VENV_PATH="${SKULL_ROOT}/venv"
APP_PATH="${SKULL_ROOT}/apps"
LOG_PATH="${SKULL_ROOT}/logs"

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

# Fonction de log
log() {
    local level="$1"
    shift
    local message="$*"
    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    
    case "$level" in
        "INFO")  echo -e "${GREEN}[INFO]${NC}  ${timestamp} - $message" ;;
        "WARN")  echo -e "${YELLOW}[WARN]${NC}  ${timestamp} - $message" ;;
        "ERROR") echo -e "${RED}[ERROR]${NC} ${timestamp} - $message" ;;
        "DEBUG") echo -e "${BLUE}[DEBUG]${NC} ${timestamp} - $message" ;;
        *)       echo -e "${NC}[$level]${NC} ${timestamp} - $message" ;;
    esac
}

# Vérifications préalables
check_dependencies() {
    log "INFO" "Vérification des dépendances..."
    
    # Vérifier l'environnement virtuel
    if [[ ! -d "$VENV_PATH" ]]; then
        log "ERROR" "Environnement virtuel non trouvé: $VENV_PATH"
        exit 1
    fi
    
    # Vérifier le dossier des applications
    if [[ ! -d "$APP_PATH/asr" ]]; then
        log "ERROR" "Module ASR non trouvé: $APP_PATH/asr"
        exit 1
    fi
    
    # Créer le dossier de logs si nécessaire
    mkdir -p "$LOG_PATH"
    
    # Vérifier MQTT
    if ! nc -z localhost 1883 2>/dev/null; then
        log "WARN" "MQTT broker non accessible sur localhost:1883"
    fi
    
    log "INFO" "Dépendances vérifiées"
}

# Nettoyage à l'arrêt
cleanup() {
    log "INFO" "Arrêt du service ASR..."
    
    # Tuer les processus enfants
    if [[ -n "${ASR_PID:-}" ]]; then
        kill -TERM "$ASR_PID" 2>/dev/null || true
        wait "$ASR_PID" 2>/dev/null || true
    fi
    
    log "INFO" "Service ASR arrêté"
    exit 0
}

# Gestionnaire de signaux
trap cleanup SIGTERM SIGINT

# Point d'entrée principal
main() {
    log "INFO" "Démarrage du service ASR Skull Pi"
    
    # Vérifications
    check_dependencies
    
    # Activer l'environnement virtuel
    # shellcheck source=/dev/null
    source "$VENV_PATH/bin/activate"
    
    # Configurer PYTHONPATH
    export PYTHONPATH="$APP_PATH:${PYTHONPATH:-}"
    
    # Variables d'environnement pour l'ASR
    export SKULL_LOG_LEVEL="${SKULL_LOG_LEVEL:-INFO}"
    export SKULL_MODEL_PATH="${SKULL_ROOT}/models"
    
    log "INFO" "Environment configuré:"
    log "INFO" "  - Python: $(python --version)"
    log "INFO" "  - PYTHONPATH: $PYTHONPATH"
    log "INFO" "  - Working dir: $(pwd)"
    
    # Démarrer le service ASR
    cd "$APP_PATH"
    
    log "INFO" "Lancement du module ASR..."
    python -m asr.main &
    ASR_PID=$!
    
    log "INFO" "Service ASR démarré (PID: $ASR_PID)"
    
    # Attendre la fin du processus
    wait "$ASR_PID"
    local exit_code=$?
    
    log "INFO" "Service ASR terminé (code: $exit_code)"
    exit $exit_code
}

# Gestion des arguments
case "${1:-run}" in
    "run")
        main
        ;;
    "check")
        check_dependencies
        log "INFO" "Vérification terminée avec succès"
        ;;
    "test")
        log "INFO" "Test du service ASR..."
        check_dependencies
        source "$VENV_PATH/bin/activate"
        export PYTHONPATH="$APP_PATH:${PYTHONPATH:-}"
        cd "$APP_PATH"
        python -c "
import asr
print('✓ Import ASR OK')
from asr.config import ASRConfig
config = ASRConfig()
print(f'✓ Configuration OK: {config.lang}')
try:
    from asr.vosk_engine import VoskEngine
    print('✓ Vosk engine OK')
except ImportError as e:
    print(f'⚠ Vosk non disponible: {e}')
"
        log "INFO" "Test terminé"
        ;;
    "--help"|"-h")
        echo "Usage: $0 [run|check|test]"
        echo "  run   : Démarre le service ASR (défaut)"
        echo "  check : Vérifie les dépendances"
        echo "  test  : Test rapide des modules"
        ;;
    *)
        log "ERROR" "Argument inconnu: $1"
        log "INFO" "Utilisez --help pour l'aide"
        exit 1
        ;;
esac