# 📖 Guide d'Installation - FireWatch AI

**Créé par Marino ATOHOUN**

Ce guide vous accompagne pas à pas dans l'installation et la configuration de FireWatch AI.

## 🎯 Prérequis Système

### Minimum requis
- **OS** : Ubuntu 20.04+, Windows 10+, macOS 10.15+
- **Python** : 3.11 ou supérieur
- **RAM** : 8 GB minimum (16 GB recommandé)
- **Stockage** : 10 GB d'espace libre
- **GPU** : Optionnel mais recommandé (NVIDIA avec CUDA)

### Logiciels requis
- Git
- Python 3.11+
- pip (gestionnaire de packages Python)
- Node.js 16+ (pour les outils de développement frontend)

## 🔧 Installation Étape par Étape

### Étape 1 : Préparation de l'environnement

#### Sur Ubuntu/Debian
```bash
# Mise à jour du système
sudo apt update && sudo apt upgrade -y

# Installation des dépendances système
sudo apt install -y python3.11 python3.11-venv python3-pip git curl
sudo apt install -y libgl1-mesa-glx libglib2.0-0 libsm6 libxext6 libxrender-dev
sudo apt install -y libgomp1 libgthread-2.0-0 libgtk-3-0 python3-opencv ffmpeg

# Installation de PostgreSQL (optionnel, pour la production)
sudo apt install -y postgresql postgresql-contrib

# Installation de Redis (optionnel, pour le cache)
sudo apt install -y redis-server
```

#### Sur Windows
```powershell
# Installer Python depuis python.org ou via Microsoft Store
# Installer Git depuis git-scm.com
# Installer Visual Studio Build Tools pour les packages natifs

# Via Chocolatey (optionnel)
choco install python git nodejs postgresql redis-64
```

#### Sur macOS
```bash
# Via Homebrew
brew install python@3.11 git node postgresql redis opencv ffmpeg

# Ou via MacPorts
sudo port install python311 git nodejs postgresql redis opencv4
```

### Étape 2 : Clonage et Configuration du Projet

```bash
# Cloner le projet
git clone https://github.com/votre-username/firewatch-ai.git
cd firewatch-ai

# Créer un environnement virtuel
python3.11 -m venv venv

# Activer l'environnement virtuel
# Sur Linux/macOS :
source venv/bin/activate
# Sur Windows :
venv\Scripts\activate

# Vérifier la version de Python
python --version  # Doit afficher Python 3.11.x
```

### Étape 3 : Installation des Dépendances Python

```bash
# Mettre à jour pip
pip install --upgrade pip

# Installer les dépendances de base
pip install -r requirements.txt

# Pour le développement (optionnel)
pip install -r requirements-dev.txt
```

**Note** : L'installation peut prendre 10-15 minutes selon votre connexion internet.

### Étape 4 : Configuration des Variables d'Environnement

```bash
# Copier le fichier d'exemple
cp .env.example .env

# Éditer le fichier .env
nano .env  # ou votre éditeur préféré
```

**Configuration minimale pour commencer :**
```bash
DEBUG=True
SECRET_KEY=votre-cle-secrete-django-changez-moi
ALLOWED_HOSTS=localhost,127.0.0.1,0.0.0.0
DATABASE_URL=sqlite:///db.sqlite3
```

### Étape 5 : Préparation des Modèles YOLOv8

```bash
# Créer le répertoire des modèles
mkdir -p models

# Copier vos modèles YOLOv8 (vous devez les avoir entraînés)
cp /chemin/vers/vos/modeles/incendies.pt models/
cp /chemin/vers/vos/modeles/intrusion.pt models/

# Vérifier que les modèles sont présents
ls -la models/
# Doit afficher : incendies.pt et intrusion.pt
```

**Si vous n'avez pas encore de modèles :**
```bash
# L'application fonctionnera en mode simulation
# Vous pourrez tester l'interface et intégrer vos modèles plus tard
echo "Les modèles seront chargés quand vous les placerez dans models/"
```

### Étape 6 : Configuration de la Base de Données

#### Option A : SQLite (Développement)
```bash
# Créer et appliquer les migrations
python manage.py makemigrations
python manage.py migrate

# Créer un superutilisateur
python manage.py createsuperuser
# Suivre les instructions à l'écran
```

#### Option B : PostgreSQL (Production)
```bash
# Se connecter à PostgreSQL
sudo -u postgres psql

# Créer la base de données et l'utilisateur
CREATE DATABASE firewatch_db;
CREATE USER firewatch WITH PASSWORD 'votre_mot_de_passe';
GRANT ALL PRIVILEGES ON DATABASE firewatch_db TO firewatch;
\q

# Modifier .env
DATABASE_URL=postgresql://firewatch:votre_mot_de_passe@localhost:5432/firewatch_db

# Appliquer les migrations
python manage.py migrate
python manage.py createsuperuser
```

### Étape 7 : Collecte des Fichiers Statiques

```bash
# Collecter les fichiers statiques
python manage.py collectstatic --noinput

# Créer les répertoires media
mkdir -p media/uploads/images media/uploads/videos media/results
```

### Étape 8 : Test de l'Installation

```bash
# Lancer le serveur de développement
python manage.py runserver 0.0.0.0:8000

# Dans un autre terminal, tester l'API
curl http://localhost:8000/
```

