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

# Installation script for Skull Pi project
# Author: DevOps Team
# Version: 2.1 - Détection automatique utilisateur + dépendances complètes

PROJECT_DIR="/opt/Skull"
VENV_DIR="${PROJECT_DIR}/venv"
SYSTEMD_DIR="/etc/systemd/system"
MOSQUITTO_CONF_DIR="/etc/mosquitto/conf.d"
SUDOERS_DIR="/etc/sudoers.d"

# Récupération de l'utilisateur réel (celui qui a lancé sudo)
REAL_USER="${SUDO_USER:-$(whoami)}"
REAL_USER_HOME=$(getent passwd "$REAL_USER" | cut -d: -f6)

# Détermination du répertoire source (là où se trouve le script)
SOURCE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

echo "🏴‍☠️ Installation du projet Skull Pi..."
echo "   Utilisateur cible: $REAL_USER"
echo "   Répertoire source: $SOURCE_DIR"
echo "   Répertoire cible: $PROJECT_DIR"
echo ""

# Vérification des privilèges
if [[ $EUID -ne 0 ]]; then
   echo "❌ Ce script doit être exécuté en tant que root (sudo)"
   echo "   Usage: sudo bash install.sh"
   exit 1
fi

# Vérification que l'utilisateur réel existe
if ! id "$REAL_USER" &>/dev/null; then
    echo "❌ Utilisateur '$REAL_USER' introuvable"
    echo "   Cela peut arriver si :"
    echo "   - Vous utilisez 'sudo su' au lieu de 'sudo bash install.sh'"
    echo "   - L'utilisateur a été supprimé depuis"
    echo ""
    echo "💡 Solutions :"
    echo "   1. Exécutez: sudo bash install.sh (directement)"
    echo "   2. Ou créez l'utilisateur: sudo useradd -m $REAL_USER"
    exit 1
fi

echo "✅ Utilisateur '$REAL_USER' valide (UID: $(id -u $REAL_USER))"

# Vérification des fichiers source requis
echo "🔍 Vérification des fichiers source..."
REQUIRED_DIRS=("bin" "systemd" "config" "mosquitto" "sudoers")
REQUIRED_FILES=("requirements.txt")

for dir in "${REQUIRED_DIRS[@]}"; do
    if [ ! -d "$SOURCE_DIR/$dir" ]; then
        echo "❌ Répertoire manquant: $SOURCE_DIR/$dir"
        exit 1
    fi
done

for file in "${REQUIRED_FILES[@]}"; do
    if [ ! -f "$SOURCE_DIR/$file" ]; then
        echo "❌ Fichier manquant: $SOURCE_DIR/$file"
        exit 1
    fi
done

echo "✅ Tous les fichiers source sont présents"

# Vérification de l'architecture (Raspberry Pi)
if ! grep -q "BCM" /proc/cpuinfo 2>/dev/null; then
    echo "⚠️  Attention: Ce système ne semble pas être un Raspberry Pi"
    read -p "Continuer quand même? (y/N) " -n 1 -r
    echo
    if [[ ! $REPLY =~ ^[Yy]$ ]]; then
        exit 1
    fi
fi

echo "📦 Mise à jour des paquets système..."
apt-get update -qq

echo "📥 Installation des dépendances système..."
apt-get install -y \
    python3-venv \
    python3-pip \
    python3-dev \
    python3-gpiozero \
    python3-opencv \
    python3-picamera2 \
    python3-pigpio \
    python-is-python3 \
    build-essential \
    mosquitto \
    mosquitto-clients \
    espeak-ng \
    espeak-ng-data \
    ffmpeg \
    alsa-utils \
    pulseaudio \
    pulseaudio-utils \
    portaudio19-dev \
    libopencv-dev \
    libcamera-apps \
    v4l-utils \
    pigpio \
    gpiod \
    i2c-tools \
    git \
    curl \
    wget \
    nano \
    htop \
    unzip \
    strace \
    pkg-config \
    libcap-dev \
    libcap2-bin

echo "📁 Création de l'arborescence du projet..."
# Suppression du répertoire existant s'il existe
if [ -d "$PROJECT_DIR" ]; then
    echo "⚠️  Répertoire $PROJECT_DIR existe déjà, sauvegarde..."
    mv "$PROJECT_DIR" "${PROJECT_DIR}_backup_$(date +%Y%m%d_%H%M%S)"
fi

# Création de l'arborescence
mkdir -p ${PROJECT_DIR}/{apps,bin,config,logs,assets/audio,systemd}
chown -R ${REAL_USER}:${REAL_USER} ${PROJECT_DIR}