**Ouvrir votre navigateur** : http://localhost:8000

Vous devriez voir la page d'accueil de FireWatch AI.

## 🐳 Installation avec Docker (Recommandée)

### Prérequis Docker
```bash
# Installer Docker
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

# Installer Docker Compose
sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

# Ajouter votre utilisateur au groupe docker
sudo usermod -aG docker $USER
# Redémarrer votre session
```

### Installation Docker
```bash
# Cloner le projet
git clone https://github.com/votre-username/firewatch-ai.git
cd firewatch-ai

# Placer vos modèles
mkdir models
cp /chemin/vers/incendies.pt models/
cp /chemin/vers/intrusion.pt models/

# Lancer avec Docker Compose
docker-compose up -d

# Vérifier que tout fonctionne
docker-compose ps
docker-compose logs web
```

**Accéder à l'application** : http://localhost:8000

## ⚙️ Configuration Avancée

### Configuration GPU (NVIDIA)

```bash
# Installer NVIDIA Docker
distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list

sudo apt-get update && sudo apt-get install -y nvidia-docker2
sudo systemctl restart docker

# Modifier docker-compose.yml pour utiliser le GPU
# Ajouter sous le service web :
#   deploy:
#     resources:
#       reservations:
#         devices:
#           - driver: nvidia
#             count: 1
#             capabilities: [gpu]
```

### Configuration Redis (Cache)

```bash
# Installer Redis
sudo apt install redis-server

# Configurer Redis
sudo nano /etc/redis/redis.conf
# Modifier : bind 127.0.0.1
# Modifier : maxmemory 256mb
# Modifier : maxmemory-policy allkeys-lru

# Redémarrer Redis
sudo systemctl restart redis-server

# Tester Redis
redis-cli ping  # Doit retourner PONG
```

### Configuration Nginx (Production)

```bash
# Installer Nginx
sudo apt install nginx

# Créer la configuration
sudo nano /etc/nginx/sites-available/firewatch

# Contenu de la configuration :
server {
    listen 80;
    server_name votre-domaine.com;
    
    client_max_body_size 50M;
    
    location /static/ {
        alias /path/to/firewatch/staticfiles/;
    }
    
    location /media/ {
        alias /path/to/firewatch/media/;
    }
    
    location / {
        proxy_pass http://127.0.0.1:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

# Activer le site
sudo ln -s /etc/nginx/sites-available/firewatch /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl restart nginx
```

## 🔍 Vérification de l'Installation

### Tests de Base
```bash
# Activer l'environnement virtuel
source venv/bin/activate

# Lancer les tests
python manage.py test

# Vérifier les modèles
python manage.py shell
>>> from detection.models import AIModelStatus
>>> AIModelStatus.objects.all()
```

### Tests Fonctionnels
1. **Interface Web** : http://localhost:8000
2. **Administration** : http://localhost:8000/admin/
3. **API Status** : http://localhost:8000/api/models/status/
4. **Upload d'image** : Tester via l'interface web

### Logs et Débogage
```bash
# Voir les logs Django
tail -f logs/firewatch.log

# Logs Docker
docker-compose logs -f web

# Déboguer les erreurs
python manage.py check
python manage.py check --deploy
```

## 🚨 Résolution des Problèmes Courants

### Erreur : "No module named 'cv2'"
```bash
pip install opencv-python
# Ou sur Ubuntu :
sudo apt install python3-opencv
```

### Erreur : "CUDA out of memory"
```bash
# Réduire la taille des batches dans settings.py
# Ou utiliser CPU uniquement :
export CUDA_VISIBLE_DEVICES=""
```

### Erreur : "Permission denied" sur media/
```bash
sudo chown -R $USER:$USER media/
chmod -R 755 media/
```

### Erreur de base de données
```bash
# Réinitialiser la base de données
rm db.sqlite3
python manage.py migrate
python manage.py createsuperuser
```

### Port 8000 déjà utilisé
```bash
# Utiliser un autre port
python manage.py runserver 0.0.0.0:8080

# Ou tuer le processus
sudo lsof -t -i tcp:8000 | xargs kill -9
```

## 📋 Checklist Post-Installation

- [ ] ✅ Python 3.11+ installé
- [ ] ✅ Environnement virtuel créé et activé
- [ ] ✅ Dépendances installées sans erreur
- [ ] ✅ Variables d'environnement configurées
- [ ] ✅ Base de données migrée
- [ ] ✅ Superutilisateur créé
- [ ] ✅ Modèles YOLOv8 placés (ou mode simulation)
- [ ] ✅ Serveur démarre sans erreur
- [ ] ✅ Interface web accessible
- [ ] ✅ Upload d'image fonctionne
- [ ] ✅ Administration accessible

## 🎉 Félicitations !

Votre installation de FireWatch AI est maintenant terminée !

### Prochaines étapes :
1. **Tester l'application** avec vos propres images/vidéos
2. **Intégrer vos modèles YOLOv8** personnalisés
3. **Configurer la production** si nécessaire
4. **Personnaliser l'interface** selon vos besoins

### Ressources utiles :
- 📖 [Documentation complète](README.md)
- 🐛 [Signaler un bug](lien-vers-issues)
- 💬 [Support communautaire](lien-vers-forum)

---

**Besoin d'aide ?** Contactez Marino ATOHOUN, créateur de FireWatch AI.