echo "📋 Copie des fichiers source..."
# Copie de tous les fichiers nécessaires depuis le répertoire source
if [ -d "$SOURCE_DIR/apps" ]; then
    cp -r "$SOURCE_DIR/apps"/* "$PROJECT_DIR/apps/" 2>/dev/null || echo "Répertoire apps vide ou inexistant"
fi

# Copie des scripts bin
cp "$SOURCE_DIR/bin"/*.sh "$PROJECT_DIR/bin/"
chmod +x "$PROJECT_DIR/bin"/*.sh
chown ${REAL_USER}:${REAL_USER} "$PROJECT_DIR/bin"/*.sh

# Copie des fichiers de configuration
cp "$SOURCE_DIR/config"/* "$PROJECT_DIR/config/" 2>/dev/null || echo "Fichiers config copiés"
chown -R ${REAL_USER}:${REAL_USER} "$PROJECT_DIR/config/"

# Copie du requirements.txt
cp "$SOURCE_DIR/requirements.txt" "$PROJECT_DIR/"
chown ${REAL_USER}:${REAL_USER} "$PROJECT_DIR/requirements.txt"

echo "✅ Fichiers source copiés dans $PROJECT_DIR"

echo "🐍 Création de l'environnement virtuel Python..."
sudo -u ${REAL_USER} python3 -m venv ${VENV_DIR}

echo "📋 Installation des dépendances Python..."
sudo -u ${REAL_USER} ${VENV_DIR}/bin/pip install --upgrade pip

# Installation par groupes pour éviter les conflits
echo "   📦 Installation par groupes de compatibilité..."

# Groupe 1: Dépendances de base
echo "   ⚙️  Installation des dépendances de base..."
sudo -u ${REAL_USER} ${VENV_DIR}/bin/pip install \
    paho-mqtt==2.1.0 \
    python-dotenv==1.0.1 \
    requests>=2.28.0,\<3.0.0 \
    psutil>=5.9.0,\<6.0.0

# Groupe 2: GPIO et Hardware
echo "   🔌 Installation des dépendances GPIO..."
sudo -u ${REAL_USER} ${VENV_DIR}/bin/pip install \
    "RPi.GPIO==0.7.1; platform_machine=='armv7l' or platform_machine=='aarch64'" \
    gpiozero==2.0.1 \
    pigpio==1.78 \
    spidev>=3.5,\<4.0 || echo "   ⚠️ Certaines dépendances GPIO non installées"

# Groupe 3: Audio de base
echo "   🎵 Installation des dépendances audio..."
sudo -u ${REAL_USER} ${VENV_DIR}/bin/pip install \
    pyaudio==0.2.14 \
    pyttsx3==2.90 || echo "   ⚠️ Certaines dépendances audio non installées"

# Groupe 4: Vision (sans mediapipe d'abord)
echo "   👁️ Installation des dépendances vision..."
sudo -u ${REAL_USER} ${VENV_DIR}/bin/pip install \
    "numpy>=1.24.0,<2.0.0" \
    "Pillow>=10.0.0,<11.0.0"

# Essayer différentes versions d'OpenCV
echo "   📷 Installation OpenCV..."
sudo -u ${REAL_USER} ${VENV_DIR}/bin/pip install opencv-python-headless>=4.8.0,\<5.0.0 || \
sudo -u ${REAL_USER} ${VENV_DIR}/bin/pip install opencv-python>=4.8.0,\<5.0.0 || \
echo "   ⚠️ OpenCV non installé, utilisation des paquets système"

# Groupe 5: Web API (optionnel)
echo "   🌐 Installation des dépendances web..."
sudo -u ${REAL_USER} ${VENV_DIR}/bin/pip install \
    "fastapi>=0.100.0,<1.0.0" \
    "uvicorn>=0.23.0,<1.0.0" || echo "   ⚠️ API web non installée"

# Groupe 6: IA (versions compatibles)
echo "   🧠 Installation des dépendances IA..."
sudo -u ${REAL_USER} ${VENV_DIR}/bin/pip install \
    "openai>=1.30.0,<2.0.0" || echo "   ⚠️ OpenAI non installé"

# Groupe 7: Speech Recognition (optionnel)
echo "   🗣️ Installation reconnaissance vocale..."
sudo -u ${REAL_USER} ${VENV_DIR}/bin/pip install \
    "SpeechRecognition>=3.10.0,<4.0.0" \
    "vosk>=0.3.40,<1.0.0" || echo "   ⚠️ Reconnaissance vocale non installée"

# Si un requirements.txt spécifique existe, l'utiliser en complément
if [ -f "$PROJECT_DIR/requirements.txt" ]; then
    echo "   📄 Installation des dépendances restantes du requirements.txt..."
    sudo -u ${REAL_USER} ${VENV_DIR}/bin/pip install -r "$PROJECT_DIR/requirements.txt" --no-deps || \
    echo "   ⚠️ Certaines dépendances du requirements.txt non installées"
fi

echo "✅ Installation Python terminée"

echo "🔧 Configuration spécifique Raspberry Pi..."
# Activation des interfaces matérielles si raspi-config est disponible
if command -v raspi-config >/dev/null 2>&1; then
    echo "Activation I2C, SPI et Camera..."
    raspi-config nonint do_i2c 0    # Active I2C
    raspi-config nonint do_spi 0    # Active SPI
    raspi-config nonint do_camera 0 # Active Camera
    echo "Interfaces matérielles activées"
else
    echo "raspi-config non disponible, activation manuelle nécessaire"
fi

# Configuration des groupes utilisateur
echo "👥 Configuration des permissions utilisateur..."
usermod -a -G audio,video,gpio,i2c,spi,camera ${REAL_USER} || echo "Certains groupes peuvent ne pas exister"

echo "🔧 Copie des scripts wrapper..."
# Les scripts sont déjà copiés, on s'assure juste des permissions
chmod +x ${PROJECT_DIR}/bin/*.sh
chown ${REAL_USER}:${REAL_USER} ${PROJECT_DIR}/bin/*.sh

echo "📄 Finalisation de la configuration..."
# S'assurer que .env existe
if [ ! -f "${PROJECT_DIR}/config/.env" ] && [ -f "${PROJECT_DIR}/config/.env.template" ]; then
    cp "${PROJECT_DIR}/config/.env.template" "${PROJECT_DIR}/config/.env"
    chown ${REAL_USER}:${REAL_USER} "${PROJECT_DIR}/config/.env"
fi

chown -R ${REAL_USER}:${REAL_USER} ${PROJECT_DIR}/config/

# Configuration spécifique pour Raspberry Pi et audio
echo "🎵 Configuration audio..."
# S'assurer que pulseaudio est configuré pour l'utilisateur
sudo -u ${REAL_USER} pulseaudio --check -v || echo "PulseAudio sera configuré au premier démarrage"

# Démarrage du daemon pigpio si disponible
if command -v pigpiod >/dev/null 2>&1; then
    systemctl enable pigpiod || echo "Impossible d'activer pigpiod"
    systemctl start pigpiod || echo "pigpiod sera démarré au prochain boot"
fi

echo "🔧 Configuration de Mosquitto..."
# Créer la configuration simplifiée pour éviter les conflits
cat > "${MOSQUITTO_CONF_DIR}/skull.conf" << 'EOF'
# Configuration Mosquitto pour Skull Pi - Version minimale
listener 1883 127.0.0.1
allow_anonymous true
EOF

# Vérifier la configuration avant de démarrer
echo "   Vérification de la configuration Mosquitto..."
if sudo mosquitto -c /etc/mosquitto/mosquitto.conf -v &>/dev/null & then
    sleep 1
    sudo pkill mosquitto
    echo "   ✅ Configuration Mosquitto valide"
else
    echo "   ❌ Erreur dans la configuration Mosquitto"
fi

systemctl enable mosquitto
systemctl restart mosquitto

# Attendre que Mosquitto soit complètement démarré
sleep 3

# Vérifier que Mosquitto fonctionne
if systemctl is-active --quiet mosquitto; then
    echo "   ✅ Mosquitto démarré avec succès"
else
    echo "   ⚠️ Mosquitto pourrait avoir des problèmes, vérifiez avec: systemctl status mosquitto"
fi

echo "⚙️ Installation des unités systemd..."
# Créer un script temporaire pour installer les services avec le bon utilisateur
cat > /tmp/install_systemd_services.sh << 'EOF'
#!/bin/bash
set -euo pipefail
USER_NAME="$1"
SOURCE_DIR="$2"
SYSTEMD_DIR="/etc/systemd/system"

echo "📝 Installation des services systemd pour l'utilisateur: $USER_NAME"

# Obtenir l'UID de l'utilisateur pour PulseAudio
USER_UID=$(id -u "$USER_NAME")

# Services à traiter
SERVICES=("skull-orchestrator" "skull-motion" "skull-vision" "skull-voice" "skull-audioin" "skull-asr" "skull-ai")

for service in "${SERVICES[@]}"; do
    echo "   Traitement de $service.service..."
    
    # Remplacer %i par le nom d'utilisateur et ajuster le path PulseAudio
    sed -e "s/%i/$USER_NAME/g" \
        -e "s|PULSE_RUNTIME_PATH=/run/user/1000/pulse|PULSE_RUNTIME_PATH=/run/user/$USER_UID/pulse|g" \
        "$SOURCE_DIR/systemd/$service.service" > "$SYSTEMD_DIR/$service.service"
    
    if [ -f "$SYSTEMD_DIR/$service.service" ]; then
        echo "   ✅ $service.service installé pour $USER_NAME (UID: $USER_UID)"
    else
        echo "   ❌ Erreur lors de l'installation de $service.service"
        exit 1
    fi
done

# Copier skull.target
cp "$SOURCE_DIR/systemd/skull.target" "$SYSTEMD_DIR/"
echo "✅ Services systemd installés pour l'utilisateur: $USER_NAME"
EOF

chmod +x /tmp/install_systemd_services.sh
/tmp/install_systemd_services.sh "$REAL_USER" "$SOURCE_DIR"
rm /tmp/install_systemd_services.sh

systemctl daemon-reload

echo "🔐 Configuration des permissions sudoers..."
# Modification du fichier sudoers pour utiliser l'utilisateur courant
sed "s/pi/${REAL_USER}/g" "$SOURCE_DIR/sudoers/skull" > "${SUDOERS_DIR}/skull"
chmod 440 ${SUDOERS_DIR}/skull

echo "🚀 Activation des services..."
systemctl enable skull.target
systemctl enable mosquitto

# Création des logs initiaux
sudo -u ${REAL_USER} touch ${PROJECT_DIR}/logs/orchestrator.log
sudo -u ${REAL_USER} touch ${PROJECT_DIR}/logs/motion.log
sudo -u ${REAL_USER} touch ${PROJECT_DIR}/logs/vision.log
sudo -u ${REAL_USER} touch ${PROJECT_DIR}/logs/voice.log
sudo -u ${REAL_USER} touch ${PROJECT_DIR}/logs/audioin.log
sudo -u ${REAL_USER} touch ${PROJECT_DIR}/logs/asr.log
sudo -u ${REAL_USER} touch ${PROJECT_DIR}/logs/ai.log

echo "🎯 Démarrage des services..."
# Démarrage de pigpiod si disponible
if systemctl is-enabled pigpiod >/dev/null 2>&1; then
    systemctl start pigpiod || echo "Attention: pigpiod n'a pas pu démarrer"
fi

systemctl start mosquitto
sleep 2
systemctl start skull.target

echo ""
echo "✅ Installation terminée avec succès!"
echo ""
echo "📊 État des services:"
systemctl status skull.target --no-pager -l
echo ""
echo "🔍 Commandes utiles:"
echo "  - Statut global: systemctl status skull.target"
echo "  - Logs live: journalctl -f -u skull-orchestrator"
echo "  - MQTT debug: mosquitto_sub -h 127.0.0.1 -t '#' -v"
echo "  - Test caméra: libcamera-hello --list-cameras"
echo "  - Test GPIO: raspi-gpio get"
echo "  - Test audio: speaker-test -t sine -f 1000 -l 1"
echo "  - Redémarrer: sudo systemctl restart skull.target"
echo ""
echo "⚠️  IMPORTANT: Redémarrez le système pour finaliser la configuration:"
echo "   sudo reboot"
echo ""
echo "📁 Projet installé dans: ${PROJECT_DIR}"
echo "👤 Propriétaire configuré: ${REAL_USER}"
echo "🏴‍☠️ Skull Pi est prêt!"

# Affichage des informations pour l'utilisateur
echo ""
echo "📝 INFORMATIONS IMPORTANTES:"
echo "  - Répertoire source: $SOURCE_DIR"
echo "  - Répertoire installation: $PROJECT_DIR"
echo "  - Utilisateur configuré: $REAL_USER"
echo "  - Configuration: ${PROJECT_DIR}/config/.env"
echo ""
echo "🔐 L'utilisateur $REAL_USER peut maintenant:"
echo "  - Contrôler les services: sudo systemctl restart skull.target"
echo "  - Voir les logs: sudo journalctl -u skull-orchestrator"
echo "  - Modifier la config: nano ${PROJECT_DIR}/config/.env"