Merge branch 'feature/detection-cible-au-sol'

- Backend IA :
  - Intégration d'OpenCV (WebAssembly) pour la détection et certification des cibles (anneaux concentriques, confiance).
  - Ajout du système de journalisation complet des uploads (SQLite, IP, appareil, statut, métadonnées).
  - Implémentation du système de modération (bannissement/débannissement de wallets, rejet 403 avec motifs).
  - Harmonisation des codes d'erreur et messages JSON (UPLOAD_SUCCESS, WALLET_BANNED, etc.).
  - Dashboard Next.js : page dédiée aux logs avec filtres, export CSV et actions de modération en un clic.
- Application Mobile (Flutter) :
  - Encapsulation des réponses d'export dans AiExportResult avec gestion fine des erreurs et statuts.
  - Mise à jour du disclaimer de participation à l'entraînement IA avec avertissements stricts de bannissement.
  - Révocation de l'envoi de photos et affichage d'un bandeau explicatif en cas de suspension.
  - Ajout d'un bouton manuel « Actualiser mon statut » dans les paramètres pour synchroniser l'état du compte.
  - Possibilité de configurer l'URL/IP du serveur IA directement depuis les paramètres.

.gitea/workflows/build-apk.yaml

@@ -0,0 +1,81 @@
+name: Build & Release Android APK
+
+on:
+  push:
+    tags:
+      - 'v*'
+      - 'V*' # Se déclenche quand vous poussez un tag comme v1.0.0, v1.0.1...
+  workflow_dispatch: # Permet aussi de lancer la compilation manuellement depuis l'interface Gitea
+
+jobs:
+  build-apk:
+    # Utilise votre runner hôte avec Docker
+    runs-on: docker
+    steps:
+      - name: 📥 Récupération du code
+        run: |
+          echo "📥 Clonage du code source dans /data/build..."
+          rm -rf /data/build
+          git config --global --add safe.directory "*"
+          git clone --depth 1 "https://${{ github.actor }}:${{ secrets.GITHUB_TOKEN }}@git.kevlar.cloud/${{ github.repository }}.git" /data/build
+
+      - name: 🔨 Compilation de l'APK (Conteneur Flutter / Android SDK avec Caches)
+        run: |
+          echo "🚀 Démarrage de la compilation Flutter avec Caches persistants..."
+          mkdir -p /data/caches/gradle /data/caches/pub /data/caches/android-ndk /data/caches/android-cmake /data/caches/android-platforms
+          
+          # Montage des caches persistants : Gradle, Pub, NDK, CMake et Plateformes Android
+          docker run --rm \
+            --volumes-from gitea-act-runner \
+            -v /data/caches/gradle:/root/.gradle \
+            -v /data/caches/pub:/root/.pub-cache \
+            -v /data/caches/android-ndk:/opt/android-sdk-linux/ndk \
+            -v /data/caches/android-cmake:/opt/android-sdk-linux/cmake \
+            -v /data/caches/android-platforms:/opt/android-sdk-linux/platforms \
+            -w /data/build \
+            ghcr.io/cirruslabs/flutter:stable \
+            sh -c "git config --global --add safe.directory '*' && flutter pub get && flutter build apk --release"
+          
+          echo "✅ APK généré avec succès dans /data/build/build/app/outputs/flutter-apk/app-release.apk"
+
+      - name: 📦 Publication de la Release sur Gitea & Upload de l'APK
+        run: |
+          which curl >/dev/null 2>&1 || apk add --no-cache curl
+          TAG_NAME="${{ github.ref_name }}"
+          if [ -z "$TAG_NAME" ] || [ "$TAG_NAME" = "main" ]; then
+            TAG_NAME="build-$(date +'%Y%m%d-%H%M%S')"
+          fi
+          
+          APK_PATH="/data/build/build/app/outputs/flutter-apk/app-release.apk"
+          APK_NAME="bully-impact-${TAG_NAME}.apk"
+
+          echo "🚀 Création de la release $TAG_NAME sur Gitea..."
+          
+          # 1. Création de la Release via l'API REST de Gitea
+          RELEASE_RESPONSE=$(curl -s -X POST "https://git.kevlar.cloud/api/v1/repos/${{ github.repository }}/releases" \
+            -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}" \
+            -H "Content-Type: application/json" \
+            -d "{
+              \"tag_name\": \"${TAG_NAME}\",
+              \"name\": \"Version ${TAG_NAME}\",
+              \"body\": \"Nouvelle version de l'application Bully Impact générée automatiquement par CI/CD.\",
+              \"draft\": false,
+              \"prerelease\": false
+            }")
+
+          RELEASE_ID=$(echo "$RELEASE_RESPONSE" | grep -o '"id":[0-9]*' | head -1 | cut -d: -f2)
+
+          if [ -z "$RELEASE_ID" ]; then
+            echo "❌ Erreur lors de la création de la release: $RELEASE_RESPONSE"
+            exit 1
+          fi
+
+          echo "📦 Upload du fichier APK (Release ID: $RELEASE_ID)..."
+
+          # 2. Upload de l'APK en tant qu'asset téléchargeable
+          curl -s -X POST "https://git.kevlar.cloud/api/v1/repos/${{ github.repository }}/releases/${RELEASE_ID}/assets?name=${APK_NAME}" \
+            -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}" \
+            -H "Content-Type: application/vnd.android.package-archive" \
+            --data-binary @"$APK_PATH"
+
+          echo "🎉 Release terminée avec succès ! APK téléchargeable sur Gitea."

.gitea/workflows/deploy.yaml

@@ -0,0 +1,30 @@
+name: Deploy Backendia
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - 'backendia/**'
+      - 'docker-compose.prod.yml'
+      - '.gitea/workflows/deploy.yaml'
+  workflow_dispatch:
+
+jobs:
+  deploy:
+    # Correspond au label 'docker:host' de votre runner
+    runs-on: docker
+    steps:
+      - name: 📥 Récupération du code
+        run: |
+          echo "📥 Récupération du code..."
+          git clone --depth 1 --branch ${{ github.ref_name }} "https://${{ github.actor }}:${{ secrets.GITHUB_TOKEN }}@git.kevlar.cloud/${{ github.repository }}.git" .
+
+      - name: 🚀 Build et Déploiement Docker
+        run: |
+          echo "🚀 Démarrage du déploiement..."
+          docker rm -f backendia-prod 2>/dev/null || true
+          docker compose -f docker-compose.prod.yml up -d --build --remove-orphans --force-recreate
+          echo "🧹 Nettoyage des anciennes images inutilisées..."
+          docker image prune -f
+          echo "✅ Déploiement terminé avec succès !"

CHANGELOG.md

@@ -1,5 +1,40 @@
 # Changelog
 
+## [v1.0.3] - 2026-08-27 (Branche `design/newdefault`)
+
+### 🎨 Refonte UI/UX "Tactical & Precision"
+- **Système de Thèmes & Couleurs d'Accentuation Personnalisables** : Choix dynamique de la couleur d'accent dans les Paramètres parmi 7 déclinaisons tactiques (Bleu Cobalt, Rouge Cible, Vert Viseur, Orange Ambre, Violet Cyber, Cyan Néon, Or Compétition) avec persistance SharedPreferences.
+- **Nouvelle Direction Artistique & Thèmes** : Thème sombre Gunmetal/Slate contrasté pour stand de tir et thème clair technique épuré avec effets Glassmorphism et flous d'arrière-plan.
+- **Barre de Navigation Principale** : Intégration de la `NavigationBar` Material 3 avec indicateur pill moderne et icônes thématiques.
+- **Dashboard d'Accueil** : En-tête dynamique "BULLY • PRÉCISION", carte interactive de session en cours (badge lumineux, reprise rapide / fin sécurisée), tuiles télémétriques de KPIs avec graphique d'évolution et accès direct aux dernières séances.
+- **Armurerie (Arsenal)** : Fiches d'armes techniques avec mise en valeur du calibre, compteurs de chargeurs/coups, puces d'accessoires et **icônes vectorielles dédiées pour chaque type d'arme** (Arme de Poing, Arme d'Épaule, Fusil à Pompe, Airsoft/Airgun).
+- **Carnet de Tir (Historique)** : Filtres par puces de type de cible et de date, cartes de séances avec pastilles de score colorées selon la précision.
+- **Setup de Session** : Sélecteurs rapides de distance (10m à 200m) et de coups par cible (3 à 30).
+- **Réseau & Export Serveur IA (Fix APK Mobile)** : Ajout des permissions `INTERNET` et `ACCESS_NETWORK_STATE` ainsi que `usesCleartextTraffic` dans le manifeste Android principal (`AndroidManifest.xml`) pour débloquer l'envoi vers le serveur IA et les IP locales depuis l'APK installée.
+
+## [v0.0.7] - 2026-08-26
+
+### 🚀 CI/CD & Déploiement Automatique (Gitea Actions)
+- **Pipeline de Release Android APK** : Compilation automatique de l'APK de production (`flutter build apk --release`) lors du push d'un tag (`v*`) et publication directe dans les Releases Gitea.
+- **Mise en cache persistante** : Sauvegarde des caches Gradle, Pub, Android NDK 28, CMake et SDK Platform pour des temps de build réduits à 1-2 minutes.
+- **Pipeline Backendia** : Déploiement continu automatisé du serveur backend et du dashboard lors des modifications sur `main`.
+
+### 🧠 Backend IA & Dashboard Web (Backendia)
+- **Architecture Tout-en-un** : API Express et Dashboard Next.js co-hébergés sur le même port sous `https://backendia.kevlar.cloud`.
+- **Validation OpenCV** : Certification et détection des anneaux de cibles concentriques.
+- **Journalisation & Modération** : Base SQLite avec historique complet des uploads, détection d'appareils, métadonnées et système de bannissement/débannissement de wallets.
+- **Dashboard Web** : Galerie de visualisation des photos de tir, éditeur de points/impacts et export global des datasets (ZIP / CSV).
+
+### 🔒 Sécurité & Reverse Proxy (YunoHost)
+- **Dashboard Privé** : Accès à l'interface d'administration protégé par le portail SSO YunoHost.
+- **API d'Upload Sécurisée** : Filtrage Nginx par en-tête secret `X-API-KEY` autorisant uniquement l'application Android.
+
+### 📱 Application Mobile Flutter
+- **Connexion Serveur Officiel** : Configuration par défaut sur `https://backendia.kevlar.cloud` avec transmission automatique de la clé d'API.
+- **Identité Anonyme & Stats** : Phrase de récupération de 15 mots, hachage SHA-256 du wallet et synchronisation du statut de modération.
+- **Expérience de Tir** : Nouveau flux de calibration, boutons de rotation fine, guidage au premier impact et popup de fin de session avec export IA intégré.
+- **Sauvegarde & Partage** : Export/Import JSON complet des sessions, statistiques et armurerie.
+
 ## [v0.0.1] - 2026-01-29
 
 ### Ajouté

CLAUDE.md

@@ -55,9 +55,11 @@ flutter test --coverage
 - Visualisation en temps réel des zones de score
 
 ### Placement des impacts
-- **Éditeur d'impacts plein écran** : tap pour ajouter, tap sur un impact pour
+- **Éditeur d'impacts plein écran** : tap pour ajouter (y compris juste à côté
-  l'éditer (score/suppression), appui long pour déplacer, pincer pour zoomer
+  ou par-dessus un impact existant), appui long pour déplacer, pincer pour zoomer
-- Le placement est entièrement manuel ; le bouton ↻ de l'écran de plotting
+- Un tap n'ouvre jamais d'édition de score : le score reste calculé
+  automatiquement d'après la position de l'impact
+- Le placement est entièrement manuel ; le bouton ↻ de l'écran de synthèse
   efface tous les impacts sans toucher à la calibration
 
 ### Calcul des scores
@@ -78,6 +80,19 @@ flutter test --coverage
 - **Distribution régionale** : répartition des tirs par quadrant
 - Filtrage par période : session, semaine, mois, toutes les sessions
 
+### Sauvegarde (export / import JSON)
+- Bouton **Exporter** en bas de l'écran Statistiques : génère un fichier JSON
+  (sessions + cibles + impacts + calibration, armurerie + entretien, et un
+  instantané des statistiques calculées) puis ouvre la feuille de partage du
+  système (`share_plus`) pour l'envoyer où l'on veut
+- Option « Inclure les photos des cibles » : photos encodées en base64 dans le
+  JSON (sauvegarde complète mais fichier lourd) ; sans elles le fichier reste léger
+- Bouton **Importer** (`file_selector`) : aperçu du contenu avant confirmation,
+  puis fusion avec les données existantes — même identifiant = mise à jour,
+  donc réimporter deux fois ne crée pas de doublon et rien n'est effacé
+- Les statistiques ne sont pas réimportées : elles sont recalculées à partir des
+  sessions. Elles figurent dans le fichier pour être exploitables telles quelles
+
 ### Historique des sessions
 - Sauvegarde des sessions avec date, score, notes
 - Visualisation des sessions passées
@@ -119,3 +134,4 @@ session_list_item.dart	  Item de liste représentant une session
 history_chart.dart	      Graphique d'évolution des 10 dernières sessions
 statistics_screen.dart	  Écran statistiques avec filtrage par période
 heat_map_widget.dart	    Heat map avec gradient bleu→rouge
+backup_service.dart	      Export/import JSON des sessions, stats et armurerie

analysis_options.yaml

@@ -7,6 +7,15 @@
 
 # The following line activates a set of recommended lints for Flutter apps,
 # packages, and plugins designed to encourage good coding practices.
+analyzer:
+  exclude:
+    - build/**
+    - android/**
+    - ios/**
+    - web/**
+    - windows/**
+    - macos/**
+    - linux/**
 include: package:flutter_lints/flutter.yaml
 
 linter:

android/app/src/main/AndroidManifest.xml

@@ -1,4 +1,6 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
     <uses-permission android:name="android.permission.CAMERA" />
     
     <!-- Pour Android 12 et inférieur -->
@@ -9,7 +11,8 @@
     <application
         android:label="bully"
         android:name="${applicationName}"
-        android:icon="@mipmap/ic_launcher">
+        android:icon="@mipmap/ic_launcher"
+        android:usesCleartextTraffic="true">
         <activity
             android:name=".MainActivity"
             android:exported="true"

android/gradle.properties

@@ -1,2 +1,6 @@
 org.gradle.jvmargs=-Xmx8G -XX:MaxMetaspaceSize=4G -XX:ReservedCodeCacheSize=512m -XX:+HeapDumpOnOutOfMemoryError
 android.useAndroidX=true
+# This builtInKotlin flag was added automatically by Flutter migrator
+android.builtInKotlin=false
+# This newDsl flag was added automatically by Flutter migrator
+android.newDsl=false

backendia/.dockerignore

@@ -0,0 +1,8 @@
+node_modules
+npm-debug.log*
+dashboard/node_modules
+dashboard/.next
+uploads
+exports
+.git
+.env*

backendia/Dockerfile

@@ -0,0 +1,31 @@
+FROM node:20-bookworm-slim
+
+WORKDIR /app
+
+# Dépendances système pour les modules natifs (sharp, sqlite3, opencv)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    python3 \
+    make \
+    g++ \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY package*.json ./
+COPY dashboard/package*.json ./dashboard/
+
+RUN npm install && npm rebuild sqlite3 --build-from-source
+RUN cd dashboard && npm install
+
+COPY . .
+
+# Build du Dashboard Next.js
+RUN cd dashboard && npm run build
+
+# Dossiers nécessaires
+RUN mkdir -p uploads/images uploads/data exports
+
+EXPOSE 3000
+
+ENV NODE_ENV=production
+ENV PORT=3000
+
+CMD ["node", "server.js"]

backendia/dashboard/src/app/layout.tsx

@@ -2,7 +2,7 @@ import type { Metadata } from "next";
 import { Inter } from "next/font/google";
 import "./globals.css";
 import Link from "next/link";
-import { LayoutDashboard, Users, Image as ImageIcon } from "lucide-react";
+import { LayoutDashboard, Users, ScrollText, Image as ImageIcon } from "lucide-react";
 
 const inter = Inter({ subsets: ["latin"] });
 
@@ -41,6 +41,13 @@ export default function RootLayout({
               <Users size={20} />
               Contributeurs
             </Link>
+            <Link 
+              href="/logs" 
+              className="flex items-center gap-3 px-3 py-2 rounded-lg hover:bg-slate-800 transition-colors text-slate-300 hover:text-white"
+            >
+              <ScrollText size={20} />
+              Logs d'Uploads
+            </Link>
           </nav>
 
           <div className="mt-auto pt-6 border-t border-slate-800">

backendia/dashboard/src/app/logs/LogsManager.tsx

@@ -0,0 +1,900 @@
+"use client";
+
+import { useState, useMemo, useEffect } from "react";
+import { 
+  ScrollText, 
+  Search, 
+  Download, 
+  RefreshCw, 
+  CheckCircle2, 
+  XCircle, 
+  Copy, 
+  Check, 
+  Trash2, 
+  Smartphone, 
+  Crosshair, 
+  Calendar, 
+  HardDrive, 
+  Users, 
+  ExternalLink, 
+  Info, 
+  Filter, 
+  Eye,
+  ShieldAlert,
+  ShieldCheck,
+  Ban,
+  AlertTriangle
+} from "lucide-react";
+import { API_BASE_URL } from "@/lib/api";
+import Link from "next/link";
+
+interface UploadLog {
+  id: number;
+  timestamp: string;
+  session_id: string | null;
+  wallet_hash: string | null;
+  image_filename: string | null;
+  json_filename: string | null;
+  file_size: number | null;
+  ip_address: string | null;
+  user_agent: string | null;
+  device_model: string | null;
+  device_os: string | null;
+  target_type: string | null;
+  weapon: string | null;
+  distance_meters: number | null;
+  impacts_count: number;
+  status: string;
+  target_valid?: number;
+  target_status?: string;
+  target_confidence?: number;
+  target_rings_count?: number;
+  target_details?: string | null;
+  error_message: string | null;
+  raw_metadata: string | null;
+}
+
+interface BannedWallet {
+  wallet_hash: string;
+  reason: string;
+  banned_at: string;
+  banned_by: string;
+}
+
+interface LogStats {
+  total_uploads: number;
+  success_count: number;
+  failed_count: number;
+  today_uploads: number;
+  unique_wallets: number;
+  total_bytes: number;
+  latest_upload: string | null;
+}
+
+export default function LogsManager({ 
+  initialLogs, 
+  initialStats 
+}: { 
+  initialLogs: UploadLog[]; 
+  initialStats: LogStats | null; 
+}) {
+  const [logs, setLogs] = useState<UploadLog[]>(initialLogs);
+  const [stats, setStats] = useState<LogStats | null>(initialStats);
+  const [bannedWallets, setBannedWallets] = useState<BannedWallet[]>([]);
+  const [searchTerm, setSearchTerm] = useState("");
+  const [statusFilter, setStatusFilter] = useState<"ALL" | "SUCCESS" | "FAILED" | "INVALID_TARGET" | "BANNED">("ALL");
+  const [copiedWallet, setCopiedWallet] = useState<string | null>(null);
+  const [selectedLog, setSelectedLog] = useState<UploadLog | null>(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [showClearConfirm, setShowClearConfirm] = useState(false);
+
+  // Moderation state
+  const [banModalWallet, setBanModalWallet] = useState<string | null>(null);
+  const [banReason, setBanReason] = useState("Images non conformes / Fausse cible");
+  const [isSubmittingBan, setIsSubmittingBan] = useState(false);
+
+  const fetchBannedWallets = async () => {
+    try {
+      const res = await fetch(`${API_BASE_URL}/api/moderation/banned`, { cache: 'no-store' });
+      if (res.ok) {
+        const data = await res.json();
+        setBannedWallets(data.banned || []);
+      }
+    } catch (e) {
+      console.error("Erreur récupération wallets bannis:", e);
+    }
+  };
+
+  useEffect(() => {
+    fetchBannedWallets();
+  }, []);
+
+  const fetchLogs = async () => {
+    setIsLoading(true);
+    try {
+      const [logsRes, statsRes] = await Promise.all([
+        fetch(`${API_BASE_URL}/api/logs?limit=200`, { cache: 'no-store' }),
+        fetch(`${API_BASE_URL}/api/logs/stats`, { cache: 'no-store' }),
+        fetchBannedWallets()
+      ]);
+      
+      if (logsRes.ok) {
+        const logsData = await logsRes.json();
+        setLogs(logsData.logs || []);
+      }
+      if (statsRes.ok) {
+        const statsData = await statsRes.json();
+        setStats(statsData.stats || null);
+      }
+    } catch (e) {
+      console.error("Erreur lors de la récupération des logs:", e);
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  const copyToClipboard = (text: string) => {
+    navigator.clipboard.writeText(text);
+    setCopiedWallet(text);
+    setTimeout(() => setCopiedWallet(null), 2000);
+  };
+
+  const isWalletBanned = (walletHash: string | null) => {
+    if (!walletHash) return false;
+    return bannedWallets.some(b => b.wallet_hash === walletHash);
+  };
+
+  const getBannedInfo = (walletHash: string | null) => {
+    if (!walletHash) return null;
+    return bannedWallets.find(b => b.wallet_hash === walletHash) || null;
+  };
+
+  const handleBanWallet = async () => {
+    if (!banModalWallet) return;
+    setIsSubmittingBan(true);
+    try {
+      const res = await fetch(`${API_BASE_URL}/api/moderation/ban`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          wallet_hash: banModalWallet,
+          reason: banReason,
+          banned_by: 'Admin Dashboard'
+        })
+      });
+      if (res.ok) {
+        setBanModalWallet(null);
+        await fetchBannedWallets();
+        await fetchLogs();
+      } else {
+        alert("Erreur lors du bannissement.");
+      }
+    } catch (e) {
+      console.error("Erreur ban:", e);
+    } finally {
+      setIsSubmittingBan(false);
+    }
+  };
+
+  const handleUnbanWallet = async (walletHash: string) => {
+    if (!confirm(`Voulez-vous vraiment débannir le wallet ${walletHash.substring(0, 10)}... ?`)) return;
+    try {
+      const res = await fetch(`${API_BASE_URL}/api/moderation/ban/${walletHash}`, {
+        method: 'DELETE'
+      });
+      if (res.ok) {
+        await fetchBannedWallets();
+        await fetchLogs();
+      }
+    } catch (e) {
+      console.error("Erreur unban:", e);
+    }
+  };
+
+  const handleDeleteLog = async (id: number) => {
+    if (!confirm("Voulez-vous vraiment supprimer ce log ?")) return;
+    try {
+      const res = await fetch(`${API_BASE_URL}/api/logs/${id}`, { method: 'DELETE' });
+      if (res.ok) {
+        setLogs(prev => prev.filter(l => l.id !== id));
+        fetchLogs();
+      }
+    } catch (e) {
+      console.error("Erreur suppression:", e);
+    }
+  };
+
+  const handleClearAll = async () => {
+    try {
+      const res = await fetch(`${API_BASE_URL}/api/logs`, { method: 'DELETE' });
+      if (res.ok) {
+        setLogs([]);
+        setShowClearConfirm(false);
+        fetchLogs();
+      }
+    } catch (e) {
+      console.error("Erreur vidage logs:", e);
+    }
+  };
+
+  const formatFileSize = (bytes: number | null) => {
+    if (!bytes || bytes === 0) return "0 B";
+    const k = 1024;
+    const sizes = ["B", "KB", "MB", "GB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
+  };
+
+  const filteredLogs = useMemo(() => {
+    return logs.filter(log => {
+      // Filter status
+      if (statusFilter === "SUCCESS" && log.status !== "SUCCESS") return false;
+      if (statusFilter === "FAILED" && log.status !== "FAILED") return false;
+      if (statusFilter === "INVALID_TARGET" && log.target_status === "VALID") return false;
+      if (statusFilter === "BANNED" && !isWalletBanned(log.wallet_hash)) return false;
+
+      // Filter search
+      if (!searchTerm.trim()) return true;
+      const term = searchTerm.toLowerCase();
+      return (
+        (log.wallet_hash && log.wallet_hash.toLowerCase().includes(term)) ||
+        (log.session_id && log.session_id.toLowerCase().includes(term)) ||
+        (log.image_filename && log.image_filename.toLowerCase().includes(term)) ||
+        (log.device_model && log.device_model.toLowerCase().includes(term)) ||
+        (log.weapon && log.weapon.toLowerCase().includes(term)) ||
+        (log.target_type && log.target_type.toLowerCase().includes(term)) ||
+        (log.target_status && log.target_status.toLowerCase().includes(term)) ||
+        (log.ip_address && log.ip_address.toLowerCase().includes(term))
+      );
+    });
+  }, [logs, searchTerm, statusFilter, bannedWallets]);
+
+  return (
+    <div className="space-y-8">
+      {/* Header */}
+      <div className="flex flex-col md:flex-row md:items-center justify-between gap-4">
+        <div className="space-y-1">
+          <div className="flex items-center gap-3">
+            <div className="p-2.5 bg-indigo-500/10 border border-indigo-500/20 rounded-xl text-indigo-400">
+              <ScrollText size={24} />
+            </div>
+            <div>
+              <h2 className="text-3xl font-bold tracking-tight">Journal & Contrôle des Uploads</h2>
+              <p className="text-slate-400 text-sm">
+                Historique des transferts, diagnostic OpenCV (détection cibles) et modération des wallets.
+              </p>
+            </div>
+          </div>
+        </div>
+
+        <div className="flex flex-wrap items-center gap-3">
+          <button
+            onClick={fetchLogs}
+            disabled={isLoading}
+            className="flex items-center gap-2 px-4 py-2.5 bg-slate-900 border border-slate-800 hover:bg-slate-800 text-slate-300 hover:text-white rounded-xl text-sm font-semibold transition-all disabled:opacity-50"
+            title="Rafraîchir les logs"
+          >
+            <RefreshCw size={16} className={isLoading ? "animate-spin text-indigo-400" : ""} />
+            <span>Actualiser</span>
+          </button>
+
+          <a
+            href={`${API_BASE_URL}/api/logs/export?format=csv`}
+            download
+            className="flex items-center gap-2 px-4 py-2.5 bg-indigo-600 hover:bg-indigo-500 text-white rounded-xl text-sm font-semibold transition-all shadow-lg shadow-indigo-600/20 hover:scale-105 active:scale-95"
+          >
+            <Download size={16} />
+            <span>Exporter CSV</span>
+          </a>
+
+          {!showClearConfirm ? (
+            <button
+              onClick={() => setShowClearConfirm(true)}
+              className="flex items-center gap-2 px-3 py-2.5 bg-slate-900 border border-slate-800 hover:border-rose-500/40 text-slate-400 hover:text-rose-400 rounded-xl text-sm transition-all"
+              title="Purger tous les logs"
+            >
+              <Trash2 size={16} />
+            </button>
+          ) : (
+            <div className="flex items-center gap-2 p-1 bg-rose-500/10 border border-rose-500/30 rounded-xl animate-in fade-in">
+              <span className="text-xs text-rose-400 px-2 font-semibold">Effacer tout ?</span>
+              <button
+                onClick={handleClearAll}
+                className="px-2.5 py-1 bg-rose-600 hover:bg-rose-500 text-white rounded-lg text-xs font-bold transition-all"
+              >
+                Oui
+              </button>
+              <button
+                onClick={() => setShowClearConfirm(false)}
+                className="px-2.5 py-1 bg-slate-800 hover:bg-slate-700 text-slate-300 rounded-lg text-xs transition-all"
+              >
+                Non
+              </button>
+            </div>
+          )}
+        </div>
+      </div>
+
+      {/* KPI Stats Cards */}
+      <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-4 gap-5">
+        <div className="bg-slate-900/80 border border-slate-800 p-5 rounded-2xl flex items-center justify-between shadow-sm">
+          <div className="space-y-1">
+            <p className="text-xs text-slate-500 font-bold uppercase tracking-wider">Total Uploads</p>
+            <div className="flex items-baseline gap-2">
+              <p className="text-2xl font-bold">{stats?.total_uploads ?? logs.length}</p>
+              {stats && stats.total_uploads > 0 && (
+                <span className="text-xs font-semibold text-emerald-400">
+                  {Math.round(((stats.success_count || 0) / stats.total_uploads) * 100)}% succès
+                </span>
+              )}
+            </div>
+          </div>
+          <div className="w-11 h-11 bg-indigo-500/10 border border-indigo-500/20 text-indigo-400 rounded-xl flex items-center justify-center">
+            <ScrollText size={20} />
+          </div>
+        </div>
+
+        <div className="bg-slate-900/80 border border-slate-800 p-5 rounded-2xl flex items-center justify-between shadow-sm">
+          <div className="space-y-1">
+            <p className="text-xs text-slate-500 font-bold uppercase tracking-wider">Aujourd'hui</p>
+            <p className="text-2xl font-bold text-indigo-400">{stats?.today_uploads ?? 0}</p>
+          </div>
+          <div className="w-11 h-11 bg-indigo-500/10 border border-indigo-500/20 text-indigo-400 rounded-xl flex items-center justify-center">
+            <Calendar size={20} />
+          </div>
+        </div>
+
+        <div className="bg-slate-900/80 border border-slate-800 p-5 rounded-2xl flex items-center justify-between shadow-sm">
+          <div className="space-y-1">
+            <p className="text-xs text-slate-500 font-bold uppercase tracking-wider">Wallets Bannis</p>
+            <div className="flex items-baseline gap-2">
+              <p className="text-2xl font-bold text-rose-400">{bannedWallets.length}</p>
+              <span className="text-xs text-slate-500 font-mono">/ {stats?.unique_wallets ?? 0} total</span>
+            </div>
+          </div>
+          <div className="w-11 h-11 bg-rose-500/10 border border-rose-500/20 text-rose-400 rounded-xl flex items-center justify-center">
+            <Ban size={20} />
+          </div>
+        </div>
+
+        <div className="bg-slate-900/80 border border-slate-800 p-5 rounded-2xl flex items-center justify-between shadow-sm">
+          <div className="space-y-1">
+            <p className="text-xs text-slate-500 font-bold uppercase tracking-wider">Volume Transféré</p>
+            <p className="text-2xl font-bold text-emerald-400">
+              {formatFileSize(stats?.total_bytes || logs.reduce((acc, l) => acc + (l.file_size || 0), 0))}
+            </p>
+          </div>
+          <div className="w-11 h-11 bg-emerald-500/10 border border-emerald-500/20 text-emerald-400 rounded-xl flex items-center justify-center">
+            <HardDrive size={20} />
+          </div>
+        </div>
+      </div>
+
+      {/* Filters & Search Toolbar */}
+      <div className="bg-slate-900 border border-slate-800 rounded-2xl p-4 flex flex-col md:flex-row gap-4 items-center justify-between">
+        {/* Search */}
+        <div className="relative w-full md:w-96">
+          <Search size={16} className="absolute left-3.5 top-1/2 -translate-y-1/2 text-slate-500" />
+          <input
+            type="text"
+            value={searchTerm}
+            onChange={(e) => setSearchTerm(e.target.value)}
+            placeholder="Rechercher par Wallet, Session, Cible, Image..."
+            className="w-full bg-slate-950 border border-slate-800 focus:border-indigo-500 focus:ring-1 focus:ring-indigo-500 rounded-xl pl-10 pr-4 py-2 text-sm text-slate-200 placeholder-slate-500 outline-none transition-all"
+          />
+          {searchTerm && (
+            <button
+              onClick={() => setSearchTerm("")}
+              className="absolute right-3 top-1/2 -translate-y-1/2 text-xs text-slate-500 hover:text-slate-300"
+            >
+              Effacer
+            </button>
+          )}
+        </div>
+
+        {/* Status & OpenCV Filter */}
+        <div className="flex items-center gap-2 w-full md:w-auto justify-start md:justify-end flex-wrap">
+          <span className="text-xs text-slate-500 font-semibold uppercase tracking-wider flex items-center gap-1.5 mr-1">
+            <Filter size={13} />
+            Filtre:
+          </span>
+          <div className="inline-flex bg-slate-950 p-1 rounded-xl border border-slate-800 flex-wrap gap-1">
+            <button
+              onClick={() => setStatusFilter("ALL")}
+              className={`px-2.5 py-1 text-xs font-semibold rounded-lg transition-all ${
+                statusFilter === "ALL"
+                  ? "bg-slate-800 text-white shadow-sm"
+                  : "text-slate-400 hover:text-slate-200"
+              }`}
+            >
+              Tous ({logs.length})
+            </button>
+            <button
+              onClick={() => setStatusFilter("SUCCESS")}
+              className={`px-2.5 py-1 text-xs font-semibold rounded-lg transition-all ${
+                statusFilter === "SUCCESS"
+                  ? "bg-emerald-500/20 text-emerald-300 border border-emerald-500/30"
+                  : "text-slate-400 hover:text-emerald-400"
+              }`}
+            >
+              Succès
+            </button>
+            <button
+              onClick={() => setStatusFilter("INVALID_TARGET")}
+              className={`px-2.5 py-1 text-xs font-semibold rounded-lg transition-all ${
+                statusFilter === "INVALID_TARGET"
+                  ? "bg-amber-500/20 text-amber-300 border border-amber-500/30"
+                  : "text-slate-400 hover:text-amber-400"
+              }`}
+              title="Photos non reconnues comme cible par OpenCV"
+            >
+              ⚠ Cibles Douteuses
+            </button>
+            <button
+              onClick={() => setStatusFilter("BANNED")}
+              className={`px-2.5 py-1 text-xs font-semibold rounded-lg transition-all ${
+                statusFilter === "BANNED"
+                  ? "bg-rose-500/20 text-rose-300 border border-rose-500/30"
+                  : "text-slate-400 hover:text-rose-400"
+              }`}
+            >
+              Bannis ({bannedWallets.length})
+            </button>
+          </div>
+        </div>
+      </div>
+
+      {/* Logs Table */}
+      <div className="bg-slate-900 border border-slate-800 rounded-2xl overflow-hidden shadow-xl shadow-black/20">
+        <div className="overflow-x-auto">
+          <table className="w-full text-left text-sm">
+            <thead className="bg-slate-950/60 border-b border-slate-800 text-slate-400 font-semibold text-xs uppercase tracking-wider">
+              <tr>
+                <th className="px-5 py-3.5">Date & Heure</th>
+                <th className="px-4 py-3.5">Diagnostic OpenCV</th>
+                <th className="px-4 py-3.5">Wallet Contributeur</th>
+                <th className="px-4 py-3.5">Session / Cible</th>
+                <th className="px-4 py-3.5">Appareil</th>
+                <th className="px-4 py-3.5">Fichier</th>
+                <th className="px-4 py-3.5 text-right">Actions</th>
+              </tr>
+            </thead>
+            <tbody className="divide-y divide-slate-800/60">
+              {filteredLogs.map((log) => {
+                const dateObj = new Date(log.timestamp);
+                const isValidDate = !isNaN(dateObj.getTime());
+                const formattedDate = isValidDate 
+                  ? dateObj.toLocaleDateString("fr-FR", { day: "2-digit", month: "2-digit", year: "numeric" })
+                  : log.timestamp;
+                const formattedTime = isValidDate 
+                  ? dateObj.toLocaleTimeString("fr-FR", { hour: "2-digit", minute: "2-digit", second: "2-digit" })
+                  : "";
+
+                const banned = isWalletBanned(log.wallet_hash);
+
+                return (
+                  <tr 
+                    key={log.id} 
+                    className="hover:bg-slate-800/40 transition-colors group"
+                  >
+                    {/* Timestamp */}
+                    <td className="px-5 py-4 whitespace-nowrap">
+                      <div className="flex flex-col">
+                        <span className="font-semibold text-slate-200">{formattedDate}</span>
+                        <span className="text-xs text-slate-500 font-mono">{formattedTime}</span>
+                      </div>
+                    </td>
+
+                    {/* OpenCV Diagnosis & Upload Status */}
+                    <td className="px-4 py-4 whitespace-nowrap">
+                      <div className="flex flex-col gap-1">
+                        {log.status === "FAILED" ? (
+                          <span className="inline-flex items-center gap-1 px-2 py-0.5 rounded text-[10px] font-bold bg-rose-500/10 text-rose-400 border border-rose-500/20 max-w-fit" title={log.error_message || "Échec upload"}>
+                            <XCircle size={12} />
+                            UPLOAD ÉCHEC
+                          </span>
+                        ) : log.target_status === "VALID" ? (
+                          <span className="inline-flex items-center gap-1 px-2 py-0.5 rounded text-[10px] font-bold bg-emerald-500/10 text-emerald-400 border border-emerald-500/20 max-w-fit" title={log.target_details || "Cible certifiée"}>
+                            <ShieldCheck size={12} />
+                            CIBLE CERTIFIÉE ({Math.round((log.target_confidence || 1) * 100)}%)
+                          </span>
+                        ) : log.target_status === "SUSPICIOUS" ? (
+                          <span className="inline-flex items-center gap-1 px-2 py-0.5 rounded text-[10px] font-bold bg-amber-500/10 text-amber-400 border border-amber-500/20 max-w-fit" title={log.target_details || "1 seul anneau détecté"}>
+                            <AlertTriangle size={12} />
+                            DOUTEUSE (1 ANNEAU)
+                          </span>
+                        ) : (
+                          <span className="inline-flex items-center gap-1 px-2 py-0.5 rounded text-[10px] font-bold bg-rose-500/10 text-rose-400 border border-rose-500/20 max-w-fit" title={log.target_details || "Aucun motif de cible"}>
+                            <ShieldAlert size={12} />
+                            NON RECONNUE
+                          </span>
+                        )}
+
+                        {log.target_rings_count ? (
+                          <span className="text-[10px] text-slate-500 font-mono">
+                            {log.target_rings_count} anneaux concentriques
+                          </span>
+                        ) : null}
+                      </div>
+                    </td>
+
+                    {/* Wallet Hash & Ban Badge */}
+                    <td className="px-4 py-4">
+                      {log.wallet_hash ? (
+                        <div className="flex flex-col gap-1">
+                          <div className="flex items-center gap-2">
+                            <span 
+                              onClick={() => setSearchTerm(log.wallet_hash || "")}
+                              className="font-mono text-xs text-indigo-300 hover:text-indigo-200 bg-indigo-500/5 px-2 py-1 rounded border border-indigo-500/10 hover:border-indigo-500/30 cursor-pointer transition-colors"
+                              title="Cliquer pour filtrer par ce wallet"
+                            >
+                              {log.wallet_hash.length > 16 
+                                ? `${log.wallet_hash.substring(0, 8)}...${log.wallet_hash.substring(log.wallet_hash.length - 8)}`
+                                : log.wallet_hash}
+                            </span>
+                            <button
+                              onClick={() => copyToClipboard(log.wallet_hash!)}
+                              className="text-slate-500 hover:text-slate-300 transition-colors p-1"
+                              title="Copier le hash du wallet"
+                            >
+                              {copiedWallet === log.wallet_hash ? (
+                                <Check size={14} className="text-emerald-400" />
+                              ) : (
+                                <Copy size={14} />
+                              )}
+                            </button>
+                          </div>
+
+                          {banned && (
+                            <span className="inline-flex items-center gap-1 text-[10px] font-bold text-rose-400 bg-rose-500/10 px-1.5 py-0.5 rounded border border-rose-500/20 max-w-fit">
+                              <Ban size={10} />
+                              WALLET BANNI
+                            </span>
+                          )}
+                        </div>
+                      ) : (
+                        <span className="text-xs text-slate-500 italic">Anonyme / Non fourni</span>
+                      )}
+                    </td>
+
+                    {/* Session & Target */}
+                    <td className="px-4 py-4">
+                      <div className="flex flex-col gap-1 max-w-[180px]">
+                        {log.session_id && (
+                          <div className="flex items-center gap-1 text-xs text-slate-300 font-mono truncate">
+                            <span className="text-slate-500">ID:</span> {log.session_id}
+                          </div>
+                        )}
+                        <div className="flex items-center flex-wrap gap-1.5">
+                          {log.target_type && (
+                            <span className="text-[10px] uppercase font-bold bg-slate-800 text-slate-300 px-1.5 py-0.5 rounded border border-slate-700">
+                              {log.target_type}
+                            </span>
+                          )}
+                          {log.weapon && (
+                            <span className="text-[10px] bg-slate-800 text-slate-400 px-1.5 py-0.5 rounded">
+                              {log.weapon}
+                            </span>
+                          )}
+                          {log.impacts_count > 0 && (
+                            <span className="text-[10px] font-bold text-indigo-400 bg-indigo-500/10 px-1.5 py-0.5 rounded border border-indigo-500/20 flex items-center gap-0.5">
+                              <Crosshair size={10} />
+                              {log.impacts_count} imp.
+                            </span>
+                          )}
+                        </div>
+                      </div>
+                    </td>
+
+                    {/* Device & IP */}
+                    <td className="px-4 py-4 whitespace-nowrap">
+                      <div className="flex flex-col gap-0.5">
+                        <div className="flex items-center gap-1.5 text-xs text-slate-300">
+                          <Smartphone size={13} className="text-indigo-400" />
+                          <span>{log.device_model || log.device_os || "Inconnu"}</span>
+                        </div>
+                        {log.ip_address && (
+                          <span className="text-[11px] text-slate-500 font-mono">
+                            {log.ip_address.replace("::ffff:", "")}
+                          </span>
+                        )}
+                      </div>
+                    </td>
+
+                    {/* File & Size */}
+                    <td className="px-4 py-4 whitespace-nowrap">
+                      <div className="flex flex-col gap-0.5">
+                        {log.image_filename ? (
+                          <Link
+                            href={`/photo/${log.image_filename}`}
+                            className="text-xs text-indigo-400 hover:text-indigo-300 font-mono flex items-center gap-1 group/link truncate max-w-[130px]"
+                            title={log.image_filename}
+                          >
+                            <span className="truncate">{log.image_filename}</span>
+                            <ExternalLink size={12} className="opacity-0 group-hover/link:opacity-100 transition-opacity" />
+                          </Link>
+                        ) : (
+                          <span className="text-xs text-slate-500 italic">Aucun fichier</span>
+                        )}
+                        <span className="text-[11px] text-slate-500 font-mono">
+                          {formatFileSize(log.file_size)}
+                        </span>
+                      </div>
+                    </td>
+
+                    {/* Actions */}
+                    <td className="px-4 py-4 text-right whitespace-nowrap">
+                      <div className="flex items-center justify-end gap-1.5">
+                        {/* Ban / Unban Button */}
+                        {log.wallet_hash && (
+                          banned ? (
+                            <button
+                              onClick={() => handleUnbanWallet(log.wallet_hash!)}
+                              className="p-1.5 text-slate-400 hover:text-emerald-400 hover:bg-slate-800 rounded-lg transition-colors"
+                              title="Débannir ce wallet"
+                            >
+                              <ShieldCheck size={16} />
+                            </button>
+                          ) : (
+                            <button
+                              onClick={() => setBanModalWallet(log.wallet_hash)}
+                              className="p-1.5 text-slate-500 hover:text-rose-400 hover:bg-slate-800 rounded-lg transition-colors"
+                              title="Bannir définitivement ce wallet"
+                            >
+                              <Ban size={16} />
+                            </button>
+                          )
+                        )}
+
+                        <button
+                          onClick={() => setSelectedLog(log)}
+                          className="p-1.5 text-slate-400 hover:text-indigo-300 hover:bg-slate-800 rounded-lg transition-colors"
+                          title="Voir les détails complets"
+                        >
+                          <Eye size={16} />
+                        </button>
+                        <button
+                          onClick={() => handleDeleteLog(log.id)}
+                          className="p-1.5 text-slate-500 hover:text-rose-400 hover:bg-slate-800 rounded-lg transition-colors"
+                          title="Supprimer ce log"
+                        >
+                          <Trash2 size={16} />
+                        </button>
+                      </div>
+                    </td>
+                  </tr>
+                );
+              })}
+            </tbody>
+          </table>
+        </div>
+
+        {/* Empty state */}
+        {filteredLogs.length === 0 && (
+          <div className="py-20 flex flex-col items-center justify-center text-center px-4">
+            <div className="p-4 bg-slate-950 border border-slate-800 rounded-2xl text-slate-600 mb-3">
+              <ScrollText size={36} />
+            </div>
+            <h3 className="text-slate-300 font-bold text-base">Aucun log trouvé</h3>
+            <p className="text-slate-500 text-xs mt-1 max-w-sm">
+              {searchTerm || statusFilter !== "ALL"
+                ? "Aucun enregistrement ne correspond à vos critères de recherche."
+                : "Les logs apparaîtront ici dès que des photos ou des sessions seront uploadées."}
+            </p>
+          </div>
+        )}
+      </div>
+
+      {/* Details Modal */}
+      {selectedLog && (
+        <div className="fixed inset-0 z-50 bg-black/70 backdrop-blur-sm flex items-center justify-center p-4">
+          <div className="bg-slate-900 border border-slate-800 rounded-2xl w-full max-w-2xl max-h-[85vh] flex flex-col overflow-hidden shadow-2xl animate-in zoom-in-95 duration-200">
+            {/* Modal Header */}
+            <div className="p-6 border-b border-slate-800 flex items-center justify-between bg-slate-950/50">
+              <div className="flex items-center gap-3">
+                <div className="p-2 bg-indigo-500/10 border border-indigo-500/20 rounded-xl text-indigo-400">
+                  <Info size={20} />
+                </div>
+                <div>
+                  <h3 className="font-bold text-lg text-slate-100">Détails du Log #{selectedLog.id}</h3>
+                  <p className="text-xs text-slate-400">{new Date(selectedLog.timestamp).toLocaleString()}</p>
+                </div>
+              </div>
+              <button
+                onClick={() => setSelectedLog(null)}
+                className="text-slate-400 hover:text-white p-2 hover:bg-slate-800 rounded-xl transition-colors"
+              >
+                ✕
+              </button>
+            </div>
+
+            {/* Modal Content */}
+            <div className="p-6 overflow-y-auto space-y-6 text-sm">
+              {/* OpenCV Diagnostic Banner */}
+              <div className={`p-4 rounded-xl border flex flex-col gap-2 ${
+                selectedLog.target_status === "VALID"
+                  ? "bg-emerald-500/10 border-emerald-500/20 text-emerald-300"
+                  : selectedLog.target_status === "SUSPICIOUS"
+                  ? "bg-amber-500/10 border-amber-500/20 text-amber-300"
+                  : "bg-rose-500/10 border-rose-500/20 text-rose-300"
+              }`}>
+                <div className="flex items-center justify-between">
+                  <div className="flex items-center gap-2 font-bold">
+                    {selectedLog.target_status === "VALID" ? <ShieldCheck size={18} /> : <AlertTriangle size={18} />}
+                    Diagnostic OpenCV : {selectedLog.target_status || "VALID"}
+                  </div>
+                  <span className="text-xs font-mono font-bold px-2 py-0.5 rounded bg-black/30">
+                    Confiance : {Math.round((selectedLog.target_confidence || 1) * 100)}%
+                  </span>
+                </div>
+                <p className="text-xs opacity-90">{selectedLog.target_details || "Cible détectée avec succès."}</p>
+              </div>
+
+              {/* General Grid */}
+              <div className="grid grid-cols-2 gap-4">
+                <div className="bg-slate-950 p-4 rounded-xl border border-slate-800 space-y-1">
+                  <span className="text-xs text-slate-500 font-bold uppercase tracking-wider">Wallet Hash</span>
+                  <div className="font-mono text-xs text-indigo-300 break-all select-all">
+                    {selectedLog.wallet_hash || "Non spécifié"}
+                  </div>
+                  {isWalletBanned(selectedLog.wallet_hash) && (
+                    <span className="inline-block mt-1 text-[10px] text-rose-400 font-bold bg-rose-500/10 px-1.5 py-0.5 rounded border border-rose-500/20">
+                      Banni ({getBannedInfo(selectedLog.wallet_hash)?.reason})
+                    </span>
+                  )}
+                </div>
+
+                <div className="bg-slate-950 p-4 rounded-xl border border-slate-800 space-y-1">
+                  <span className="text-xs text-slate-500 font-bold uppercase tracking-wider">Session ID</span>
+                  <div className="font-mono text-xs text-slate-300 break-all select-all">
+                    {selectedLog.session_id || "N/A"}
+                  </div>
+                </div>
+
+                <div className="bg-slate-950 p-4 rounded-xl border border-slate-800 space-y-1">
+                  <span className="text-xs text-slate-500 font-bold uppercase tracking-wider">Appareil</span>
+                  <div className="text-xs text-slate-300">
+                    {selectedLog.device_model || "Inconnu"} ({selectedLog.device_os || "OS inconnu"})
+                  </div>
+                </div>
+
+                <div className="bg-slate-950 p-4 rounded-xl border border-slate-800 space-y-1">
+                  <span className="text-xs text-slate-500 font-bold uppercase tracking-wider">Adresse IP</span>
+                  <div className="font-mono text-xs text-slate-300">
+                    {selectedLog.ip_address || "Inconnue"}
+                  </div>
+                </div>
+
+                <div className="bg-slate-950 p-4 rounded-xl border border-slate-800 space-y-1">
+                  <span className="text-xs text-slate-500 font-bold uppercase tracking-wider">Cible & Arme</span>
+                  <div className="text-xs text-slate-300">
+                    Type: <span className="font-bold text-white">{selectedLog.target_type || "N/A"}</span> | Arme: {selectedLog.weapon || "N/A"} | {selectedLog.distance_meters ? `${selectedLog.distance_meters}m` : ""}
+                  </div>
+                </div>
+
+                <div className="bg-slate-950 p-4 rounded-xl border border-slate-800 space-y-1">
+                  <span className="text-xs text-slate-500 font-bold uppercase tracking-wider">Fichiers & Taille</span>
+                  <div className="text-xs text-slate-300">
+                    Image: <span className="font-mono">{selectedLog.image_filename || "N/A"}</span> ({formatFileSize(selectedLog.file_size)})
+                  </div>
+                </div>
+              </div>
+
+              {/* Raw Metadata JSON */}
+              {selectedLog.raw_metadata && (
+                <div className="space-y-2">
+                  <span className="text-xs text-slate-500 font-bold uppercase tracking-wider">Données Brutes (JSON)</span>
+                  <pre className="bg-slate-950 border border-slate-800 p-4 rounded-xl text-xs font-mono text-slate-300 overflow-x-auto max-h-48">
+                    {(() => {
+                      try {
+                        return JSON.stringify(JSON.parse(selectedLog.raw_metadata), null, 2);
+                      } catch {
+                        return selectedLog.raw_metadata;
+                      }
+                    })()}
+                  </pre>
+                </div>
+              )}
+            </div>
+
+            {/* Modal Footer */}
+            <div className="p-4 border-t border-slate-800 bg-slate-950/50 flex justify-between items-center">
+              <div className="flex items-center gap-2">
+                {selectedLog.image_filename && (
+                  <Link
+                    href={`/photo/${selectedLog.image_filename}`}
+                    className="flex items-center gap-2 px-4 py-2 bg-indigo-600 hover:bg-indigo-500 text-white rounded-xl text-xs font-bold transition-all"
+                  >
+                    <Eye size={14} />
+                    Ouvrir la session
+                  </Link>
+                )}
+                {selectedLog.wallet_hash && (
+                  isWalletBanned(selectedLog.wallet_hash) ? (
+                    <button
+                      onClick={() => handleUnbanWallet(selectedLog.wallet_hash!)}
+                      className="px-3 py-2 bg-slate-800 hover:bg-emerald-600/30 text-emerald-400 rounded-xl text-xs font-bold transition-all border border-emerald-500/20"
+                    >
+                      Débannir ce wallet
+                    </button>
+                  ) : (
+                    <button
+                      onClick={() => {
+                        setSelectedLog(null);
+                        setBanModalWallet(selectedLog.wallet_hash);
+                      }}
+                      className="px-3 py-2 bg-rose-600/10 hover:bg-rose-600 text-rose-400 hover:text-white rounded-xl text-xs font-bold transition-all border border-rose-500/20"
+                    >
+                      Bannir ce wallet
+                    </button>
+                  )
+                )}
+              </div>
+
+              <button
+                onClick={() => setSelectedLog(null)}
+                className="px-4 py-2 bg-slate-800 hover:bg-slate-700 text-slate-300 rounded-xl text-xs font-semibold transition-all"
+              >
+                Fermer
+              </button>
+            </div>
+          </div>
+        </div>
+      )}
+
+      {/* Ban Confirmation Modal */}
+      {banModalWallet && (
+        <div className="fixed inset-0 z-50 bg-black/75 backdrop-blur-sm flex items-center justify-center p-4">
+          <div className="bg-slate-900 border border-slate-800 rounded-2xl w-full max-w-md p-6 space-y-6 shadow-2xl animate-in zoom-in-95 duration-200">
+            <div className="flex items-center gap-3">
+              <div className="p-3 bg-rose-500/10 border border-rose-500/20 rounded-xl text-rose-400">
+                <Ban size={24} />
+              </div>
+              <div>
+                <h3 className="font-bold text-lg text-slate-100">Bannir un Wallet</h3>
+                <p className="text-xs text-slate-400">Bloquer définitivement tout upload futur de ce compte.</p>
+              </div>
+            </div>
+
+            <div className="bg-slate-950 p-3 rounded-xl border border-slate-800 font-mono text-xs text-indigo-300 break-all">
+              {banModalWallet}
+            </div>
+
+            <div className="space-y-2">
+              <label className="text-xs font-bold uppercase tracking-wider text-slate-400">
+                Motif du bannissement
+              </label>
+              <select
+                value={banReason}
+                onChange={(e) => setBanReason(e.target.value)}
+                className="w-full bg-slate-950 border border-slate-800 focus:border-rose-500 rounded-xl px-3 py-2 text-sm text-slate-200 outline-none"
+              >
+                <option value="Images non conformes / Fausse cible">Images non conformes / Fausse cible</option>
+                <option value="Spam / Uploads abusifs répétés">Spam / Uploads abusifs répétés</option>
+                <option value="Contenu inapproprié ou illicite">Contenu inapproprié ou illicite</option>
+                <option value="Tentative de manipulation des données">Tentative de manipulation des données</option>
+              </select>
+            </div>
+
+            <div className="flex justify-end gap-3 pt-2">
+              <button
+                onClick={() => setBanModalWallet(null)}
+                className="px-4 py-2 bg-slate-800 hover:bg-slate-700 text-slate-300 rounded-xl text-xs font-semibold transition-all"
+              >
+                Annuler
+              </button>
+              <button
+                onClick={handleBanWallet}
+                disabled={isSubmittingBan}
+                className="px-4 py-2 bg-rose-600 hover:bg-rose-500 text-white rounded-xl text-xs font-bold transition-all disabled:opacity-50 flex items-center gap-1.5"
+              >
+                <Ban size={14} />
+                {isSubmittingBan ? "Bannissement..." : "Confirmer le Bannissement"}
+              </button>
+            </div>
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}

backendia/dashboard/src/app/logs/page.tsx

@@ -0,0 +1,30 @@
+import { fetchApi } from "@/lib/api";
+import LogsManager from "./LogsManager";
+
+export const metadata = {
+  title: "Logs d'Uploads | Bully IA Dashboard",
+  description: "Journal complet des téléversements de sessions et métadonnées",
+};
+
+export default async function LogsPage() {
+  let logs = [];
+  let stats = null;
+
+  try {
+    const [logsRes, statsRes] = await Promise.all([
+      fetchApi('/api/logs?limit=100'),
+      fetchApi('/api/logs/stats')
+    ]);
+    logs = logsRes.logs || [];
+    stats = statsRes.stats || null;
+  } catch (error) {
+    console.error("Erreur chargement initial des logs:", error);
+  }
+
+  return (
+    <LogsManager 
+      initialLogs={logs} 
+      initialStats={stats} 
+    />
+  );
+}

backendia/dashboard/src/app/page.tsx

@@ -1,4 +1,4 @@
-import { fetchApi, API_BASE_URL } from "@/lib/api";
+import { fetchApi } from "@/lib/api";
 import DatasetToolbar from "@/components/DatasetToolbar";
 import { Calendar, User, Crosshair } from "lucide-react";
 import Link from "next/link";
@@ -49,7 +49,7 @@ export default async function DashboardPage() {
             <div className="aspect-[3/4] relative overflow-hidden bg-slate-800">
               {/* eslint-disable-next-line @next/next/no-img-element */}
               <img 
-                src={`${API_BASE_URL}${photo.imageUrl}`}
+                src={photo.imageUrl}
                 alt={photo.filename}
                 className="w-full h-full object-cover group-hover:scale-105 transition-transform duration-500"
               />

backendia/dashboard/src/app/photo/[id]/page.tsx

@@ -1,4 +1,4 @@
-import { fetchApi, API_BASE_URL } from "@/lib/api";
+import { fetchApi } from "@/lib/api";
 import PhotoEditor from "@/components/PhotoEditor";
 import { ChevronLeft, Download } from "lucide-react";
 import Link from "next/link";
@@ -33,7 +33,7 @@ export default async function PhotoDetailPage({ params }: { params: Promise<{ id
         
         <div className="flex gap-3">
           <a 
-            href={`${API_BASE_URL}/uploads/images/${id}`}
+            href={`/uploads/images/${id}`}
             download
             className="flex items-center gap-2 bg-slate-800 hover:bg-slate-700 px-4 py-2 rounded-lg text-sm font-medium transition-colors"
           >

backendia/dashboard/src/components/PhotoEditor.tsx

@@ -112,7 +112,7 @@ export default function PhotoEditor({ initialPhoto }: PhotoEditorProps) {
         </div>
 
         <PhotoOverlay 
-          imageUrl={`${API_BASE_URL}${initialPhoto.imageUrl}`}
+          imageUrl={initialPhoto.imageUrl}
           impacts={impacts}
           targetCorners={photoData?.plotting?.target_corners || []}
           isEditing={isEditing}

backendia/dashboard/src/lib/api.ts

@@ -1,4 +1,7 @@
-export const API_BASE_URL = 'http://127.0.0.1:3000';
+const isServer = typeof window === 'undefined';
+export const API_BASE_URL = isServer 
+  ? `http://127.0.0.1:${process.env.PORT || 3000}` 
+  : '';
 
 export async function fetchApi(endpoint: string) {
   const res = await fetch(`${API_BASE_URL}${endpoint}`, {

backendia/package-lock.json

@@ -9,14 +9,526 @@
       "version": "1.0.0",
       "license": "ISC",
       "dependencies": {
+        "@techstark/opencv-js": "^5.0.0-release.1",
         "adm-zip": "^0.5.17",
         "cors": "^2.8.6",
         "dotenv": "^17.4.2",
         "express": "^5.2.1",
         "multer": "^2.1.1",
+        "sharp": "^0.35.3",
         "sqlite3": "^6.0.1"
       }
     },
+    "node_modules/@emnapi/runtime": {
+      "version": "1.11.3",
+      "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.11.3.tgz",
+      "integrity": "sha512-Xz4Tpyki7XyrpbUK1jR1AhdAdaXyhhY4lZ3neLodmhpuWfy2PAQN5B46sAiU4liOXGLkHypn/qU+jvfWSCYYLA==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@img/colour": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@img/colour/-/colour-1.1.0.tgz",
+      "integrity": "sha512-Td76q7j57o/tLVdgS746cYARfSyxk8iEfRxewL9h4OMzYhbW4TAcppl0mT4eyqXddh6L/jwoM75mo7ixa/pCeQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@img/sharp-darwin-arm64": {
+      "version": "0.35.3",
+      "resolved": "https://registry.npmjs.org/@img/sharp-darwin-arm64/-/sharp-darwin-arm64-0.35.3.tgz",
+      "integrity": "sha512-RMnFX7YQsMoh7lWfcM4NEHHymBX/rLuKNPVM84XE9ONPcaSCDgE7CHIHpSgPcO2xcRthgBy1HfNO319mwhIAkg==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-darwin-arm64": "1.3.2"
+      }
+    },
+    "node_modules/@img/sharp-darwin-x64": {
+      "version": "0.35.3",
+      "resolved": "https://registry.npmjs.org/@img/sharp-darwin-x64/-/sharp-darwin-x64-0.35.3.tgz",
+      "integrity": "sha512-Xo+5uFBtLN0BKqieTxiFzFPQAUlBbbH5iBKyRX/z1JrbnYsHTfKJnUfL8+p2TPXr1pXqao4eeL4Rl144uDpK9w==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-darwin-x64": "1.3.2"
+      }
+    },
+    "node_modules/@img/sharp-freebsd-wasm32": {
+      "version": "0.35.3",
+      "resolved": "https://registry.npmjs.org/@img/sharp-freebsd-wasm32/-/sharp-freebsd-wasm32-0.35.3.tgz",
+      "integrity": "sha512-lUxcqWIj2wMQ9BrwNjngcr1gWUr5xgaGThBRqPPalIC2n67Cqj1uPh8NnA/ZhAg8hUbKl+kVHKwgUIwe6ZYPrg==",
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "dependencies": {
+        "@img/sharp-wasm32": "0.35.3"
+      },
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-darwin-arm64": {
+      "version": "1.3.2",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-darwin-arm64/-/sharp-libvips-darwin-arm64-1.3.2.tgz",
+      "integrity": "sha512-9J6ypZFpQBj4YnePGoq/S38w6nz+vqg5WZLrLGY4YuSemdMq47GMLBPO42MzwdGwpg/agZ7xzZcFHa48xlywfg==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-darwin-x64": {
+      "version": "1.3.2",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-darwin-x64/-/sharp-libvips-darwin-x64-1.3.2.tgz",
+      "integrity": "sha512-m2pW1n6cns9VaubNwsZ+c3CRYjxNQWgJ5gPlnL1nbBcpkBvFm6SCFN5o0psFHI8w9n11NKhFkeEDns98tiqbEw==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linux-arm": {
+      "version": "1.3.2",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-arm/-/sharp-libvips-linux-arm-1.3.2.tgz",
+      "integrity": "sha512-1eMLzy92I4J6rmi4mAT8yC3HxOtniyGELlzGbNMLLeqe052ahFQ0h6LFq+lh5DsDIdYViIDst08abvSbcEdLXQ==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linux-arm64": {
+      "version": "1.3.2",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-arm64/-/sharp-libvips-linux-arm64-1.3.2.tgz",
+      "integrity": "sha512-dqVSFynCox4C/J8kT16V7SIFAns0IjgLwkvYT7p8LQVmJ5OS5b6tI9IGflxTeuBS//zXeFIUbwt5dwxyZ17cnA==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linux-ppc64": {
+      "version": "1.3.2",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-ppc64/-/sharp-libvips-linux-ppc64-1.3.2.tgz",
+      "integrity": "sha512-3z0NHDxD6n5I9gc05U1eW1AyRm+Gznzq3naMrthPNqE6oYykcogW0l/jfpJdjYnuNl8R7yI9pNbE1XiUeyq0Aw==",
+      "cpu": [
+        "ppc64"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linux-riscv64": {
+      "version": "1.3.2",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-riscv64/-/sharp-libvips-linux-riscv64-1.3.2.tgz",
+      "integrity": "sha512-bsb4rI+NldGOsXuej2r8OdSS8+zXDVaCWxyWrcv6kneTOlgAHtZABRzBBCwdsPiD90J4myNJuHpg6kA20ImW/w==",
+      "cpu": [
+        "riscv64"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linux-s390x": {
+      "version": "1.3.2",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-s390x/-/sharp-libvips-linux-s390x-1.3.2.tgz",
+      "integrity": "sha512-/ABshyj8gCpyIrNXnHn4LorDJ0HHm1VhXPBlxZ8zAtfVPAaSafXPGn+sUSIRiwaSBy0mmFjSjiXI5mkcwdChKQ==",
+      "cpu": [
+        "s390x"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linux-x64": {
+      "version": "1.3.2",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-x64/-/sharp-libvips-linux-x64-1.3.2.tgz",
+      "integrity": "sha512-ITPEtgffGJ0S6G9dRyw/366tJQqFRcHWPHhC+Stpg3Z8AEMrDrTr2lhdz4f/Y/HMbRh//7Z5mBzEpVdi62Oc3w==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linuxmusl-arm64": {
+      "version": "1.3.2",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linuxmusl-arm64/-/sharp-libvips-linuxmusl-arm64-1.3.2.tgz",
+      "integrity": "sha512-zE9EdiUzUmg5mDT5a1rk5fYJ6GWPloTwWBYDS14naqHsL+EaMpDj1AWnpLgh3u0YCORv2Tt50wrcrpYqkP97Kw==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linuxmusl-x64": {
+      "version": "1.3.2",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linuxmusl-x64/-/sharp-libvips-linuxmusl-x64-1.3.2.tgz",
+      "integrity": "sha512-m0lrLiUt+lBYnCFr8qV/65yMR4E/c7/wf78I5eKTdkEakFAlZ9QlzEM3QIhhAwVeUhLAHLcCq7a7Vszq/oFNZQ==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-linux-arm": {
+      "version": "0.35.3",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-arm/-/sharp-linux-arm-0.35.3.tgz",
+      "integrity": "sha512-affVWCTLooy8TSxbDx2qkzuDeaWLNVBA+P//FNBirHsXpP2fuBhk5AuboYUnrDnzoXes8GFjpTx0SBFOCRg+FA==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-arm": "1.3.2"
+      }
+    },
+    "node_modules/@img/sharp-linux-arm64": {
+      "version": "0.35.3",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-arm64/-/sharp-linux-arm64-0.35.3.tgz",
+      "integrity": "sha512-QgKDspHPnrU+GQ55XPhGwyhC8acLVOOSyAvo1oVfFmrIXLkDNmGWzAfDZ4xK8oSA1qBQrALcHX0G5UZni/SuFQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-arm64": "1.3.2"
+      }
+    },
+    "node_modules/@img/sharp-linux-ppc64": {
+      "version": "0.35.3",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-ppc64/-/sharp-linux-ppc64-0.35.3.tgz",
+      "integrity": "sha512-sMd8rDxmpLOwv/7N44klFjOD5DUO7FLdjiXDI0hoxYaf7Ar262dQIEkosE98bps+5HPLtp/EvNqeqQtOycP/IA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-ppc64": "1.3.2"
+      }
+    },
+    "node_modules/@img/sharp-linux-riscv64": {
+      "version": "0.35.3",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-riscv64/-/sharp-linux-riscv64-0.35.3.tgz",
+      "integrity": "sha512-0Eob78yjlYPfL5vMNWAW55l3R9Y6BQS/gOfe0ZcP9mEz9ohhKSt4im1hayiknXgf8AWrFqMvJcKIdmLmEe7yeQ==",
+      "cpu": [
+        "riscv64"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-riscv64": "1.3.2"
+      }
+    },
+    "node_modules/@img/sharp-linux-s390x": {
+      "version": "0.35.3",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-s390x/-/sharp-linux-s390x-0.35.3.tgz",
+      "integrity": "sha512-KgAxQ0DxpNOq1rG2t5cgTgShJFGSuU7XO45cqC+1NVOuZnP6tlgZRuSYOfNupGkHID0o3cJOsw4DVeJpMovcGw==",
+      "cpu": [
+        "s390x"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-s390x": "1.3.2"
+      }
+    },
+    "node_modules/@img/sharp-linux-x64": {
+      "version": "0.35.3",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-x64/-/sharp-linux-x64-0.35.3.tgz",
+      "integrity": "sha512-8pqvxubL2PGdhlPy6GLqzDYMUjyRmKAwKHYKixpdJYBUK7PJ0C029XdsnpFIdgRZG68fZiGdHVWcKPvtiPB4cA==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-x64": "1.3.2"
+      }
+    },
+    "node_modules/@img/sharp-linuxmusl-arm64": {
+      "version": "0.35.3",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linuxmusl-arm64/-/sharp-linuxmusl-arm64-0.35.3.tgz",
+      "integrity": "sha512-Vz0iQjzzcSX3HCbfwFfCSG/9SCIqyO0mH2sXyiHaAYfBk0cRsCWXRyQYX0ovCK/PAQBbTzQ0dsPQHh5MAFL59w==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linuxmusl-arm64": "1.3.2"
+      }
+    },
+    "node_modules/@img/sharp-linuxmusl-x64": {
+      "version": "0.35.3",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linuxmusl-x64/-/sharp-linuxmusl-x64-0.35.3.tgz",
+      "integrity": "sha512-6O1NPKcDVj9QEdg7Hx549EX8U0rp6yXQERqru6yRN7fGBn32UvIRJUlWnk+8xDCiG76hXVBbX82NZ/ZKr0euIg==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linuxmusl-x64": "1.3.2"
+      }
+    },
+    "node_modules/@img/sharp-wasm32": {
+      "version": "0.35.3",
+      "resolved": "https://registry.npmjs.org/@img/sharp-wasm32/-/sharp-wasm32-0.35.3.tgz",
+      "integrity": "sha512-cZ0XkcYGpHZkqW6iCkqTcmUC0CD9DhD5d/qeZlZkfRBn6GnHniZXLUo5+9xw8Iv76YE6LQFN9YNBlKREcCG76w==",
+      "license": "Apache-2.0 AND LGPL-3.0-or-later AND MIT",
+      "optional": true,
+      "dependencies": {
+        "@emnapi/runtime": "^1.11.1"
+      },
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-webcontainers-wasm32": {
+      "version": "0.35.3",
+      "resolved": "https://registry.npmjs.org/@img/sharp-webcontainers-wasm32/-/sharp-webcontainers-wasm32-0.35.3.tgz",
+      "integrity": "sha512-2rnq7bX3NzeR2T4YWgz8qiG4h3TSdMe+vN1iQXpJleSJ3SM5zQ8Fy2SyyXAWlbxpEZ2Y+Z4u1BePgJEYbSy80Q==",
+      "cpu": [
+        "wasm32"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "dependencies": {
+        "@img/sharp-wasm32": "0.35.3"
+      },
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-win32-arm64": {
+      "version": "0.35.3",
+      "resolved": "https://registry.npmjs.org/@img/sharp-win32-arm64/-/sharp-win32-arm64-0.35.3.tgz",
+      "integrity": "sha512-4bPwFdMbeC4JQ8L8LOyWp6nsHcboP5fxkp6iPOXz2Vg49R42TuMs2whkJ5OAP4/Ul035qOzy0AecOF9VOscn4w==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "Apache-2.0 AND LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-win32-ia32": {
+      "version": "0.35.3",
+      "resolved": "https://registry.npmjs.org/@img/sharp-win32-ia32/-/sharp-win32-ia32-0.35.3.tgz",
+      "integrity": "sha512-r53mXsBN6lFUDiST764SvgwUdHAqM4rPAiDzAmf4fLoB6X/rkfyTrLCg6+g17wJJiCmB3JYgHuUldCWUIRFSXw==",
+      "cpu": [
+        "ia32"
+      ],
+      "license": "Apache-2.0 AND LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": "^20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-win32-x64": {
+      "version": "0.35.3",
+      "resolved": "https://registry.npmjs.org/@img/sharp-win32-x64/-/sharp-win32-x64-0.35.3.tgz",
+      "integrity": "sha512-D4y1vNeZrIIJCN+uHaWVtH86B+aCrdMYYjicy9pXHvbGZeGYLLSd3wdVuC37FxVXlU1ARsk84eKWfWMXGYEqvA==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "Apache-2.0 AND LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
     "node_modules/@isaacs/fs-minipass": {
       "version": "4.0.1",
       "resolved": "https://registry.npmjs.org/@isaacs/fs-minipass/-/fs-minipass-4.0.1.tgz",
@@ -29,6 +541,12 @@
         "node": ">=18.0.0"
       }
     },
+    "node_modules/@techstark/opencv-js": {
+      "version": "5.0.0-release.1",
+      "resolved": "https://registry.npmjs.org/@techstark/opencv-js/-/opencv-js-5.0.0-release.1.tgz",
+      "integrity": "sha512-PIm+eB0MFtieXoNC2GRao0dv/02sehG+Nv2nSW5D6pQm6J/4WqvDHm0RyoqOmGYQm67jdGiaOdIeTShCY3PIUg==",
+      "license": "Apache-2.0"
+    },
     "node_modules/abbrev": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-4.0.0.tgz",
@@ -1264,9 +1782,9 @@
       "license": "MIT"
     },
     "node_modules/semver": {
-      "version": "7.7.4",
+      "version": "7.8.5",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.8.5.tgz",
-      "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
+      "integrity": "sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA==",
       "license": "ISC",
       "bin": {
         "semver": "bin/semver.js"
@@ -1326,6 +1844,55 @@
       "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==",
       "license": "ISC"
     },
+    "node_modules/sharp": {
+      "version": "0.35.3",
+      "resolved": "https://registry.npmjs.org/sharp/-/sharp-0.35.3.tgz",
+      "integrity": "sha512-ej0zVHuZGHCiABXcNxeYhpRnPNPAcvbG8RMdBAhDAxLKkCRVSpK3Iyu7qbqw3JMzoj0REeM6f3tJLtVwl0023Q==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@img/colour": "^1.1.0",
+        "detect-libc": "^2.1.2",
+        "semver": "^7.8.5"
+      },
+      "engines": {
+        "node": ">=20.9.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-darwin-arm64": "0.35.3",
+        "@img/sharp-darwin-x64": "0.35.3",
+        "@img/sharp-freebsd-wasm32": "0.35.3",
+        "@img/sharp-libvips-darwin-arm64": "1.3.2",
+        "@img/sharp-libvips-darwin-x64": "1.3.2",
+        "@img/sharp-libvips-linux-arm": "1.3.2",
+        "@img/sharp-libvips-linux-arm64": "1.3.2",
+        "@img/sharp-libvips-linux-ppc64": "1.3.2",
+        "@img/sharp-libvips-linux-riscv64": "1.3.2",
+        "@img/sharp-libvips-linux-s390x": "1.3.2",
+        "@img/sharp-libvips-linux-x64": "1.3.2",
+        "@img/sharp-libvips-linuxmusl-arm64": "1.3.2",
+        "@img/sharp-libvips-linuxmusl-x64": "1.3.2",
+        "@img/sharp-linux-arm": "0.35.3",
+        "@img/sharp-linux-arm64": "0.35.3",
+        "@img/sharp-linux-ppc64": "0.35.3",
+        "@img/sharp-linux-riscv64": "0.35.3",
+        "@img/sharp-linux-s390x": "0.35.3",
+        "@img/sharp-linux-x64": "0.35.3",
+        "@img/sharp-linuxmusl-arm64": "0.35.3",
+        "@img/sharp-linuxmusl-x64": "0.35.3",
+        "@img/sharp-webcontainers-wasm32": "0.35.3",
+        "@img/sharp-win32-arm64": "0.35.3",
+        "@img/sharp-win32-ia32": "0.35.3",
+        "@img/sharp-win32-x64": "0.35.3"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/side-channel": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz",
@@ -1581,6 +2148,13 @@
         "node": ">=0.6"
       }
     },
+    "node_modules/tslib": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+      "license": "0BSD",
+      "optional": true
+    },
     "node_modules/tunnel-agent": {
       "version": "0.6.0",
       "resolved": "https://registry.npmjs.org/tunnel-agent/-/tunnel-agent-0.6.0.tgz",

backendia/package.json

@@ -12,11 +12,16 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
+    "@techstark/opencv-js": "^5.0.0-release.1",
     "adm-zip": "^0.5.17",
     "cors": "^2.8.6",
     "dotenv": "^17.4.2",
     "express": "^5.2.1",
     "multer": "^2.1.1",
+    "next": "^16.2.4",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "sharp": "^0.35.3",
     "sqlite3": "^6.0.1"
   }
 }

backendia/server.js

@@ -7,6 +7,8 @@ const sqlite3 = require('sqlite3').verbose();
 const AdmZip = require('adm-zip');
 
 
+const TargetValidator = require('./services/target_validator');
+
 const app = express();
 const PORT = process.env.PORT || 3000;
 
@@ -34,14 +36,128 @@ const db = new sqlite3.Database(dbPath, (err) => {
         console.error('Erreur de connexion à SQLite:', err.message);
     } else {
         console.log('Connecté à la base de données SQLite.');
+        db.serialize(() => {
             db.run(`CREATE TABLE IF NOT EXISTS user_stats (
                 wallet_hash TEXT PRIMARY KEY,
                 photo_count INTEGER DEFAULT 0,
                 last_upload DATETIME DEFAULT CURRENT_TIMESTAMP
             )`);
+
+            db.run(`CREATE TABLE IF NOT EXISTS banned_wallets (
+                wallet_hash TEXT PRIMARY KEY,
+                reason TEXT,
+                banned_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                banned_by TEXT DEFAULT 'Admin'
+            )`);
+
+            db.run(`CREATE TABLE IF NOT EXISTS upload_logs (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
+                session_id TEXT,
+                wallet_hash TEXT,
+                image_filename TEXT,
+                json_filename TEXT,
+                file_size INTEGER,
+                ip_address TEXT,
+                user_agent TEXT,
+                device_model TEXT,
+                device_os TEXT,
+                target_type TEXT,
+                weapon TEXT,
+                distance_meters INTEGER,
+                impacts_count INTEGER DEFAULT 0,
+                status TEXT DEFAULT 'SUCCESS',
+                target_valid INTEGER DEFAULT 1,
+                target_status TEXT DEFAULT 'VALID',
+                target_confidence REAL DEFAULT 1.0,
+                target_rings_count INTEGER DEFAULT 0,
+                target_details TEXT,
+                error_message TEXT,
+                raw_metadata TEXT
+            )`);
+
+            // Migration safe des colonnes OpenCV si la table existait déjà
+            const migrations = [
+                "ALTER TABLE upload_logs ADD COLUMN target_valid INTEGER DEFAULT 1",
+                "ALTER TABLE upload_logs ADD COLUMN target_status TEXT DEFAULT 'VALID'",
+                "ALTER TABLE upload_logs ADD COLUMN target_confidence REAL DEFAULT 1.0",
+                "ALTER TABLE upload_logs ADD COLUMN target_rings_count INTEGER DEFAULT 0",
+                "ALTER TABLE upload_logs ADD COLUMN target_details TEXT"
+            ];
+            migrations.forEach(sql => {
+                db.run(sql, () => {});
+            });
+
+            db.run(`CREATE INDEX IF NOT EXISTS idx_upload_logs_wallet ON upload_logs(wallet_hash)`);
+            db.run(`CREATE INDEX IF NOT EXISTS idx_upload_logs_timestamp ON upload_logs(timestamp)`);
+        });
     }
 });
 
+// Helper pour insérer un log d'upload
+function logUploadEntry({
+    sessionId = null,
+    walletHash = null,
+    imageFilename = null,
+    jsonFilename = null,
+    fileSize = null,
+    ipAddress = null,
+    userAgent = null,
+    deviceModel = null,
+    deviceOs = null,
+    targetType = null,
+    weapon = null,
+    distanceMeters = null,
+    impactsCount = 0,
+    status = 'SUCCESS',
+    targetValid = 1,
+    targetStatus = 'VALID',
+    targetConfidence = 1.0,
+    targetRingsCount = 0,
+    targetDetails = null,
+    errorMessage = null,
+    rawMetadata = null
+}) {
+    const query = `
+        INSERT INTO upload_logs (
+            session_id, wallet_hash, image_filename, json_filename, file_size,
+            ip_address, user_agent, device_model, device_os, target_type,
+            weapon, distance_meters, impacts_count, status,
+            target_valid, target_status, target_confidence, target_rings_count, target_details,
+            error_message, raw_metadata
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `;
+    db.run(query, [
+        sessionId,
+        walletHash,
+        imageFilename,
+        jsonFilename,
+        fileSize,
+        ipAddress,
+        userAgent,
+        deviceModel,
+        deviceOs,
+        targetType,
+        weapon,
+        distanceMeters,
+        impactsCount,
+        status,
+        targetValid ? 1 : 0,
+        targetStatus,
+        targetConfidence,
+        targetRingsCount,
+        targetDetails,
+        errorMessage,
+        rawMetadata ? JSON.stringify(rawMetadata) : null
+    ], function(err) {
+        if (err) {
+            console.error("Erreur lors de l'insertion dans upload_logs:", err.message);
+        } else {
+            console.log(`[LOG] Upload enregistré (ID: ${this.lastID}) - Statut: ${status} - OpenCV: ${targetStatus}`);
+        }
+    });
+}
+
 // Configuration de multer pour le stockage des fichiers
 const storage = multer.diskStorage({
     destination: function (req, file, cb) {
@@ -81,10 +197,22 @@ app.get('/api/health', (req, res) => {
 
 // Route pour l'upload de photo + données JSON
 // Attend un form-data avec un champ nommé 'photo' et un champ texte 'plotting'
-app.post('/api/upload', upload.single('photo'), (req, res) => {
+app.post('/api/upload', upload.single('photo'), async (req, res) => {
+    const ipAddress = req.headers['x-forwarded-for'] || req.socket.remoteAddress || req.ip || '';
+    const userAgent = req.headers['user-agent'] || '';
+
     try {
         if (!req.file) {
-            return res.status(400).json({ error: 'Aucune photo fournie' });
+            logUploadEntry({
+                ipAddress,
+                userAgent,
+                status: 'FAILED',
+                errorMessage: 'Aucune photo fournie'
+            });
+            return res.status(400).json({
+                code: 'MISSING_PHOTO',
+                error: 'Aucune photo fournie dans la requête'
+            });
         }
         
         let plottingData = {};
@@ -93,10 +221,75 @@ app.post('/api/upload', upload.single('photo'), (req, res) => {
                 plottingData = JSON.parse(req.body.plotting);
             } catch (e) {
                 console.error("Erreur parsing JSON:", e);
-                return res.status(400).json({ error: 'Le champ plotting doit être un JSON valide' });
+                logUploadEntry({
+                    imageFilename: req.file.filename,
+                    fileSize: req.file.size,
+                    ipAddress,
+                    userAgent,
+                    status: 'FAILED',
+                    errorMessage: 'Le champ plotting doit être un JSON valide'
+                });
+                return res.status(400).json({
+                    code: 'INVALID_PLOTTING_JSON',
+                    error: 'Le champ plotting contient un format JSON invalide'
+                });
             }
         }
 
+        const walletHash = plottingData.wallet_hash || null;
+        const sessionId = plottingData.session_id || null;
+
+        // 1. Vérification du bannissement de wallet
+        if (walletHash) {
+            const bannedEntry = await new Promise((resolve) => {
+                db.get('SELECT * FROM banned_wallets WHERE wallet_hash = ?', [walletHash], (err, row) => {
+                    resolve(row || null);
+                });
+            });
+
+            if (bannedEntry) {
+                // Supprimer le fichier image temporaire pour ne pas consommer d'espace
+                if (req.file.path && fs.existsSync(req.file.path)) {
+                    try { fs.unlinkSync(req.file.path); } catch (e) {}
+                }
+                const banReason = bannedEntry.reason || 'Non-respect des règles de contribution / Image non conforme';
+                logUploadEntry({
+                    sessionId,
+                    walletHash,
+                    imageFilename: req.file.filename,
+                    fileSize: req.file.size,
+                    ipAddress,
+                    userAgent,
+                    status: 'FAILED',
+                    errorMessage: `Upload bloqué : wallet banni (${banReason})`
+                });
+                console.warn(`[MODÉRATION] Upload rejeté pour wallet banni: ${walletHash}`);
+                return res.status(403).json({
+                    code: 'WALLET_BANNED',
+                    error: 'Votre participation au programme d\'entraînement IA a été suspendue par la modération.',
+                    reason: banReason,
+                    banned_at: bannedEntry.banned_at
+                });
+            }
+        }
+
+        // 2. Validation de la cible par OpenCV
+        let validation = {
+            isValid: true,
+            status: 'VALID',
+            confidence: 1.0,
+            ringsCount: 0,
+            bestCenter: null,
+            details: 'Analyse non effectuée'
+        };
+
+        try {
+            validation = await TargetValidator.validateTarget(req.file.path);
+            console.log(`[OPENCV] Diagnostic cible pour ${req.file.filename}: ${validation.status} (${Math.round(validation.confidence * 100)}% conf, ${validation.ringsCount} anneaux)`);
+        } catch (cvErr) {
+            console.error("[OPENCV] Erreur analyse cible:", cvErr);
+        }
+
         // Nom de base sans l'extension
         const baseFilename = path.parse(req.file.filename).name;
         const jsonFilename = `${baseFilename}.json`;
@@ -105,8 +298,13 @@ app.post('/api/upload', upload.single('photo'), (req, res) => {
         // Sauvegarde du JSON dans uploads/data/
         fs.writeFileSync(jsonFilePath, JSON.stringify(plottingData, null, 2));
 
+        // Extraction des métadonnées
+        const deviceInfo = plottingData.device_info || {};
+        const targetMeta = plottingData.target_metadata || {};
+        const impacts = plottingData.plotting?.impacts || [];
+        const impactsCount = Array.isArray(impacts) ? impacts.length : 0;
+
         // Mise à jour de la BDD si on a un wallet_hash
-        const walletHash = plottingData.wallet_hash;
         if (walletHash) {
             db.run(`
                 INSERT INTO user_stats (wallet_hash, photo_count, last_upload) 
@@ -123,11 +321,36 @@ app.post('/api/upload', upload.single('photo'), (req, res) => {
             });
         }
 
+        // Enregistrement dans la table des logs d'upload avec diagnostic OpenCV
+        logUploadEntry({
+            sessionId,
+            walletHash,
+            imageFilename: req.file.filename,
+            jsonFilename,
+            fileSize: req.file.size,
+            ipAddress,
+            userAgent,
+            deviceModel: deviceInfo.model || null,
+            deviceOs: deviceInfo.os || null,
+            targetType: targetMeta.type || null,
+            weapon: targetMeta.weapon || null,
+            distanceMeters: targetMeta.distance_meters || null,
+            impactsCount,
+            status: 'SUCCESS',
+            targetValid: validation.isValid ? 1 : 0,
+            targetStatus: validation.status,
+            targetConfidence: validation.confidence,
+            targetRingsCount: validation.ringsCount,
+            targetDetails: validation.details,
+            rawMetadata: plottingData
+        });
+        
         console.log(`Données reçues et sauvegardées:`);
         console.log(`- Image: uploads/images/${req.file.filename}`);
         console.log(`- JSON : uploads/data/${jsonFilename}`);
         
         res.status(200).json({
+            code: 'UPLOAD_SUCCESS',
             message: 'Photo et données uploadées avec succès',
             file: {
                 filename: req.file.filename,
@@ -136,14 +359,254 @@ app.post('/api/upload', upload.single('photo'), (req, res) => {
             },
             data: {
                 filename: jsonFilename
-            }
+            },
+            target_validation: validation
         });
     } catch (error) {
         console.error('Erreur lors de l\'upload:', error);
-        res.status(500).json({ error: 'Erreur interne du serveur lors de l\'upload' });
+        logUploadEntry({
+            imageFilename: req.file ? req.file.filename : null,
+            fileSize: req.file ? req.file.size : null,
+            ipAddress,
+            userAgent,
+            status: 'FAILED',
+            errorMessage: error.message || 'Erreur interne lors de l\'upload'
+        });
+        res.status(500).json({
+            code: 'SERVER_ERROR',
+            error: error.message || 'Erreur interne du serveur lors de l\'upload'
+        });
     }
 });
 
+// Routes de Modération : Gestion des bannissements de wallets
+app.get('/api/moderation/banned', (req, res) => {
+    db.all('SELECT * FROM banned_wallets ORDER BY banned_at DESC', [], (err, rows) => {
+        if (err) {
+            console.error("Erreur lecture wallets bannis:", err);
+            return res.status(500).json({ error: 'Erreur lecture wallets bannis' });
+        }
+        res.json({ banned: rows || [] });
+    });
+});
+
+app.post('/api/moderation/ban', (req, res) => {
+    const { wallet_hash, reason, banned_by } = req.body;
+    if (!wallet_hash) {
+        return res.status(400).json({ error: 'wallet_hash obligatoire' });
+    }
+
+    db.run(
+        `INSERT INTO banned_wallets (wallet_hash, reason, banned_by, banned_at)
+         VALUES (?, ?, ?, CURRENT_TIMESTAMP)
+         ON CONFLICT(wallet_hash) DO UPDATE SET 
+         reason = excluded.reason,
+         banned_at = CURRENT_TIMESTAMP`,
+        [wallet_hash, reason || 'Contenu invalide ou non conforme aux règles', banned_by || 'Admin'],
+        function(err) {
+            if (err) {
+                console.error("Erreur bannissement:", err);
+                return res.status(500).json({ error: 'Erreur lors du bannissement du wallet' });
+            }
+            console.log(`[MODÉRATION] Wallet ${wallet_hash} banni (Motif: ${reason})`);
+            res.json({ message: 'Wallet banni avec succès', wallet_hash });
+        }
+    );
+});
+
+app.delete('/api/moderation/ban/:wallet_hash', (req, res) => {
+    const wallet_hash = req.params.wallet_hash;
+    db.run('DELETE FROM banned_wallets WHERE wallet_hash = ?', [wallet_hash], function(err) {
+        if (err) {
+            console.error("Erreur débannissement:", err);
+            return res.status(500).json({ error: 'Erreur lors du débannissement' });
+        }
+        console.log(`[MODÉRATION] Wallet ${wallet_hash} débanni`);
+        res.json({ message: 'Wallet débanni avec succès', wallet_hash });
+    });
+});
+
+// Route pour relancer l'analyse OpenCV sur une photo déjà existante
+app.post('/api/moderation/verify/:filename', async (req, res) => {
+    const filename = req.params.filename;
+    const imgPath = path.join(imagesDir, filename);
+    if (!fs.existsSync(imgPath)) {
+        return res.status(404).json({ error: 'Image non trouvée' });
+    }
+    try {
+        const result = await TargetValidator.validateTarget(imgPath);
+        res.json({ filename, validation: result });
+    } catch (e) {
+        res.status(500).json({ error: e.message });
+    }
+});
+
+// Route pour lister les logs avec filtres, recherche et pagination
+app.get('/api/logs', (req, res) => {
+    const limit = Math.min(Math.max(parseInt(req.query.limit) || 50, 1), 200);
+    const offset = Math.max(parseInt(req.query.offset) || 0, 0);
+    const wallet = req.query.wallet || req.query.wallet_hash;
+    const status = req.query.status;
+    const search = req.query.search;
+    
+    let whereClauses = [];
+    let params = [];
+    
+    if (wallet) {
+        whereClauses.push("wallet_hash LIKE ?");
+        params.push(`%${wallet}%`);
+    }
+    if (status) {
+        whereClauses.push("status = ?");
+        params.push(status);
+    }
+    if (search) {
+        whereClauses.push("(session_id LIKE ? OR wallet_hash LIKE ? OR device_model LIKE ? OR weapon LIKE ? OR target_type LIKE ? OR image_filename LIKE ?)");
+        const s = `%${search}%`;
+        params.push(s, s, s, s, s, s);
+    }
+    
+    const whereSql = whereClauses.length > 0 ? `WHERE ${whereClauses.join(' AND ')}` : '';
+    
+    db.get(`SELECT COUNT(*) as total FROM upload_logs ${whereSql}`, params, (err, countRow) => {
+        if (err) {
+            console.error("Erreur comptage logs:", err);
+            return res.status(500).json({ error: 'Erreur lors du comptage des logs' });
+        }
+        
+        const total = countRow ? countRow.total : 0;
+        const query = `
+            SELECT * FROM upload_logs 
+            ${whereSql} 
+            ORDER BY timestamp DESC, id DESC 
+            LIMIT ? OFFSET ?
+        `;
+        
+        db.all(query, [...params, limit, offset], (err, rows) => {
+            if (err) {
+                console.error("Erreur lecture logs:", err);
+                return res.status(500).json({ error: 'Erreur lors de la lecture des logs' });
+            }
+            res.json({
+                logs: rows,
+                total,
+                limit,
+                offset
+            });
+        });
+    });
+});
+
+// Route pour les statistiques des logs
+app.get('/api/logs/stats', (req, res) => {
+    const statsQuery = `
+        SELECT 
+            COUNT(*) as total_uploads,
+            SUM(CASE WHEN status = 'SUCCESS' THEN 1 ELSE 0 END) as success_count,
+            SUM(CASE WHEN status = 'FAILED' THEN 1 ELSE 0 END) as failed_count,
+            SUM(CASE WHEN date(timestamp, 'localtime') = date('now', 'localtime') THEN 1 ELSE 0 END) as today_uploads,
+            COUNT(DISTINCT wallet_hash) as unique_wallets,
+            SUM(COALESCE(file_size, 0)) as total_bytes,
+            MAX(timestamp) as latest_upload
+        FROM upload_logs
+    `;
+    
+    db.get(statsQuery, [], (err, stats) => {
+        if (err) {
+            console.error("Erreur stats logs:", err);
+            return res.status(500).json({ error: 'Erreur calcul statistiques' });
+        }
+        res.json({
+            status: 'ok',
+            stats: stats || {
+                total_uploads: 0,
+                success_count: 0,
+                failed_count: 0,
+                today_uploads: 0,
+                unique_wallets: 0,
+                total_bytes: 0,
+                latest_upload: null
+            }
+        });
+    });
+});
+
+// Route pour exporter les logs (CSV ou JSON)
+app.get('/api/logs/export', (req, res) => {
+    const format = req.query.format || 'csv';
+    
+    db.all('SELECT * FROM upload_logs ORDER BY timestamp DESC, id DESC', [], (err, rows) => {
+        if (err) {
+            console.error("Erreur export logs:", err);
+            return res.status(500).json({ error: 'Erreur export logs' });
+        }
+        
+        if (format === 'json') {
+            res.setHeader('Content-Disposition', `attachment; filename=upload_logs_${Date.now()}.json`);
+            res.setHeader('Content-Type', 'application/json');
+            return res.send(JSON.stringify(rows, null, 2));
+        }
+        
+        // CSV Export
+        const headers = [
+            'ID', 'Date/Heure', 'Statut', 'Wallet Hash', 'Session ID',
+            'Image', 'JSON', 'Taille (octets)', 'Cible', 'Arme', 'Distance (m)',
+            'Impacts', 'Modèle Appareil', 'OS', 'IP', 'Erreur'
+        ];
+        
+        const csvLines = [headers.join(';')];
+        
+        rows.forEach(r => {
+            const line = [
+                r.id,
+                `"${r.timestamp || ''}"`,
+                `"${r.status || ''}"`,
+                `"${r.wallet_hash || ''}"`,
+                `"${r.session_id || ''}"`,
+                `"${r.image_filename || ''}"`,
+                `"${r.json_filename || ''}"`,
+                r.file_size || 0,
+                `"${r.target_type || ''}"`,
+                `"${r.weapon || ''}"`,
+                r.distance_meters || '',
+                r.impacts_count || 0,
+                `"${r.device_model || ''}"`,
+                `"${r.device_os || ''}"`,
+                `"${r.ip_address || ''}"`,
+                `"${(r.error_message || '').replace(/"/g, '""')}"`
+            ];
+            csvLines.push(line.join(';'));
+        });
+        
+        res.setHeader('Content-Disposition', `attachment; filename=upload_logs_${Date.now()}.csv`);
+        res.setHeader('Content-Type', 'text/csv; charset=utf-8');
+        res.send('\uFEFF' + csvLines.join('\r\n'));
+    });
+});
+
+// Route pour supprimer un log spécifique
+app.delete('/api/logs/:id', (req, res) => {
+    const id = req.params.id;
+    db.run('DELETE FROM upload_logs WHERE id = ?', [id], function(err) {
+        if (err) {
+            console.error("Erreur suppression log:", err);
+            return res.status(500).json({ error: 'Erreur lors de la suppression' });
+        }
+        res.json({ message: 'Log supprimé avec succès', deletedId: id });
+    });
+});
+
+// Route pour vider les logs
+app.delete('/api/logs', (req, res) => {
+    db.run('DELETE FROM upload_logs', [], function(err) {
+        if (err) {
+            console.error("Erreur vidage logs:", err);
+            return res.status(500).json({ error: 'Erreur lors de la réinitialisation des logs' });
+        }
+        res.json({ message: 'Tous les logs ont été effacés', changes: this.changes });
+    });
+});
+
 // Route pour récupérer toutes les photos disponibles
 app.get('/api/photos', (req, res) => {
     try {
@@ -164,20 +627,42 @@ app.get('/api/photos', (req, res) => {
     }
 });
 
-// Route pour récupérer les statistiques d'un wallet_hash
+// Route pour récupérer les statistiques d'un wallet_hash + statut de modération
 app.get('/api/stats/:wallet_hash', (req, res) => {
     const walletHash = req.params.wallet_hash;
     
-    db.get('SELECT photo_count, last_upload FROM user_stats WHERE wallet_hash = ?', [walletHash], (err, row) => {
+    db.get('SELECT photo_count, last_upload FROM user_stats WHERE wallet_hash = ?', [walletHash], (err, statRow) => {
         if (err) {
             return res.status(500).json({ error: 'Erreur lors de la lecture des statistiques' });
         }
         
-        if (row) {
+        db.get('SELECT reason, banned_at FROM banned_wallets WHERE wallet_hash = ?', [walletHash], (bErr, bannedRow) => {
-            res.json({ status: 'ok', stats: row });
+            const isBanned = !!bannedRow;
-        } else {
+            const stats = statRow || { photo_count: 0, last_upload: null };
-            res.json({ status: 'ok', stats: { photo_count: 0, last_upload: null } });
+            res.json({
+                status: 'ok',
+                stats,
+                is_banned: isBanned,
+                ban_reason: bannedRow ? bannedRow.reason : null,
+                banned_at: bannedRow ? bannedRow.banned_at : null
+            });
+        });
+    });
+});
+
+// Route directe pour vérifier l'état de modération d'un wallet
+app.get('/api/moderation/status/:wallet_hash', (req, res) => {
+    const walletHash = req.params.wallet_hash;
+    db.get('SELECT reason, banned_at FROM banned_wallets WHERE wallet_hash = ?', [walletHash], (err, bannedRow) => {
+        if (err) {
+            return res.status(500).json({ error: 'Erreur lecture statut modération' });
         }
+        res.json({
+            wallet_hash: walletHash,
+            is_banned: !!bannedRow,
+            ban_reason: bannedRow ? bannedRow.reason : null,
+            banned_at: bannedRow ? bannedRow.banned_at : null
+        });
     });
 });
 
@@ -333,10 +818,33 @@ app.use((err, req, res, next) => {
     res.status(500).json({ error: err.message || 'Une erreur inattendue est survenue' });
 });
 
-// Démarrer le serveur
+// Intégration du Dashboard Next.js
+const dashboardDir = path.join(__dirname, 'dashboard');
+const dev = process.env.NODE_ENV !== 'production';
+
+let nextApp;
+try {
+    const next = require('next');
+    nextApp = next({ dev, dir: dashboardDir });
+} catch (e) {
+    console.warn("Module 'next' non disponible, mode API seule.");
+}
+
+async function startServer() {
+    if (nextApp) {
+        try {
+            await nextApp.prepare();
+            const handle = nextApp.getRequestHandler();
+            app.use((req, res) => handle(req, res));
+            console.log("Dashboard Next.js initialisé avec succès.");
+        } catch (err) {
+            console.error("Erreur d'initialisation du Dashboard Next.js:", err);
+        }
+    }
+
     app.listen(PORT, () => {
         console.log(`=================================`);
-    console.log(`Serveur Backend IA démarré`);
+        console.log(`Serveur Backend IA & Dashboard démarré`);
         console.log(`Port: ${PORT}`);
         console.log(`Dossiers:`);
         console.log(` - Images: ${imagesDir}`);
@@ -344,3 +852,6 @@ app.listen(PORT, () => {
         console.log(` - Export: ${exportsDir}`);
         console.log(`=================================`);
     });
+}
+
+startServer();

backendia/services/target_validator.js

@@ -0,0 +1,230 @@
+const cvPromise = require('@techstark/opencv-js');
+const sharp = require('sharp');
+
+let cvInstance = null;
+
+async function getCV() {
+  if (!cvInstance) {
+    cvInstance = await cvPromise;
+  }
+  return cvInstance;
+}
+
+/**
+ * Service de validation OpenCV pour vérifier si une image reçue est bien une cible de tir.
+ */
+class TargetValidator {
+  /**
+   * Analyse une image et renvoie le diagnostic OpenCV
+   * @param {string|Buffer} imageInput - Chemin du fichier ou Buffer de l'image
+   * @returns {Promise<{
+   *   isValid: boolean,
+   *   status: 'VALID' | 'SUSPICIOUS' | 'INVALID',
+   *   confidence: number,
+   *   ringsCount: number,
+   *   bestCenter: { x: number, y: number, radius: number } | null,
+   *   details: string
+   * }>}
+   */
+  static async validateTarget(imageInput) {
+    const cv = await getCV();
+
+    let src = null;
+    let gray = null;
+    let blurred = null;
+    let circles = null;
+
+    try {
+      // 1. Charger et décoder l'image avec Sharp pour obtenir les pixels bruts RGBA
+      const { data, info } = await sharp(imageInput)
+        .ensureAlpha() // 4 canaux RGBA
+        .raw()
+        .toBuffer({ resolveWithObject: true });
+
+      const width = info.width;
+      const height = info.height;
+      const minDim = Math.min(width, height);
+
+      // 2. Créer une Mat OpenCV à partir des pixels RGBA
+      src = new cv.Mat(height, width, cv.CV_8UC4);
+      src.data.set(data);
+
+      // 3. Conversion en niveaux de gris
+      gray = new cv.Mat();
+      cv.cvtColor(src, gray, cv.COLOR_RGBA2GRAY);
+
+      // 4. Flou Gaussien pour réduire le bruit
+      blurred = new cv.Mat();
+      const ksize = new cv.Size(9, 9);
+      cv.GaussianBlur(gray, blurred, ksize, 2, 2, cv.BORDER_DEFAULT);
+
+      // 5. Détection multi-bandes pour capturer tous les anneaux concentriques
+      // (Puisque minDist dans HoughCircles empêche la détection de cercles concentriques sur un seul passage)
+      const detectedCircles = [];
+      const bands = [
+        { min: Math.floor(minDim * 0.04), max: Math.floor(minDim * 0.18), p2: 45 },
+        { min: Math.floor(minDim * 0.18), max: Math.floor(minDim * 0.35), p2: 48 },
+        { min: Math.floor(minDim * 0.35), max: Math.floor(minDim * 0.55), p2: 50 }
+      ];
+
+      circles = new cv.Mat();
+
+      for (const band of bands) {
+        cv.HoughCircles(
+          blurred,
+          circles,
+          cv.HOUGH_GRADIENT,
+          1,
+          Math.max(Math.floor(minDim * 0.05), 10),
+          100,
+          band.p2,
+          band.min,
+          band.max
+        );
+
+        if (circles.cols > 0 && circles.data32F) {
+          for (let i = 0; i < circles.cols; i++) {
+            const x = circles.data32F[i * 3];
+            const y = circles.data32F[i * 3 + 1];
+            const r = circles.data32F[i * 3 + 2];
+            if (!isNaN(x) && !isNaN(y) && !isNaN(r) && r > 0) {
+              detectedCircles.push({ x, y, r });
+            }
+          }
+        }
+      }
+
+      // Si aucun cercle dans les bandes, tentative globale tolérante
+      if (detectedCircles.length === 0) {
+        cv.HoughCircles(
+          blurred,
+          circles,
+          cv.HOUGH_GRADIENT,
+          1,
+          Math.max(Math.floor(minDim * 0.08), 10),
+          100,
+          35,
+          Math.floor(minDim * 0.05),
+          Math.floor(minDim * 0.55)
+        );
+
+        if (circles.cols > 0 && circles.data32F) {
+          for (let i = 0; i < circles.cols; i++) {
+            const x = circles.data32F[i * 3];
+            const y = circles.data32F[i * 3 + 1];
+            const r = circles.data32F[i * 3 + 2];
+            if (!isNaN(x) && !isNaN(y) && !isNaN(r) && r > 0) {
+              detectedCircles.push({ x, y, r });
+            }
+          }
+        }
+      }
+
+      // Si aucun cercle détecté
+      if (detectedCircles.length === 0) {
+        return {
+          isValid: false,
+          status: 'INVALID',
+          confidence: 0.02,
+          ringsCount: 0,
+          bestCenter: null,
+          details: 'Aucun motif circulaire ou cible détecté sur cette photo.'
+        };
+      }
+
+      // 6. Clustering des cercles pour trouver les anneaux concentriques
+      const tolerance = minDim * 0.07; // Tolérance de 7% pour le décalage de centre
+      const clusters = [];
+
+      for (const circle of detectedCircles) {
+        let added = false;
+        for (const cluster of clusters) {
+          // Prendre le centre moyen actuel du cluster
+          const avgClusterX = cluster.reduce((sum, c) => sum + c.x, 0) / cluster.length;
+          const avgClusterY = cluster.reduce((sum, c) => sum + c.y, 0) / cluster.length;
+          const dist = Math.sqrt(Math.pow(circle.x - avgClusterX, 2) + Math.pow(circle.y - avgClusterY, 2));
+
+          if (dist < tolerance) {
+            // Vérifier que le rayon n'est pas un doublon exact (< 10px de différence)
+            const isDuplicate = cluster.some(c => Math.abs(c.r - circle.r) < minDim * 0.03);
+            if (!isDuplicate) {
+              cluster.push(circle);
+            }
+            added = true;
+            break;
+          }
+        }
+        if (!added) {
+          clusters.push([circle]);
+        }
+      }
+
+      // Trier les clusters par nombre de cercles concentriques décroissant
+      clusters.sort((a, b) => b.length - a.length);
+      const bestCluster = clusters[0];
+      const ringsCount = bestCluster.length;
+
+      // Calculer le centre moyen du meilleur cluster
+      const avgX = bestCluster.reduce((acc, c) => acc + c.x, 0) / ringsCount;
+      const avgY = bestCluster.reduce((acc, c) => acc + c.y, 0) / ringsCount;
+      const maxR = Math.max(...bestCluster.map(c => c.r));
+
+      // 7. Évaluation du statut et de la confiance
+      if (ringsCount >= 3) {
+        return {
+          isValid: true,
+          status: 'VALID',
+          confidence: Math.min(0.92 + (ringsCount - 3) * 0.02, 0.99),
+          ringsCount,
+          bestCenter: { x: avgX, y: avgY, radius: maxR },
+          details: `Cible certifiée : ${ringsCount} anneaux concentriques identifiés.`
+        };
+      } else if (ringsCount === 2) {
+        return {
+          isValid: true,
+          status: 'VALID',
+          confidence: 0.85,
+          ringsCount,
+          bestCenter: { x: avgX, y: avgY, radius: maxR },
+          details: `Cible confirmée : ${ringsCount} anneaux concentriques détectés.`
+        };
+      } else if (ringsCount === 1) {
+        return {
+          isValid: true,
+          status: 'SUSPICIOUS',
+          confidence: 0.50,
+          ringsCount: 1,
+          bestCenter: { x: avgX, y: avgY, radius: maxR },
+          details: 'Un seul anneau détecté, confirmation visuelle recommandée.'
+        };
+      } else {
+        return {
+          isValid: false,
+          status: 'INVALID',
+          confidence: 0.1,
+          ringsCount: 0,
+          bestCenter: null,
+          details: 'Motif de cible non conforme.'
+        };
+      }
+    } catch (error) {
+      console.error('Erreur TargetValidator OpenCV:', error);
+      return {
+        isValid: false,
+        status: 'INVALID',
+        confidence: 0.0,
+        ringsCount: 0,
+        bestCenter: null,
+        details: `Erreur d'analyse OpenCV: ${error.message}`
+      };
+    } finally {
+      // 8. Nettoyage mémoire
+      if (src && !src.isDeleted()) src.delete();
+      if (gray && !gray.isDeleted()) gray.delete();
+      if (blurred && !blurred.isDeleted()) blurred.delete();
+      if (circles && !circles.isDeleted()) circles.delete();
+    }
+  }
+}
+
+module.exports = TargetValidator;

docker-compose.prod.yml

@@ -0,0 +1,21 @@
+name: backendia
+
+services:
+  backendia:
+    build:
+      context: ./backendia
+      dockerfile: Dockerfile
+    container_name: backendia-prod
+    restart: unless-stopped
+    ports:
+      - "3005:3000"
+    environment:
+      - NODE_ENV=production
+      - PORT=3000
+    volumes:
+      - backendia_uploads:/app/uploads
+      - backendia_exports:/app/exports
+
+volumes:
+  backendia_uploads:
+  backendia_exports:

lib/app.dart

@@ -1,7 +1,6 @@
 import 'package:flutter/material.dart';
 import 'package:provider/provider.dart';
 import 'core/theme/theme_provider.dart';
-import 'core/theme/app_theme.dart';
 import 'main_navigation_holder.dart';
 import 'package:flutter_localizations/flutter_localizations.dart';
 
@@ -15,8 +14,8 @@ class BullyApp extends StatelessWidget {
         return MaterialApp(
           title: 'Bully - Analyse de Cibles',
           debugShowCheckedModeBanner: false,
-          theme: AppTheme.lightTheme,
+          theme: themeProvider.lightTheme,
-          darkTheme: AppTheme.darkTheme,
+          darkTheme: themeProvider.darkTheme,
           themeMode: themeProvider.themeMode,
           localizationsDelegates: const [
             GlobalMaterialLocalizations.delegate,
@@ -27,7 +26,7 @@ class BullyApp extends StatelessWidget {
             Locale('fr', 'FR'), // Français
           ],
           locale: const Locale('fr', 'FR'), // Force l'interface en français
-          home: const MainNavigationHolder(),
+          home: MainNavigationHolder(key: mainNavKey),
         );
       },
     );

lib/core/theme/app_theme.dart

@@ -1,90 +1,425 @@
 import 'package:flutter/material.dart';
 
+/// Définition des couleurs d'accent disponibles pour la personnalisation.
+class AppAccentColor {
+  final String id;
+  final String name;
+  final Color color;
+  final Color lightColor;
+  final Color darkColor;
+  final IconData icon;
+
+  const AppAccentColor({
+    required this.id,
+    required this.name,
+    required this.color,
+    required this.lightColor,
+    required this.darkColor,
+    required this.icon,
+  });
+
+  static const AppAccentColor blue = AppAccentColor(
+    id: 'blue',
+    name: 'Bleu Cobalt',
+    color: Color(0xFF2563EB),
+    lightColor: Color(0xFF60A5FA),
+    darkColor: Color(0xFF1D4ED8),
+    icon: Icons.lens,
+  );
+
+  static const AppAccentColor red = AppAccentColor(
+    id: 'red',
+    name: 'Rouge Cible',
+    color: Color(0xFFDC2626),
+    lightColor: Color(0xFFF87171),
+    darkColor: Color(0xFFB91C1C),
+    icon: Icons.lens,
+  );
+
+  static const AppAccentColor green = AppAccentColor(
+    id: 'green',
+    name: 'Vert Viseur',
+    color: Color(0xFF10B981),
+    lightColor: Color(0xFF34D399),
+    darkColor: Color(0xFF059669),
+    icon: Icons.lens,
+  );
+
+  static const AppAccentColor orange = AppAccentColor(
+    id: 'orange',
+    name: 'Orange Ambre',
+    color: Color(0xFFFF6D00),
+    lightColor: Color(0xFFFF9E40),
+    darkColor: Color(0xFFD84315),
+    icon: Icons.lens,
+  );
+
+  static const AppAccentColor purple = AppAccentColor(
+    id: 'purple',
+    name: 'Violet Cyber',
+    color: Color(0xFF8B5CF6),
+    lightColor: Color(0xFFA78BFA),
+    darkColor: Color(0xFF6D28D9),
+    icon: Icons.lens,
+  );
+
+  static const AppAccentColor cyan = AppAccentColor(
+    id: 'cyan',
+    name: 'Cyan Néon',
+    color: Color(0xFF06B6D4),
+    lightColor: Color(0xFF67E8F9),
+    darkColor: Color(0xFF0E7490),
+    icon: Icons.lens,
+  );
+
+  static const AppAccentColor gold = AppAccentColor(
+    id: 'gold',
+    name: 'Or Compétition',
+    color: Color(0xFFF59E0B),
+    lightColor: Color(0xFFFBBF24),
+    darkColor: Color(0xFFD97706),
+    icon: Icons.lens,
+  );
+
+  static const List<AppAccentColor> allAccents = [
+    blue,
+    red,
+    green,
+    orange,
+    purple,
+    cyan,
+    gold,
+  ];
+
+  static AppAccentColor fromId(String? id) {
+    return allAccents.firstWhere(
+      (a) => a.id == id,
+      orElse: () => blue,
+    );
+  }
+}
+
+/// Système de design et thème de l'application Bully.
 class AppTheme {
   AppTheme._();
 
-  static const Color primaryColor = Color(0xFF1E88E5);
+  // Accents par défaut (compatibilité statique)
-  static const Color secondaryColor = Color(0xFF43A047);
+  static const Color primaryColor = Color(0xFF2563EB);
-  static const Color errorColor = Color(0xFFE53935);
+  static const Color primaryLight = Color(0xFF60A5FA);
-  static const Color warningColor = Color(0xFFFFA726);
+  static const Color primaryDark = Color(0xFF1D4ED8);
-  static const Color successColor = Color(0xFF66BB6A);
 
-  static const Color backgroundColor = Color(0xFFF5F5F5);
+  static const Color secondaryColor = Color(0xFF10B981);
-  static const Color surfaceColor = Colors.white;
+  static const Color secondaryDark = Color(0xFF059669);
-  static const Color textPrimary = Color(0xFF212121);
-  static const Color textSecondary = Color(0xFF757575);
 
-  // Impact colors for visualization
+  static const Color accentBlue = Color(0xFF0EA5E9);
-  static const Color impactColor = Color(0xFFFF5722);
+  static const Color accentGold = Color(0xFFFFB300);
+
+  static const Color errorColor = Color(0xFFEF4444);
+  static const Color warningColor = Color(0xFFF59E0B);
+  static const Color successColor = Color(0xFF10B981);
+
+  // Palette Thème Sombre (Standard Stand de Tir)
+  static const Color darkBackground = Color(0xFF0D1219);
+  static const Color darkSurface = Color(0xFF161E28);
+  static const Color darkSurfaceElevated = Color(0xFF1E2836);
+  static const Color darkSurfaceVariant = Color(0xFF253243);
+  static const Color darkBorder = Color(0xFF2C3B4E);
+  static const Color darkBorderLight = Color(0xFF3B4D65);
+  static const Color darkTextPrimary = Color(0xFFF1F5F9);
+  static const Color darkTextSecondary = Color(0xFF94A3B8);
+  static const Color darkTextMuted = Color(0xFF64748B);
+
+  // Palette Thème Clair
+  static const Color lightBackground = Color(0xFFF8FAFC);
+  static const Color lightSurface = Color(0xFFFFFFFF);
+  static const Color lightSurfaceElevated = Color(0xFFFFFFFF);
+  static const Color lightSurfaceVariant = Color(0xFFF1F5F9);
+  static const Color lightBorder = Color(0xFFE2E8F0);
+  static const Color lightTextPrimary = Color(0xFF0F172A);
+  static const Color lightTextSecondary = Color(0xFF64748B);
+  static const Color lightTextMuted = Color(0xFF94A3B8);
+
+  // Compatibilité ascendante
+  static const Color backgroundColor = lightBackground;
+  static const Color surfaceColor = lightSurface;
+  static const Color textPrimary = lightTextPrimary;
+  static const Color textSecondary = lightTextSecondary;
+
+  // Couleurs des impacts pour l'overlay
+  static const Color impactColor = Color(0xFFFF3D00);
   static const Color impactOutlineColor = Color(0xFFFFFFFF);
-  static const Color groupingCenterColor = Color(0xFF2196F3);
+  static const Color groupingCenterColor = Color(0xFF00E5FF);
-  static const Color groupingCircleColor = Color(0x4D2196F3);
+  static const Color groupingCircleColor = Color(0x4D00E5FF);
 
-  // Score zone colors
+  // Couleurs des zones de score cibles concentriques
   static const List<Color> zoneColors = [
-    Color(0xFFFFEB3B), // Zone 10 - Gold
+    Color(0xFFFFB300), // Zone 10 - Or
-    Color(0xFFFFEB3B), // Zone 9
+    Color(0xFFFFCA28), // Zone 9
     Color(0xFFFF5722), // Zone 8
-    Color(0xFFFF5722), // Zone 7
+    Color(0xFFFF7043), // Zone 7
-    Color(0xFF2196F3), // Zone 6
+    Color(0xFF29B6F6), // Zone 6
-    Color(0xFF2196F3), // Zone 5
+    Color(0xFF4FC3F7), // Zone 5
-    Color(0xFF4CAF50), // Zone 4
+    Color(0xFF66BB6A), // Zone 4
-    Color(0xFF4CAF50), // Zone 3
+    Color(0xFF81C784), // Zone 3
     Color(0xFFFFFFFF), // Zone 2
-    Color(0xFFFFFFFF), // Zone 1
+    Color(0xFFE0E0E0), // Zone 1
   ];
 
-  static ThemeData get lightTheme {
+  static ThemeData get lightTheme => buildLightTheme(AppAccentColor.blue);
+  static ThemeData get darkTheme => buildDarkTheme(AppAccentColor.blue);
+
+  static ThemeData buildLightTheme(AppAccentColor accent) {
+    final activePrimary = accent.color;
+
     return ThemeData(
       useMaterial3: true,
-      colorScheme: ColorScheme.fromSeed(
-        seedColor: primaryColor,
       brightness: Brightness.light,
+      colorScheme: ColorScheme.light(
+        primary: activePrimary,
+        secondary: secondaryColor,
+        surface: lightSurface,
+        error: errorColor,
+        onPrimary: Colors.white,
+        onSecondary: Colors.white,
+        onSurface: lightTextPrimary,
+        onError: Colors.white,
+        outline: lightBorder,
       ),
-      scaffoldBackgroundColor: backgroundColor,
+      scaffoldBackgroundColor: lightBackground,
+      cardColor: lightSurface,
       appBarTheme: const AppBarTheme(
         elevation: 0,
         centerTitle: true,
-        backgroundColor: primaryColor,
+        backgroundColor: lightSurface,
-        foregroundColor: Colors.white,
+        foregroundColor: lightTextPrimary,
+        surfaceTintColor: Colors.transparent,
+        titleTextStyle: TextStyle(
+          fontSize: 18,
+          fontWeight: FontWeight.w700,
+          color: lightTextPrimary,
+          letterSpacing: 0.3,
+        ),
       ),
       cardTheme: CardThemeData(
-        elevation: 2,
+        elevation: 0,
+        color: lightSurface,
+        surfaceTintColor: Colors.transparent,
+        margin: EdgeInsets.zero,
         shape: RoundedRectangleBorder(
-          borderRadius: BorderRadius.circular(12),
+          borderRadius: BorderRadius.circular(16),
+          side: const BorderSide(color: lightBorder, width: 1),
         ),
       ),
       elevatedButtonTheme: ElevatedButtonThemeData(
         style: ElevatedButton.styleFrom(
-          padding: const EdgeInsets.symmetric(horizontal: 24, vertical: 12),
+          elevation: 0,
-          shape: RoundedRectangleBorder(
+          backgroundColor: activePrimary,
-            borderRadius: BorderRadius.circular(8),
-          ),
-        ),
-      ),
-      floatingActionButtonTheme: const FloatingActionButtonThemeData(
-        backgroundColor: primaryColor,
           foregroundColor: Colors.white,
+          minimumSize: const Size(double.infinity, 50),
+          padding: const EdgeInsets.symmetric(horizontal: 20, vertical: 14),
+          shape: RoundedRectangleBorder(
+            borderRadius: BorderRadius.circular(12),
+          ),
+          textStyle: const TextStyle(
+            fontSize: 15,
+            fontWeight: FontWeight.w600,
+            letterSpacing: 0.2,
+          ),
+        ),
+      ),
+      outlinedButtonTheme: OutlinedButtonThemeData(
+        style: OutlinedButton.styleFrom(
+          foregroundColor: lightTextPrimary,
+          minimumSize: const Size(double.infinity, 50),
+          padding: const EdgeInsets.symmetric(horizontal: 20, vertical: 14),
+          side: const BorderSide(color: lightBorder, width: 1.5),
+          shape: RoundedRectangleBorder(
+            borderRadius: BorderRadius.circular(12),
+          ),
+          textStyle: const TextStyle(
+            fontSize: 15,
+            fontWeight: FontWeight.w600,
+          ),
+        ),
+      ),
+      chipTheme: ChipThemeData(
+        backgroundColor: lightSurfaceVariant,
+        selectedColor: activePrimary.withValues(alpha: 0.15),
+        labelStyle: const TextStyle(
+          fontSize: 13,
+          fontWeight: FontWeight.w500,
+          color: lightTextPrimary,
+        ),
+        secondaryLabelStyle: TextStyle(
+          fontSize: 13,
+          fontWeight: FontWeight.w600,
+          color: activePrimary,
+        ),
+        side: const BorderSide(color: lightBorder, width: 1),
+        shape: RoundedRectangleBorder(
+          borderRadius: BorderRadius.circular(10),
+        ),
+        padding: const EdgeInsets.symmetric(horizontal: 10, vertical: 6),
+      ),
+      inputDecorationTheme: InputDecorationTheme(
+        filled: true,
+        fillColor: lightSurfaceVariant,
+        contentPadding: const EdgeInsets.symmetric(horizontal: 16, vertical: 14),
+        border: OutlineInputBorder(
+          borderRadius: BorderRadius.circular(12),
+          borderSide: const BorderSide(color: lightBorder),
+        ),
+        enabledBorder: OutlineInputBorder(
+          borderRadius: BorderRadius.circular(12),
+          borderSide: const BorderSide(color: lightBorder),
+        ),
+        focusedBorder: OutlineInputBorder(
+          borderRadius: BorderRadius.circular(12),
+          borderSide: BorderSide(color: activePrimary, width: 1.8),
+        ),
+        labelStyle: const TextStyle(color: lightTextSecondary),
+        hintStyle: const TextStyle(color: lightTextMuted),
+      ),
+      dividerTheme: const DividerThemeData(
+        color: lightBorder,
+        thickness: 1,
+        space: 24,
+      ),
+      floatingActionButtonTheme: FloatingActionButtonThemeData(
+        backgroundColor: activePrimary,
+        foregroundColor: Colors.white,
+        elevation: 3,
+        shape: const RoundedRectangleBorder(
+          borderRadius: BorderRadius.all(Radius.circular(16)),
+        ),
       ),
     );
   }
 
-  static ThemeData get darkTheme {
+  static ThemeData buildDarkTheme(AppAccentColor accent) {
+    final activePrimary = accent.color;
+
     return ThemeData(
       useMaterial3: true,
-      colorScheme: ColorScheme.fromSeed(
-        seedColor: primaryColor,
       brightness: Brightness.dark,
+      colorScheme: ColorScheme.dark(
+        primary: activePrimary,
+        secondary: secondaryColor,
+        surface: darkSurface,
+        error: errorColor,
+        onPrimary: Colors.white,
+        onSecondary: Colors.white,
+        onSurface: darkTextPrimary,
+        onError: Colors.white,
+        outline: darkBorder,
       ),
+      scaffoldBackgroundColor: darkBackground,
+      cardColor: darkSurface,
       appBarTheme: const AppBarTheme(
         elevation: 0,
         centerTitle: true,
+        backgroundColor: darkBackground,
+        foregroundColor: darkTextPrimary,
+        surfaceTintColor: Colors.transparent,
+        titleTextStyle: TextStyle(
+          fontSize: 18,
+          fontWeight: FontWeight.w700,
+          color: darkTextPrimary,
+          letterSpacing: 0.3,
+        ),
       ),
       cardTheme: CardThemeData(
-        elevation: 2,
+        elevation: 0,
+        color: darkSurface,
+        surfaceTintColor: Colors.transparent,
+        margin: EdgeInsets.zero,
+        shape: RoundedRectangleBorder(
+          borderRadius: BorderRadius.circular(16),
+          side: const BorderSide(color: darkBorder, width: 1),
+        ),
+      ),
+      elevatedButtonTheme: ElevatedButtonThemeData(
+        style: ElevatedButton.styleFrom(
+          elevation: 0,
+          backgroundColor: activePrimary,
+          foregroundColor: Colors.white,
+          minimumSize: const Size(double.infinity, 50),
+          padding: const EdgeInsets.symmetric(horizontal: 20, vertical: 14),
           shape: RoundedRectangleBorder(
             borderRadius: BorderRadius.circular(12),
           ),
+          textStyle: const TextStyle(
+            fontSize: 15,
+            fontWeight: FontWeight.w600,
+            letterSpacing: 0.2,
+          ),
+        ),
+      ),
+      outlinedButtonTheme: OutlinedButtonThemeData(
+        style: OutlinedButton.styleFrom(
+          foregroundColor: darkTextPrimary,
+          minimumSize: const Size(double.infinity, 50),
+          padding: const EdgeInsets.symmetric(horizontal: 20, vertical: 14),
+          side: const BorderSide(color: darkBorder, width: 1.5),
+          shape: RoundedRectangleBorder(
+            borderRadius: BorderRadius.circular(12),
+          ),
+          textStyle: const TextStyle(
+            fontSize: 15,
+            fontWeight: FontWeight.w600,
+          ),
+        ),
+      ),
+      chipTheme: ChipThemeData(
+        backgroundColor: darkSurfaceElevated,
+        selectedColor: activePrimary.withValues(alpha: 0.2),
+        labelStyle: const TextStyle(
+          fontSize: 13,
+          fontWeight: FontWeight.w500,
+          color: darkTextPrimary,
+        ),
+        secondaryLabelStyle: TextStyle(
+          fontSize: 13,
+          fontWeight: FontWeight.w600,
+          color: activePrimary,
+        ),
+        side: const BorderSide(color: darkBorder, width: 1),
+        shape: RoundedRectangleBorder(
+          borderRadius: BorderRadius.circular(10),
+        ),
+        padding: const EdgeInsets.symmetric(horizontal: 10, vertical: 6),
+      ),
+      inputDecorationTheme: InputDecorationTheme(
+        filled: true,
+        fillColor: darkSurfaceElevated,
+        contentPadding: const EdgeInsets.symmetric(horizontal: 16, vertical: 14),
+        border: OutlineInputBorder(
+          borderRadius: BorderRadius.circular(12),
+          borderSide: const BorderSide(color: darkBorder),
+        ),
+        enabledBorder: OutlineInputBorder(
+          borderRadius: BorderRadius.circular(12),
+          borderSide: const BorderSide(color: darkBorder),
+        ),
+        focusedBorder: OutlineInputBorder(
+          borderRadius: BorderRadius.circular(12),
+          borderSide: BorderSide(color: activePrimary, width: 1.8),
+        ),
+        labelStyle: const TextStyle(color: darkTextSecondary),
+        hintStyle: const TextStyle(color: darkTextMuted),
+      ),
+      dividerTheme: const DividerThemeData(
+        color: darkBorder,
+        thickness: 1,
+        space: 24,
+      ),
+      floatingActionButtonTheme: FloatingActionButtonThemeData(
+        backgroundColor: activePrimary,
+        foregroundColor: Colors.white,
+        elevation: 3,
+        shape: const RoundedRectangleBorder(
+          borderRadius: BorderRadius.all(Radius.circular(16)),
+        ),
       ),
     );
   }

lib/core/theme/theme_provider.dart

@@ -1,24 +1,37 @@
 import 'package:flutter/material.dart';
 import 'package:shared_preferences/shared_preferences.dart';
+import 'app_theme.dart';
 
 class ThemeProvider with ChangeNotifier {
   static const String _themeModeKey = 'user_theme_mode';
+  static const String _accentKey = 'user_accent_color';
 
   ThemeMode _themeMode = ThemeMode.system;
+  AppAccentColor _accent = AppAccentColor.blue;
 
   ThemeMode get themeMode => _themeMode;
+  AppAccentColor get currentAccent => _accent;
+  Color get primaryColor => _accent.color;
+
+  ThemeData get lightTheme => AppTheme.buildLightTheme(_accent);
+  ThemeData get darkTheme => AppTheme.buildDarkTheme(_accent);
 
   ThemeProvider() {
-    loadThemeMode();
+    loadSettings();
   }
 
-  Future<void> loadThemeMode() async {
+  Future<void> loadSettings() async {
     final prefs = await SharedPreferences.getInstance();
     final modeIndex = prefs.getInt(_themeModeKey);
+    final accentId = prefs.getString(_accentKey);
+
     if (modeIndex != null) {
       _themeMode = ThemeMode.values[modeIndex];
-      notifyListeners();
     }
+    if (accentId != null) {
+      _accent = AppAccentColor.fromId(accentId);
+    }
+    notifyListeners();
   }
 
   Future<void> setThemeMode(ThemeMode mode) async {
@@ -31,6 +44,16 @@ class ThemeProvider with ChangeNotifier {
     await prefs.setInt(_themeModeKey, mode.index);
   }
 
+  Future<void> setAccent(AppAccentColor accent) async {
+    if (_accent.id == accent.id) return;
+
+    _accent = accent;
+    notifyListeners();
+
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setString(_accentKey, accent.id);
+  }
+
   String get themeModeName {
     switch (_themeMode) {
       case ThemeMode.system:

lib/core/widgets/glass_container.dart

@@ -0,0 +1,109 @@
+import 'dart:ui';
+import 'package:flutter/material.dart';
+import '../theme/app_theme.dart';
+
+/// Conteneur avec effet de verre givré (Glassmorphism),
+/// bordures translucides fines et reflets subtils pour casser l'aspect standard Flutter.
+class GlassContainer extends StatelessWidget {
+  final Widget child;
+  final double borderRadius;
+  final double blur;
+  final EdgeInsetsGeometry padding;
+  final EdgeInsetsGeometry margin;
+  final Color? customBackgroundColor;
+  final Color? borderColor;
+  final Color? glowColor;
+  final VoidCallback? onTap;
+  final VoidCallback? onLongPress;
+
+  const GlassContainer({
+    super.key,
+    required this.child,
+    this.borderRadius = 18.0,
+    this.blur = 12.0,
+    this.padding = const EdgeInsets.all(16.0),
+    this.margin = EdgeInsets.zero,
+    this.customBackgroundColor,
+    this.borderColor,
+    this.glowColor,
+    this.onTap,
+    this.onLongPress,
+  });
+
+  @override
+  Widget build(BuildContext context) {
+    final isDark = Theme.of(context).brightness == Brightness.dark;
+
+    final defaultBg = isDark
+        ? const Color(0xFF141C26).withValues(alpha: 0.72)
+        : Colors.white.withValues(alpha: 0.82);
+
+    final defaultBorder = isDark
+        ? Colors.white.withValues(alpha: 0.12)
+        : Colors.black.withValues(alpha: 0.08);
+
+    final resolvedBorderColor = borderColor ?? defaultBorder;
+    final resolvedBg = customBackgroundColor ?? defaultBg;
+
+    Widget content = Container(
+      padding: padding,
+      decoration: BoxDecoration(
+        color: resolvedBg,
+        borderRadius: BorderRadius.circular(borderRadius),
+        border: Border.all(color: resolvedBorderColor, width: 1.2),
+        boxShadow: [
+          if (glowColor != null)
+            BoxShadow(
+              color: glowColor!.withValues(alpha: isDark ? 0.25 : 0.15),
+              blurRadius: 18,
+              spreadRadius: -2,
+              offset: const Offset(0, 4),
+            )
+          else
+            BoxShadow(
+              color: Colors.black.withValues(alpha: isDark ? 0.28 : 0.04),
+              blurRadius: 16,
+              offset: const Offset(0, 6),
+            ),
+        ],
+      ),
+      child: child,
+    );
+
+    if (blur > 0) {
+      content = ClipRRect(
+        borderRadius: BorderRadius.circular(borderRadius),
+        child: BackdropFilter(
+          filter: ImageFilter.blur(sigmaX: blur, sigmaY: blur),
+          child: content,
+        ),
+      );
+    } else {
+      content = ClipRRect(
+        borderRadius: BorderRadius.circular(borderRadius),
+        child: content,
+      );
+    }
+
+    if (margin != EdgeInsets.zero) {
+      content = Padding(padding: margin, child: content);
+    }
+
+    if (onTap != null || onLongPress != null) {
+      return Material(
+        color: Colors.transparent,
+        borderRadius: BorderRadius.circular(borderRadius),
+        child: InkWell(
+          borderRadius: BorderRadius.circular(borderRadius),
+          onTap: onTap,
+          onLongPress: onLongPress,
+          splashColor: (glowColor ?? AppTheme.primaryColor).withValues(alpha: 0.15),
+          highlightColor: (glowColor ?? AppTheme.primaryColor).withValues(alpha: 0.08),
+          child: content,
+        ),
+      );
+    }
+
+    return content;
+  }
+}

lib/core/widgets/weapon_type_icon.dart

@@ -0,0 +1,335 @@
+import 'package:flutter/material.dart';
+import '../../data/models/weapon.dart';
+
+/// Widget affichant une icône vectorielle stylisée et fidèle pour chaque type d'arme.
+class WeaponTypeIcon extends StatelessWidget {
+  final WeaponType type;
+  final Color? color;
+  final double size;
+
+  const WeaponTypeIcon({
+    super.key,
+    required this.type,
+    this.color,
+    this.size = 24,
+  });
+
+  @override
+  Widget build(BuildContext context) {
+    final effectiveColor = color ?? Theme.of(context).colorScheme.primary;
+
+    return CustomPaint(
+      size: Size(size, size),
+      painter: _WeaponTypePainter(
+        type: type,
+        color: effectiveColor,
+      ),
+    );
+  }
+}
+
+class _WeaponTypePainter extends CustomPainter {
+  final WeaponType type;
+  final Color color;
+
+  _WeaponTypePainter({
+    required this.type,
+    required this.color,
+  });
+
+  @override
+  void paint(Canvas canvas, Size size) {
+    final fillPaint = Paint()
+      ..color = color
+      ..style = PaintingStyle.fill
+      ..isAntiAlias = true;
+
+    final strokePaint = Paint()
+      ..color = color
+      ..style = PaintingStyle.stroke
+      ..strokeWidth = 1.0
+      ..strokeCap = StrokeCap.round
+      ..strokeJoin = StrokeJoin.round
+      ..isAntiAlias = true;
+
+    canvas.save();
+    // Normalisation sur une grille 32x32 pour un rendu très précis
+    final scale = size.width / 32.0;
+    canvas.scale(scale, scale);
+
+    switch (type) {
+      case WeaponType.handgun:
+        _drawGlock(canvas, fillPaint, strokePaint);
+        break;
+      case WeaponType.rifle:
+        _drawKalashnikov(canvas, fillPaint, strokePaint);
+        break;
+      case WeaponType.shotgun:
+        _drawPumpShotgun(canvas, fillPaint, strokePaint);
+        break;
+      case WeaponType.airgun:
+        _drawAirgun(canvas, fillPaint, strokePaint);
+        break;
+    }
+
+    canvas.restore();
+  }
+
+  /// Silhouette fidèle d'un Glock : culasse carrée "boxy", pontet angulaire et poignée ergonomique
+  void _drawGlock(Canvas canvas, Paint fillPaint, Paint strokePaint) {
+    // 1. Culasse rectangulaire Glock (Slide)
+    final slidePath = Path();
+    slidePath.moveTo(4, 9);
+    slidePath.lineTo(26.5, 9); // dessus de culasse
+    slidePath.lineTo(27.5, 10); // chanfrein nez avant
+    slidePath.lineTo(27.5, 14.5); // bouche du canon
+    slidePath.lineTo(4, 14.5); // bas de culasse
+    slidePath.lineTo(3.5, 13); // chanfrein arrière
+    slidePath.lineTo(3.5, 10);
+    slidePath.close();
+    canvas.drawPath(slidePath, fillPaint);
+
+    // Organes de visée Glock
+    // Cran de mire arrière carré
+    canvas.drawRect(const Rect.fromLTWH(5, 7.2, 2.5, 1.8), fillPaint);
+    // Guidon avant
+    canvas.drawRect(const Rect.fromLTWH(24.5, 7.2, 1.8, 1.8), fillPaint);
+
+    // 2. Carcasse inférieure & Poignée (Frame & Grip)
+    final framePath = Path();
+    framePath.moveTo(4, 14.5);
+    framePath.lineTo(26, 14.5); // rail picatinny avant
+    framePath.lineTo(25.5, 16.5);
+    framePath.lineTo(17.5, 16.5); // bas du rail avant pontet
+    framePath.lineTo(17.5, 19.5); // face avant du pontet carré Glock
+    framePath.lineTo(12.5, 20.5); // bas du pontet
+    framePath.lineTo(12, 17.5); // jonction détente / poignée avant
+    framePath.lineTo(9.5, 27); // poignée avant avec empreinte
+    framePath.lineTo(4.5, 27); // talon de chargeur / magwell
+    framePath.lineTo(8, 16.5); // dos de poignée / beavertail Glock
+    framePath.lineTo(4, 15.5);
+    framePath.close();
+    canvas.drawPath(framePath, fillPaint);
+
+    // 3. Queue de détente Safe Action
+    final triggerPath = Path();
+    triggerPath.moveTo(15.5, 15.5);
+    triggerPath.quadraticBezierTo(14, 17.5, 15.2, 19);
+    canvas.drawPath(triggerPath, strokePaint..strokeWidth = 1.3);
+
+    // 4. Stries de préhension arrière (Serrations)
+    for (double i = 6; i <= 10; i += 1.5) {
+      canvas.drawLine(
+        Offset(i, 10),
+        Offset(i, 13.5),
+        Paint()
+          ..color = Colors.black.withValues(alpha: 0.35)
+          ..strokeWidth = 0.8,
+      );
+    }
+  }
+
+  /// Silhouette fidèle d'une Kalashnikov (AK-47 / AKM) : chargeur banane, emprunt de gaz et guidon haut
+  void _drawKalashnikov(Canvas canvas, Paint fillPaint, Paint strokePaint) {
+    // 1. Crosse arrière en bois / épaule
+    final stockPath = Path();
+    stockPath.moveTo(1.5, 13);
+    stockPath.lineTo(8, 14.5);
+    stockPath.lineTo(8, 18);
+    stockPath.lineTo(1.5, 20.5);
+    stockPath.close();
+    canvas.drawPath(stockPath, fillPaint);
+
+    // 2. Boîtier de culasse (Receiver) & Capot supérieur
+    final receiverPath = Path();
+    receiverPath.moveTo(8, 13.5);
+    receiverPath.lineTo(17, 13.5);
+    receiverPath.lineTo(17, 18);
+    receiverPath.lineTo(8, 18);
+    receiverPath.close();
+    canvas.drawPath(receiverPath, fillPaint);
+
+    // 3. Garde-main & Tube d'emprunt de gaz supérieur
+    final handguardPath = Path();
+    handguardPath.moveTo(17, 13.5);
+    handguardPath.lineTo(24, 13.5);
+    handguardPath.lineTo(24, 17);
+    handguardPath.lineTo(17, 17);
+    handguardPath.close();
+    canvas.drawPath(handguardPath, fillPaint);
+
+    // 4. Canon fin avant & Bloc guidon Kalash
+    final barrelPath = Path();
+    barrelPath.moveTo(24, 14.5);
+    barrelPath.lineTo(30.5, 14.5);
+    barrelPath.lineTo(30.5, 16);
+    barrelPath.lineTo(24, 16);
+    barrelPath.close();
+    canvas.drawPath(barrelPath, fillPaint);
+
+    // Bloc guidon triangulaire surélevé avant
+    final frontSightPath = Path();
+    frontSightPath.moveTo(28, 14.5);
+    frontSightPath.lineTo(29, 11);
+    frontSightPath.lineTo(30, 14.5);
+    frontSightPath.close();
+    canvas.drawPath(frontSightPath, fillPaint);
+
+    // Hausse arrière au dessus du boîtier
+    canvas.drawRect(const Rect.fromLTWH(16.5, 12, 2, 1.5), fillPaint);
+
+    // 5. Chargeur courbé "banane" emblématique (30 coups)
+    final magPath = Path();
+    magPath.moveTo(14, 18);
+    magPath.lineTo(16.5, 18);
+    magPath.quadraticBezierTo(17.5, 22.5, 15, 26);
+    magPath.lineTo(12, 25.5);
+    magPath.quadraticBezierTo(14, 22, 13.5, 18);
+    magPath.close();
+    canvas.drawPath(magPath, fillPaint);
+
+    // 6. Poignée pistolet séparée
+    final gripPath = Path();
+    gripPath.moveTo(8.5, 18);
+    gripPath.lineTo(10.5, 18);
+    gripPath.lineTo(9.5, 23.5);
+    gripPath.lineTo(7.5, 23);
+    gripPath.close();
+    canvas.drawPath(gripPath, fillPaint);
+
+    // 7. Pontet et détente
+    final triggerGuard = Path();
+    triggerGuard.moveTo(11, 18);
+    triggerGuard.quadraticBezierTo(11.5, 20, 13, 19.5);
+    canvas.drawPath(triggerGuard, strokePaint..strokeWidth = 1.0);
+  }
+
+  /// Silhouette fidèle d'un Fusil à Pompe (Pump Action Shotgun : type Remington 870)
+  void _drawPumpShotgun(Canvas canvas, Paint fillPaint, Paint strokePaint) {
+    // 1. Crosse arrière traditionnelle ergonomique
+    final stockPath = Path();
+    stockPath.moveTo(1, 14.5);
+    stockPath.lineTo(9, 15.5);
+    stockPath.lineTo(9, 19.5);
+    stockPath.lineTo(6.5, 20); // poignée semi-pistolet
+    stockPath.lineTo(1, 21.5);
+    stockPath.close();
+    canvas.drawPath(stockPath, fillPaint);
+
+    // 2. Boîtier de culasse récepteur (Receiver)
+    final receiverPath = Path();
+    receiverPath.moveTo(9, 14);
+    receiverPath.lineTo(16.5, 14);
+    receiverPath.lineTo(16.5, 19);
+    receiverPath.lineTo(9, 19);
+    receiverPath.close();
+    canvas.drawPath(receiverPath, fillPaint);
+
+    // 3. Canon long calibre 12 (Barrel)
+    final barrelPath = Path();
+    barrelPath.moveTo(16.5, 14);
+    barrelPath.lineTo(31, 14);
+    barrelPath.lineTo(31, 15.5);
+    barrelPath.lineTo(16.5, 15.5);
+    barrelPath.close();
+    canvas.drawPath(barrelPath, fillPaint);
+
+    // Grain d'orge / mire avant sur le canon
+    canvas.drawCircle(const Offset(30, 13.2), 0.8, fillPaint);
+
+    // 4. Tube magasin inférieur sous le canon
+    final magTubePath = Path();
+    magTubePath.moveTo(16.5, 16);
+    magTubePath.lineTo(27, 16);
+    magTubePath.lineTo(27, 17.5);
+    magTubePath.lineTo(16.5, 17.5);
+    magTubePath.close();
+    canvas.drawPath(magTubePath, fillPaint);
+
+    // Bague de fixation canon / tube magasin
+    canvas.drawRect(const Rect.fromLTWH(26, 14, 1.2, 4), fillPaint);
+
+    // 5. Pompe mobile striée d'actionnement (Forend / Pump)
+    final pumpPath = Path();
+    pumpPath.addRRect(RRect.fromRectAndRadius(
+      const Rect.fromLTWH(18, 15.5, 6.5, 3.5),
+      const Radius.circular(0.8),
+    ));
+    canvas.drawPath(pumpPath, fillPaint);
+
+    // Stries sur la pompe
+    for (double x = 19.5; x <= 23.5; x += 1.3) {
+      canvas.drawLine(
+        Offset(x, 16),
+        Offset(x, 18.5),
+        Paint()
+          ..color = Colors.black.withValues(alpha: 0.4)
+          ..strokeWidth = 0.6,
+      );
+    }
+
+    // 6. Pontet et détente
+    final triggerGuard = Path();
+    triggerGuard.moveTo(10, 19);
+    triggerGuard.quadraticBezierTo(11.5, 21.5, 13.5, 20);
+    triggerGuard.lineTo(13.5, 19);
+    canvas.drawPath(triggerGuard, strokePaint..strokeWidth = 1.0);
+  }
+
+  /// Silhouette fidèle d'une arme à air comprimé / cible plomb (Airgun)
+  void _drawAirgun(Canvas canvas, Paint fillPaint, Paint strokePaint) {
+    // Pistolet match 10m / Airgun olympique avec réservoir d'air cylindrique
+    // 1. Canon supérieur et boîtier
+    final barrelPath = Path();
+    barrelPath.moveTo(4, 12);
+    barrelPath.lineTo(28, 12);
+    barrelPath.lineTo(28, 14);
+    barrelPath.lineTo(4, 14);
+    barrelPath.close();
+    canvas.drawPath(barrelPath, fillPaint);
+
+    // Organes de visée match : dioptre arrière et tunnel de guidon avant
+    canvas.drawRect(const Rect.fromLTWH(4.5, 9.5, 3, 2.5), fillPaint);
+    canvas.drawRect(const Rect.fromLTWH(25, 10, 2.5, 2), fillPaint);
+
+    // 2. Bonbonne d'air comprimé cylindrique inférieure (Cylinder)
+    final tankPath = Path();
+    tankPath.addRRect(RRect.fromRectAndRadius(
+      const Rect.fromLTWH(10, 14.5, 15, 3),
+      const Radius.circular(1.5),
+    ));
+    canvas.drawPath(tankPath, fillPaint);
+
+    // Manomètre avant
+    canvas.drawCircle(const Offset(25, 16), 1.2, strokePaint..strokeWidth = 0.8);
+
+    // 3. Poignée anatomique bois de tir sportif avec repose-paume
+    final gripPath = Path();
+    gripPath.moveTo(6, 14);
+    gripPath.lineTo(10, 14);
+    gripPath.lineTo(9.5, 23.5);
+    gripPath.lineTo(3.5, 22.5);
+    gripPath.close();
+    canvas.drawPath(gripPath, fillPaint);
+
+    // Tablette repose-paume réglable
+    canvas.drawRRect(
+      RRect.fromRectAndRadius(
+        const Rect.fromLTWH(2, 22.5, 9, 2.2),
+        const Radius.circular(0.8),
+      ),
+      fillPaint,
+    );
+
+    // 4. Pontet match
+    final guardPath = Path();
+    guardPath.moveTo(10, 14.5);
+    guardPath.quadraticBezierTo(12, 18.5, 9.5, 18.5);
+    canvas.drawPath(guardPath, strokePaint..strokeWidth = 1.0);
+  }
+
+  @override
+  bool shouldRepaint(covariant _WeaponTypePainter oldDelegate) {
+    return oldDelegate.type != type || oldDelegate.color != color;
+  }
+}

lib/data/database/database_helper.dart

@@ -590,6 +590,16 @@ class DatabaseHelper {
     );
   }
 
+  /// Toutes les entrées de maintenance, armes confondues (export/sauvegarde).
+  Future<List<MaintenanceEntry>> getAllMaintenance() async {
+    final db = await database;
+    final maps = await db.query(
+      AppConstants.maintenanceTable,
+      orderBy: 'date DESC',
+    );
+    return List.generate(maps.length, (i) => MaintenanceEntry.fromMap(maps[i]));
+  }
+
   Future<List<MaintenanceEntry>> getMaintenanceForWeapon(String weaponId) async {
     final db = await database;
     final maps = await db.query(

lib/data/models/weapon.dart

@@ -1,11 +1,14 @@
+import 'package:flutter/material.dart';
+
 enum WeaponType {
-  handgun('Arme de Poing'),
+  handgun('Arme de Poing', Icons.shield),
-  rifle('Arme d\'Épaule'),
+  rifle('Arme d\'Épaule', Icons.filter_center_focus),
-  shotgun('Fusil à Pompe'),
+  shotgun('Fusil à Pompe', Icons.splitscreen),
-  airgun('Airsoft / Airgun');
+  airgun('Airsoft / Airgun', Icons.air);
 
   final String displayName;
-  const WeaponType(this.displayName);
+  final IconData defaultIcon;
+  const WeaponType(this.displayName, this.defaultIcon);
 
   static WeaponType fromString(String value) {
     return WeaponType.values.firstWhere(

lib/data/repositories/session_repository.dart

@@ -131,6 +131,29 @@ class SessionRepository {
     return await _databaseHelper.getStatistics();
   }
 
+  /// Enregistre une session déjà construite (import de sauvegarde).
+  /// Les identifiants existants sont écrasés : réimporter deux fois la même
+  /// sauvegarde ne crée pas de doublons.
+  Future<void> saveSession(Session session) async {
+    await _databaseHelper.insertSession(session);
+  }
+
+  /// Copie une image dans le dossier des cibles de l'app (import de sauvegarde).
+  Future<String> saveImageBytes(List<int> bytes, String extension) async {
+    final appDir = await getApplicationDocumentsDirectory();
+    final imagesDir = Directory(path.join(appDir.path, 'target_images'));
+
+    if (!await imagesDir.exists()) {
+      await imagesDir.create(recursive: true);
+    }
+
+    final fileName = '${_uuid.v4()}$extension';
+    final destPath = path.join(imagesDir.path, fileName);
+    await File(destPath).writeAsBytes(bytes);
+
+    return destPath;
+  }
+
   String generateId() {
     return _uuid.v4();
   }
@@ -170,6 +193,11 @@ class SessionRepository {
     return await _databaseHelper.getAllWeapons();
   }
 
+  /// Enregistre une arme déjà construite (import de sauvegarde).
+  Future<void> saveWeapon(Weapon weapon) async {
+    await _databaseHelper.insertWeapon(weapon);
+  }
+
   Future<void> updateWeapon(Weapon weapon) async {
     await _databaseHelper.updateWeapon(weapon);
   }
@@ -208,6 +236,16 @@ class SessionRepository {
     return await _databaseHelper.getMaintenanceForWeapon(weaponId);
   }
 
+  /// Tout l'historique de maintenance de l'armurerie (export de sauvegarde).
+  Future<List<MaintenanceEntry>> getAllMaintenance() async {
+    return await _databaseHelper.getAllMaintenance();
+  }
+
+  /// Enregistre une entrée de maintenance déjà construite (import).
+  Future<void> saveMaintenanceEntry(MaintenanceEntry entry) async {
+    await _databaseHelper.insertMaintenance(entry);
+  }
+
   Future<void> deleteMaintenanceEntry(String id) async {
     await _databaseHelper.deleteMaintenance(id);
   }

lib/features/analysis/analysis_provider.dart

@@ -135,7 +135,7 @@ class AnalysisProvider extends ChangeNotifier {
     notifyListeners();
   }
 
-  /// Efface tous les impacts en un clic (bouton ↻ de l'écran Plotting).
+  /// Efface tous les impacts en un clic (bouton ↻ de l'écran Synthèse).
   /// La calibration (centre, rayon, anneaux) n'est pas touchée.
   void clearShots() {
     _shots.clear();
@@ -239,17 +239,24 @@ class AnalysisProvider extends ChangeNotifier {
   }
 
   /// Exporte l'image et le json vers le backend IA.
-  /// [sessionId], [distance] et [weapon] proviennent du SessionProvider de
+  /// [sessionId], [distance] et [caliber] proviennent du SessionProvider de
   /// l'écran appelant, pour que le dataset contienne les vraies métadonnées.
-  Future<bool> exportToAiBackend({
+  ///
+  /// Le nom de l'arme n'est volontairement pas transmis : il est souvent
+  /// personnalisé par l'utilisateur et n'apporte rien au modèle de détection.
+  Future<AiExportResult> exportToAiBackend({
     String? sessionId,
     int? distance,
-    String? weapon,
+    String? caliber,
+    int? expectedShots,
   }) async {
     if (_imagePath == null || _targetType == null) {
-      _errorMessage = "Impossible d'export : image ou type de cible manquant.";
+      _errorMessage = "Impossible d'exporter : image ou type de cible manquant.";
       notifyListeners();
-      return false;
+      return AiExportResult.error(
+        code: 'MISSING_DATA',
+        message: "Impossible d'exporter : image ou type de cible manquant.",
+      );
     }
 
     final service = AiExportService();
@@ -257,7 +264,7 @@ class AnalysisProvider extends ChangeNotifier {
     _state = AnalysisState.loading;
     notifyListeners();
 
-    final success = await service.exportData(
+    final result = await service.exportData(
       imagePath: _imagePath!,
       sessionId: sessionId ?? 'export',
       targetType: _targetType!,
@@ -266,15 +273,16 @@ class AnalysisProvider extends ChangeNotifier {
       targetRadius: _targetRadius,
       shots: _shots,
       distanceMeters: distance ?? 25,
-      weaponName: weapon ?? 'Unknown',
+      caliber: caliber ?? 'unknown',
+      expectedShots: expectedShots,
     );
 
     _state = AnalysisState.success;
-    if (!success) {
+    if (!result.isSuccess) {
-      _errorMessage = "Échec de l'export vers le serveur IA.";
+      _errorMessage = result.message;
     }
     notifyListeners();
-    return success;
+    return result;
   }
 
   /// Save the session

lib/features/analysis/analysis_screen.dart

@@ -1,7 +1,9 @@
-/// Écran principal de Plotting et d'analyse - Interface centrale de traitement des cibles.
+/// Écran principal de Synthèse et d'analyse - Interface centrale de traitement des cibles.
 ///
 /// Affiche d'abord la calibration de la cible, puis l'overlay des anneaux et impacts détectés.
-/// Permet le calcul des scores et statistiques de groupement (Plotting).
+/// Permet le calcul des scores et statistiques de groupement (Synthèse), et
+/// c'est de là que l'on termine la session. L'ajout des impacts, lui, se fait
+/// dans l'éditeur d'impacts plein écran.
 library;
 
 import 'dart:io';
@@ -9,6 +11,7 @@ import 'dart:math' as math;
 import 'package:flutter/material.dart';
 import 'package:provider/provider.dart';
 
+import '../../main_navigation_holder.dart';
 import '../../core/constants/app_constants.dart';
 import '../../core/theme/app_theme.dart';
 import '../../data/models/target_type.dart';
@@ -16,6 +19,7 @@ import '../../data/repositories/session_repository.dart';
 import '../../services/score_calculator_service.dart';
 import '../../services/grouping_analyzer_service.dart';
 import '../../services/wallet_identity_service.dart';
+import '../../services/ai_export_service.dart';
 import '../session/session_provider.dart';
 import 'analysis_provider.dart';
 import 'impact_editor_screen.dart';
@@ -25,7 +29,6 @@ import 'widgets/target_overlay.dart';
 import 'widgets/target_calibration.dart';
 import 'widgets/score_card.dart';
 import 'widgets/grouping_stats.dart';
-import 'widgets/shot_details_sheet.dart';
 
 class AnalysisScreen extends StatelessWidget {
   final String imagePath;
@@ -110,16 +113,15 @@ class _AnalysisScreenContentState extends State<_AnalysisScreenContent> {
   bool _isCalibrating = true;
   bool _isAtBottom = false;
 
+  // Affichage du réglage manuel de l'espacement des anneaux.
+  bool _showSpacing = false;
+
   final ScrollController _scrollController = ScrollController();
-  final TransformationController _transformationController =
-  TransformationController();
   final GlobalKey _imageKey = GlobalKey();
-  double _currentZoomScale = 1.0;
 
   @override
   void initState() {
     super.initState();
-    _transformationController.addListener(_onTransformChanged);
     _scrollController.addListener(_onScroll);
   }
 
@@ -137,32 +139,22 @@ class _AnalysisScreenContentState extends State<_AnalysisScreenContent> {
 
   @override
   void dispose() {
-    _transformationController.removeListener(_onTransformChanged);
-    _transformationController.dispose();
     _scrollController.removeListener(_onScroll);
     _scrollController.dispose();
     super.dispose();
   }
 
-  void _onTransformChanged() {
+  /// Repasse en mode calibration.
-    final scale = _transformationController.value.getMaxScaleOnAxis();
-    if (scale != _currentZoomScale) {
-      setState(() {
-        _currentZoomScale = scale;
-      });
-    }
-  }
-
-  /// Repasse en mode calibration en réinitialisant le zoom de l'InteractiveViewer.
   ///
-  /// Sans cette remise à zéro, le facteur de zoom accumulé en mode Plotting
+  /// La cible du mode Synthèse est désormais un élément fixe (aucun zoom à
-  /// persiste dans le TransformationController et se réapplique au retour,
+  /// réinitialiser) : on se contente donc de rebasculer l'état.
-  /// ce qui faisait "zoomer" légèrement la photo. On repart donc toujours
-  /// d'une transformation identité (zoom 1.0).
   void _enterCalibration() {
-    _transformationController.value = Matrix4.identity();
+    setState(() {
-    _currentZoomScale = 1.0;
+      _isCalibrating = true;
-    setState(() => _isCalibrating = true);
+      // La calibration est reconstruite à neuf (espacement manuel désactivé) :
+      // on aligne l'état du panneau pour ne pas afficher un mode inactif.
+      _showSpacing = false;
+    });
   }
 
   /// Ouvre l'éditeur d'impacts (plein écran) en PARTAGEANT le provider courant.
@@ -171,10 +163,11 @@ class _AnalysisScreenContentState extends State<_AnalysisScreenContent> {
   /// exactement le même AnalysisProvider que cet écran : les impacts ajoutés,
   /// déplacés ou supprimés sont donc immédiatement répercutés ici.
   ///
-  /// Au retour : si l'utilisateur a validé (résultat true) on bascule en mode
+  /// Au retour, quel que soit le résultat (validation OU retour arrière), on
-  /// Plotting (lecture seule) ; sinon on repasse en calibration.
+  /// revient TOUJOURS sur la Synthèse. L'éditeur d'impacts n'est ouvert que
+  /// depuis la Synthèse : il doit donc y ramener, jamais sur la calibration.
   Future<void> _openImpactEditor(AnalysisProvider provider) async {
-    final validated = await Navigator.of(context).push<bool>(
+    await Navigator.of(context).push<bool>(
       MaterialPageRoute(
         builder: (_) => ChangeNotifierProvider<AnalysisProvider>.value(
           value: provider,
@@ -185,13 +178,9 @@ class _AnalysisScreenContentState extends State<_AnalysisScreenContent> {
 
     if (!mounted) return;
 
-    if (validated == true) {
     setState(() {
       _isCalibrating = false;
     });
-    } else {
-      _enterCalibration();
-    }
   }
 
   /// Chemin à utiliser pour repartir dans le CropScreen lors d'un retour arrière.
@@ -204,6 +193,181 @@ class _AnalysisScreenContentState extends State<_AnalysisScreenContent> {
     return widget.originalImagePath ?? provider.imagePath!;
   }
 
+  /// Panneau de réglages de la calibration (taille + espacement).
+  ///
+  /// Rendu AU-DESSUS de l'image (et non plus en surimpression) pour ne pas
+  /// masquer la cible. Les valeurs affichées viennent du provider ; les
+  /// modifications sont poussées dans l'état de [TargetCalibration] via sa clé.
+  Widget _buildCalibrationSettings(AnalysisProvider provider) {
+    final radius = provider.targetRadius.clamp(
+      TargetCalibrationState.minRadius,
+      TargetCalibrationState.maxRadius,
+    );
+    final spacing =
+        (provider.targetRadius > 0
+                ? provider.targetInnerRadius / provider.targetRadius
+                : 0.1)
+            .clamp(
+              TargetCalibrationState.minSpacing,
+              TargetCalibrationState.maxSpacing,
+            );
+
+    return Padding(
+      padding: const EdgeInsets.fromLTRB(12, 0, 12, 4),
+      child: Column(
+        mainAxisSize: MainAxisSize.min,
+        children: [
+          SizedBox(
+            height: 36,
+            child: Row(
+              children: [
+                const Text(
+                  'Taille',
+                  style: TextStyle(fontSize: 12, fontWeight: FontWeight.bold),
+                ),
+                const SizedBox(width: 4),
+                const Icon(Icons.zoom_out, size: 16),
+                Expanded(
+                  child: Slider(
+                    value: radius,
+                    min: TargetCalibrationState.minRadius,
+                    max: TargetCalibrationState.maxRadius,
+                    activeColor: AppTheme.primaryColor,
+                    onChanged: (value) =>
+                        _calibrationKey.currentState?.setRadius(value),
+                  ),
+                ),
+                const Icon(Icons.zoom_in, size: 16),
+              ],
+            ),
+          ),
+          SizedBox(
+            height: 32,
+            child: Row(
+              children: [
+                const Expanded(
+                  child: Text(
+                    'Options d\'espacement avancées',
+                    style: TextStyle(fontSize: 11, fontWeight: FontWeight.w500),
+                  ),
+                ),
+                Switch(
+                  value: _showSpacing,
+                  materialTapTargetSize: MaterialTapTargetSize.shrinkWrap,
+                  onChanged: (value) {
+                    setState(() => _showSpacing = value);
+                    _calibrationKey.currentState?.setSpacingMode(value);
+                  },
+                ),
+              ],
+            ),
+          ),
+          if (_showSpacing)
+            SizedBox(
+              height: 36,
+              child: Row(
+                children: [
+                  const Text(
+                    'Espacement',
+                    style: TextStyle(fontSize: 12, fontWeight: FontWeight.bold),
+                  ),
+                  const SizedBox(width: 4),
+                  const Icon(Icons.compress, size: 16),
+                  Expanded(
+                    child: Slider(
+                      value: spacing,
+                      min: TargetCalibrationState.minSpacing,
+                      max: TargetCalibrationState.maxSpacing,
+                      activeColor: Colors.orange,
+                      onChanged: (value) =>
+                          _calibrationKey.currentState?.setSpacingRatio(value),
+                    ),
+                  ),
+                  const Icon(Icons.expand, size: 16),
+                  IconButton(
+                    icon: const Icon(Icons.refresh, size: 20),
+                    tooltip: 'Réinitialiser l\'espacement',
+                    constraints: const BoxConstraints(),
+                    padding: const EdgeInsets.symmetric(horizontal: 8),
+                    onPressed: () =>
+                        _calibrationKey.currentState?.resetSpacing(),
+                  ),
+                ],
+              ),
+            ),
+        ],
+      ),
+    );
+  }
+
+  /// Indication affichée sous le titre en mode Synthèse.
+  ///
+  /// Rien n'indiquait comment ajouter un impact une fois la calibration
+  /// validée : ce rappel pointe vers le geste (toucher la cible).
+  Widget _buildSyntheseHint(AnalysisProvider provider) {
+    final hasShots = provider.shotCount > 0;
+
+    return Padding(
+      padding: const EdgeInsets.fromLTRB(16, 0, 16, 8),
+      child: Row(
+        mainAxisAlignment: MainAxisAlignment.center,
+        children: [
+          Icon(
+            hasShots ? Icons.touch_app : Icons.add_location_alt,
+            size: 16,
+            color: AppTheme.primaryColor,
+          ),
+          const SizedBox(width: 6),
+          Flexible(
+            child: Text(
+              hasShots
+                  ? 'Touchez la cible pour modifier vos impacts'
+                  : 'Touchez la cible pour placer vos impacts',
+              style: const TextStyle(fontSize: 13, fontWeight: FontWeight.w500),
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+
+  /// Bouton flottant du bas de l'écran.
+  ///
+  /// En calibration : VALIDER. En synthèse : tant qu'aucun impact n'est placé,
+  /// on ne propose pas de terminer la session mais de placer un impact (le
+  /// bouton ouvre l'éditeur, comme un tap sur la cible).
+  Widget _buildBottomAction(BuildContext context, AnalysisProvider provider) {
+    if (_isCalibrating) {
+      return FloatingActionButton.extended(
+        // Même bouton bleu flottant que « TERMINER LA SESSION » :
+        // on fige la calibration puis on bascule sur la Synthèse.
+        onPressed: () {
+          _calibrationKey.currentState?.commitCalibration();
+          setState(() => _isCalibrating = false);
+        },
+        backgroundColor: AppTheme.primaryColor,
+        icon: const Icon(Icons.check),
+        label: const Text('VALIDER'),
+      );
+    }
+
+    if (provider.shotCount == 0) {
+      return FloatingActionButton.extended(
+        onPressed: () => _openImpactEditor(provider),
+        backgroundColor: AppTheme.primaryColor,
+        icon: const Icon(Icons.add_location_alt),
+        label: const Text('PLACER UN IMPACT'),
+      );
+    }
+
+    return FloatingActionButton.extended(
+      onPressed: () => _showSaveSessionDialog(context, provider),
+      backgroundColor: AppTheme.primaryColor,
+      icon: const Icon(Icons.save),
+      label: const Text('TERMINER LA SESSION'),
+    );
+  }
+
   @override
   Widget build(BuildContext context) {
     final provider = context.watch<AnalysisProvider>();
@@ -212,10 +376,10 @@ class _AnalysisScreenContentState extends State<_AnalysisScreenContent> {
         ? sessionProvider.targetCount + 1
         : null;
 
-    final titlePrefix = _isCalibrating ? 'Calibration' : 'Plotting';
+    final titlePrefix = _isCalibrating ? 'Calibration' : 'Synthèse';
     final title = targetNumber != null
         ? '$titlePrefix - Cible $targetNumber'
-        : (_isCalibrating ? 'Calibration' : 'Plotting du Tir');
+        : (_isCalibrating ? 'Calibration' : 'Synthèse du Tir');
 
     return Scaffold(
       appBar: AppBar(
@@ -239,92 +403,12 @@ class _AnalysisScreenContentState extends State<_AnalysisScreenContent> {
                 ),
               );
             } else {
-              // Retour Plotting -> Calibration : on réinitialise le zoom.
+              // Retour Synthèse -> Calibration : on réinitialise le zoom.
               _enterCalibration();
             }
           },
         ),
-        actions: [
+        actions: const [],
-          // Remise à zéro des impacts : efface tous les impacts en un clic,
-          // sans modifier la calibration (centre, rayon, anneaux).
-          if (!_isCalibrating)
-            IconButton(
-              icon: const Icon(Icons.refresh),
-              tooltip: 'Effacer tous les impacts',
-              onPressed: () => provider.clearShots(),
-            ),
-          // Nuage d'export vers le backend IA : visible uniquement si l'analyse
-          // a réussi ET que l'utilisateur a activé l'option dans les Paramètres.
-          if (!_isCalibrating)
-            FutureBuilder<bool>(
-              future: WalletIdentityService().isUploadEnabled(),
-              builder: (context, snapshot) {
-                final isEnabled = snapshot.data ?? false;
-                if (!isEnabled ||
-                    provider.state != AnalysisState.success) {
-                  return const SizedBox.shrink();
-                }
-                return IconButton(
-                  icon: const Icon(Icons.cloud_upload),
-                  tooltip: 'Exporter pour IA',
-                  onPressed: () async {
-                    final p = context.read<AnalysisProvider>();
-                    if (p.state != AnalysisState.success) return;
-
-                    ScaffoldMessenger.of(context).showSnackBar(
-                      const SnackBar(content: Text('Exportation en cours...')),
-                    );
-
-                    // Métadonnées réelles de la session en cours (distance,
-                    // arme) plutôt que les placeholders par défaut.
-                    final sp = context.read<SessionProvider>();
-                    final success = await p.exportToAiBackend(
-                      sessionId: sp.activeSessionId,
-                      distance: sp.distance,
-                      weapon: sp.currentWeapon,
-                    );
-
-                    if (!context.mounted) return;
-                    ScaffoldMessenger.of(context).hideCurrentSnackBar();
-                    if (success) {
-                      ScaffoldMessenger.of(context).showSnackBar(
-                        const SnackBar(
-                          content: Text('Export réussi vers le backend IA !'),
-                          backgroundColor: AppTheme.successColor,
-                        ),
-                      );
-                    } else {
-                      ScaffoldMessenger.of(context).showSnackBar(
-                        SnackBar(
-                          content:
-                              Text(p.errorMessage ?? 'Erreur d\'export'),
-                          backgroundColor: AppTheme.errorColor,
-                        ),
-                      );
-                    }
-                  },
-                );
-              },
-            ),
-          if (_isCalibrating)
-            TextButton(
-              onPressed: () {
-                // On fige la calibration courante AVANT d'ouvrir l'éditeur,
-                // puis on passe sur l'écran d'édition d'impacts plein écran
-                // (zoom fiable + placement). Le mode Plotting (lecture seule)
-                // s'affichera au retour si l'utilisateur valide.
-                _calibrationKey.currentState?.commitCalibration();
-                _openImpactEditor(context.read<AnalysisProvider>());
-              },
-              child: const Text(
-                'VALIDER',
-                style: TextStyle(
-                  color: Colors.white,
-                  fontWeight: FontWeight.bold,
-                ),
-              ),
-            ),
-        ],
       ),
       body: Stack(
         children: [
@@ -332,22 +416,21 @@ class _AnalysisScreenContentState extends State<_AnalysisScreenContent> {
             controller: _scrollController,
             child: Column(
               children: [
-                Padding(
+                // Plus de bloc vide au-dessus de l'image : l'indicateur n'occupe
-                  padding: const EdgeInsets.all(AppConstants.defaultPadding),
+                // de la place que pendant le chargement.
-                  child: Column(
-                    crossAxisAlignment: CrossAxisAlignment.start,
-                    children: [
                 if (provider.state == AnalysisState.loading)
-                        const Center(
+                  const Padding(
-                          child: Padding(
                     padding: EdgeInsets.symmetric(vertical: 8.0),
-                            child: CircularProgressIndicator(),
+                    child: Center(child: CircularProgressIndicator()),
-                          ),
-                        ),
-                    ],
-                  ),
                   ),
 
+                // Réglages de calibration : au-dessus de la photo pour ne rien
+                // masquer de la cible.
+                if (_isCalibrating)
+                  _buildCalibrationSettings(provider)
+                else
+                  _buildSyntheseHint(provider),
+
                 AspectRatio(
                   aspectRatio: provider.imageAspectRatio,
                   child: _isCalibrating
@@ -416,27 +499,6 @@ class _AnalysisScreenContentState extends State<_AnalysisScreenContent> {
                     padding: const EdgeInsets.all(AppConstants.defaultPadding),
                     child: Column(
                       children: [
-                        Card(
-                          color: AppTheme.primaryColor.withValues(alpha: 0.18),
-                          child: ListTile(
-                            leading: const Icon(
-                              Icons.edit_location_alt,
-                              color: AppTheme.primaryColor,
-                            ),
-                            title: const Text('Modifier les impacts'),
-                            subtitle: const Text(
-                              'Ajouter, déplacer ou supprimer des impacts (plein écran)',
-                            ),
-                            trailing: const Icon(
-                              Icons.open_in_full,
-                              size: 16,
-                            ),
-                            // Rouvre l'éditeur plein écran en partageant le provider.
-                            onTap: () =>
-                                _openImpactEditor(context.read<AnalysisProvider>()),
-                          ),
-                        ),
-                        const SizedBox(height: 12),
                         Card(
                           color: AppTheme.primaryColor.withValues(alpha: 0.1),
                           child: ListTile(
@@ -462,6 +524,14 @@ class _AnalysisScreenContentState extends State<_AnalysisScreenContent> {
                           shotCount: provider.shotCount,
                           scoreResult: provider.scoreResult,
                           targetType: provider.targetType!,
+                          // Cumul de la session : cibles déjà validées + cible
+                          // en cours (absent hors session).
+                          sessionTotalScore: sessionProvider.isSessionActive
+                              ? sessionProvider.totalSessionScore +
+                                    provider.totalScore
+                              : null,
+                          sessionTargetCount:
+                              sessionProvider.targetCount + 1,
                         ),
                         const SizedBox(height: 12),
                         if (provider.groupingResult != null &&
@@ -574,15 +644,7 @@ class _AnalysisScreenContentState extends State<_AnalysisScreenContent> {
                 padding: _isAtBottom
                     ? EdgeInsets.zero
                     : const EdgeInsets.all(16.0),
-                child: _isCalibrating
+                child: _buildBottomAction(context, provider),
-                    ? const SizedBox.shrink()
-                    : FloatingActionButton.extended(
-                  onPressed: () =>
-                      _showSaveSessionDialog(context, provider),
-                  backgroundColor: AppTheme.primaryColor,
-                  icon: const Icon(Icons.save),
-                  label: const Text('TERMINER LA SESSION'),
-                ),
               ),
             ),
           ),
@@ -604,22 +666,21 @@ class _AnalysisScreenContentState extends State<_AnalysisScreenContent> {
     );
   }
 
-  /// Affichage du plotting en LECTURE SEULE.
+  /// Affichage de la synthèse en LECTURE SEULE.
   ///
-  /// L'édition (ajout / déplacement / suppression) se fait désormais
+  /// La cible est un élément d'écran FIXE : elle ne se déplace pas et ne se
-  /// exclusivement dans l'éditeur plein écran (ImpactEditorScreen). Ici on se
+  /// zoome pas (plus d'InteractiveViewer). Un tap n'importe où sur la cible
-  /// contente d'afficher l'image + l'overlay, avec un zoom de consultation.
+  /// ouvre directement l'éditeur d'impacts plein écran (ImpactEditorScreen),
-  /// Le tap sur un impact ouvre simplement ses détails.
+  /// exactement comme le faisait l'ancien bouton « Modifier les impacts ».
+  /// C'est là que se fait toute l'édition (ajout / déplacement / suppression),
+  /// avec un zoom fiable.
   Widget _buildReadOnlyPlotImage(
       BuildContext context,
       AnalysisProvider provider,
       ) {
-    return InteractiveViewer(
+    return GestureDetector(
-      transformationController: _transformationController,
+      behavior: HitTestBehavior.opaque,
-      minScale: 1.0,
+      onTap: () => _openImpactEditor(context.read<AnalysisProvider>()),
-      maxScale: 10.0,
-      boundaryMargin: const EdgeInsets.all(80),
-      panEnabled: true,
       child: Stack(
         children: [
           Image.file(
@@ -635,10 +696,7 @@ class _AnalysisScreenContentState extends State<_AnalysisScreenContent> {
               targetType: provider.targetType!,
               shots: provider.shots,
               showRings: true,
-              zoomScale: _currentZoomScale,
+              zoomScale: 1.0,
-              // Lecture seule : tap sur impact -> détails (consultation).
-              onShotTapped: (shot) =>
-                  showShotDetailsSheet(context, provider, shot),
             ),
           ),
         ],
@@ -646,22 +704,93 @@ class _AnalysisScreenContentState extends State<_AnalysisScreenContent> {
     );
   }
 
-  void _showSaveSessionDialog(BuildContext context, AnalysisProvider provider) {
+  Future<void> _showSaveSessionDialog(
+    BuildContext context,
+    AnalysisProvider provider,
+  ) async {
+    // L'option « Participer à l'entraînement IA » (Paramètres) est lue AVANT
+    // d'ouvrir la popup : elle décide de la présence du bouton d'export.
+    final canExport =
+        await WalletIdentityService().isUploadEnabled() &&
+        provider.state == AnalysisState.success;
+
+    if (!context.mounted) return;
+
     showDialog(
       context: context,
       builder: (context) => AlertDialog(
-        title: const Text('Session Terminee'),
+        // Protège des petits écrans / grandes polices : la popup défile au
-        content: Column(
+        // lieu de déborder.
-          mainAxisSize: MainAxisSize.min,
+        scrollable: true,
-          crossAxisAlignment: CrossAxisAlignment.start,
+        // En-tête bleu pleine largeur : le titre occupe toute la bande, d'où
+        // les paddings mis à zéro.
+        titlePadding: EdgeInsets.zero,
+        contentPadding: const EdgeInsets.fromLTRB(20, 16, 20, 16),
+        shape: RoundedRectangleBorder(
+          borderRadius: BorderRadius.circular(16),
+        ),
+        clipBehavior: Clip.antiAlias,
+        title: Container(
+          width: double.infinity,
+          color: AppTheme.primaryColor,
+          padding: const EdgeInsets.symmetric(horizontal: 20, vertical: 16),
+          child: const Row(
             children: [
-            Text('Nombre de tirs: ${provider.shotCount}'),
+              Icon(Icons.flag, color: Colors.white),
-            Text('Score total: ${provider.totalScore}'),
+              SizedBox(width: 10),
-            const SizedBox(height: 16),
+              Text(
-            const Text('Voulez-vous enregistrer cette session ?'),
+                'Session terminée',
+                style: TextStyle(
+                  color: Colors.white,
+                  fontSize: 18,
+                  fontWeight: FontWeight.bold,
+                ),
+              ),
             ],
           ),
-        actions: [
+        ),
+        // Les boutons sont dans le contenu (et non dans `actions`) pour être
+        // tous à la même largeur, alignés les uns sous les autres.
+        content: Column(
+          mainAxisSize: MainAxisSize.min,
+          crossAxisAlignment: CrossAxisAlignment.stretch,
+          children: [
+            _buildDialogRecap(context, provider),
+            const SizedBox(height: 16),
+            const Text('Voulez-vous enregistrer cette session ?'),
+            const SizedBox(height: 16),
+            _buildDialogButton(
+              icon: const Icon(Icons.add_a_photo, color: Colors.white),
+              label: 'AJOUTER UNE CIBLE',
+              color: AppTheme.secondaryColor,
+              onPressed: () => _saveAndAddTarget(context, provider),
+            ),
+            const SizedBox(height: 8),
+            _buildDialogButton(
+              icon: const Icon(Icons.save, color: Colors.white),
+              label: 'TERMINER TOUT',
+              color: AppTheme.primaryColor,
+              onPressed: () => _finishSession(context, provider),
+            ),
+            // Bouton d'export : uniquement si l'entraînement IA est autorisé.
+            if (canExport) ...[
+              const SizedBox(height: 8),
+              _buildDialogButton(
+                icon: Image.asset(
+                  'assets/icons/cloud_save.png',
+                  width: 24,
+                  height: 24,
+                  // L'icône est un trait noir : on la recolore en blanc pour
+                  // qu'elle ressorte sur le bouton.
+                  color: Colors.white,
+                ),
+                label: 'TERMINER ET CONTRIBUER À L\'IA',
+                color: AppTheme.warningColor,
+                onPressed: () =>
+                    _finishSession(context, provider, export: true),
+              ),
+            ],
+            const SizedBox(height: 4),
             TextButton(
               onPressed: () {
                 Navigator.pop(context);
@@ -683,8 +812,72 @@ class _AnalysisScreenContentState extends State<_AnalysisScreenContent> {
               },
               child: const Text('ANNULER'),
             ),
-          ElevatedButton(
+          ],
-            onPressed: () async {
+        ),
+      ),
+    );
+  }
+
+  /// Rappel chiffré (tirs / score) en tête de la popup de fin de session.
+  Widget _buildDialogRecap(BuildContext context, AnalysisProvider provider) {
+    return Container(
+      padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 12),
+      decoration: BoxDecoration(
+        color: AppTheme.primaryColor.withValues(alpha: 0.10),
+        borderRadius: BorderRadius.circular(12),
+      ),
+      child: Row(
+        mainAxisAlignment: MainAxisAlignment.spaceAround,
+        children: [
+          _buildRecapValue(context, '${provider.shotCount}', 'Tirs'),
+          _buildRecapValue(context, '${provider.totalScore}', 'Score total'),
+        ],
+      ),
+    );
+  }
+
+  Widget _buildRecapValue(BuildContext context, String value, String label) {
+    return Column(
+      children: [
+        Text(
+          value,
+          style: Theme.of(context).textTheme.headlineSmall?.copyWith(
+            fontWeight: FontWeight.bold,
+            color: AppTheme.primaryColor,
+          ),
+        ),
+        Text(label, style: Theme.of(context).textTheme.bodySmall),
+      ],
+    );
+  }
+
+  /// Bouton pleine largeur de la popup, aux couleurs du thème.
+  Widget _buildDialogButton({
+    required Widget icon,
+    required String label,
+    required Color color,
+    required VoidCallback onPressed,
+  }) {
+    return ElevatedButton.icon(
+      icon: icon,
+      label: Text(label, style: const TextStyle(fontWeight: FontWeight.bold)),
+      style: ElevatedButton.styleFrom(
+        backgroundColor: color,
+        foregroundColor: Colors.white,
+        padding: const EdgeInsets.symmetric(vertical: 14),
+        shape: RoundedRectangleBorder(
+          borderRadius: BorderRadius.circular(10),
+        ),
+      ),
+      onPressed: onPressed,
+    );
+  }
+
+  /// Enregistre la cible courante et enchaîne sur une nouvelle capture.
+  Future<void> _saveAndAddTarget(
+    BuildContext context,
+    AnalysisProvider provider,
+  ) async {
     try {
       final sessionProvider = context.read<SessionProvider>();
       final analysis = await provider.saveSession(
@@ -701,9 +894,7 @@ class _AnalysisScreenContentState extends State<_AnalysisScreenContent> {
         Navigator.pop(context);
         Navigator.pushAndRemoveUntil(
           context,
-                    MaterialPageRoute(
+          MaterialPageRoute(builder: (context) => const CaptureScreen()),
-                      builder: (context) => const CaptureScreen(),
-                    ),
           (route) => route.isFirst,
         );
       }
@@ -717,13 +908,24 @@ class _AnalysisScreenContentState extends State<_AnalysisScreenContent> {
         );
       }
     }
-            },
+  }
-            child: const Text('AJOUTER UNE CIBLE'),
+
-          ),
+  /// Clôture la session et revient sur l'onglet Statistiques.
-          ElevatedButton(
+  ///
-            onPressed: () async {
+  /// Avec [export], la cible est en plus envoyée au backend d'entraînement IA.
-              try {
+  /// L'enregistrement local reste prioritaire : un échec d'export n'empêche
+  /// jamais la session d'être sauvegardée.
+  Future<void> _finishSession(
+    BuildContext context,
+    AnalysisProvider provider, {
+    bool export = false,
+  }) async {
+    // Messenger et session capturés AVANT les await : le contexte de la popup
+    // ne sera plus valide ensuite.
+    final messenger = ScaffoldMessenger.of(context);
     final sessionProvider = context.read<SessionProvider>();
+
+    try {
       await provider.saveSession(
         sessionId: sessionProvider.activeSessionId,
         weaponName: sessionProvider.currentWeapon,
@@ -732,14 +934,97 @@ class _AnalysisScreenContentState extends State<_AnalysisScreenContent> {
         date: sessionProvider.sessionDate,
       );
 
+      AiExportResult? exportResult;
+      if (export) {
+        messenger.showSnackBar(
+          const SnackBar(content: Text('Exportation vers le serveur IA en cours...')),
+        );
+        exportResult = await provider.exportToAiBackend(
+          sessionId: sessionProvider.activeSessionId,
+          distance: sessionProvider.distance,
+          caliber: sessionProvider.currentWeaponCaliber,
+          // Hors session, shotsPerTarget vaut sa valeur par defaut : mieux
+          // vaut ne rien annoncer qu'annoncer un nombre faux.
+          expectedShots: sessionProvider.isSessionActive
+              ? sessionProvider.shotsPerTarget
+              : null,
+        );
+        messenger.hideCurrentSnackBar();
+      }
+
       if (context.mounted) {
         sessionProvider.endSession();
         Navigator.pop(context);
         Navigator.of(context).popUntil((route) => route.isFirst);
+        // Fin de session : on atterrit sur les statistiques.
+        openMainTab(mainTabStats);
+      }
+
+      if (exportResult != null) {
+        if (exportResult.isBanned) {
+          messenger.showSnackBar(
+            SnackBar(
+              content: Row(
+                children: [
+                  const Icon(Icons.block, color: Colors.white),
+                  const SizedBox(width: 12),
+                  Expanded(
+                    child: Text(
+                      'Participation IA suspendue : ${exportResult.reason ?? "Non-respect des règles"}',
+                      style: const TextStyle(fontWeight: FontWeight.bold),
+                    ),
+                  ),
+                ],
+              ),
+              backgroundColor: AppTheme.errorColor,
+              duration: const Duration(seconds: 6),
+            ),
+          );
+        } else if (exportResult.isSuccess) {
+          final targetStatus = exportResult.targetValidation?['status'];
+          final isCertified = targetStatus == 'VALID';
+          messenger.showSnackBar(
+            SnackBar(
+              content: Row(
+                children: [
+                  Icon(
+                    isCertified ? Icons.verified : Icons.cloud_done,
+                    color: Colors.white,
+                  ),
+                  const SizedBox(width: 12),
+                  Expanded(
+                    child: Text(
+                      isCertified
+                          ? 'Export réussi ! Cible certifiée par l\'IA.'
+                          : exportResult.message,
+                    ),
+                  ),
+                ],
+              ),
+              backgroundColor: AppTheme.successColor,
+              duration: const Duration(seconds: 4),
+            ),
+          );
+        } else {
+          messenger.showSnackBar(
+            SnackBar(
+              content: Row(
+                children: [
+                  const Icon(Icons.warning_amber_rounded, color: Colors.white),
+                  const SizedBox(width: 12),
+                  Expanded(
+                    child: Text('Échec de l\'export : ${exportResult.message}'),
+                  ),
+                ],
+              ),
+              backgroundColor: AppTheme.errorColor,
+              duration: const Duration(seconds: 4),
+            ),
+          );
+        }
       }
     } catch (e) {
-                if (context.mounted) {
+      messenger.showSnackBar(
-                  ScaffoldMessenger.of(context).showSnackBar(
         SnackBar(
           content: Text('Erreur: $e'),
           backgroundColor: AppTheme.errorColor,
@@ -747,11 +1032,4 @@ class _AnalysisScreenContentState extends State<_AnalysisScreenContent> {
       );
     }
   }
-            },
-            child: const Text('TERMINER TOUT'),
-          ),
-        ],
-      ),
-    );
-  }
 }

lib/features/analysis/impact_editor_screen.dart

@@ -7,8 +7,11 @@
 /// scroll vertical ou une transformation parente.
 ///
 /// Interactions :
-///   - Tap sur zone vide      -> ajoute un impact
+///   - Tap                    -> ajoute TOUJOURS un impact, même juste à côté
-///   - Tap sur un impact      -> ouvre l'édition (score / suppression)
+///                               (ou par-dessus) un impact existant. Aucun tap
+///                               n'ouvre d'édition de score : on peut donc
+///                               placer un impact au pouce près sans être
+///                               interrompu par une popup.
 ///   - Appui long + glisser   -> déplace l'impact
 ///
 /// L'état des impacts est partagé avec l'écran d'analyse via le MÊME
@@ -20,10 +23,10 @@ import 'dart:math' as math;
 import 'package:flutter/material.dart';
 import 'package:provider/provider.dart';
 
+import '../../core/theme/app_theme.dart';
 import '../../data/models/shot.dart';
 import 'analysis_provider.dart';
 import 'widgets/target_overlay.dart';
-import 'widgets/shot_details_sheet.dart';
 
 class ImpactEditorScreen extends StatefulWidget {
   const ImpactEditorScreen({super.key});
@@ -72,8 +75,11 @@ class _ImpactEditorScreenState extends State<ImpactEditorScreen> {
   }
 
   /// Renvoie l'impact le plus proche de [rel] dans la tolérance, sinon null.
+  ///
+  /// Utilisé uniquement par l'appui long (déplacement) : le tap simple, lui,
+  /// ajoute toujours un impact sans chercher à en sélectionner un.
   Shot? _hitTestShot(AnalysisProvider provider, Offset rel,
-      {double tolerance = 0.04}) {
+      {double tolerance = 0.06}) {
     Shot? closest;
     double minDistance = double.infinity;
     for (final shot in provider.shots) {
@@ -99,16 +105,29 @@ class _ImpactEditorScreenState extends State<ImpactEditorScreen> {
         title: Text('Placement des impacts (${provider.shotCount})'),
         leading: IconButton(
           icon: const Icon(Icons.arrow_back),
-          tooltip: 'Retour à la calibration',
+          tooltip: 'Retour à la synthèse',
           onPressed: () => Navigator.pop(context, false),
         ),
-        actions: [
-          TextButton(
-            onPressed: () => Navigator.pop(context, true),
-            child: const Text(
-              'VALIDER',
-              style: TextStyle(color: Colors.white, fontWeight: FontWeight.bold),
       ),
+      // Corbeille (efface tous les impacts) + bouton bleu flottant VALIDER.
+      // heroTag distinct sur chaque FAB pour éviter le conflit de Hero.
+      floatingActionButton: Row(
+        mainAxisSize: MainAxisSize.min,
+        children: [
+          FloatingActionButton(
+            heroTag: 'reset_impacts',
+            onPressed: () => provider.clearShots(),
+            backgroundColor: Colors.grey.shade800,
+            tooltip: 'Effacer tous les impacts',
+            child: const Icon(Icons.delete),
+          ),
+          const SizedBox(width: 12),
+          FloatingActionButton.extended(
+            heroTag: 'validate_impacts',
+            onPressed: () => Navigator.pop(context, true),
+            backgroundColor: AppTheme.primaryColor,
+            icon: const Icon(Icons.check),
+            label: const Text('VALIDER'),
           ),
         ],
       ),
@@ -120,7 +139,7 @@ class _ImpactEditorScreenState extends State<ImpactEditorScreen> {
             color: Colors.white10,
             padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
             child: const Text(
-              'Tap : ajouter • Tap sur impact : éditer • Appui long : déplacer • Pincer : zoomer',
+              'Tap : ajouter un impact • Appui long : déplacer • Pincer : zoomer',
               style: TextStyle(color: Colors.white70, fontSize: 12),
               textAlign: TextAlign.center,
             ),
@@ -137,24 +156,20 @@ class _ImpactEditorScreenState extends State<ImpactEditorScreen> {
               child: Center(
                 child: GestureDetector(
                   behavior: HitTestBehavior.opaque,
-                  // TAP : éditer si on touche un impact, sinon ajouter.
+                  // TAP : ajoute un impact, sans exception. Même collé à un
+                  // impact existant, le tap crée le nouvel impact au lieu
+                  // d'ouvrir l'édition du score.
                   onTapUp: (details) {
                     if (_movingShotId != null) return;
                     final rel = _toImageRelative(details.globalPosition);
                     if (rel == null) return;
-
-                    final hit = _hitTestShot(provider, rel);
-                    if (hit != null) {
-                      showShotDetailsSheet(context, provider, hit);
-                    } else {
                     provider.addShot(rel.dx, rel.dy);
-                    }
                   },
                   // APPUI LONG : on saisit l'impact le plus proche pour le déplacer.
                   onLongPressStart: (details) {
                     final rel = _toImageRelative(details.globalPosition);
                     if (rel == null) return;
-                    final hit = _hitTestShot(provider, rel, tolerance: 0.06);
+                    final hit = _hitTestShot(provider, rel);
                     if (hit != null) {
                       setState(() => _movingShotId = hit.id);
                     }
@@ -190,10 +205,10 @@ class _ImpactEditorScreenState extends State<ImpactEditorScreen> {
                           shots: provider.shots,
                           showRings: true,
                           zoomScale: _currentZoomScale,
-                          // L'ajout et la sélection sont gérés par le
+                          // Aucun onShotTapped : les impacts ne captent plus le
-                          // GestureDetector parent ci-dessus.
+                          // toucher, tout va au GestureDetector parent qui
-                          onShotTapped: (shot) =>
+                          // ajoute un impact (y compris pile sur un impact
-                              showShotDetailsSheet(context, provider, shot),
+                          // existant).
                         ),
                       ),
                     ],

lib/features/analysis/widgets/score_card.dart

@@ -17,12 +17,22 @@ class ScoreCard extends StatelessWidget {
   final ScoreResult? scoreResult;
   final TargetType targetType;
 
+  /// Score cumulé de la session (cibles déjà validées + cible en cours).
+  ///
+  /// null hors session : le bandeau de session n'est alors pas affiché.
+  final int? sessionTotalScore;
+
+  /// Nombre de cibles comptabilisées dans [sessionTotalScore].
+  final int sessionTargetCount;
+
   const ScoreCard({
     super.key,
     required this.totalScore,
     required this.shotCount,
     this.scoreResult,
     required this.targetType,
+    this.sessionTotalScore,
+    this.sessionTargetCount = 0,
   });
 
   @override
@@ -46,13 +56,23 @@ class ScoreCard extends StatelessWidget {
                   ),
                 ),
                 const Spacer(),
+                if (sessionTotalScore != null) ...[
+                  Flexible(child: _buildSessionBadge(context)),
+                  const SizedBox(width: 4),
+                ],
                 MetricInfoButton(
                   title: 'Score',
                   explanations: [
                     MetricExplanation(
                       'Total',
-                      'Somme des points de tous vos impacts, sur le maximum '
+                      'Somme des points de tous vos impacts sur CETTE cible, '
-                          'possible (nombre d\'impacts × $maxScore points).',
+                          'sur le maximum possible (nombre d\'impacts × '
+                          '$maxScore points).',
+                    ),
+                    const MetricExplanation(
+                      'Session',
+                      'Score cumulé de toutes les cibles de la session en '
+                          'cours, cible affichée comprise.',
                     ),
                     const MetricExplanation(
                       'Impacts',
@@ -122,6 +142,30 @@ class ScoreCard extends StatelessWidget {
     );
   }
 
+  /// Bandeau compact rappelant le score total de la session en cours.
+  Widget _buildSessionBadge(BuildContext context) {
+    // Le nombre de cibles n'est rappelé qu'à partir de la deuxième : sur la
+    // première il n'apporte rien et allonge le bandeau pour rien.
+    final cibles = sessionTargetCount > 1 ? ' ($sessionTargetCount cibles)' : '';
+
+    return Container(
+      padding: const EdgeInsets.symmetric(horizontal: 10, vertical: 4),
+      decoration: BoxDecoration(
+        color: AppTheme.primaryColor.withValues(alpha: 0.15),
+        borderRadius: BorderRadius.circular(12),
+      ),
+      child: Text(
+        'Session : $sessionTotalScore pts$cibles',
+        maxLines: 1,
+        overflow: TextOverflow.ellipsis,
+        style: Theme.of(context).textTheme.bodySmall?.copyWith(
+          fontWeight: FontWeight.bold,
+          color: AppTheme.primaryColor,
+        ),
+      ),
+    );
+  }
+
   Widget _buildScoreStat(
     BuildContext context,
     String label,

lib/features/analysis/widgets/shot_details_sheet.dart

@@ -1,85 +0,0 @@
-/// Bottom sheet de détails d'un impact : modification du score et suppression.
-///
-/// Partagée entre l'écran d'analyse (consultation du plotting) et l'éditeur
-/// d'impacts plein écran, qui opèrent sur le même AnalysisProvider.
-library;
-
-import 'package:flutter/material.dart';
-
-import '../../../data/models/shot.dart';
-import '../analysis_provider.dart';
-
-void showShotDetailsSheet(
-  BuildContext context,
-  AnalysisProvider provider,
-  Shot shot,
-) {
-  showModalBottomSheet(
-    context: context,
-    builder: (context) => Container(
-      padding: const EdgeInsets.all(24),
-      child: Column(
-        mainAxisSize: MainAxisSize.min,
-        children: [
-          Text(
-            'Impact #${provider.shots.indexOf(shot) + 1}',
-            style: const TextStyle(fontWeight: FontWeight.bold, fontSize: 18),
-          ),
-          Text(
-            'ID: ${shot.id}',
-            style: Theme.of(context)
-                .textTheme
-                .bodySmall
-                ?.copyWith(color: Colors.grey, fontSize: 10),
-          ),
-          const SizedBox(height: 16),
-          ListTile(
-            leading: const Icon(Icons.score),
-            title: const Text('Modifier le score'),
-            trailing: DropdownButton<int>(
-              value: shot.score.clamp(0, 10),
-              items: List.generate(11, (index) => index)
-                  .map(
-                    (s) => DropdownMenuItem(
-                      value: s,
-                      child: Text(
-                        '$s',
-                        style: const TextStyle(
-                          fontWeight: FontWeight.bold,
-                          fontSize: 18,
-                        ),
-                      ),
-                    ),
-                  )
-                  .toList(),
-              onChanged: (newScore) {
-                if (newScore != null) {
-                  provider.updateShotScore(shot.id, newScore);
-                  Navigator.pop(context);
-                }
-              },
-            ),
-          ),
-          const SizedBox(height: 24),
-          Row(
-            children: [
-              Expanded(
-                child: OutlinedButton.icon(
-                  onPressed: () {
-                    provider.removeShot(shot.id);
-                    Navigator.pop(context);
-                  },
-                  icon: const Icon(Icons.delete, color: Colors.red),
-                  label: const Text(
-                    'SUPPRIMER',
-                    style: TextStyle(color: Colors.red),
-                  ),
-                ),
-              ),
-            ],
-          ),
-        ],
-      ),
-    ),
-  );
-}

lib/features/analysis/widgets/target_calibration.dart

@@ -6,7 +6,6 @@ library;
 
 import 'package:flutter/foundation.dart';
 import 'package:flutter/material.dart';
-import '../../../core/theme/app_theme.dart';
 import '../../../data/models/target_type.dart';
 
 class TargetCalibration extends StatefulWidget {
@@ -44,6 +43,15 @@ class TargetCalibration extends StatefulWidget {
 }
 
 class TargetCalibrationState extends State<TargetCalibration> {
+  /// Bornes du rayon global (mesurées pour laisser de la liberté sans
+  /// débordement incontrôlé).
+  static const double minRadius = 0.3;
+  static const double maxRadius = 0.95;
+
+  /// Bornes de l'espacement : max bridé à 0.70 pour confiner le dernier cercle.
+  static const double minSpacing = 0.01;
+  static const double maxSpacing = 0.70;
+
   late double _centerX;
   late double _centerY;
   late double _radius;
@@ -154,9 +162,9 @@ class TargetCalibrationState extends State<TargetCalibration> {
       builder: (context, constraints) {
         final size = constraints.biggest;
 
-        return Stack(
+        // Les réglages (taille / espacement) sont rendus par l'écran hôte
-          children: [
+        // AU-DESSUS de l'image : rien ne vient masquer la cible ici.
-            GestureDetector(
+        return GestureDetector(
           onScaleStart: (details) {
             _baseRadiusBeforeScale = _radius;
             final tapX = details.localFocalPoint.dx / size.width;
@@ -186,125 +194,68 @@ class TargetCalibrationState extends State<TargetCalibration> {
               isDraggingInnerRadius: false,
             ),
           ),
-            ),
+        );
+      },
+    );
+  }
 
-            Positioned(
+  // ---------------------------------------------------------------------------
-              top: 10,
+  // API publique pilotée par l'écran hôte (panneau de réglages hors de l'image)
-              left: 40,
+  // ---------------------------------------------------------------------------
-              right: 40,
+
-              child: Column(
+  /// Espacement courant (rayon du premier anneau, en fraction du rayon global).
-                mainAxisSize: MainAxisSize.min,
+  double get spacingRatio => _currentEspacementRatio;
-                children: [
+
-                  Container(
+  /// Mode d'espacement manuel actif ou non.
-                    margin: const EdgeInsets.only(bottom: 8),
+  bool get isSpacingModeEnabled => _showEspacement;
-                    padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 2),
+
-                    decoration: BoxDecoration(
+  /// Applique une nouvelle taille globale (rayon normalisé).
-                      color: Colors.black54,
+  void setRadius(double value) {
-                      borderRadius: BorderRadius.circular(20),
-                    ),
-                    child: Row(
-                      mainAxisAlignment: MainAxisAlignment.spaceBetween,
-                      children: [
-                        const Text(
-                          'Options d\'espacement avancées',
-                          style: TextStyle(color: Colors.white70, fontSize: 11, fontWeight: FontWeight.w500),
-                        ),
-                        SizedBox(
-                          height: 28,
-                          child: Switch(
-                            value: _showEspacement,
-                            activeThumbColor: const Color(0xFF00FF00),
-                            onChanged: (bool value) {
     setState(() {
-                                _showEspacement = value;
+      _radius = value.clamp(minRadius, maxRadius);
-                                // Quand on désactive l'espacement manuel, on restaure la configuration d'usine !
+      _innerRadius = _radius * _currentEspacementRatio;
-                                if (!value) {
+      // Si le mode avancé n'est pas coché, on applique la taille pure sans
+      // détruire le ratio d'origine.
+      _initRingRadii(forceRecalculate: _showEspacement);
+    });
+    _notifyChange();
+  }
+
+  /// Agrandit / réduit la cible de [deltaPixels] pixels.
+  ///
+  /// La conversion utilise la plus petite dimension de [size], exactement comme
+  /// le painter, pour que le pas corresponde bien à un pixel à l'écran.
+  void adjustRadiusByPixels(double deltaPixels, Size size) {
+    final minDim = size.width < size.height ? size.width : size.height;
+    if (minDim <= 0) return;
+    setRadius(_radius + deltaPixels / minDim);
+  }
+
+  /// Active ou non le réglage manuel de l'espacement.
+  ///
+  /// À la désactivation, on restaure la configuration d'usine.
+  void setSpacingMode(bool enabled) {
+    setState(() {
+      _showEspacement = enabled;
+      if (!enabled) {
         _initRingRadii(forceRecalculate: false);
       }
     });
     _notifyChange();
-                            },
+  }
-                          ),
-                        ),
-                      ],
-                    ),
-                  ),
 
-                  // Slider pour la taille (toujours visible)
+  /// Applique un nouvel espacement entre les anneaux.
-                  Container(
+  void setSpacingRatio(double value) {
-                    padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 4),
-                    decoration: BoxDecoration(
-                      color: Colors.black54,
-                      borderRadius: BorderRadius.circular(20),
-                    ),
-                    child: Row(
-                      children: [
-                        const Text('Taille ', style: TextStyle(color: Colors.white, fontSize: 12, fontWeight: FontWeight.bold)),
-                        const Icon(Icons.zoom_out, color: Colors.white, size: 16),
-                        Expanded(
-                          child: Slider(
-                            // SÉCURITÉ : Ouverture mesurée des bornes pour plus de liberté sans débordement incontrôlé
-                            value: _radius.clamp(0.3, 0.95),
-                            min: 0.3,
-                            max: 0.95,
-                            activeColor: AppTheme.primaryColor,
-                            onChanged: (value) {
     setState(() {
-                                _radius = value;
+      _currentEspacementRatio = value.clamp(minSpacing, maxSpacing);
-                                _innerRadius = _radius * _currentEspacementRatio;
-                                // CORRECTION : Si le mode avancé n'est pas coché, on applique la taille pure sans détruire le ratio d'origine
-                                _initRingRadii(forceRecalculate: _showEspacement);
-                              });
-                              _notifyChange();
-                            },
-                          ),
-                        ),
-                        const Icon(Icons.zoom_in, color: Colors.white, size: 16),
-                      ],
-                    ),
-                  ),
-
-                  // Affichage conditionnel du slider d'espacement orange
-                  if (_showEspacement) ...[
-                    const SizedBox(height: 8),
-                    Container(
-                      padding: const EdgeInsets.fromLTRB(16, 4, 4, 4),
-                      decoration: BoxDecoration(
-                        color: Colors.black54,
-                        borderRadius: BorderRadius.circular(20),
-                      ),
-                      child: Row(
-                        children: [
-                          const Text('Espacement ', style: TextStyle(color: Colors.white, fontSize: 12, fontWeight: FontWeight.bold)),
-                          const Icon(Icons.compress, color: Colors.white, size: 16),
-                          Expanded(
-                            child: Row(
-                              children: [
-                                Expanded(
-                                  child: Slider(
-                                    value: _currentEspacementRatio,
-                                    min: 0.01,
-                                    // SÉCURITÉ : Écartement max bridé à 0.70 pour confiner le dernier cercle
-                                    max: 0.70,
-                                    activeColor: Colors.orange,
-                                    onChanged: (value) {
-                                      setState(() {
-                                        _currentEspacementRatio = value;
       _innerRadius = _radius * _currentEspacementRatio;
       _initRingRadii(forceRecalculate: true);
     });
     _notifyChange();
-                                    },
+  }
-                                  ),
+
-                                ),
+  /// Restaure le vrai profil d'usine détecté sur l'image.
-                                const Icon(Icons.expand, color: Colors.white, size: 16),
+  void resetSpacing() {
-                              ],
-                            ),
-                          ),
-                          // CORRECTION DU BOUTON RESET : Restaure désormais le vrai profil d'usine de l'IA
-                          IconButton(
-                            icon: const Icon(Icons.refresh, color: Colors.white70, size: 20),
-                            onPressed: () {
     setState(() {
       if (_originalRingRadii != null) {
         _initRingRadii(forceRecalculate: false);
@@ -319,22 +270,6 @@ class TargetCalibrationState extends State<TargetCalibration> {
       }
     });
     _notifyChange();
-                            },
-                            tooltip: 'Réinitialiser l\'espacement',
-                            constraints: const BoxConstraints(),
-                            padding: const EdgeInsets.symmetric(horizontal: 8),
-                          ),
-                        ],
-                      ),
-                    ),
-                  ],
-                ],
-              ),
-            ),
-          ],
-        );
-      },
-    );
   }
 
   Widget buildDirectionalControls(BuildContext context, Size size) {
@@ -348,7 +283,8 @@ class TargetCalibrationState extends State<TargetCalibration> {
       child: Row(
         mainAxisSize: MainAxisSize.min,
         children: [
-          _buildSignLabel('−'),
+          // Réduit la cible d'un pixel.
+          _buildSizeButton('−', () => adjustRadiusByPixels(-1, size)),
           const SizedBox(width: 12),
           Column(
             mainAxisSize: MainAxisSize.min,
@@ -366,17 +302,27 @@ class TargetCalibrationState extends State<TargetCalibration> {
             ],
           ),
           const SizedBox(width: 12),
-          _buildSignLabel('+'),
+          // Agrandit la cible d'un pixel.
+          _buildSizeButton('+', () => adjustRadiusByPixels(1, size)),
         ],
       ),
     );
   }
 
-  // Symbole purement décoratif affiché de part et d'autre de la croix.
+  /// Bouton − / + de part et d'autre de la croix : ajuste la TAILLE de la cible.
-  Widget _buildSignLabel(String text) {
+  Widget _buildSizeButton(String sign, VoidCallback onPressed) {
-    return Text(
+    return Container(
-      text,
+      decoration: BoxDecoration(color: Colors.black87, borderRadius: BorderRadius.circular(8)),
-      style: const TextStyle(color: Colors.white54, fontSize: 28, fontWeight: FontWeight.bold),
+      child: IconButton(
+        icon: Text(
+          sign,
+          style: const TextStyle(color: Colors.white, fontSize: 24, fontWeight: FontWeight.bold),
+        ),
+        onPressed: onPressed,
+        padding: EdgeInsets.zero,
+        constraints: const BoxConstraints(minWidth: 44, minHeight: 44),
+        tooltip: sign == '+' ? 'Agrandir la cible' : 'Réduire la cible',
+      ),
     );
   }
 
@@ -415,7 +361,7 @@ class TargetCalibrationState extends State<TargetCalibration> {
   void _onScaleUpdate(ScaleUpdateDetails details, Size size) {
     setState(() {
       if (details.pointerCount == 2) {
-        _radius = (_baseRadiusBeforeScale * details.scale).clamp(0.3, 0.95);
+        _radius = (_baseRadiusBeforeScale * details.scale).clamp(minRadius, maxRadius);
         _innerRadius = _radius * _currentEspacementRatio;
         _initRingRadii(forceRecalculate: _showEspacement);
       } else if (_isDraggingCenter) {

lib/features/analysis/widgets/target_overlay.dart

@@ -53,7 +53,10 @@ class TargetOverlay extends StatelessWidget {
     // Désormais :
     //  - L'AJOUT d'impact est géré par le GestureDetector parent (analysis_screen).
     //  - Seule la SÉLECTION d'un impact existant est gérée ici, via des petites
-    //    zones de tap localisées (deferToChild) placées sur chaque impact.
+    //    zones de tap localisées (deferToChild) placées sur chaque impact —
+    //    et UNIQUEMENT si [onShotTapped] est fourni. Sans callback, aucune zone
+    //    de tap n'est créée : un tap pile sur un impact traverse jusqu'au parent
+    //    au lieu d'être absorbé dans le vide.
     return IgnorePointer(
       ignoring: false,
       child: CustomPaint(
@@ -73,6 +76,8 @@ class TargetOverlay extends StatelessWidget {
         ),
         child: LayoutBuilder(
           builder: (context, constraints) {
+            final onTapped = onShotTapped;
+            if (onTapped == null) return const SizedBox.expand();
             return Stack(
               children: shots.map((shot) {
                 final x = shot.x * constraints.maxWidth;
@@ -89,7 +94,7 @@ class TargetOverlay extends StatelessWidget {
                     // Le reste de la surface reste donc disponible pour le
                     // pinch/pan de l'InteractiveViewer.
                     behavior: HitTestBehavior.deferToChild,
-                    onTap: () => onShotTapped?.call(shot),
+                    onTap: () => onTapped(shot),
                     child: Container(
                       width: tapSize,
                       height: tapSize,

lib/features/capture/capture_screen.dart

@@ -169,8 +169,9 @@ class _CaptureScreenState extends State<CaptureScreen>
       final prev = _parallelismData;
       final bool changed = prev == null ||
           prev.status != data.status ||
-          prev.pitchDegrees.toStringAsFixed(1) !=
+          prev.pose != data.pose ||
-              data.pitchDegrees.toStringAsFixed(1) ||
+          prev.pitchDeviation.toStringAsFixed(1) !=
+              data.pitchDeviation.toStringAsFixed(1) ||
           prev.rollDegrees.toStringAsFixed(1) !=
               data.rollDegrees.toStringAsFixed(1);
 
@@ -218,16 +219,21 @@ class _CaptureScreenState extends State<CaptureScreen>
       return 'ALIGNEZ LA CIBLE DANS LE CADRE';
     }
 
+    final bool onGround = _parallelismData!.pose == TargetPose.ground;
+
     // Aligné → message de validation (avec bonus si la cible est détectée)
     if (_parallelismData!.isAligned) {
-      return _targetReady
+      if (_targetReady) return 'PARFAIT — CIBLE DÉTECTÉE, PRÊT';
-          ? 'PARFAIT — CIBLE DÉTECTÉE, PRÊT'
+      return onGround
+          ? 'CIBLE AU SOL — PRÊT À PHOTOGRAPHIER'
           : 'PARALLÈLE OK — PRÊT À PHOTOGRAPHIER';
     }
 
-    // Mal aligné → message directif selon l'axe le plus dévié
+    // Mal aligné → message directif selon l'axe le plus dévié.
-    final double pitch = _parallelismData!.pitchDegrees;
+    // On raisonne sur les écarts à la pose détectée, pas sur le tangage brut :
-    final double roll = _parallelismData!.rollDegrees;
+    // à plat, celui-ci vaut -90° alors que le cadrage peut être parfait.
+    final double pitch = _parallelismData!.pitchDeviation;
+    final double roll = _parallelismData!.rollDeviation;
 
     if (pitch.abs() >= roll.abs()) {
       return pitch > 0
@@ -776,15 +782,25 @@ class _CaptureScreenState extends State<CaptureScreen>
         crossAxisAlignment: CrossAxisAlignment.start,
         mainAxisSize: MainAxisSize.min,
         children: [
+          Text(
+            data.pose == TargetPose.ground ? 'CIBLE AU SOL' : 'CIBLE AU MUR',
+            style: TextStyle(
+              color: color,
+              fontSize: 10,
+              fontWeight: FontWeight.w700,
+              letterSpacing: 0.5,
+            ),
+          ),
+          const SizedBox(height: 4),
           _buildAngleRow(
             label: 'Pitch',
-            value: data.pitchDegrees,
+            value: data.pitchDeviation,
             color: color,
           ),
           const SizedBox(height: 2),
           _buildAngleRow(
             label: 'Roll ',
-            value: data.rollDegrees,
+            value: data.rollDeviation,
             color: color,
           ),
         ],

lib/features/crop/crop_screen.dart

@@ -27,6 +27,11 @@ class CropScreen extends StatefulWidget {
 }
 
 class _CropScreenState extends State<CropScreen> {
+  // Bornes et pas de la rotation, partagés par la jauge et les boutons − / +.
+  static const double _minRotation = -15.0;
+  static const double _maxRotation = 15.0;
+  static const double _rotationStep = 0.1;
+
   final ImageCropService _cropService = ImageCropService();
 
   // États de transformation
@@ -113,7 +118,7 @@ class _CropScreenState extends State<CropScreen> {
                     const SizedBox(width: 8),
                     Flexible(
                       child: Text(
-                        'Alignez et pivotez la cible sur la croix',
+                        'Zoomer au maximum puis aligner votre cible',
                         style: TextStyle(color: Colors.white.withValues(alpha: 0.8), fontSize: 14, fontWeight: FontWeight.w500),
                       ),
                     ),
@@ -155,7 +160,8 @@ class _CropScreenState extends State<CropScreen> {
 
           const SizedBox(height: 8),
 
-          // CROIX DIRECTIONNELLE — déplace la photo pixel par pixel.
+          // CROIX DIRECTIONNELLE — déplace la photo pixel par pixel,
+          // encadrée par les deux boutons de rotation fine.
           _buildDirectionalPad(),
 
           const SizedBox(height: 16),
@@ -180,12 +186,13 @@ class _CropScreenState extends State<CropScreen> {
                 ),
                 Row(
                   children: [
-                    const Icon(Icons.rotate_left, color: Colors.white38, size: 20),
+                    // Les icônes de sens de rotation ont rejoint les boutons − / +
+                    // de la croix directionnelle.
                     Expanded(
                       child: Slider(
                         value: _rotation,
-                        min: -15.0,
+                        min: _minRotation,
-                        max: 15.0,
+                        max: _maxRotation,
                         divisions: 300,
                         label: '${_rotation.toStringAsFixed(1)}°',
                         activeColor: const Color(0xFF1A73E8),
@@ -197,7 +204,6 @@ class _CropScreenState extends State<CropScreen> {
                         },
                       ),
                     ),
-                    const Icon(Icons.rotate_right, color: Colors.white38, size: 20),
                     const SizedBox(width: 4),
                     IconButton(
                       icon: const Icon(Icons.restart_alt, color: Colors.white54, size: 20),
@@ -363,12 +369,18 @@ class _CropScreenState extends State<CropScreen> {
   }
 
   // Croix directionnelle compacte pour déplacer la photo pixel par pixel.
-  // Les symboles « − » et « + » de part et d'autre sont purement décoratifs.
+  // Les boutons « − » et « + » de part et d'autre pivotent l'image de 0,1°.
   Widget _buildDirectionalPad() {
     return Row(
       mainAxisAlignment: MainAxisAlignment.center,
       children: [
-        _buildCropSignLabel('−'),
+        _buildRotationButton(
+          icon: Icons.rotate_left,
+          sign: '−',
+          iconFirst: true,
+          tooltip: 'Pivoter vers la gauche',
+          onPressed: () => _rotateBy(-_rotationStep),
+        ),
         const SizedBox(width: 10),
         Column(
           mainAxisSize: MainAxisSize.min,
@@ -386,7 +398,13 @@ class _CropScreenState extends State<CropScreen> {
           ],
         ),
         const SizedBox(width: 10),
-        _buildCropSignLabel('+'),
+        _buildRotationButton(
+          icon: Icons.rotate_right,
+          sign: '+',
+          iconFirst: false,
+          tooltip: 'Pivoter vers la droite',
+          onPressed: () => _rotateBy(_rotationStep),
+        ),
       ],
     );
   }
@@ -404,10 +422,40 @@ class _CropScreenState extends State<CropScreen> {
     );
   }
 
-  Widget _buildCropSignLabel(String text) {
+  // Bouton de rotation : l'icône de sens est accolée au signe − / +.
-    return Text(
+  Widget _buildRotationButton({
-      text,
+    required IconData icon,
-      style: const TextStyle(color: Colors.white54, fontSize: 24, fontWeight: FontWeight.bold),
+    required String sign,
+    required bool iconFirst,
+    required String tooltip,
+    required VoidCallback onPressed,
+  }) {
+    final content = [
+      Icon(icon, color: Colors.white70, size: 20),
+      const SizedBox(width: 4),
+      Text(
+        sign,
+        style: const TextStyle(color: Colors.white, fontSize: 22, fontWeight: FontWeight.bold),
+      ),
+    ];
+
+    return Tooltip(
+      message: tooltip,
+      child: Material(
+        color: Colors.black54,
+        borderRadius: BorderRadius.circular(6),
+        child: InkWell(
+          onTap: onPressed,
+          borderRadius: BorderRadius.circular(6),
+          child: Padding(
+            padding: const EdgeInsets.symmetric(horizontal: 10, vertical: 8),
+            child: Row(
+              mainAxisSize: MainAxisSize.min,
+              children: iconFirst ? content : content.reversed.toList(),
+            ),
+          ),
+        ),
+      ),
     );
   }
 
@@ -417,6 +465,17 @@ class _CropScreenState extends State<CropScreen> {
     });
   }
 
+  /// Pivote l'image de [delta] degrés, dans les mêmes bornes que la jauge.
+  ///
+  /// La valeur est arrondie au dixième pour rester calée sur les crans de la
+  /// jauge (300 divisions sur 30°) et sur l'affichage.
+  void _rotateBy(double delta) {
+    setState(() {
+      final value = (_rotation + delta).clamp(_minRotation, _maxRotation);
+      _rotation = (value * 10).roundToDouble() / 10;
+    });
+  }
+
   void _onScaleStart(ScaleStartDetails details) {
     _baseScale = _scale;
     _startFocalPoint = details.focalPoint;

lib/features/garage/weapon_detail_screen.dart

@@ -3,6 +3,7 @@ import 'package:provider/provider.dart';
 import 'package:intl/intl.dart';
 import '../../core/constants/app_constants.dart';
 import '../../core/theme/app_theme.dart';
+import '../../core/widgets/weapon_type_icon.dart';
 import '../../data/models/weapon.dart';
 import '../../data/models/maintenance.dart';
 import '../../data/repositories/session_repository.dart';
@@ -131,7 +132,26 @@ class _WeaponDetailScreenState extends State<WeaponDetailScreen> {
             const Text('Informations techniques', style: TextStyle(fontWeight: FontWeight.bold, fontSize: 16)),
             const Divider(),
             _buildInfoRow('Modèle', _weapon.name),
-            _buildInfoRow('Type', _weapon.type.displayName),
+            Padding(
+              padding: const EdgeInsets.symmetric(vertical: 4.0),
+              child: Row(
+                mainAxisAlignment: MainAxisAlignment.spaceBetween,
+                children: [
+                  const Text('Type', style: TextStyle(color: Colors.grey)),
+                  Row(
+                    mainAxisSize: MainAxisSize.min,
+                    children: [
+                      WeaponTypeIcon(type: _weapon.type, size: 16),
+                      const SizedBox(width: 6),
+                      Text(
+                        _weapon.type.displayName,
+                        style: const TextStyle(fontWeight: FontWeight.w500),
+                      ),
+                    ],
+                  ),
+                ],
+              ),
+            ),
             _buildInfoRow('Calibre', _weapon.caliber),
             _buildInfoRow('Chargeurs', '${_weapon.magazineCount} x ${_weapon.magazineCapacity} coups'),
             if (_weapon.notes != null && _weapon.notes!.isNotEmpty) ...[
@@ -313,7 +333,20 @@ class _WeaponDetailScreenState extends State<WeaponDetailScreen> {
                 DropdownButtonFormField<WeaponType>(
                   initialValue: selectedType,
                   decoration: const InputDecoration(labelText: 'Type'),
-                  items: WeaponType.values.map((t) => DropdownMenuItem(value: t, child: Text(t.displayName))).toList(),
+                  items: WeaponType.values
+                      .map(
+                        (t) => DropdownMenuItem(
+                          value: t,
+                          child: Row(
+                            children: [
+                              WeaponTypeIcon(type: t, size: 20),
+                              const SizedBox(width: 10),
+                              Text(t.displayName),
+                            ],
+                          ),
+                        ),
+                      )
+                      .toList(),
                   onChanged: (v) => setState(() => selectedType = v!),
                 ),
                 _autoScrollOnFocus(TextField(

lib/features/garage/weapon_list_screen.dart

@@ -2,12 +2,16 @@ import 'package:flutter/material.dart';
 import 'package:provider/provider.dart';
 import '../../core/constants/app_constants.dart';
 import '../../core/theme/app_theme.dart';
+import '../../core/widgets/glass_container.dart';
+import '../../core/widgets/weapon_type_icon.dart';
 import '../../data/models/weapon.dart';
 import '../../data/repositories/session_repository.dart';
 import 'weapon_detail_screen.dart';
 
 class WeaponListScreen extends StatefulWidget {
-  const WeaponListScreen({super.key});
+  final int refreshTick;
+
+  const WeaponListScreen({super.key, this.refreshTick = 0});
 
   @override
   State<WeaponListScreen> createState() => _WeaponListScreenState();
@@ -23,6 +27,14 @@ class _WeaponListScreenState extends State<WeaponListScreen> {
     _loadWeapons();
   }
 
+  @override
+  void didUpdateWidget(WeaponListScreen oldWidget) {
+    super.didUpdateWidget(oldWidget);
+    if (oldWidget.refreshTick != widget.refreshTick) {
+      _loadWeapons();
+    }
+  }
+
   Future<void> _loadWeapons() async {
     final repository = context.read<SessionRepository>();
     final weapons = await repository.getWeapons();
@@ -36,118 +48,242 @@ class _WeaponListScreenState extends State<WeaponListScreen> {
 
   @override
   Widget build(BuildContext context) {
+    final isDark = Theme.of(context).brightness == Brightness.dark;
+
     return Scaffold(
+      extendBody: true,
       appBar: AppBar(
         title: const Text('Mon Armurerie'),
+        actions: [
+          IconButton(
+            icon: const Icon(Icons.add_circle_outline),
+            tooltip: 'Ajouter une arme',
+            onPressed: _showAddWeaponDialog,
+          ),
+          const SizedBox(width: 8),
+        ],
       ),
       body: _isLoading
           ? const Center(child: CircularProgressIndicator())
           : _weapons.isEmpty
-              ? _buildEmptyState()
+              ? _buildEmptyState(isDark)
-              : _buildWeaponList(),
+              : _buildWeaponList(isDark),
-      floatingActionButton: FloatingActionButton(
-        onPressed: _showAddWeaponDialog,
-        child: const Icon(Icons.add),
-      ),
     );
   }
 
-  Widget _buildEmptyState() {
+  Widget _buildEmptyState(bool isDark) {
     return Center(
+      child: Padding(
+        padding: const EdgeInsets.all(32.0),
         child: Column(
           mainAxisAlignment: MainAxisAlignment.center,
           children: [
-          Icon(Icons.shield, size: 64, color: Colors.grey[400]),
+            GlassContainer(
-          const SizedBox(height: 16),
+              borderRadius: 30,
-          const Text('Aucune arme enregistrée'),
+              padding: const EdgeInsets.all(28),
+              child: Icon(
+                Icons.shield_outlined,
+                size: 64,
+                color: isDark ? AppTheme.darkTextMuted : AppTheme.lightTextMuted,
+              ),
+            ),
             const SizedBox(height: 24),
-          ElevatedButton(
+            Text(
+              'Aucune arme enregistrée',
+              style: TextStyle(
+                fontSize: 18,
+                fontWeight: FontWeight.w800,
+                color: isDark ? AppTheme.darkTextPrimary : AppTheme.lightTextPrimary,
+              ),
+            ),
+            const SizedBox(height: 8),
+            Text(
+              'Ajoutez vos armes pour suivre vos tirs, chargeurs et entretiens.',
+              textAlign: TextAlign.center,
+              style: TextStyle(
+                fontSize: 13,
+                color: isDark ? AppTheme.darkTextSecondary : AppTheme.lightTextSecondary,
+              ),
+            ),
+            const SizedBox(height: 24),
+            ElevatedButton.icon(
               onPressed: _showAddWeaponDialog,
-            child: const Text('Ajouter ma première arme'),
+              icon: const Icon(Icons.add),
+              label: const Text('Ajouter ma première arme'),
             ),
           ],
         ),
+      ),
     );
   }
 
-  Widget _buildWeaponList() {
+  Widget _buildWeaponList(bool isDark) {
     return ListView.builder(
-      padding: const EdgeInsets.all(AppConstants.defaultPadding),
+      padding: const EdgeInsets.fromLTRB(
+        AppConstants.defaultPadding,
+        12,
+        AppConstants.defaultPadding,
+        100, // Espace pour le floating dock
+      ),
       itemCount: _weapons.length,
       itemBuilder: (context, index) {
         final weapon = _weapons[index];
-        final accessories = _accessoryChips(weapon);
+        final accessories = _accessoryChips(weapon, isDark);
-        return Card(
+        final primaryColor = Theme.of(context).colorScheme.primary;
-          margin: const EdgeInsets.only(bottom: 12),
+
-          child: InkWell(
+        return GlassContainer(
-            borderRadius: BorderRadius.circular(12),
+          borderRadius: 18,
+          blur: 14,
+          glowColor: primaryColor,
+          borderColor: isDark
+              ? primaryColor.withValues(alpha: 0.18)
+              : primaryColor.withValues(alpha: 0.12),
+          margin: const EdgeInsets.only(bottom: 14),
+          padding: const EdgeInsets.all(16),
           onTap: () async {
             await Navigator.push(
               context,
-                MaterialPageRoute(builder: (_) => WeaponDetailScreen(weapon: weapon)),
+              MaterialPageRoute(
+                builder: (_) => WeaponDetailScreen(weapon: weapon),
+              ),
             );
-              _loadWeapons(); // Reload in case it was edited or maintenance was added
+            _loadWeapons();
           },
           onLongPress: () => _confirmDelete(weapon),
-            child: Padding(
+          child: Column(
-              // La hauteur du cadre s'adapte automatiquement à la liste d'accessoires.
+            crossAxisAlignment: CrossAxisAlignment.start,
-              padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 12),
+            children: [
-              child: Row(
+              Row(
                 crossAxisAlignment: CrossAxisAlignment.center,
                 children: [
-                  CircleAvatar(
+                  Container(
-                    backgroundColor: AppTheme.primaryColor.withValues(alpha: 0.1),
+                    padding: const EdgeInsets.all(10),
-                    child: Icon(
+                    decoration: BoxDecoration(
-                      weapon.type == WeaponType.handgun ? Icons.shield : Icons.ads_click,
+                      gradient: LinearGradient(
-                      color: AppTheme.primaryColor,
+                        colors: [
+                          primaryColor.withValues(
+                            alpha: isDark ? 0.25 : 0.15,
+                          ),
+                          primaryColor.withValues(
+                            alpha: 0.05,
+                          ),
+                        ],
+                        begin: Alignment.topLeft,
+                        end: Alignment.bottomRight,
+                      ),
+                      borderRadius: BorderRadius.circular(14),
+                      border: Border.all(
+                        color: primaryColor.withValues(
+                          alpha: isDark ? 0.35 : 0.2,
                         ),
                       ),
-                  const SizedBox(width: 16),
+                    ),
+                    child: WeaponTypeIcon(
+                      type: weapon.type,
+                      color: primaryColor,
+                      size: 28,
+                    ),
+                  ),
+                  const SizedBox(width: 14),
                   Expanded(
                     child: Column(
                       crossAxisAlignment: CrossAxisAlignment.start,
-                      mainAxisSize: MainAxisSize.min,
                       children: [
-                        Text(weapon.displayName, style: const TextStyle(fontWeight: FontWeight.bold)),
+                        Text(
+                          weapon.displayName,
+                          style: TextStyle(
+                            fontSize: 16,
+                            fontWeight: FontWeight.w800,
+                            color: isDark
+                                ? AppTheme.darkTextPrimary
+                                : AppTheme.lightTextPrimary,
+                          ),
+                        ),
+                        const SizedBox(height: 4),
+                        Row(
+                          children: [
+                            Container(
+                              padding: const EdgeInsets.symmetric(
+                                horizontal: 7,
+                                vertical: 2,
+                              ),
+                              decoration: BoxDecoration(
+                                color: (isDark ? Colors.white : Colors.black)
+                                    .withValues(alpha: 0.08),
+                                borderRadius: BorderRadius.circular(6),
+                                border: Border.all(
+                                  color: isDark
+                                      ? AppTheme.darkBorder
+                                      : AppTheme.lightBorder,
+                                ),
+                              ),
+                              child: Text(
+                                weapon.caliber,
+                                style: TextStyle(
+                                  fontSize: 11,
+                                  fontWeight: FontWeight.w800,
+                                  color: primaryColor,
+                                ),
+                              ),
+                            ),
+                            const SizedBox(width: 8),
+                            Text(
+                              weapon.type.displayName,
+                              style: TextStyle(
+                                fontSize: 12,
+                                color: isDark
+                                    ? AppTheme.darkTextSecondary
+                                    : AppTheme.lightTextSecondary,
+                              ),
+                            ),
+                          ],
+                        ),
+                      ],
+                    ),
+                  ),
+                  Column(
+                    crossAxisAlignment: CrossAxisAlignment.end,
+                    children: [
+                      Text(
+                        '${weapon.magazineCount} chargeur${weapon.magazineCount > 1 ? 's' : ''}',
+                        style: TextStyle(
+                          fontSize: 12,
+                          fontWeight: FontWeight.w700,
+                          color: isDark
+                              ? AppTheme.darkTextPrimary
+                              : AppTheme.lightTextPrimary,
+                        ),
+                      ),
+                      const SizedBox(height: 2),
+                      Text(
+                        '${weapon.magazineCapacity} coups/ch.',
+                        style: TextStyle(
+                          fontSize: 11,
+                          color: isDark
+                              ? AppTheme.darkTextMuted
+                              : AppTheme.lightTextMuted,
+                        ),
+                      ),
+                    ],
+                  ),
+                ],
+              ),
               if (accessories.isNotEmpty) ...[
-                          const SizedBox(height: 6),
+                const SizedBox(height: 12),
                 Wrap(
                   spacing: 6,
                   runSpacing: 6,
                   children: accessories,
                 ),
-                          const SizedBox(height: 6),
-                        ] else
-                          const SizedBox(height: 2),
-                        Text(
-                          '${weapon.type.displayName} • ${weapon.caliber}',
-                          style: const TextStyle(fontSize: 13, color: Colors.grey),
-                        ),
               ],
-                    ),
-                  ),
-                  const SizedBox(width: 12),
-                  Column(
-                    mainAxisAlignment: MainAxisAlignment.center,
-                    crossAxisAlignment: CrossAxisAlignment.end,
-                    children: [
-                      Text('${weapon.magazineCount} chargeurs', style: const TextStyle(fontSize: 12)),
-                      Text('${weapon.magazineCapacity} coups', style: const TextStyle(fontSize: 12, color: Colors.grey)),
             ],
           ),
-                ],
-              ),
-            ),
-          ),
         );
       },
     );
   }
 
-  // Construit la liste des "puces" d'accessoires renseignés pour une arme.
+  List<Widget> _accessoryChips(Weapon weapon, bool isDark) {
-  // Seuls les accessoires effectivement définis sont affichés ; la card
-  // s'agrandit donc en fonction du nombre d'accessoires.
-  List<Widget> _accessoryChips(Weapon weapon) {
     final items = <(IconData, String)>[];
     if (weapon.optic != null && weapon.optic!.isNotEmpty) {
       items.add((Icons.center_focus_strong, weapon.optic!));
@@ -163,16 +299,29 @@ class _WeaponListScreenState extends State<WeaponListScreen> {
       return Container(
         padding: const EdgeInsets.symmetric(horizontal: 8, vertical: 3),
         decoration: BoxDecoration(
-          color: AppTheme.primaryColor.withValues(alpha: 0.08),
+          color: (isDark ? Colors.white : Colors.black).withValues(alpha: 0.05),
-          borderRadius: BorderRadius.circular(20),
+          borderRadius: BorderRadius.circular(8),
-          border: Border.all(color: AppTheme.primaryColor.withValues(alpha: 0.25)),
+          border: Border.all(
+            color: isDark ? AppTheme.darkBorder : AppTheme.lightBorder,
+          ),
         ),
         child: Row(
           mainAxisSize: MainAxisSize.min,
           children: [
-            Icon(item.$1, size: 13, color: AppTheme.primaryColor),
+            Icon(
-            const SizedBox(width: 4),
+              item.$1,
-            Text(item.$2, style: const TextStyle(fontSize: 12)),
+              size: 13,
+              color: isDark ? AppTheme.darkTextSecondary : AppTheme.lightTextSecondary,
+            ),
+            const SizedBox(width: 5),
+            Text(
+              item.$2,
+              style: TextStyle(
+                fontSize: 11,
+                fontWeight: FontWeight.w600,
+                color: isDark ? AppTheme.darkTextSecondary : AppTheme.lightTextSecondary,
+              ),
+            ),
           ],
         ),
       );
@@ -180,7 +329,6 @@ class _WeaponListScreenState extends State<WeaponListScreen> {
   }
 
   void _showAddWeaponDialog() async {
-    // Capturé AVANT l'await : plus aucun usage du context après le dialogue.
     final repository = context.read<SessionRepository>();
     final nameController = TextEditingController();
     final caliberController = TextEditingController();
@@ -190,7 +338,7 @@ class _WeaponListScreenState extends State<WeaponListScreen> {
 
     final result = await showDialog<bool>(
       context: context,
-      builder: (context) => StatefulBuilder(
+      builder: (dialogCtx) => StatefulBuilder(
         builder: (context, setState) => AlertDialog(
           title: const Text('Ajouter une arme'),
           content: SingleChildScrollView(
@@ -199,18 +347,40 @@ class _WeaponListScreenState extends State<WeaponListScreen> {
               children: [
                 TextField(
                   controller: nameController,
-                  decoration: const InputDecoration(labelText: 'Nom de l\'arme', hintText: 'ex: Glock 17'),
+                  decoration: const InputDecoration(
+                    labelText: 'Nom de l\'arme',
+                    hintText: 'ex: Glock 17 Gen 5',
                   ),
+                ),
+                const SizedBox(height: 12),
                 DropdownButtonFormField<WeaponType>(
                   initialValue: selectedType,
                   decoration: const InputDecoration(labelText: 'Type'),
-                  items: WeaponType.values.map((t) => DropdownMenuItem(value: t, child: Text(t.displayName))).toList(),
+                  items: WeaponType.values
+                      .map(
+                        (t) => DropdownMenuItem(
+                          value: t,
+                          child: Row(
+                            children: [
+                              WeaponTypeIcon(type: t, size: 20),
+                              const SizedBox(width: 10),
+                              Text(t.displayName),
+                            ],
+                          ),
+                        ),
+                      )
+                      .toList(),
                   onChanged: (v) => setState(() => selectedType = v!),
                 ),
+                const SizedBox(height: 12),
                 TextField(
                   controller: caliberController,
-                  decoration: const InputDecoration(labelText: 'Calibre', hintText: 'ex: 9mm, .22LR'),
+                  decoration: const InputDecoration(
+                    labelText: 'Calibre',
+                    hintText: 'ex: 9x19mm, .22 LR, .223 Rem',
                   ),
+                ),
+                const SizedBox(height: 12),
                 Row(
                   children: [
                     Expanded(
@@ -220,7 +390,7 @@ class _WeaponListScreenState extends State<WeaponListScreen> {
                         keyboardType: TextInputType.number,
                       ),
                     ),
-                    const SizedBox(width: 16),
+                    const SizedBox(width: 12),
                     Expanded(
                       child: TextField(
                         controller: magCapController,
@@ -234,8 +404,14 @@ class _WeaponListScreenState extends State<WeaponListScreen> {
             ),
           ),
           actions: [
-            TextButton(onPressed: () => Navigator.pop(context, false), child: const Text('Annuler')),
+            TextButton(
-            ElevatedButton(onPressed: () => Navigator.pop(context, true), child: const Text('Ajouter')),
+              onPressed: () => Navigator.pop(dialogCtx, false),
+              child: const Text('Annuler'),
+            ),
+            ElevatedButton(
+              onPressed: () => Navigator.pop(dialogCtx, true),
+              child: const Text('Ajouter'),
+            ),
           ],
         ),
       ),
@@ -255,18 +431,24 @@ class _WeaponListScreenState extends State<WeaponListScreen> {
   }
 
   void _confirmDelete(Weapon weapon) async {
-    // Capturé AVANT l'await : plus aucun usage du context après le dialogue.
     final repository = context.read<SessionRepository>();
     final confirmed = await showDialog<bool>(
       context: context,
       builder: (context) => AlertDialog(
-        title: const Text('Supprimer'),
+        title: const Text('Supprimer l\'arme'),
         content: Text('Voulez-vous supprimer ${weapon.name} de votre armurerie ?'),
         actions: [
-          TextButton(onPressed: () => Navigator.pop(context, false), child: const Text('Annuler')),
           TextButton(
+            onPressed: () => Navigator.pop(context, false),
+            child: const Text('Annuler'),
+          ),
+          ElevatedButton(
             onPressed: () => Navigator.pop(context, true),
-            child: const Text('Supprimer', style: TextStyle(color: AppTheme.errorColor)),
+            style: ElevatedButton.styleFrom(
+              backgroundColor: AppTheme.errorColor,
+              foregroundColor: Colors.white,
+            ),
+            child: const Text('Supprimer'),
           ),
         ],
       ),

lib/features/history/history_screen.dart

@@ -1,7 +1,6 @@
 import 'package:flutter/material.dart';
 import 'package:provider/provider.dart';
 import 'package:intl/intl.dart';
-import '../../core/constants/app_constants.dart';
 import '../../core/theme/app_theme.dart';
 import '../../data/models/session.dart';
 import '../../data/models/target_type.dart';
@@ -11,10 +10,6 @@ import 'widgets/session_list_item.dart';
 import 'widgets/history_chart.dart';
 
 class HistoryScreen extends StatefulWidget {
-  /// Incrémenté par la navigation à chaque ouverture de l'onglet Historique,
-  /// pour forcer un rechargement des sessions (l'écran est gardé vivant par un
-  /// IndexedStack, sinon une session tout juste clôturée n'apparaîtrait pas
-  /// tant qu'on ne tire pas manuellement pour rafraîchir).
   final int refreshTick;
 
   const HistoryScreen({super.key, this.refreshTick = 0});
@@ -27,8 +22,6 @@ class _HistoryScreenState extends State<HistoryScreen> {
   List<Session> _sessions = [];
   bool _isLoading = true;
   TargetType? _filterType;
-
-  // --- MODIFICATION : Remplacement de DateTime par DateTimeRange ---
   DateTimeRange? _selectedDateRange;
 
   @override
@@ -40,8 +33,6 @@ class _HistoryScreenState extends State<HistoryScreen> {
   @override
   void didUpdateWidget(HistoryScreen oldWidget) {
     super.didUpdateWidget(oldWidget);
-    // L'onglet vient d'être ré-ouvert : on recharge pour afficher les sessions
-    // récemment clôturées sans avoir à tirer manuellement pour rafraîchir.
     if (oldWidget.refreshTick != widget.refreshTick) {
       _loadSessions();
     }
@@ -59,18 +50,14 @@ class _HistoryScreenState extends State<HistoryScreen> {
         setState(() {
           _sessions = sessions;
 
-          // --- FILTRAGE PAR TYPE DE CIBLE ---
-          // Une session est retenue si au moins une de ses cibles est du type choisi.
           if (_filterType != null) {
             _sessions = _sessions
                 .where((s) => s.analyses.any((a) => a.targetType == _filterType))
                 .toList();
           }
 
-          // --- LOGIQUE DE FILTRAGE PAR PÉRIODE ---
           if (_selectedDateRange != null) {
             _sessions = _sessions.where((s) {
-              // On compare uniquement les dates (sans les heures) pour éviter les bugs
               final sessionDate = DateTime(
                 s.createdAt.year,
                 s.createdAt.month,
@@ -109,32 +96,13 @@ class _HistoryScreenState extends State<HistoryScreen> {
     }
   }
 
-  // --- MODIFICATION : Fonction DateRangePicker ---
   Future<void> _pickDateRange() async {
-    final DateTimeRange? picked = await showDateRangePicker(
+    final picked = await showDateRangePicker(
       context: context,
       initialDateRange: _selectedDateRange,
       firstDate: DateTime(2020),
       lastDate: DateTime.now().add(const Duration(days: 1)),
       locale: const Locale('fr', 'FR'),
-      builder: (context, child) {
-        return Theme(
-          data: ThemeData.light().copyWith(
-            colorScheme: ColorScheme.light(
-              primary: AppTheme.primaryColor,   // En-tête et sélection
-              onPrimary: Colors.white,          // Texte sur en-tête/sélection
-              surface: Colors.white,            // Fond du calendrier
-              onSurface: Colors.black87,        // Texte des dates (Noir sur Blanc)
-              secondary: AppTheme.primaryColor,
-            ),
-            dialogTheme: const DialogThemeData(backgroundColor: Colors.white),
-            textButtonTheme: TextButtonThemeData(
-              style: TextButton.styleFrom(foregroundColor: AppTheme.primaryColor),
-            ),
-          ),
-          child: child!,
-        );
-      },
     );
 
     if (picked != null) {
@@ -145,88 +113,139 @@ class _HistoryScreenState extends State<HistoryScreen> {
 
   @override
   Widget build(BuildContext context) {
+    final isDark = Theme.of(context).brightness == Brightness.dark;
+
     return Scaffold(
+      extendBody: true,
       appBar: AppBar(
-        title: const Text('Historique'),
+        title: const Text('Carnet de Tir'),
         actions: [
-          // NOTE : on passe par un String sentinelle ('all') car un
+          IconButton(
-          // PopupMenuItem avec value null ne déclenche jamais onSelected
-          // (Flutter l'interprète comme une annulation du menu).
-          PopupMenuButton<String>(
             icon: Icon(
-              Icons.filter_list,
+              Icons.date_range_outlined,
-              // Icône colorée quand un filtre est actif, pour le rendre visible.
+              color: _selectedDateRange != null ? AppTheme.primaryColor : null,
-              color: _filterType != null ? AppTheme.primaryColor : null,
             ),
-            onSelected: (value) {
+            tooltip: 'Filtrer par date',
-              setState(() {
+            onPressed: _pickDateRange,
-                _filterType =
-                    value == 'all' ? null : TargetType.fromString(value);
-              });
-              _loadSessions();
-            },
-            itemBuilder: (context) => [
-              const PopupMenuItem(value: 'all', child: Text('Tous')),
-              ...TargetType.values.map(
-                (type) => PopupMenuItem(
-                  value: type.name,
-                  child: Text(type.displayName),
-                ),
-              ),
-            ],
           ),
+          const SizedBox(width: 8),
         ],
       ),
       body: Column(
         children: [
+          _buildFilterChips(isDark),
           Expanded(
             child: _isLoading
                 ? const Center(child: CircularProgressIndicator())
                 : _sessions.isEmpty
-                ? _buildEmptyState()
+                    ? _buildEmptyState(isDark)
-                : _buildContent(),
+                    : _buildContent(isDark),
           ),
-          _buildBottomFilterBar(),
+          if (_selectedDateRange != null) _buildActivePeriodBanner(isDark),
         ],
       ),
     );
   }
 
-  Widget _buildBottomFilterBar() {
+  Widget _buildFilterChips(bool isDark) {
     return Container(
-      padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 12),
+      padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
       decoration: BoxDecoration(
-        color: Theme.of(context).cardColor,
+        color: isDark ? AppTheme.darkBackground : AppTheme.lightBackground,
-        boxShadow: const [
+        border: Border(
-          BoxShadow(
+          bottom: BorderSide(
-            color: Colors.black26,
+            color: isDark ? AppTheme.darkBorder : AppTheme.lightBorder,
-            blurRadius: 4,
+            width: 1,
-            offset: Offset(0, -2),
+          ),
+        ),
+      ),
+      child: SingleChildScrollView(
+        scrollDirection: Axis.horizontal,
+        child: Row(
+          children: [
+            _buildTypeFilterChip('Toutes les cibles', null),
+            const SizedBox(width: 8),
+            _buildTypeFilterChip(
+              'Cibles 1-10',
+              TargetType.concentric,
+            ),
+            const SizedBox(width: 8),
+            _buildTypeFilterChip(
+              'Silhouettes',
+              TargetType.silhouette,
             ),
           ],
         ),
+      ),
+    );
+  }
+
+  Widget _buildTypeFilterChip(String label, TargetType? type) {
+    final isSelected = _filterType == type;
+    return ChoiceChip(
+      label: Text(label),
+      selected: isSelected,
+      onSelected: (selected) {
+        if (selected) {
+          setState(() => _filterType = type);
+          _loadSessions();
+        }
+      },
+    );
+  }
+
+  Widget _buildActivePeriodBanner(bool isDark) {
+    final start = DateFormat('dd/MM/yy').format(_selectedDateRange!.start);
+    final end = DateFormat('dd/MM/yy').format(_selectedDateRange!.end);
+
+    return Container(
+      padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 10),
+      decoration: BoxDecoration(
+        color: isDark ? AppTheme.darkSurface : AppTheme.lightSurface,
+        border: Border(
+          top: BorderSide(
+            color: isDark ? AppTheme.darkBorder : AppTheme.lightBorder,
+          ),
+        ),
+      ),
       child: SafeArea(
         top: false,
         child: Row(
           children: [
-            Expanded(
+            const Icon(Icons.event, size: 18, color: AppTheme.primaryColor),
-              child: OutlinedButton.icon(
+            const SizedBox(width: 8),
-                onPressed: _pickDateRange,
+            Text(
-                icon: const Icon(Icons.date_range, size: 18),
+              'Période : $start - $end',
-                label: Text(
+              style: TextStyle(
-                  _selectedDateRange == null
+                fontSize: 13,
-                      ? 'Choisir une période'
+                fontWeight: FontWeight.w600,
-                      : '${DateFormat('dd/MM/yy').format(_selectedDateRange!.start)} - ${DateFormat('dd/MM/yy').format(_selectedDateRange!.end)}',
+                color: isDark ? AppTheme.darkTextPrimary : AppTheme.lightTextPrimary,
               ),
             ),
-            ),
+            const Spacer(),
-            if (_selectedDateRange != null)
+            InkWell(
-              IconButton(
+              onTap: () {
-                icon: const Icon(Icons.close, color: AppTheme.errorColor),
-                onPressed: () {
                 setState(() => _selectedDateRange = null);
                 _loadSessions();
               },
+              borderRadius: BorderRadius.circular(6),
+              child: Padding(
+                padding: const EdgeInsets.symmetric(horizontal: 8, vertical: 4),
+                child: Row(
+                  children: [
+                    Text(
+                      'Effacer',
+                      style: TextStyle(
+                        fontSize: 12,
+                        fontWeight: FontWeight.w600,
+                        color: AppTheme.errorColor,
+                      ),
+                    ),
+                    const SizedBox(width: 4),
+                    const Icon(Icons.close, size: 14, color: AppTheme.errorColor),
+                  ],
+                ),
+              ),
             ),
           ],
         ),
@@ -234,45 +253,81 @@ class _HistoryScreenState extends State<HistoryScreen> {
     );
   }
 
-  Widget _buildEmptyState() {
+  Widget _buildEmptyState(bool isDark) {
     return Center(
+      child: Padding(
+        padding: const EdgeInsets.all(32.0),
         child: Column(
           mainAxisAlignment: MainAxisAlignment.center,
           children: [
-          Icon(Icons.history, size: 64, color: Colors.grey[400]),
+            Container(
-          const SizedBox(height: 16),
+              padding: const EdgeInsets.all(24),
-          const Text('Aucune session sur cette période'),
+              decoration: BoxDecoration(
+                color: isDark ? AppTheme.darkSurface : AppTheme.lightSurfaceVariant,
+                shape: BoxShape.circle,
+                border: Border.all(
+                  color: isDark ? AppTheme.darkBorder : AppTheme.lightBorder,
+                ),
+              ),
+              child: Icon(
+                Icons.history_toggle_off,
+                size: 56,
+                color: isDark ? AppTheme.darkTextMuted : AppTheme.lightTextMuted,
+              ),
+            ),
+            const SizedBox(height: 18),
+            Text(
+              'Aucune session trouvée',
+              style: TextStyle(
+                fontSize: 17,
+                fontWeight: FontWeight.w700,
+                color: isDark ? AppTheme.darkTextPrimary : AppTheme.lightTextPrimary,
+              ),
+            ),
+            const SizedBox(height: 6),
+            Text(
+              _selectedDateRange != null || _filterType != null
+                  ? 'Essayez de réinitialiser vos filtres de recherche.'
+                  : 'Vos sessions enregistrées apparaîtront ici.',
+              textAlign: TextAlign.center,
+              style: TextStyle(
+                fontSize: 13,
+                color: isDark ? AppTheme.darkTextSecondary : AppTheme.lightTextSecondary,
+              ),
+            ),
           ],
         ),
+      ),
     );
   }
 
-  Widget _buildContent() {
+  Widget _buildContent(bool isDark) {
     return RefreshIndicator(
       onRefresh: _loadSessions,
+      color: AppTheme.primaryColor,
       child: CustomScrollView(
         slivers: [
           if (_sessions.length >= 2 && _selectedDateRange == null)
             SliverToBoxAdapter(
               child: Padding(
-                padding: const EdgeInsets.all(AppConstants.defaultPadding),
+                padding: const EdgeInsets.fromLTRB(16, 16, 16, 8),
                 child: HistoryChart(sessions: _sessions),
               ),
             ),
           SliverPadding(
-            padding: const EdgeInsets.all(AppConstants.defaultPadding),
+            padding: const EdgeInsets.fromLTRB(16, 8, 16, 100),
             sliver: SliverList(
-              delegate: SliverChildBuilderDelegate((context, index) {
+              delegate: SliverChildBuilderDelegate(
+                (context, index) {
                   final session = _sessions[index];
-                return Padding(
+                  return SessionListItem(
-                  padding: const EdgeInsets.only(bottom: 12),
-                  child: SessionListItem(
                     session: session,
                     onTap: () => _openSessionDetail(session),
                     onDelete: () => _deleteSession(session),
-                  ),
                   );
-              }, childCount: _sessions.length),
+                },
+                childCount: _sessions.length,
+              ),
             ),
           ),
         ],
@@ -292,21 +347,22 @@ class _HistoryScreenState extends State<HistoryScreen> {
     final confirmed = await showDialog<bool>(
       context: context,
       builder: (context) => AlertDialog(
-        title: const Text('Supprimer'),
+        title: const Text('Supprimer la session'),
         content: Text(
-          'Supprimer la session du ${DateFormat('dd/MM/yyyy').format(session.createdAt)}?',
+          'Voulez-vous supprimer définitivement la session du ${DateFormat('dd/MM/yyyy à HH:mm').format(session.createdAt)} ?',
         ),
         actions: [
           TextButton(
             onPressed: () => Navigator.pop(context, false),
             child: const Text('Annuler'),
           ),
-          TextButton(
+          ElevatedButton(
             onPressed: () => Navigator.pop(context, true),
-            child: const Text(
+            style: ElevatedButton.styleFrom(
-              'Supprimer',
+              backgroundColor: AppTheme.errorColor,
-              style: TextStyle(color: AppTheme.errorColor),
+              foregroundColor: Colors.white,
             ),
+            child: const Text('Supprimer'),
           ),
         ],
       ),

lib/features/history/widgets/session_list_item.dart

@@ -2,6 +2,7 @@ import 'dart:io';
 import 'package:flutter/material.dart';
 import 'package:intl/intl.dart';
 import '../../../core/theme/app_theme.dart';
+import '../../../core/widgets/glass_container.dart';
 import '../../../data/models/session.dart';
 
 class SessionListItem extends StatelessWidget {
@@ -18,60 +19,99 @@ class SessionListItem extends StatelessWidget {
 
   @override
   Widget build(BuildContext context) {
-    return Card(
+    final isDark = Theme.of(context).brightness == Brightness.dark;
-      clipBehavior: Clip.antiAlias,
+    final textSecondary = isDark ? AppTheme.darkTextSecondary : AppTheme.lightTextSecondary;
-      child: InkWell(
+    final textMuted = isDark ? AppTheme.darkTextMuted : AppTheme.lightTextMuted;
+
+    // Calcul de la couleur du score selon la moyenne par tir
+    final primaryColor = Theme.of(context).colorScheme.primary;
+    final avg = session.averageScore;
+    Color scoreColor = primaryColor;
+    if (avg >= 9.0) {
+      scoreColor = AppTheme.secondaryColor;
+    } else if (avg >= 7.5) {
+      scoreColor = primaryColor;
+    } else {
+      scoreColor = isDark ? AppTheme.darkTextSecondary : AppTheme.lightTextSecondary;
+    }
+
+    final formattedDate = DateFormat('dd/MM/yyyy • HH:mm', 'fr_FR').format(session.createdAt);
+
+    return GlassContainer(
+      borderRadius: 18,
+      blur: 14,
+      glowColor: scoreColor,
+      borderColor: isDark ? scoreColor.withValues(alpha: 0.2) : scoreColor.withValues(alpha: 0.15),
+      margin: const EdgeInsets.only(bottom: 12),
+      padding: const EdgeInsets.all(14),
       onTap: onTap,
-        child: Padding(
-          padding: const EdgeInsets.all(12),
       child: Row(
         children: [
-              // Thumbnail (from first target)
+          // Aperçu de la cible avec bordure nette
           ClipRRect(
-                borderRadius: BorderRadius.circular(8),
+            borderRadius: BorderRadius.circular(12),
-                child: SizedBox(
+            child: Container(
-                  width: 60,
+              width: 56,
-                  height: 60,
+              height: 56,
-                  child: _buildThumbnail(),
+              decoration: BoxDecoration(
+                color: (isDark ? Colors.white : Colors.black).withValues(alpha: 0.05),
+                borderRadius: BorderRadius.circular(12),
+                border: Border.all(
+                  color: isDark ? AppTheme.darkBorder : AppTheme.lightBorder,
                 ),
               ),
-              const SizedBox(width: 12),
+              child: _buildThumbnail(isDark),
+            ),
+          ),
+          const SizedBox(width: 14),
 
-              // Info
+          // Informations de la session
           Expanded(
             child: Column(
               crossAxisAlignment: CrossAxisAlignment.start,
               children: [
-                    Row(
-                      children: [
-                        const Icon(
-                          Icons.shield,
-                          size: 16,
-                          color: AppTheme.primaryColor,
-                        ),
-                        const SizedBox(width: 4),
                 Text(
                   session.weapon,
-                          style: const TextStyle(
+                  style: TextStyle(
-                            fontWeight: FontWeight.bold,
+                    fontSize: 15,
+                    fontWeight: FontWeight.w700,
+                    color: isDark ? AppTheme.darkTextPrimary : AppTheme.lightTextPrimary,
                   ),
+                  maxLines: 1,
+                  overflow: TextOverflow.ellipsis,
                 ),
-                      ],
+                const SizedBox(height: 3),
-                    ),
-                    const SizedBox(height: 4),
                 Text(
-                      DateFormat('dd/MM/yyyy HH:mm').format(session.createdAt),
+                  formattedDate,
-                      style: Theme.of(context).textTheme.bodySmall,
+                  style: TextStyle(
+                    fontSize: 11,
+                    color: textSecondary,
                   ),
-                    const SizedBox(height: 4),
+                ),
+                const SizedBox(height: 5),
                 Row(
                   children: [
-                        Icon(Icons.track_changes, size: 14, color: Colors.grey[600]),
+                    Container(
-                        const SizedBox(width: 4),
+                      padding: const EdgeInsets.symmetric(horizontal: 7, vertical: 2),
+                      decoration: BoxDecoration(
+                        color: (isDark ? Colors.white : Colors.black).withValues(alpha: 0.06),
+                        borderRadius: BorderRadius.circular(6),
+                      ),
+                      child: Text(
+                        '${session.distance}m',
+                        style: TextStyle(
+                          fontSize: 10,
+                          fontWeight: FontWeight.w700,
+                          color: isDark ? AppTheme.darkTextPrimary : AppTheme.lightTextPrimary,
+                        ),
+                      ),
+                    ),
+                    const SizedBox(width: 6),
                     Text(
-                          '${session.targetCount} cible(s) • ${session.distance}m',
+                      '${session.targetCount} cible${session.targetCount > 1 ? 's' : ''} • ${session.totalShots} tirs',
-                          style: Theme.of(context).textTheme.bodySmall?.copyWith(
+                      style: TextStyle(
-                            color: Colors.grey[600],
+                        fontSize: 11,
+                        color: textMuted,
                       ),
                     ),
                   ],
@@ -80,41 +120,58 @@ class SessionListItem extends StatelessWidget {
             ),
           ),
 
-              // Score
+          // Score et moyenne stylisés façon cyber HUD
-              Column(
+          Container(
+            padding: const EdgeInsets.symmetric(horizontal: 10, vertical: 6),
+            decoration: BoxDecoration(
+              color: scoreColor.withValues(alpha: isDark ? 0.12 : 0.08),
+              borderRadius: BorderRadius.circular(12),
+              border: Border.all(
+                color: scoreColor.withValues(alpha: isDark ? 0.3 : 0.2),
+              ),
+            ),
+            child: Column(
               crossAxisAlignment: CrossAxisAlignment.end,
               children: [
                 Text(
                   '${session.totalScore}',
-                    style: Theme.of(context).textTheme.headlineSmall?.copyWith(
+                  style: TextStyle(
-                      fontWeight: FontWeight.bold,
+                    fontSize: 18,
-                      color: AppTheme.primaryColor,
+                    fontWeight: FontWeight.w900,
+                    color: scoreColor,
+                    letterSpacing: -0.5,
                   ),
                 ),
                 Text(
-                    '${session.totalShots} tirs',
+                  'Moy. ${session.averageScore.toStringAsFixed(1)}',
-                    style: Theme.of(context).textTheme.bodySmall,
+                  style: TextStyle(
+                    fontSize: 10,
+                    fontWeight: FontWeight.w700,
+                    color: scoreColor,
+                  ),
                 ),
               ],
             ),
+          ),
 
-              // Delete button
+          // Bouton supprimer
-              if (onDelete != null)
+          if (onDelete != null) ...[
+            const SizedBox(width: 4),
             IconButton(
-                  icon: const Icon(Icons.delete_outline),
+              icon: const Icon(Icons.delete_outline_rounded),
               onPressed: onDelete,
-                  color: Colors.grey,
+              color: textMuted,
               iconSize: 20,
+              tooltip: 'Supprimer',
             ),
           ],
-          ),
+        ],
-        ),
       ),
     );
   }
 
-  Widget _buildThumbnail() {
+  Widget _buildThumbnail(bool isDark) {
-    if (session.analyses.isEmpty) return _buildPlaceholder();
+    if (session.analyses.isEmpty) return _buildPlaceholder(isDark);
 
     final file = File(session.analyses.first.imagePath);
 
@@ -122,20 +179,18 @@ class SessionListItem extends StatelessWidget {
       return Image.file(
         file,
         fit: BoxFit.cover,
-        errorBuilder: (_, _, _) => _buildPlaceholder(),
+        errorBuilder: (_, _, _) => _buildPlaceholder(isDark),
       );
     }
 
-    return _buildPlaceholder();
+    return _buildPlaceholder(isDark);
   }
 
-  Widget _buildPlaceholder() {
+  Widget _buildPlaceholder(bool isDark) {
-    return Container(
+    return Icon(
-      color: Colors.grey[200],
-      child: Icon(
       Icons.track_changes,
-        color: Colors.grey[400],
+      color: isDark ? AppTheme.darkTextMuted : AppTheme.lightTextMuted,
-      ),
+      size: 24,
     );
   }
 }

lib/features/home/widgets/stats_card.dart

@@ -1,17 +1,14 @@
-/// Widget carte réutilisable pour afficher une statistique.
-///
-/// Affiche une icône, un titre et une valeur avec une couleur personnalisable.
-/// Utilisé sur l'écran d'accueil pour les statistiques rapides.
-library;
-
 import 'package:flutter/material.dart';
-import '../../../core/constants/app_constants.dart';
+import '../../../core/theme/app_theme.dart';
+import '../../../core/widgets/glass_container.dart';
 
+/// Widget carte télémétrique moderne avec effet Glassmorphism givré.
 class StatsCard extends StatelessWidget {
   final IconData icon;
   final String title;
   final String value;
   final Color color;
+  final String? subtitle;
 
   const StatsCard({
     super.key,
@@ -19,33 +16,82 @@ class StatsCard extends StatelessWidget {
     required this.title,
     required this.value,
     required this.color,
+    this.subtitle,
   });
 
   @override
   Widget build(BuildContext context) {
-    return Card(
+    final isDark = Theme.of(context).brightness == Brightness.dark;
-      child: Padding(
+    final textSecondary = isDark ? AppTheme.darkTextSecondary : AppTheme.lightTextSecondary;
-        padding: const EdgeInsets.all(AppConstants.defaultPadding),
+
+    return GlassContainer(
+      borderRadius: 18,
+      blur: 14,
+      glowColor: color,
+      borderColor: isDark ? color.withValues(alpha: 0.22) : color.withValues(alpha: 0.18),
+      padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 14),
       child: Column(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        mainAxisAlignment: MainAxisAlignment.center,
         children: [
-            Icon(icon, color: color, size: 32),
+          Row(
-            const SizedBox(height: 8),
+            mainAxisAlignment: MainAxisAlignment.spaceBetween,
-            Text(
+            children: [
-              value,
+              Container(
-              style: Theme.of(context).textTheme.headlineSmall?.copyWith(
+                padding: const EdgeInsets.all(8),
-                fontWeight: FontWeight.bold,
+                decoration: BoxDecoration(
-                color: color,
+                  color: color.withValues(alpha: isDark ? 0.18 : 0.12),
+                  borderRadius: BorderRadius.circular(10),
+                  border: Border.all(
+                    color: color.withValues(alpha: isDark ? 0.35 : 0.25),
+                    width: 1,
                   ),
                 ),
-            const SizedBox(height: 4),
+                child: Icon(icon, color: color, size: 20),
-            Text(
+              ),
-              title,
+              if (subtitle != null)
-              style: Theme.of(context).textTheme.bodySmall?.copyWith(
+                Container(
-                color: Colors.grey[600],
+                  padding: const EdgeInsets.symmetric(horizontal: 6, vertical: 2),
+                  decoration: BoxDecoration(
+                    color: (isDark ? Colors.white : Colors.black).withValues(alpha: 0.05),
+                    borderRadius: BorderRadius.circular(6),
+                  ),
+                  child: Text(
+                    subtitle!,
+                    style: TextStyle(
+                      fontSize: 10,
+                      fontWeight: FontWeight.w600,
+                      color: textSecondary,
+                    ),
                   ),
                 ),
             ],
           ),
+          const SizedBox(height: 12),
+          Text(
+            value,
+            style: TextStyle(
+              fontSize: 22,
+              fontWeight: FontWeight.w800,
+              color: isDark ? AppTheme.darkTextPrimary : AppTheme.lightTextPrimary,
+              letterSpacing: -0.5,
+            ),
+            maxLines: 1,
+            overflow: TextOverflow.ellipsis,
+          ),
+          const SizedBox(height: 2),
+          Text(
+            title,
+            style: TextStyle(
+              fontSize: 12,
+              fontWeight: FontWeight.w500,
+              color: textSecondary,
+              letterSpacing: 0.1,
+            ),
+            maxLines: 1,
+            overflow: TextOverflow.ellipsis,
+          ),
+        ],
       ),
     );
   }

lib/features/session/session_provider.dart

@@ -6,6 +6,7 @@ class SessionProvider extends ChangeNotifier {
   DateTime? get sessionDate => _sessionDate;
   String? _currentWeaponName;
   String? _currentWeaponId;
+  String? _currentWeaponCaliber;
   int _shotsPerTarget = 5;
   int _distance = 25;
   String? _activeSessionId;
@@ -14,6 +15,11 @@ class SessionProvider extends ChangeNotifier {
 
   String? get currentWeapon => _currentWeaponName;
   String? get currentWeaponId => _currentWeaponId;
+
+  /// Calibre de l'arme de la session. Contrairement au nom d'arme, il ne
+  /// designe pas l'utilisateur : c'est la seule donnee d'arme envoyee au
+  /// backend d'entrainement (le diametre des trous en depend).
+  String? get currentWeaponCaliber => _currentWeaponCaliber;
   int get shotsPerTarget => _shotsPerTarget;
   int get distance => _distance;
   bool get isSessionActive => _isSessionActive;
@@ -23,9 +29,10 @@ class SessionProvider extends ChangeNotifier {
   int get totalSessionScore => _currentAnalyses.fold(0, (sum, a) => sum + a.totalScore);
   int get targetCount => _currentAnalyses.length;
 
-  void startSession(String weaponName, int shots, String sessionId, {String? weaponId, int distance = 25, DateTime? date}) {
+  void startSession(String weaponName, int shots, String sessionId, {String? weaponId, String? caliber, int distance = 25, DateTime? date}) {
     _currentWeaponName = weaponName;
     _currentWeaponId = weaponId;
+    _currentWeaponCaliber = caliber;
     _shotsPerTarget = shots;
     _distance = distance;
     _sessionDate = date ?? DateTime.now();
@@ -45,6 +52,7 @@ class SessionProvider extends ChangeNotifier {
     _activeSessionId = null;
     _currentWeaponId = null;
     _currentWeaponName = null;
+    _currentWeaponCaliber = null;
     _currentAnalyses.clear();
     _distance = 25;
     notifyListeners();

lib/features/session/session_setup_screen.dart

@@ -1,6 +1,6 @@
 import 'package:flutter/material.dart';
 import 'package:provider/provider.dart';
-import 'package:intl/intl.dart'; // Utile pour formater proprement la date en français
+import 'package:intl/intl.dart';
 import '../../core/constants/app_constants.dart';
 import '../../core/theme/app_theme.dart';
 import '../../data/models/weapon.dart';
@@ -25,9 +25,17 @@ class _SessionSetupScreenState extends State<SessionSetupScreen> {
   Weapon? _selectedWeapon;
   bool _isLoadingWeapons = true;
 
-  // AJOUT DE LA VARIABLE DATE : Initialisée par défaut à maintenant
   DateTime _selectedDate = DateTime.now();
 
+  /// Valeur sentinelle de l'item "Ajouter une nouvelle arme" du menu deroulant.
+  static const String _addWeaponValue = '__add_weapon__';
+
+  final GlobalKey<FormFieldState<String>> _weaponFieldKey =
+      GlobalKey<FormFieldState<String>>();
+
+  static const List<int> _presetDistances = [10, 15, 25, 50, 100, 200];
+  static const List<int> _presetShots = [3, 5, 10, 15, 20, 30, 50];
+
   @override
   void initState() {
     super.initState();
@@ -42,8 +50,21 @@ class _SessionSetupScreenState extends State<SessionSetupScreen> {
     if (mounted) {
       setState(() {
         _availableWeapons = weapons;
-        if (_availableWeapons.isNotEmpty && _selectedWeapon == null) {
+
-          _selectedWeapon = _availableWeapons.first;
+        // Les armes rechargees sont de nouvelles instances (Weapon n'a pas
+        // d'operator ==) et l'arme selectionnee a pu etre supprimee : on
+        // re-resout la selection par identifiant.
+        final previousId = _selectedWeapon?.id;
+        _selectedWeapon = null;
+        for (final weapon in weapons) {
+          if (weapon.id == previousId) {
+            _selectedWeapon = weapon;
+            break;
+          }
+        }
+
+        if (_selectedWeapon == null && weapons.isNotEmpty) {
+          _selectedWeapon = weapons.first;
           _updateSettingsForWeapon(_selectedWeapon!);
         }
         _isLoadingWeapons = false;
@@ -51,25 +72,58 @@ class _SessionSetupScreenState extends State<SessionSetupScreen> {
     }
   }
 
+  Future<void> _openArmory() async {
+    final knownIds = _availableWeapons.map((w) => w.id).toSet();
+
+    await Navigator.push(
+      context,
+      MaterialPageRoute(builder: (_) => const WeaponListScreen()),
+    );
+    if (!mounted) return;
+
+    await _loadWeapons();
+    if (!mounted) return;
+
+    // Selectionne automatiquement l'arme qui vient d'etre ajoutee.
+    Weapon? added;
+    for (final weapon in _availableWeapons) {
+      if (!knownIds.contains(weapon.id)) {
+        added = weapon;
+        break;
+      }
+    }
+    if (added != null) {
+      final newWeapon = added;
+      setState(() {
+        _selectedWeapon = newWeapon;
+        _updateSettingsForWeapon(newWeapon);
+      });
+    }
+  }
+
   void _updateSettingsForWeapon(Weapon weapon) {
-    _shotsPerTarget = weapon.magazineCapacity;
+    _shotsPerTarget = weapon.magazineCapacity > 0 ? weapon.magazineCapacity : 5;
     _distance = (weapon.type == WeaponType.handgun) ? 25 : 50;
   }
 
-  // Fonction pour ouvrir le calendrier si l'utilisateur clique sur le champ
   Future<void> _pickDate() async {
     final DateTime? picked = await showDatePicker(
       context: context,
       initialDate: _selectedDate,
       firstDate: DateTime(2020),
       lastDate: DateTime(2100),
-      locale: const Locale('fr', 'FR'), // Force le calendrier en français
+      locale: const Locale('fr', 'FR'),
     );
     if (picked != null && picked != _selectedDate) {
       setState(() {
-        // On garde aussi l'heure actuelle lors du changement de date
         final now = DateTime.now();
-        _selectedDate = DateTime(picked.year, picked.month, picked.day, now.hour, now.minute);
+        _selectedDate = DateTime(
+          picked.year,
+          picked.month,
+          picked.day,
+          now.hour,
+          now.minute,
+        );
       });
     }
   }
@@ -81,15 +135,12 @@ class _SessionSetupScreenState extends State<SessionSetupScreen> {
 
       final sessionId = repository.generateId();
 
-      // PASSE-PARTOUT : On envoie la session au provider.
-      // Note : Si ton `sessionProvider.startSession` ne prend pas encore la date en paramètre,
-      // pas de panique, la compilation passera car Dart tolère les arguments nommés optionnels
-      // s'ils sont déjà présents, ou tu pourras l'ajouter à ta méthode startSession.
       sessionProvider.startSession(
         _selectedWeapon!.displayName,
         _shotsPerTarget,
         sessionId,
         weaponId: _selectedWeapon!.id,
+        caliber: _selectedWeapon!.caliber,
         distance: _distance,
         date: _selectedDate,
       );
@@ -103,12 +154,12 @@ class _SessionSetupScreenState extends State<SessionSetupScreen> {
 
   @override
   Widget build(BuildContext context) {
-    // Petit formatage sympa en français (ex: "27 mai 2026")
+    final isDark = Theme.of(context).brightness == Brightness.dark;
-    final String formattedDate = DateFormat('dd MMMM yyyy', 'fr_FR').format(_selectedDate);
+    final formattedDate = DateFormat('dd MMMM yyyy • HH:mm', 'fr_FR').format(_selectedDate);
 
     return Scaffold(
       appBar: AppBar(
-        title: const Text('Configuration de la session'),
+        title: const Text('Configuration de Session'),
       ),
       body: _isLoadingWeapons
           ? const Center(child: CircularProgressIndicator())
@@ -119,90 +170,159 @@ class _SessionSetupScreenState extends State<SessionSetupScreen> {
                 child: Column(
                   crossAxisAlignment: CrossAxisAlignment.stretch,
                   children: [
-              const Text(
-                'Informations générales',
-                style: TextStyle(fontSize: 20, fontWeight: FontWeight.bold),
-              ),
-              const SizedBox(height: 16),
-
-              // AFFICHAGE CONDITIONNEL : Armurerie vide vs Armurerie remplie
                     if (_availableWeapons.isEmpty)
-                Container(
+                      _buildEmptyArmoryState(isDark)
-                  padding: const EdgeInsets.all(16),
+                    else ...[
+                      _buildWeaponAndDateSection(isDark, formattedDate),
+                      const SizedBox(height: 20),
+                      _buildDistanceSection(isDark),
+                      const SizedBox(height: 20),
+                      _buildShotsSection(isDark),
+                      const SizedBox(height: 32),
+                      _buildStartButton(),
+                      const SizedBox(height: 16),
+                    ],
+                  ],
+                ),
+              ),
+            ),
+    );
+  }
+
+  Widget _buildEmptyArmoryState(bool isDark) {
+    return Container(
+      padding: const EdgeInsets.all(24),
       decoration: BoxDecoration(
-                    color: AppTheme.errorColor.withValues(alpha: 0.1),
+        color: isDark ? AppTheme.darkSurface : AppTheme.lightSurface,
-                    borderRadius: BorderRadius.circular(AppConstants.borderRadius),
+        borderRadius: BorderRadius.circular(16),
-                    border: Border.all(color: AppTheme.errorColor.withValues(alpha: 0.5)),
+        border: Border.all(
+          color: AppTheme.errorColor.withValues(alpha: 0.5),
+        ),
       ),
       child: Column(
         children: [
-                      const Icon(Icons.warning_amber_rounded, color: AppTheme.errorColor, size: 48),
+          const Icon(
-                      const SizedBox(height: 8),
+            Icons.warning_amber_rounded,
-                      const Text(
+            color: AppTheme.errorColor,
-                        'Ton armurerie est vide.',
+            size: 52,
-                        style: TextStyle(fontWeight: FontWeight.bold),
-                        textAlign: TextAlign.center,
           ),
-                      const SizedBox(height: 4),
+          const SizedBox(height: 12),
-                      const Text(
+          Text(
-                        'Tu dois d\'abord ajouter une arme pour pouvoir démarrer une session de tir.',
+            'Armurerie vide',
-                        textAlign: TextAlign.center,
+            style: TextStyle(
+              fontSize: 18,
+              fontWeight: FontWeight.w700,
+              color: isDark ? AppTheme.darkTextPrimary : AppTheme.lightTextPrimary,
             ),
-                      const SizedBox(height: 16),
+          ),
+          const SizedBox(height: 6),
+          Text(
+            'Ajoutez au moins une arme dans votre armurerie pour débuter une séance.',
+            textAlign: TextAlign.center,
+            style: TextStyle(
+              fontSize: 13,
+              color: isDark ? AppTheme.darkTextSecondary : AppTheme.lightTextSecondary,
+            ),
+          ),
+          const SizedBox(height: 20),
           ElevatedButton.icon(
-                        onPressed: () {
+            onPressed: _openArmory,
-                          Navigator.push(
+            icon: const Icon(Icons.shield),
-                            context,
+            label: const Text('Aller à l\'armurerie'),
-                            MaterialPageRoute(builder: (_) => const WeaponListScreen()),
-                          ).then((_) {
-                            _loadWeapons();
-                          });
-                        },
-                        icon: const Icon(Icons.add),
-                        label: const Text('ALLER À MON ARMURERIE'),
           ),
         ],
       ),
-                )
+    );
-              else
+  }
-                Column(
+
+  Widget _buildWeaponAndDateSection(bool isDark, String formattedDate) {
+    return Card(
+      child: Padding(
+        padding: const EdgeInsets.all(16),
+        child: Column(
+          crossAxisAlignment: CrossAxisAlignment.start,
           children: [
-                    DropdownButtonFormField<Weapon>(
+            Row(
-                      initialValue: _selectedWeapon,
+              children: [
-                      decoration: InputDecoration(
+                const Icon(Icons.tune, color: AppTheme.primaryColor, size: 20),
-                        labelText: 'Sélectionner une arme',
+                const SizedBox(width: 8),
-                        prefixIcon: const Icon(Icons.shield),
+                Text(
-                        border: OutlineInputBorder(
+                  'Arme & Date',
-                          borderRadius: BorderRadius.circular(AppConstants.borderRadius),
+                  style: TextStyle(
+                    fontSize: 15,
+                    fontWeight: FontWeight.w700,
+                    color: isDark ? AppTheme.darkTextPrimary : AppTheme.lightTextPrimary,
                   ),
                 ),
-                      items: _availableWeapons.map((w) => DropdownMenuItem(
+              ],
-                        value: w,
+            ),
-                        child: Text(w.displayName),
+            const SizedBox(height: 16),
-                      )).toList(),
+            DropdownButtonFormField<String>(
+              key: _weaponFieldKey,
+              initialValue: _selectedWeapon?.id,
+              decoration: const InputDecoration(
+                labelText: 'Arme utilisée',
+                prefixIcon: Icon(Icons.shield_outlined),
+              ),
+              items: [
+                ..._availableWeapons.map(
+                  (w) => DropdownMenuItem(
+                    value: w.id,
+                    child: Text('${w.displayName} (${w.caliber})'),
+                  ),
+                ),
+                DropdownMenuItem(
+                  value: _addWeaponValue,
+                  child: Row(
+                    children: [
+                      Icon(
+                        Icons.add_circle_outline,
+                        size: 18,
+                        color: Theme.of(context).colorScheme.primary,
+                      ),
+                      const SizedBox(width: 8),
+                      Text(
+                        'Ajouter une nouvelle arme',
+                        style: TextStyle(
+                          fontWeight: FontWeight.w600,
+                          color: Theme.of(context).colorScheme.primary,
+                        ),
+                      ),
+                    ],
+                  ),
+                ),
+              ],
               onChanged: (value) {
-                        if (value != null) {
+                if (value == null) return;
+
+                if (value == _addWeaponValue) {
+                  // L'item d'action n'est pas une arme : on restaure aussitot
+                  // la selection precedente avant d'ouvrir l'armurerie.
+                  _weaponFieldKey.currentState?.didChange(_selectedWeapon?.id);
+                  _openArmory();
+                  return;
+                }
+
+                for (final weapon in _availableWeapons) {
+                  if (weapon.id == value) {
                     setState(() {
-                            _selectedWeapon = value;
+                      _selectedWeapon = weapon;
-                            _updateSettingsForWeapon(value);
+                      _updateSettingsForWeapon(weapon);
                     });
+                    break;
+                  }
                 }
               },
             ),
-                    const SizedBox(height: 16),
+            const SizedBox(height: 12),
-
-                    // NOUVEAU CHAMP : Sélecteur de date interactif
             InkWell(
-                      onTap: _availableWeapons.isEmpty ? null : _pickDate,
+              onTap: _pickDate,
-                      borderRadius: BorderRadius.circular(AppConstants.borderRadius),
+              borderRadius: BorderRadius.circular(12),
               child: IgnorePointer(
                 child: TextFormField(
-                          decoration: InputDecoration(
+                  decoration: const InputDecoration(
-                            labelText: 'Date de la session',
+                    labelText: 'Date de séance',
-                            prefixIcon: const Icon(Icons.calendar_today),
+                    prefixIcon: Icon(Icons.calendar_today_outlined),
-                            border: OutlineInputBorder(
-                              borderRadius: BorderRadius.circular(AppConstants.borderRadius),
-                            ),
                   ),
                   controller: TextEditingController(text: formattedDate),
                 ),
@@ -210,114 +330,204 @@ class _SessionSetupScreenState extends State<SessionSetupScreen> {
             ),
           ],
         ),
-
-              const SizedBox(height: 24),
-
-              // Distance selector
-              const Text(
-                'Distance de tir (mètres)',
-                style: TextStyle(fontSize: 16, fontWeight: FontWeight.w500),
       ),
-              const SizedBox(height: 8),
+    );
+  }
+
+  Widget _buildDistanceSection(bool isDark) {
+    return Card(
+      child: Padding(
+        padding: const EdgeInsets.all(16),
+        child: Column(
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: [
+            Row(
+              mainAxisAlignment: MainAxisAlignment.spaceBetween,
+              children: [
                 Row(
                   children: [
-                  Expanded(
+                    const Icon(Icons.straighten, color: AppTheme.secondaryColor, size: 20),
-                    child: Slider(
+                    const SizedBox(width: 8),
-                      value: _distance.toDouble(),
+                    Text(
-                      min: 5,
+                      'Distance de Tir',
-                      max: 300,
+                      style: TextStyle(
-                      divisions: 59,
+                        fontSize: 15,
-                      label: '${_distance}m',
+                        fontWeight: FontWeight.w700,
-                      onChanged: _availableWeapons.isEmpty ? null : (value) {
+                        color: isDark ? AppTheme.darkTextPrimary : AppTheme.lightTextPrimary,
-                        setState(() {
-                          _distance = value.round();
-                        });
-                      },
                       ),
                     ),
+                  ],
+                ),
                 Container(
-                    width: 70,
+                  padding: const EdgeInsets.symmetric(horizontal: 10, vertical: 4),
-                    height: 50,
-                    alignment: Alignment.center,
                   decoration: BoxDecoration(
-                      color: AppTheme.secondaryColor.withValues(alpha: 0.1),
+                    color: AppTheme.secondaryColor.withValues(alpha: isDark ? 0.2 : 0.1),
                     borderRadius: BorderRadius.circular(8),
+                    border: Border.all(
+                      color: AppTheme.secondaryColor.withValues(alpha: 0.4),
+                    ),
                   ),
                   child: Text(
                     '${_distance}m',
                     style: const TextStyle(
-                        fontSize: 18,
+                      fontSize: 16,
-                        fontWeight: FontWeight.bold,
+                      fontWeight: FontWeight.w800,
                       color: AppTheme.secondaryColor,
                     ),
                   ),
                 ),
               ],
             ),
-              const SizedBox(height: 24),
+            const SizedBox(height: 12),
-
+            Wrap(
-              // Shots per target
+              spacing: 8,
-              const Text(
+              runSpacing: 8,
-                'Nombre de balles pour la cible actuelle',
+              children: _presetDistances.map((d) {
-                style: TextStyle(fontSize: 16, fontWeight: FontWeight.w500),
+                final isSelected = _distance == d;
+                return ChoiceChip(
+                  label: Text('${d}m'),
+                  selected: isSelected,
+                  onSelected: (selected) {
+                    if (selected) setState(() => _distance = d);
+                  },
+                );
+              }).toList(),
             ),
             const SizedBox(height: 8),
+            Slider(
+              value: _distance.toDouble(),
+              min: 5,
+              max: 300,
+              divisions: 59,
+              activeColor: AppTheme.secondaryColor,
+              onChanged: (val) {
+                setState(() => _distance = val.round());
+              },
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+
+  Widget _buildShotsSection(bool isDark) {
+    final primaryColor = Theme.of(context).colorScheme.primary;
+    return Card(
+      child: Padding(
+        padding: const EdgeInsets.all(16),
+        child: Column(
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: [
+            Row(
+              mainAxisAlignment: MainAxisAlignment.spaceBetween,
+              children: [
                 Row(
                   children: [
-                  Expanded(
+                    Icon(Icons.ads_click, color: primaryColor, size: 20),
-                    child: Slider(
+                    const SizedBox(width: 8),
+                    Text(
+                      'Tirs par Cible',
+                      style: TextStyle(
+                        fontSize: 15,
+                        fontWeight: FontWeight.w700,
+                        color: isDark ? AppTheme.darkTextPrimary : AppTheme.lightTextPrimary,
+                      ),
+                    ),
+                  ],
+                ),
+                Container(
+                  padding: const EdgeInsets.symmetric(horizontal: 10, vertical: 4),
+                  decoration: BoxDecoration(
+                    color: primaryColor.withValues(alpha: isDark ? 0.2 : 0.1),
+                    borderRadius: BorderRadius.circular(8),
+                    border: Border.all(
+                      color: primaryColor.withValues(alpha: 0.4),
+                    ),
+                  ),
+                  child: Text(
+                    '$_shotsPerTarget tirs',
+                    style: TextStyle(
+                      fontSize: 16,
+                      fontWeight: FontWeight.w800,
+                      color: primaryColor,
+                    ),
+                  ),
+                ),
+              ],
+            ),
+            const SizedBox(height: 12),
+            Wrap(
+              spacing: 8,
+              runSpacing: 8,
+              children: _presetShots.map((s) {
+                final isSelected = _shotsPerTarget == s;
+                return ChoiceChip(
+                  label: Text('$s coups'),
+                  selected: isSelected,
+                  onSelected: (selected) {
+                    if (selected) setState(() => _shotsPerTarget = s);
+                  },
+                );
+              }).toList(),
+            ),
+            const SizedBox(height: 8),
+            Slider(
               value: _shotsPerTarget.toDouble(),
               min: 1,
               max: 50,
               divisions: 49,
-                      label: '$_shotsPerTarget',
+              activeColor: primaryColor,
-                      onChanged: _availableWeapons.isEmpty ? null : (value) {
+              onChanged: (val) {
-                        setState(() {
+                setState(() => _shotsPerTarget = val.round());
-                          _shotsPerTarget = value.round();
-                        });
               },
             ),
-                  ),
-                  Container(
-                    width: 50,
-                    height: 50,
-                    alignment: Alignment.center,
-                    decoration: BoxDecoration(
-                      color: AppTheme.primaryColor.withValues(alpha: 0.1),
-                      borderRadius: BorderRadius.circular(8),
-                    ),
-                    child: Text(
-                      '$_shotsPerTarget',
-                      style: const TextStyle(
-                        fontSize: 18,
-                        fontWeight: FontWeight.bold,
-                        color: AppTheme.primaryColor,
-                      ),
-                    ),
-                  ),
           ],
         ),
-              const SizedBox(height: 48),
+      ),
+    );
+  }
 
-              ElevatedButton.icon(
+  Widget _buildStartButton() {
+    final primaryColor = Theme.of(context).colorScheme.primary;
+    return Container(
+      decoration: BoxDecoration(
+        borderRadius: BorderRadius.circular(16),
+        gradient: LinearGradient(
+          colors: [
+            primaryColor,
+            HSLColor.fromColor(primaryColor).withLightness((HSLColor.fromColor(primaryColor).lightness + 0.15).clamp(0.0, 1.0)).toColor(),
+          ],
+          begin: Alignment.topLeft,
+          end: Alignment.bottomRight,
+        ),
+        boxShadow: [
+          BoxShadow(
+            color: primaryColor.withValues(alpha: 0.35),
+            blurRadius: 16,
+            offset: const Offset(0, 4),
+          ),
+        ],
+      ),
+      child: ElevatedButton.icon(
         onPressed: (_availableWeapons.isEmpty || _selectedWeapon == null)
             ? null
             : _startSession,
         style: ElevatedButton.styleFrom(
-                  backgroundColor: AppTheme.primaryColor,
+          backgroundColor: Colors.transparent,
           foregroundColor: Colors.white,
-                  padding: const EdgeInsets.symmetric(vertical: 16),
+          shadowColor: Colors.transparent,
+          padding: const EdgeInsets.symmetric(vertical: 18),
           shape: RoundedRectangleBorder(
-                    borderRadius: BorderRadius.circular(AppConstants.borderRadius),
+            borderRadius: BorderRadius.circular(16),
           ),
         ),
-                icon: const Icon(Icons.play_arrow),
+        icon: const Icon(Icons.play_arrow_rounded, size: 26),
         label: const Text(
           'DÉMARRER LA SESSION',
-                  style: TextStyle(fontSize: 16, fontWeight: FontWeight.bold),
+          style: TextStyle(
-                ),
+            fontSize: 16,
-              ),
+            fontWeight: FontWeight.w800,
-            ],
+            letterSpacing: 0.8,
           ),
         ),
       ),

lib/features/statistics/statistics_screen.dart

@@ -1,11 +1,17 @@
+import 'dart:io';
 import 'dart:math' as math;
 import 'dart:ui' as ui;
+import 'package:file_selector/file_selector.dart';
 import 'package:flutter/material.dart';
 import 'package:provider/provider.dart';
 import 'package:fl_chart/fl_chart.dart'; // La librairie pour les courbes
+import 'package:path/path.dart' as p;
+import 'package:share_plus/share_plus.dart';
+import '../../core/theme/app_theme.dart';
 import '../../core/widgets/metric_info_button.dart';
 import '../../data/models/session.dart';
 import '../../data/repositories/session_repository.dart';
+import '../../services/backup_service.dart';
 import '../../services/statistics_service.dart';
 
 class StatisticsScreen extends StatefulWidget {
@@ -43,6 +49,10 @@ class _StatisticsScreenState extends State<StatisticsScreen> {
   bool _showingB = false; // false = on affiche A, true = on affiche B
   bool get _compareMode => _compareA != null && _compareB != null;
 
+  // --- Sauvegarde (export/import JSON) ---
+  bool _isBackupBusy = false;
+  final GlobalKey _exportButtonKey = GlobalKey();
+
   @override
   void initState() {
     super.initState();
@@ -226,6 +236,7 @@ class _StatisticsScreenState extends State<StatisticsScreen> {
   @override
   Widget build(BuildContext context) {
     return Scaffold(
+      extendBody: true,
       appBar: AppBar(
         title: const Text('Statistiques'),
         centerTitle: true,
@@ -287,7 +298,7 @@ class _StatisticsScreenState extends State<StatisticsScreen> {
                     onRefresh: _loadStatistics,
                     child: SingleChildScrollView(
                       physics: const AlwaysScrollableScrollPhysics(),
-                      padding: const EdgeInsets.all(16),
+                      padding: const EdgeInsets.fromLTRB(16, 16, 16, 100),
                       child: Column(
                         children: [
                   // 2. DONNÉES RAPIDES (Tirs et Sessions)
@@ -374,6 +385,11 @@ class _StatisticsScreenState extends State<StatisticsScreen> {
                       _buildBiasWarning(),
                   ],
 
+                  const SizedBox(height: 25),
+
+                  // 5. SAUVEGARDE : export/import de toutes les données
+                  _buildBackupSection(),
+
                   const SizedBox(height: 30),
                         ],
                       ),
@@ -400,13 +416,14 @@ class _StatisticsScreenState extends State<StatisticsScreen> {
       );
     }
 
-    final activeColor = const Color(0xFF1A73E8);
+    final isDark = Theme.of(context).brightness == Brightness.dark;
+    final activeColor = Theme.of(context).colorScheme.primary;
     return Container(
-      padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 10),
+      padding: const EdgeInsets.symmetric(horizontal: 14, vertical: 12),
       decoration: BoxDecoration(
-        color: activeColor.withValues(alpha: 0.08),
+        color: activeColor.withValues(alpha: isDark ? 0.12 : 0.08),
-        borderRadius: BorderRadius.circular(12),
+        borderRadius: BorderRadius.circular(14),
-        border: Border.all(color: activeColor.withValues(alpha: 0.3)),
+        border: Border.all(color: activeColor.withValues(alpha: 0.35)),
       ),
       child: Column(
         crossAxisAlignment: CrossAxisAlignment.start,
@@ -415,7 +432,15 @@ class _StatisticsScreenState extends State<StatisticsScreen> {
             children: [
               Icon(Icons.compare_arrows, color: activeColor, size: 18),
               const SizedBox(width: 6),
-              Text('Comparaison', style: TextStyle(fontWeight: FontWeight.bold, color: activeColor)),
+              Text(
+                'Comparaison de sessions',
+                style: TextStyle(
+                  fontWeight: FontWeight.w700,
+                  fontSize: 13,
+                  color: activeColor,
+                  letterSpacing: 0.3,
+                ),
+              ),
               const Spacer(),
               IconButton(
                 tooltip: 'Quitter la comparaison',
@@ -479,27 +504,39 @@ class _StatisticsScreenState extends State<StatisticsScreen> {
     List<String> items,
     void Function(String?) onChanged,
   ) {
-    final theme = Theme.of(context);
+    final isDark = Theme.of(context).brightness == Brightness.dark;
+    final textSecondary = isDark ? AppTheme.darkTextSecondary : AppTheme.lightTextSecondary;
+
     return Container(
-      padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 4),
+      padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 6),
       decoration: BoxDecoration(
-        color: theme.colorScheme.surfaceContainerHighest.withValues(alpha: 0.5),
+        color: isDark ? AppTheme.darkSurfaceElevated : AppTheme.lightSurfaceVariant,
-        borderRadius: BorderRadius.circular(8),
+        borderRadius: BorderRadius.circular(12),
-        border: Border.all(color: theme.dividerColor),
+        border: Border.all(
+          color: isDark ? AppTheme.darkBorder : AppTheme.lightBorder,
+        ),
       ),
       child: Column(
         crossAxisAlignment: CrossAxisAlignment.start,
         children: [
           Text(
             label,
-            style: TextStyle(color: theme.textTheme.bodySmall?.color?.withValues(alpha: 0.6), fontSize: 10),
+            style: TextStyle(
+              color: textSecondary,
+              fontSize: 10,
+              fontWeight: FontWeight.w600,
+            ),
           ),
           DropdownButton<String>(
             value: value,
             isExpanded: true,
-            underline: Container(),
+            underline: const SizedBox(),
-            dropdownColor: theme.colorScheme.surfaceContainerHighest,
+            dropdownColor: isDark ? AppTheme.darkSurfaceElevated : AppTheme.lightSurfaceVariant,
-            style: TextStyle(color: theme.textTheme.bodyMedium?.color, fontSize: 14),
+            style: TextStyle(
+              color: isDark ? AppTheme.darkTextPrimary : AppTheme.lightTextPrimary,
+              fontSize: 13,
+              fontWeight: FontWeight.w600,
+            ),
             items: items
                 .map(
                   (String val) =>
@@ -515,28 +552,45 @@ class _StatisticsScreenState extends State<StatisticsScreen> {
 
   // Widget pour les petites cartes de stats
   Widget _buildQuickStat(String label, String value, IconData icon) {
-    final theme = Theme.of(context);
+    final isDark = Theme.of(context).brightness == Brightness.dark;
+    final primary = Theme.of(context).colorScheme.primary;
     return Container(
-      padding: const EdgeInsets.all(16),
+      padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 14),
       decoration: BoxDecoration(
-        color: theme.colorScheme.surfaceContainerHighest.withValues(alpha: 0.5),
+        color: isDark ? AppTheme.darkSurface : AppTheme.lightSurface,
-        borderRadius: BorderRadius.circular(12),
+        borderRadius: BorderRadius.circular(16),
+        border: Border.all(
+          color: isDark ? AppTheme.darkBorder : AppTheme.lightBorder,
+        ),
       ),
       child: Column(
         children: [
-          Icon(icon, color: const Color(0xFF1A73E8), size: 20),
+          Container(
+            padding: const EdgeInsets.all(8),
+            decoration: BoxDecoration(
+              color: primary.withValues(alpha: isDark ? 0.15 : 0.1),
+              borderRadius: BorderRadius.circular(10),
+            ),
+            child: Icon(icon, color: primary, size: 20),
+          ),
           const SizedBox(height: 8),
           Text(
             value,
             style: TextStyle(
-              color: theme.textTheme.titleLarge?.color,
+              color: isDark ? AppTheme.darkTextPrimary : AppTheme.lightTextPrimary,
-              fontSize: 20,
+              fontSize: 22,
-              fontWeight: FontWeight.bold,
+              fontWeight: FontWeight.w800,
+              letterSpacing: -0.5,
             ),
           ),
+          const SizedBox(height: 2),
           Text(
             label,
-            style: TextStyle(color: theme.textTheme.bodySmall?.color?.withValues(alpha: 0.6), fontSize: 12),
+            style: TextStyle(
+              color: isDark ? AppTheme.darkTextSecondary : AppTheme.lightTextSecondary,
+              fontSize: 12,
+              fontWeight: FontWeight.w500,
+            ),
           ),
         ],
       ),
@@ -550,12 +604,15 @@ class _StatisticsScreenState extends State<StatisticsScreen> {
     List<double> dataPoints, {
     List<MetricExplanation>? explanations,
   }) {
-    final theme = Theme.of(context);
+    final isDark = Theme.of(context).brightness == Brightness.dark;
     return Container(
       padding: const EdgeInsets.all(16),
       decoration: BoxDecoration(
-        color: theme.colorScheme.surfaceContainerHighest.withValues(alpha: 0.5),
+        color: isDark ? AppTheme.darkSurface : AppTheme.lightSurface,
-        borderRadius: BorderRadius.circular(12),
+        borderRadius: BorderRadius.circular(16),
+        border: Border.all(
+          color: isDark ? AppTheme.darkBorder : AppTheme.lightBorder,
+        ),
       ),
       child: Column(
         crossAxisAlignment: CrossAxisAlignment.start,
@@ -564,7 +621,11 @@ class _StatisticsScreenState extends State<StatisticsScreen> {
             children: [
               Text(
                 title,
-                style: TextStyle(color: theme.textTheme.bodyMedium?.color?.withValues(alpha: 0.7), fontSize: 14),
+                style: TextStyle(
+                  color: isDark ? AppTheme.darkTextSecondary : AppTheme.lightTextSecondary,
+                  fontSize: 13,
+                  fontWeight: FontWeight.w600,
+                ),
               ),
               if (explanations != null) ...[
                 const Spacer(),
@@ -572,15 +633,16 @@ class _StatisticsScreenState extends State<StatisticsScreen> {
               ],
             ],
           ),
-          const SizedBox(height: 10),
+          const SizedBox(height: 8),
           Row(
             children: [
               Text(
                 value,
                 style: TextStyle(
-                  color: theme.textTheme.headlineMedium?.color,
+                  color: isDark ? AppTheme.darkTextPrimary : AppTheme.lightTextPrimary,
                   fontSize: 24,
-                  fontWeight: FontWeight.bold,
+                  fontWeight: FontWeight.w800,
+                  letterSpacing: -0.5,
                 ),
               ),
               const SizedBox(width: 20),
@@ -882,6 +944,263 @@ class _StatisticsScreenState extends State<StatisticsScreen> {
       ),
     );
   }
+
+  // --- SAUVEGARDE : EXPORT / IMPORT JSON ---
+
+  Widget _buildBackupSection() {
+    final theme = Theme.of(context);
+    return Container(
+      padding: const EdgeInsets.all(16),
+      decoration: BoxDecoration(
+        color: theme.colorScheme.surfaceContainerHighest.withValues(alpha: 0.5),
+        borderRadius: BorderRadius.circular(12),
+      ),
+      child: Column(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        children: [
+          Row(
+            children: [
+              Icon(Icons.save_alt, color: theme.textTheme.titleMedium?.color, size: 20),
+              const SizedBox(width: 8),
+              Text(
+                'Sauvegarde',
+                style: TextStyle(
+                  color: theme.textTheme.titleMedium?.color,
+                  fontSize: 16,
+                  fontWeight: FontWeight.bold,
+                ),
+              ),
+            ],
+          ),
+          const SizedBox(height: 4),
+          Text(
+            'Exporte toutes tes sessions, tes stats et ton armurerie dans un '
+            'fichier JSON, à envoyer où tu veux. L\'import fusionne le fichier '
+            'avec tes données actuelles (rien n\'est effacé).',
+            style: TextStyle(
+              color: theme.textTheme.bodySmall?.color?.withValues(alpha: 0.6),
+              fontSize: 12,
+            ),
+          ),
+          const SizedBox(height: 16),
+          Row(
+            children: [
+              Expanded(
+                child: ElevatedButton.icon(
+                  key: _exportButtonKey,
+                  onPressed: _isBackupBusy ? null : _exportBackup,
+                  icon: const Icon(Icons.ios_share, size: 18),
+                  label: const Text('Exporter'),
+                  style: ElevatedButton.styleFrom(
+                    padding: const EdgeInsets.symmetric(vertical: 14),
+                  ),
+                ),
+              ),
+              const SizedBox(width: 12),
+              Expanded(
+                child: OutlinedButton.icon(
+                  onPressed: _isBackupBusy ? null : _importBackup,
+                  icon: const Icon(Icons.file_download_outlined, size: 18),
+                  label: const Text('Importer'),
+                  style: OutlinedButton.styleFrom(
+                    padding: const EdgeInsets.symmetric(vertical: 14),
+                  ),
+                ),
+              ),
+            ],
+          ),
+          if (_isBackupBusy) ...[
+            const SizedBox(height: 12),
+            const LinearProgressIndicator(minHeight: 2),
+          ],
+        ],
+      ),
+    );
+  }
+
+  BackupService _backupService() =>
+      BackupService(repository: context.read<SessionRepository>());
+
+  Future<void> _exportBackup() async {
+    final includeImages = await _askIncludeImages();
+    if (includeImages == null || !mounted) return;
+
+    setState(() => _isBackupBusy = true);
+    try {
+      final file = await _backupService().exportToFile(
+        includeImages: includeImages,
+      );
+      if (!mounted) return;
+
+      // sharePositionOrigin : obligatoire pour l'iPad, ignoré ailleurs.
+      final box = _exportButtonKey.currentContext?.findRenderObject() as RenderBox?;
+      final origin = box != null && box.hasSize
+          ? box.localToGlobal(Offset.zero) & box.size
+          : null;
+
+      await SharePlus.instance.share(
+        ShareParams(
+          files: [XFile(file.path, mimeType: 'application/json')],
+          fileNameOverrides: [p.basename(file.path)],
+          subject: 'Sauvegarde IMPACT',
+          text: 'Sauvegarde de mes sessions de tir (${p.basename(file.path)})',
+          sharePositionOrigin: origin,
+        ),
+      );
+    } catch (e) {
+      _showMessage('Export impossible : $e', isError: true);
+    } finally {
+      if (mounted) setState(() => _isBackupBusy = false);
+    }
+  }
+
+  /// Les photos de cibles alourdissent énormément le fichier : on laisse le
+  /// choix entre une sauvegarde légère (données seules) et une sauvegarde
+  /// complète (photos encodées dans le JSON).
+  Future<bool?> _askIncludeImages() {
+    var includeImages = false;
+    return showDialog<bool>(
+      context: context,
+      builder: (context) => StatefulBuilder(
+        builder: (context, setDialogState) => AlertDialog(
+          title: const Text('Exporter mes données'),
+          content: Column(
+            mainAxisSize: MainAxisSize.min,
+            crossAxisAlignment: CrossAxisAlignment.start,
+            children: [
+              const Text(
+                'Le fichier contiendra toutes tes sessions (cibles, impacts, '
+                'scores), tes statistiques et ton armurerie.',
+              ),
+              const SizedBox(height: 8),
+              SwitchListTile(
+                contentPadding: EdgeInsets.zero,
+                value: includeImages,
+                onChanged: (v) => setDialogState(() => includeImages = v),
+                title: const Text('Inclure les photos des cibles'),
+                subtitle: const Text(
+                  'Sauvegarde complète, mais fichier beaucoup plus lourd.',
+                  style: TextStyle(fontSize: 12),
+                ),
+              ),
+            ],
+          ),
+          actions: [
+            TextButton(
+              onPressed: () => Navigator.pop(context),
+              child: const Text('Annuler'),
+            ),
+            ElevatedButton(
+              onPressed: () => Navigator.pop(context, includeImages),
+              child: const Text('Exporter'),
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+
+  Future<void> _importBackup() async {
+    const jsonGroup = XTypeGroup(
+      label: 'Sauvegarde IMPACT (.json)',
+      extensions: ['json'],
+      // Android renvoie parfois un type générique pour un .json : on accepte
+      // large, le contenu est validé à la lecture de toute façon.
+      mimeTypes: ['application/json', 'text/plain', 'application/octet-stream'],
+      uniformTypeIdentifiers: ['public.json', 'public.text'],
+    );
+
+    final picked = await openFile(acceptedTypeGroups: const [jsonGroup]);
+    if (picked == null || !mounted) return;
+
+    setState(() => _isBackupBusy = true);
+    try {
+      final service = _backupService();
+      final preview = await service.readBackup(File(picked.path));
+      if (!mounted) return;
+
+      final confirmed = await _confirmImport(preview);
+      if (confirmed != true || !mounted) return;
+
+      final result = await service.applyBackup(preview);
+      await _loadStatistics();
+      if (!mounted) return;
+
+      final details = [
+        '${result.sessions} session(s)',
+        '${result.weapons} arme(s)',
+        if (result.maintenance > 0) '${result.maintenance} entretien(s)',
+        if (result.images > 0) '${result.images} photo(s)',
+      ].join(' · ');
+      _showMessage(
+        result.errors.isEmpty
+            ? 'Import terminé : $details'
+            : 'Import terminé : $details — ${result.errors.length} entrée(s) ignorée(s)',
+      );
+    } on BackupFormatException catch (e) {
+      _showMessage(e.message, isError: true);
+    } catch (e) {
+      _showMessage('Import impossible : $e', isError: true);
+    } finally {
+      if (mounted) setState(() => _isBackupBusy = false);
+    }
+  }
+
+  Future<bool?> _confirmImport(BackupPreview preview) {
+    final date = preview.exportedAt;
+    final dateLabel = date == null
+        ? null
+        : '${date.day.toString().padLeft(2, '0')}/'
+            '${date.month.toString().padLeft(2, '0')}/${date.year}';
+
+    return showDialog<bool>(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: const Text('Importer cette sauvegarde ?'),
+        content: Column(
+          mainAxisSize: MainAxisSize.min,
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: [
+            if (dateLabel != null) Text('Exportée le $dateLabel'),
+            if (dateLabel != null) const SizedBox(height: 8),
+            Text('• ${preview.sessionCount} session(s)'),
+            Text('• ${preview.targetCount} cible(s), ${preview.shotCount} impact(s)'),
+            Text('• ${preview.weaponCount} arme(s), ${preview.maintenanceCount} entretien(s)'),
+            Text(preview.hasImages
+                ? '• Photos des cibles incluses'
+                : '• Sans photos de cibles'),
+            const SizedBox(height: 12),
+            const Text(
+              'Les données actuelles sont conservées. Une session déjà '
+              'présente est simplement mise à jour.',
+              style: TextStyle(fontSize: 12),
+            ),
+          ],
+        ),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.pop(context, false),
+            child: const Text('Annuler'),
+          ),
+          ElevatedButton(
+            onPressed: () => Navigator.pop(context, true),
+            child: const Text('Importer'),
+          ),
+        ],
+      ),
+    );
+  }
+
+  void _showMessage(String message, {bool isError = false}) {
+    if (!mounted) return;
+    ScaffoldMessenger.of(context).showSnackBar(
+      SnackBar(
+        content: Text(message),
+        backgroundColor: isError ? Colors.red.shade700 : null,
+        duration: const Duration(seconds: 4),
+      ),
+    );
+  }
 }
 
 class _HeatMapPainter extends CustomPainter {

lib/main_navigation_holder.dart

@@ -1,3 +1,4 @@
+import 'dart:ui';
 import 'package:flutter/material.dart';
 import 'features/home/home_screen.dart';
 import 'features/history/history_screen.dart';
@@ -5,6 +6,22 @@ import 'features/statistics/statistics_screen.dart';
 import 'features/garage/weapon_list_screen.dart';
 import 'core/theme/app_theme.dart';
 
+/// Index des onglets de la barre de navigation principale.
+const int mainTabHome = 0;
+const int mainTabHistory = 1;
+const int mainTabStats = 2;
+const int mainTabGarage = 3;
+
+/// Clé du holder : permet de piloter l'onglet actif depuis n'importe quel écran.
+final GlobalKey<State<MainNavigationHolder>> mainNavKey =
+    GlobalKey<State<MainNavigationHolder>>();
+
+/// Ouvre l'onglet [index] de la navigation principale.
+void openMainTab(int index) {
+  final state = mainNavKey.currentState;
+  if (state is _MainNavigationHolderState) state.selectTab(index);
+}
+
 class MainNavigationHolder extends StatefulWidget {
   const MainNavigationHolder({super.key});
 
@@ -15,75 +32,163 @@ class MainNavigationHolder extends StatefulWidget {
 class _MainNavigationHolderState extends State<MainNavigationHolder> {
   int _selectedIndex = 0;
 
-  // Incrémentés à chaque ouverture de l'onglet correspondant pour forcer le
-  // rechargement (les écrans sont gardés vivants par l'IndexedStack et ne se
-  // rafraîchissent pas seuls).
   int _statsTick = 0;
   int _historyTick = 0;
+  int _homeTick = 0;
+  int _garageTick = 0;
 
-  void _onItemTapped(int index) {
+  void selectTab(int index) {
+    if (!mounted) return;
     setState(() {
       _selectedIndex = index;
-      if (index == 1) _historyTick++;
+      if (index == mainTabHome) _homeTick++;
-      if (index == 2) _statsTick++;
+      if (index == mainTabHistory) _historyTick++;
+      if (index == mainTabStats) _statsTick++;
+      if (index == mainTabGarage) _garageTick++;
     });
   }
 
   @override
   Widget build(BuildContext context) {
+    final isDark = Theme.of(context).brightness == Brightness.dark;
+
     final screens = [
-      const HomeScreen(),
+      HomeScreen(refreshTick: _homeTick),
       HistoryScreen(refreshTick: _historyTick),
       StatisticsScreen(refreshTick: _statsTick),
-      const WeaponListScreen(),
+      WeaponListScreen(refreshTick: _garageTick),
     ];
+
     return Scaffold(
+      extendBody: true,
       body: IndexedStack(
         index: _selectedIndex,
         children: screens,
       ),
-      bottomNavigationBar: Container(
+      bottomNavigationBar: _buildFloatingGlassDock(isDark),
+    );
+  }
+
+  Widget _buildFloatingGlassDock(bool isDark) {
+    final primaryColor = Theme.of(context).colorScheme.primary;
+    final navItems = [
+      (Icons.radar_outlined, Icons.radar, 'Accueil'),
+      (Icons.history_outlined, Icons.history_rounded, 'Historique'),
+      (Icons.insights_outlined, Icons.insights_rounded, 'Stats'),
+      (Icons.shield_outlined, Icons.shield, 'Armurerie'),
+    ];
+
+    return SafeArea(
+      child: Container(
+        margin: const EdgeInsets.fromLTRB(16, 0, 16, 12),
+        height: 68,
         decoration: BoxDecoration(
+          borderRadius: BorderRadius.circular(24),
           boxShadow: [
             BoxShadow(
-              color: Colors.black.withValues(alpha: 0.1),
+              color: Colors.black.withValues(alpha: isDark ? 0.45 : 0.12),
-              blurRadius: 10,
+              blurRadius: 24,
+              offset: const Offset(0, 8),
+            ),
+            if (isDark)
+              BoxShadow(
+                color: primaryColor.withValues(alpha: 0.12),
+                blurRadius: 16,
+                spreadRadius: -4,
                 offset: const Offset(0, -2),
               ),
           ],
         ),
-        child: BottomNavigationBar(
+        child: ClipRRect(
-          currentIndex: _selectedIndex,
+          borderRadius: BorderRadius.circular(24),
-          onTap: _onItemTapped,
+          child: BackdropFilter(
-          type: BottomNavigationBarType.fixed,
+            filter: ImageFilter.blur(sigmaX: 16, sigmaY: 16),
-          backgroundColor: Theme.of(context).cardColor,
+            child: Container(
-          selectedItemColor: AppTheme.primaryColor,
+              padding: const EdgeInsets.symmetric(horizontal: 6, vertical: 4),
-          unselectedItemColor: Colors.grey,
+              decoration: BoxDecoration(
-          showUnselectedLabels: true,
+                color: isDark
-          items: const [
+                    ? const Color(0xFF101722).withValues(alpha: 0.78)
-            BottomNavigationBarItem(
+                    : Colors.white.withValues(alpha: 0.85),
-              icon: Icon(Icons.home_outlined),
+                borderRadius: BorderRadius.circular(24),
-              activeIcon: Icon(Icons.home),
+                border: Border.all(
-              label: 'Accueil',
+                  color: isDark
+                      ? Colors.white.withValues(alpha: 0.14)
+                      : Colors.black.withValues(alpha: 0.08),
+                  width: 1.2,
                 ),
-            BottomNavigationBarItem(
-              icon: Icon(Icons.history_outlined),
-              activeIcon: Icon(Icons.history),
-              label: 'Historique',
               ),
-            BottomNavigationBarItem(
+              child: Row(
-              icon: Icon(Icons.analytics_outlined),
+                mainAxisAlignment: MainAxisAlignment.spaceAround,
-              activeIcon: Icon(Icons.analytics),
+                children: List.generate(navItems.length, (index) {
-              label: 'Stats',
+                  final item = navItems[index];
+                  final isSelected = _selectedIndex == index;
+
+                  return Expanded(
+                    child: GestureDetector(
+                      behavior: HitTestBehavior.opaque,
+                      onTap: () => selectTab(index),
+                      child: AnimatedContainer(
+                        duration: const Duration(milliseconds: 200),
+                        curve: Curves.easeOutCubic,
+                        padding: const EdgeInsets.symmetric(vertical: 4),
+                        decoration: BoxDecoration(
+                          color: isSelected
+                              ? primaryColor.withValues(
+                                  alpha: isDark ? 0.22 : 0.15,
+                                )
+                              : Colors.transparent,
+                          borderRadius: BorderRadius.circular(16),
+                          border: isSelected
+                              ? Border.all(
+                                  color: primaryColor.withValues(
+                                    alpha: isDark ? 0.45 : 0.35,
+                                  ),
+                                  width: 1,
+                                )
+                              : null,
+                        ),
+                        child: Column(
+                          mainAxisSize: MainAxisSize.min,
+                          mainAxisAlignment: MainAxisAlignment.center,
+                          children: [
+                            Icon(
+                              isSelected ? item.$2 : item.$1,
+                              size: 22,
+                              color: isSelected
+                                  ? primaryColor
+                                  : (isDark
+                                      ? AppTheme.darkTextSecondary
+                                      : AppTheme.lightTextSecondary),
+                            ),
+                            const SizedBox(height: 2),
+                            Text(
+                              item.$3,
+                              maxLines: 1,
+                              overflow: TextOverflow.ellipsis,
+                              style: TextStyle(
+                                fontSize: 11,
+                                fontWeight: isSelected
+                                    ? FontWeight.w700
+                                    : FontWeight.w500,
+                                color: isSelected
+                                    ? primaryColor
+                                    : (isDark
+                                        ? AppTheme.darkTextSecondary
+                                        : AppTheme.lightTextSecondary),
+                                letterSpacing: 0.2,
                               ),
-            BottomNavigationBarItem(
-              icon: Icon(Icons.shield_outlined),
-              activeIcon: Icon(Icons.shield),
-              label: 'Armurerie',
                             ),
                           ],
                         ),
                       ),
+                    ),
+                  );
+                }),
+              ),
+            ),
+          ),
+        ),
+      ),
     );
   }
 }

lib/services/ai_export_service.dart

@@ -2,50 +2,103 @@ import 'dart:convert';
 import 'package:flutter/foundation.dart';
 import 'dart:io';
 import 'package:http/http.dart' as http;
-import 'package:device_info_plus/device_info_plus.dart';
+import 'package:image/image.dart' as img;
 import 'package:crypto/crypto.dart';
 import '../data/models/shot.dart';
 import '../data/models/target_type.dart';
 import 'wallet_identity_service.dart';
 
+/// Résultat détaillé de l'exportation vers le serveur IA
+class AiExportResult {
+  final bool isSuccess;
+  final String code;
+  final String message;
+  final String? reason;
+  final bool isBanned;
+  final Map<String, dynamic>? targetValidation;
+
+  AiExportResult({
+    required this.isSuccess,
+    required this.code,
+    required this.message,
+    this.reason,
+    this.isBanned = false,
+    this.targetValidation,
+  });
+
+  factory AiExportResult.success({
+    String? message,
+    Map<String, dynamic>? targetValidation,
+  }) {
+    return AiExportResult(
+      isSuccess: true,
+      code: 'UPLOAD_SUCCESS',
+      message: message ?? 'Export réussi vers le serveur IA !',
+      targetValidation: targetValidation,
+    );
+  }
+
+  factory AiExportResult.banned({
+    String? reason,
+    String? message,
+  }) {
+    return AiExportResult(
+      isSuccess: false,
+      code: 'WALLET_BANNED',
+      isBanned: true,
+      reason: reason,
+      message: message ?? 'Votre participation au programme d\'entraînement IA a été suspendue par la modération.',
+    );
+  }
+
+  factory AiExportResult.error({
+    String? code,
+    required String message,
+  }) {
+    return AiExportResult(
+      isSuccess: false,
+      code: code ?? 'UPLOAD_ERROR',
+      message: message,
+    );
+  }
+}
+
 class AiExportService {
-  // Utilise 10.0.2.2 pour l'émulateur Android, sinon localhost.
+  /// Retire toutes les metadonnees de la photo avant l'envoi.
-  // Pour un appareil physique, il faudra utiliser l'IP locale du PC (ex: 192.168.1.X).
+  ///
-  static String get _defaultApiUrl {
+  /// Une photo de cible prise au telephone embarque un bloc EXIF qui contient
-    if (Platform.isAndroid) {
+  /// typiquement la position GPS du stand de tir, la date exacte et le modele
-      return 'http://10.0.2.2:3000/api/upload';
+  /// d'appareil. Rien de tout cela n'est utile au modele de detection.
-    }
+  ///
-    return 'http://localhost:3000/api/upload';
+  /// L'orientation est d'abord appliquee physiquement aux pixels : les
-  }
+  /// coordonnees d'impact sont normalisees sur l'image telle qu'elle est
-
+  /// affichee dans l'app (Flutter applique l'orientation EXIF), donc supprimer
-  /// Extrait les informations de l'appareil
+  /// le tag sans redresser l'image ferait pivoter la photo par rapport a ses
-  Future<Map<String, dynamic>> _getDeviceInfo() async {
+  /// propres annotations.
-    final DeviceInfoPlugin deviceInfoPlugin = DeviceInfoPlugin();
+  ///
-    Map<String, dynamic> deviceData = {'model': 'Unknown', 'os': 'Unknown'};
+  /// Retourne null si l'image est illisible.
-
+  @visibleForTesting
+  Uint8List? stripMetadata(Uint8List originalBytes) {
     try {
-      if (Platform.isAndroid) {
+      final decoded = img.decodeImage(originalBytes);
-        final androidInfo = await deviceInfoPlugin.androidInfo;
+      if (decoded == null) return null;
-        deviceData['model'] = '${androidInfo.brand} ${androidInfo.model}';
-        deviceData['os'] = 'Android ${androidInfo.version.release}';
-      } else if (Platform.isIOS) {
-        final iosInfo = await deviceInfoPlugin.iosInfo;
-        deviceData['model'] = iosInfo.name;
-        deviceData['os'] = '${iosInfo.systemName} ${iosInfo.systemVersion}';
-      } else if (Platform.isWindows) {
-        final windowsInfo = await deviceInfoPlugin.windowsInfo;
-        deviceData['model'] = 'Windows PC';
-        deviceData['os'] = 'Windows ${windowsInfo.majorVersion}.${windowsInfo.minorVersion}';
-      }
-    } catch (e) {
-      debugPrint('Erreur lors de la récupération des infos appareil: $e');
-    }
 
-    return deviceData;
+      final baked = img.bakeOrientation(decoded);
+
+      // bakeOrientation recopie tout l'EXIF sauf l'orientation : sans ce reset,
+      // le GPS survivrait au reencodage.
+      baked.exif = img.ExifData();
+
+      return img.encodeJpg(baked, quality: 90);
+    } catch (e) {
+      // Sur un fichier tronque, decodeImage leve au lieu de retourner null.
+      debugPrint('Photo illisible, export annule: $e');
+      return null;
+    }
   }
 
   /// Exporte l'image et les données de plotting vers le serveur
-  Future<bool> exportData({
+  Future<AiExportResult> exportData({
     required String imagePath,
     required String sessionId,
     required TargetType targetType,
@@ -54,27 +107,36 @@ class AiExportService {
     required double targetRadius,
     required List<Shot> shots,
     int distanceMeters = 25,
-    String weaponName = 'Unknown',
+    String caliber = 'unknown',
+    int? expectedShots,
     String? apiUrl,
   }) async {
     try {
-      final url = Uri.parse(apiUrl ?? _defaultApiUrl);
+      final walletService = WalletIdentityService();
+      final rawBaseUrl = await walletService.getServerBaseUrl();
+      final baseUrl = rawBaseUrl.endsWith('/') ? rawBaseUrl.substring(0, rawBaseUrl.length - 1) : rawBaseUrl;
+      final effectiveUrl = apiUrl ?? '$baseUrl/api/upload';
+      final url = Uri.parse(effectiveUrl);
       final request = http.MultipartRequest('POST', url);
+      request.headers['X-API-KEY'] = WalletIdentityService.apiKey;
 
       // 1. Prepare image
       final file = File(imagePath);
       if (!await file.exists()) {
-        throw Exception('Le fichier image n\'existe pas');
+        return AiExportResult.error(
+          code: 'FILE_NOT_FOUND',
+          message: 'Le fichier image cible est introuvable.',
+        );
       }
 
-      // Read image metadata (approximate dimensions since decoding image can be heavy)
+      final sanitizedPhoto = stripMetadata(await file.readAsBytes());
-      // On the frontend we usually have aspectRatio, here we use generic values if not available.
+      if (sanitizedPhoto == null) {
-      final deviceData = await _getDeviceInfo();
+        return AiExportResult.error(
+          code: 'INVALID_IMAGE',
+          message: 'La photo de la cible est illisible et n\'a pas pu être envoyée.',
+        );
+      }
 
-      // We approximate the target corners from center and radius
-      // radius is relative (0 to 1). We need image width/height to get pixels.
-      // But we can just pass relative corners as well, or a normalized bounding box.
-      // Let's create normalized corners (0 to 1).
       final corners = [
         {"norm_x": targetCenterX - targetRadius, "norm_y": targetCenterY - targetRadius},
         {"norm_x": targetCenterX + targetRadius, "norm_y": targetCenterY - targetRadius},
@@ -98,7 +160,6 @@ class AiExportService {
       }).toList();
 
       // Get and hash the wallet identity
-      final walletService = WalletIdentityService();
       final phrase = await walletService.getIdentityPhrase();
       final phraseBytes = utf8.encode(phrase);
       final walletHash = sha256.convert(phraseBytes).toString();
@@ -108,12 +169,15 @@ class AiExportService {
         "session_id": sessionId,
         "wallet_hash": walletHash,
         "timestamp": DateTime.now().toIso8601String(),
-        "device_info": deviceData,
         "target_metadata": {
           "type": targetType.name,
           "distance_meters": distanceMeters,
-          "weapon": weaponName,
+          "caliber": caliber,
-          // The backend could extract exact width/height from the image.
+          // Nombre de coups prevus pour cette cible, null hors session.
+          // Un ecart avec le nombre d'impacts ne signifie pas que le
+          // marquage est faux (un coup peut etre parti hors papier) : c'est
+          // au tri du dataset d'en decider, pas au client.
+          "expected_shots": expectedShots,
         },
         "plotting": {
           "target_corners": corners,
@@ -121,29 +185,65 @@ class AiExportService {
         }
       };
 
-      // Add fields to request
       request.fields['plotting'] = jsonEncode(plottingJson);
-
-      // Add file
       request.files.add(
-        await http.MultipartFile.fromPath('photo', imagePath),
+        http.MultipartFile.fromBytes(
+          'photo',
+          sanitizedPhoto,
+          filename: 'target.jpg',
+        ),
       );
 
-      // Send request
+      final streamedResponse = await request.send().timeout(
-      final response = await request.send();
+        const Duration(seconds: 15),
+        onTimeout: () => throw Exception('Délai d\'attente dépassé (timeout)'),
+      );
 
-      if (response.statusCode == 200) {
+      final responseBody = await streamedResponse.stream.bytesToString();
-        final responseData = await response.stream.bytesToString();
+      Map<String, dynamic> responseJson = {};
-        debugPrint('Export réussi: $responseData');
+      try {
-        return true;
+        responseJson = jsonDecode(responseBody);
+      } catch (_) {}
+
+      final statusCode = streamedResponse.statusCode;
+
+      if (statusCode == 200) {
+        debugPrint('Export réussi: $responseBody');
+        return AiExportResult.success(
+          message: responseJson['message'] ?? 'Photo et données exportées avec succès.',
+          targetValidation: responseJson['target_validation'] as Map<String, dynamic>?,
+        );
+      } else if (statusCode == 403 || responseJson['code'] == 'WALLET_BANNED') {
+        final reason = responseJson['reason'] ?? 'Non-respect des règles de contribution';
+        debugPrint('Export rejeté (banni): $reason');
+        // Persister le bannissement localement et couper l'envoi de photos
+        await walletService.setBanned(true, reason: reason);
+        return AiExportResult.banned(
+          reason: reason,
+          message: responseJson['error'] ?? 'Votre wallet a été suspendu par la modération.',
+        );
+      } else if (statusCode == 400) {
+        return AiExportResult.error(
+          code: responseJson['code'] ?? 'BAD_REQUEST',
+          message: responseJson['error'] ?? 'Requête d\'export invalide.',
+        );
       } else {
-        final errorData = await response.stream.bytesToString();
+        return AiExportResult.error(
-        debugPrint('Erreur d\'export: ${response.statusCode} - $errorData');
+          code: responseJson['code'] ?? 'SERVER_ERROR',
-        return false;
+          message: responseJson['error'] ?? 'Erreur serveur ($statusCode).',
+        );
       }
+    } on SocketException {
+      return AiExportResult.error(
+        code: 'NETWORK_ERROR',
+        message: 'Impossible de joindre le serveur IA. Vérifiez l\'adresse IP ou votre connexion.',
+      );
     } catch (e) {
       debugPrint('Exception lors de l\'export: $e');
-      return false;
+      return AiExportResult.error(
+        code: 'UNKNOWN_ERROR',
+        message: 'Erreur lors de l\'export: $e',
+      );
     }
   }
 }

lib/services/backup_service.dart

@@ -0,0 +1,426 @@
+import 'dart:convert';
+import 'dart:io';
+
+import 'package:flutter/foundation.dart';
+import 'package:path/path.dart' as p;
+import 'package:path_provider/path_provider.dart';
+
+import '../data/models/maintenance.dart';
+import '../data/models/session.dart';
+import '../data/models/shot.dart';
+import '../data/models/target_analysis.dart';
+import '../data/models/weapon.dart';
+import '../data/repositories/session_repository.dart';
+import 'statistics_service.dart';
+
+/// Résumé d'un fichier de sauvegarde, affiché avant de confirmer un import.
+class BackupPreview {
+  final int sessionCount;
+  final int targetCount;
+  final int shotCount;
+  final int weaponCount;
+  final int maintenanceCount;
+  final bool hasImages;
+  final DateTime? exportedAt;
+  final Map<String, dynamic> raw;
+
+  const BackupPreview({
+    required this.sessionCount,
+    required this.targetCount,
+    required this.shotCount,
+    required this.weaponCount,
+    required this.maintenanceCount,
+    required this.hasImages,
+    required this.exportedAt,
+    required this.raw,
+  });
+}
+
+/// Résultat d'un import : ce qui a réellement été écrit en base.
+class ImportResult {
+  final int sessions;
+  final int weapons;
+  final int maintenance;
+  final int images;
+  final List<String> errors;
+
+  const ImportResult({
+    required this.sessions,
+    required this.weapons,
+    required this.maintenance,
+    required this.images,
+    required this.errors,
+  });
+}
+
+/// Erreur « propre » d'import : message directement affichable à l'utilisateur.
+class BackupFormatException implements Exception {
+  final String message;
+  BackupFormatException(this.message);
+
+  @override
+  String toString() => message;
+}
+
+/// Import / export de l'intégralité des données de l'app dans un fichier JSON :
+/// sessions (avec cibles, impacts et calibration), armurerie (armes +
+/// maintenance) et un instantané des statistiques calculées.
+///
+/// Les statistiques ne sont pas réimportées : elles sont recalculées à partir
+/// des sessions. Elles figurent dans le fichier pour pouvoir être lues telles
+/// quelles (analyse externe, IA, tableur).
+class BackupService {
+  static const String formatId = 'impact.backup';
+  static const int formatVersion = 1;
+
+  final SessionRepository _repository;
+  final StatisticsService _statisticsService;
+
+  BackupService({
+    required SessionRepository repository,
+    StatisticsService? statisticsService,
+  })  : _repository = repository,
+        _statisticsService = statisticsService ?? StatisticsService();
+
+  // ---------------------------------------------------------------- EXPORT
+
+  /// Construit le fichier de sauvegarde et renvoie le fichier écrit dans le
+  /// dossier temporaire, prêt à être passé à la feuille de partage du système.
+  Future<File> exportToFile({bool includeImages = false}) async {
+    final json = await buildBackupJson(includeImages: includeImages);
+
+    final tempDir = await getTemporaryDirectory();
+    final file = File(p.join(tempDir.path, _buildFileName()));
+    await file.writeAsString(
+      const JsonEncoder.withIndent('  ').convert(json),
+      flush: true,
+    );
+
+    return file;
+  }
+
+  String _buildFileName() {
+    final now = DateTime.now();
+    String two(int v) => v.toString().padLeft(2, '0');
+    return 'impact_sauvegarde_${now.year}-${two(now.month)}-${two(now.day)}'
+        '_${two(now.hour)}${two(now.minute)}.json';
+  }
+
+  @visibleForTesting
+  Future<Map<String, dynamic>> buildBackupJson({
+    bool includeImages = false,
+  }) async {
+    final sessions = await _repository.getAllSessions();
+    final weapons = await _repository.getWeapons();
+    final maintenance = await _repository.getAllMaintenance();
+
+    // Maintenance regroupée par arme : une arme reste autonome dans le fichier.
+    final maintenanceByWeapon = <String, List<MaintenanceEntry>>{};
+    for (final entry in maintenance) {
+      (maintenanceByWeapon[entry.weaponId] ??= []).add(entry);
+    }
+
+    var totalTargets = 0;
+    var totalShots = 0;
+    final sessionsJson = <Map<String, dynamic>>[];
+    for (final session in sessions) {
+      final analysesJson = <Map<String, dynamic>>[];
+      for (final analysis in session.analyses) {
+        totalTargets++;
+        totalShots += analysis.shots.length;
+        analysesJson.add(await _analysisToJson(analysis, includeImages));
+      }
+      sessionsJson.add({
+        ...session.toMap(),
+        'analyses': analysesJson,
+      });
+    }
+
+    return {
+      'format': formatId,
+      'version': formatVersion,
+      'app': 'bully',
+      'exported_at': DateTime.now().toIso8601String(),
+      'includes_images': includeImages,
+      'counts': {
+        'sessions': sessions.length,
+        'targets': totalTargets,
+        'shots': totalShots,
+        'weapons': weapons.length,
+        'maintenance': maintenance.length,
+      },
+      'statistics': _statisticsToJson(sessions),
+      'weapons': weapons
+          .map((w) => {
+                ...w.toMap(),
+                'maintenance': (maintenanceByWeapon[w.id] ?? [])
+                    .map((e) => e.toMap())
+                    .toList(),
+              })
+          .toList(),
+      'sessions': sessionsJson,
+      // Maintenance orpheline (arme supprimée) : conservée pour ne rien perdre.
+      'orphan_maintenance': maintenance
+          .where((e) => !weapons.any((w) => w.id == e.weaponId))
+          .map((e) => e.toMap())
+          .toList(),
+    };
+  }
+
+  Future<Map<String, dynamic>> _analysisToJson(
+    TargetAnalysis analysis,
+    bool includeImages,
+  ) async {
+    final json = <String, dynamic>{
+      ...analysis.toMap(),
+      'shots': analysis.shots.map((s) => s.toMap()).toList(),
+    };
+
+    if (includeImages) {
+      try {
+        final file = File(analysis.imagePath);
+        if (await file.exists()) {
+          json['image_extension'] = p.extension(analysis.imagePath);
+          json['image_base64'] = base64Encode(await file.readAsBytes());
+        }
+      } catch (e) {
+        // Une photo illisible ne doit pas faire échouer toute la sauvegarde.
+        debugPrint('Sauvegarde : image ignorée (${analysis.id}) : $e');
+      }
+    }
+
+    return json;
+  }
+
+  Map<String, dynamic> _statisticsToJson(List<Session> sessions) {
+    final stats = _statisticsService.calculateStatistics(
+      sessions,
+      period: StatsPeriod.all,
+    );
+
+    return {
+      'total_shots': stats.totalShots,
+      'total_score': stats.totalScore,
+      'average_score': stats.avgScore,
+      'max_score': stats.maxScore,
+      'min_score': stats.minScore,
+      'precision': {
+        'avg_distance_from_center': stats.precision.avgDistanceFromCenter,
+        'grouping_diameter': stats.precision.groupingDiameter,
+        'precision_score': stats.precision.precisionScore,
+        'consistency_score': stats.precision.consistencyScore,
+      },
+      'std_dev': {
+        'x': stats.stdDev.stdDevX,
+        'y': stats.stdDev.stdDevY,
+        'radial': stats.stdDev.stdDevRadial,
+        'score': stats.stdDev.stdDevScore,
+        'mean_x': stats.stdDev.meanX,
+        'mean_y': stats.stdDev.meanY,
+        'mean_score': stats.stdDev.meanScore,
+      },
+      'regional': {
+        'quadrants': stats.regional.quadrantDistribution,
+        'sectors': stats.regional.sectorDistribution,
+        'dominant_direction': stats.regional.dominantDirection,
+        'bias_x': stats.regional.biasX,
+        'bias_y': stats.regional.biasY,
+      },
+      'heat_map': {
+        'grid_size': stats.heatMap.gridSize,
+        'max_shots_in_zone': stats.heatMap.maxShotsInZone,
+        'zones': [
+          for (final row in stats.heatMap.zones)
+            for (final zone in row)
+              {
+                'row': zone.row,
+                'col': zone.col,
+                'shot_count': zone.shotCount,
+                'intensity': zone.intensity,
+                'avg_score': zone.avgScore,
+              },
+        ],
+      },
+    };
+  }
+
+  // ---------------------------------------------------------------- IMPORT
+
+  /// Lit et valide un fichier de sauvegarde sans rien écrire en base.
+  Future<BackupPreview> readBackup(File file) async {
+    late final dynamic decoded;
+    try {
+      decoded = jsonDecode(await file.readAsString());
+    } catch (e) {
+      throw BackupFormatException(
+        'Fichier illisible : ce n\'est pas un JSON valide.',
+      );
+    }
+
+    if (decoded is! Map<String, dynamic>) {
+      throw BackupFormatException('Fichier illisible : format inattendu.');
+    }
+    if (decoded['format'] != formatId) {
+      throw BackupFormatException(
+        'Ce fichier n\'est pas une sauvegarde IMPACT.',
+      );
+    }
+    final version = (decoded['version'] as num?)?.toInt() ?? 0;
+    if (version > formatVersion) {
+      throw BackupFormatException(
+        'Sauvegarde créée par une version plus récente de l\'application '
+        '(format $version). Mettez l\'app à jour pour l\'importer.',
+      );
+    }
+
+    final sessions = _asList(decoded['sessions']);
+    final weapons = _asList(decoded['weapons']);
+
+    var targets = 0;
+    var shots = 0;
+    var hasImages = false;
+    for (final session in sessions) {
+      for (final analysis in _asList(session['analyses'])) {
+        targets++;
+        shots += _asList(analysis['shots']).length;
+        if (analysis['image_base64'] != null) hasImages = true;
+      }
+    }
+
+    var maintenance = _asList(decoded['orphan_maintenance']).length;
+    for (final weapon in weapons) {
+      maintenance += _asList(weapon['maintenance']).length;
+    }
+
+    return BackupPreview(
+      sessionCount: sessions.length,
+      targetCount: targets,
+      shotCount: shots,
+      weaponCount: weapons.length,
+      maintenanceCount: maintenance,
+      hasImages: hasImages,
+      exportedAt: DateTime.tryParse(decoded['exported_at'] as String? ?? ''),
+      raw: decoded,
+    );
+  }
+
+  /// Écrit en base le contenu d'une sauvegarde déjà lue par [readBackup].
+  ///
+  /// Fusion : les entrées existantes portant le même identifiant sont
+  /// remplacées, les autres sont conservées. Réimporter deux fois la même
+  /// sauvegarde ne crée donc pas de doublons.
+  Future<ImportResult> applyBackup(BackupPreview preview) async {
+    final errors = <String>[];
+    var importedSessions = 0;
+    var importedWeapons = 0;
+    var importedMaintenance = 0;
+    var importedImages = 0;
+
+    // 1. Armurerie d'abord : les sessions y font référence par weapon_id.
+    for (final weaponJson in _asList(preview.raw['weapons'])) {
+      try {
+        await _repository.saveWeapon(Weapon.fromMap(weaponJson));
+        importedWeapons++;
+      } catch (e) {
+        errors.add('Arme ignorée : $e');
+        continue;
+      }
+      for (final entryJson in _asList(weaponJson['maintenance'])) {
+        try {
+          await _repository.saveMaintenanceEntry(
+            MaintenanceEntry.fromMap(entryJson),
+          );
+          importedMaintenance++;
+        } catch (e) {
+          errors.add('Entretien ignoré : $e');
+        }
+      }
+    }
+
+    // 2. Sessions, cibles et impacts.
+    for (final sessionJson in _asList(preview.raw['sessions'])) {
+      try {
+        final analyses = <TargetAnalysis>[];
+        for (final analysisJson in _asList(sessionJson['analyses'])) {
+          final shots = _asList(analysisJson['shots'])
+              .map((s) => Shot.fromMap(s))
+              .toList();
+
+          var map = _normalizeAnalysis(analysisJson);
+          final imagePath = await _restoreImage(analysisJson);
+          if (imagePath != null) {
+            map = {...map, 'image_path': imagePath};
+            importedImages++;
+          }
+
+          analyses.add(TargetAnalysis.fromMap(map, shots));
+        }
+        await _repository.saveSession(Session.fromMap(sessionJson, analyses));
+        importedSessions++;
+      } catch (e) {
+        errors.add('Session ignorée : $e');
+      }
+    }
+
+    // 3. Maintenance dont l'arme a été supprimée avant l'export.
+    for (final entryJson in _asList(preview.raw['orphan_maintenance'])) {
+      try {
+        await _repository.saveMaintenanceEntry(
+          MaintenanceEntry.fromMap(entryJson),
+        );
+        importedMaintenance++;
+      } catch (e) {
+        errors.add('Entretien ignoré : $e');
+      }
+    }
+
+    return ImportResult(
+      sessions: importedSessions,
+      weapons: importedWeapons,
+      maintenance: importedMaintenance,
+      images: importedImages,
+      errors: errors,
+    );
+  }
+
+  /// Recrée la photo de cible si la sauvegarde l'embarque, et renvoie son
+  /// nouveau chemin local. `null` si la sauvegarde est sans photos : le chemin
+  /// d'origine est alors conservé (l'app affiche un placeholder s'il est mort).
+  Future<String?> _restoreImage(Map<String, dynamic> analysisJson) async {
+    final encoded = analysisJson['image_base64'] as String?;
+    if (encoded == null || encoded.isEmpty) return null;
+
+    try {
+      final bytes = base64Decode(encoded);
+      final extension = analysisJson['image_extension'] as String? ?? '.jpg';
+      return await _repository.saveImageBytes(bytes, extension);
+    } catch (e) {
+      debugPrint('Import : image ignorée : $e');
+      return null;
+    }
+  }
+
+  /// JSON ne distingue pas 1 de 1.0 : une valeur ronde relue devient un `int`
+  /// et casse les `as double?` des modèles. On reforce donc les doubles.
+  Map<String, dynamic> _normalizeAnalysis(Map<String, dynamic> json) {
+    const doubleKeys = [
+      'grouping_diameter',
+      'grouping_center_x',
+      'grouping_center_y',
+      'target_center_x',
+      'target_center_y',
+      'target_radius',
+    ];
+
+    final map = Map<String, dynamic>.from(json);
+    for (final key in doubleKeys) {
+      map[key] = (map[key] as num?)?.toDouble();
+    }
+    return map;
+  }
+
+  List<Map<String, dynamic>> _asList(dynamic value) {
+    if (value is! List) return const [];
+    return value.whereType<Map<String, dynamic>>().toList();
+  }
+}

lib/services/parallelism_service.dart

@@ -1,5 +1,6 @@
 import 'dart:async';
 import 'dart:math' as math;
+import 'package:flutter/foundation.dart';
 import 'package:sensors_plus/sensors_plus.dart';
 
 /// Statut de parallélisme retourné en temps réel.
@@ -14,31 +15,67 @@ enum ParallelismStatus {
   misaligned,
 }
 
+/// Pose de prise de vue déduite de l'inclinaison de l'appareil.
+enum TargetPose {
+  /// Cible accrochée verticalement : l'appareil est tenu droit.
+  wall,
+
+  /// Cible posée au sol : l'appareil est à plat, caméra vers le bas.
+  ground,
+}
+
 /// Données de parallélisme calculées à chaque frame capteur.
 class ParallelismData {
   final ParallelismStatus status;
 
-  /// Inclinaison avant/arrière en degrés (0° = parfaitement vertical).
+  /// Pose détectée automatiquement, qui sert de référence aux écarts.
+  final TargetPose pose;
+
+  /// Inclinaison avant/arrière brute en degrés (0° = appareil vertical,
+  /// +90° = appareil à plat, caméra vers le sol).
   final double pitchDegrees;
 
   /// Inclinaison gauche/droite en degrés (0° = parfaitement droit).
   final double rollDegrees;
 
+  /// Écart de tangage par rapport à la pose détectée.
+  ///
+  /// En pose [TargetPose.wall] il vaut exactement [pitchDegrees] ; en pose
+  /// [TargetPose.ground] il mesure l'écart aux +90° de l'appareil à plat.
+  /// C'est cette valeur qu'il faut afficher : le tangage brut vaudrait -90°
+  /// alors que le cadrage est parfait.
+  final double pitchDeviation;
+
   const ParallelismData({
     required this.status,
+    required this.pose,
     required this.pitchDegrees,
     required this.rollDegrees,
+    required this.pitchDeviation,
   });
 
   bool get isAligned => status == ParallelismStatus.aligned;
 
+  /// Écart latéral. Le roulis se mesure de la même façon dans les deux poses.
+  double get rollDeviation => rollDegrees;
+
   @override
   String toString() =>
-      'ParallelismData(status: $status, pitch: ${pitchDegrees.toStringAsFixed(1)}°, roll: ${rollDegrees.toStringAsFixed(1)}°)';
+      'ParallelismData(status: $status, pose: $pose, pitch: ${pitchDegrees.toStringAsFixed(1)}°, '
+      'écart: ${pitchDeviation.toStringAsFixed(1)}°, roll: ${rollDegrees.toStringAsFixed(1)}°)';
 }
 
 /// Service de détection du parallélisme par accéléromètre.
 ///
+/// Deux poses de prise de vue sont reconnues, et celle dont l'appareil est le
+/// plus proche est retenue automatiquement :
+///
+///   [TargetPose.wall]   — cible au mur, appareil vertical (tangage ≈ 0°)
+///   [TargetPose.ground] — cible au sol, appareil à plat (tangage ≈ +90°)
+///
+/// Seul le tangage positif vaut pour la pose au sol : à plat écran vers le
+/// haut, la caméra vise le plafond et le vert n'aurait aucun sens.
+///
 /// Implémente une hystérésis à deux seuils pour éviter le clignotement :
 ///
 ///   État actuel = misaligned → passe à aligned si angle < [alignThreshold]
@@ -58,6 +95,13 @@ class ParallelismService {
   /// Doit être > alignThreshold pour créer la zone d'hystérésis.
   final double misalignThreshold;
 
+  /// Écart minimum en faveur de l'autre pose pour basculer.
+  ///
+  /// Les deux poses sont séparées de 90°, donc la bascule se joue vers 45° —
+  /// très loin des deux zones vertes. Cette marge évite seulement que
+  /// l'étiquette de pose clignote pile à la frontière.
+  static const double poseSwitchMargin = 5.0;
+
   StreamSubscription<AccelerometerEvent>? _subscription;
   final StreamController<ParallelismData> _controller =
   StreamController<ParallelismData>.broadcast();
@@ -65,6 +109,9 @@ class ParallelismService {
   /// État interne mémorisé entre deux frames (cœur de l'hystérésis).
   ParallelismStatus _currentStatus = ParallelismStatus.unknown;
 
+  /// Pose retenue à la frame précédente, pour l'hystérésis de pose.
+  TargetPose? _currentPose;
+
   ParallelismService({
     this.alignThreshold = 25.0,
     this.misalignThreshold = 32.0,
@@ -86,10 +133,13 @@ class ParallelismService {
         // Simulateur ou capteur absent — on reste en "unknown" sans bloquer l'UI
         if (!_controller.isClosed) {
           _currentStatus = ParallelismStatus.unknown;
+          _currentPose = null;
           _controller.add(const ParallelismData(
             status: ParallelismStatus.unknown,
+            pose: TargetPose.wall,
             pitchDegrees: 0,
             rollDegrees: 0,
+            pitchDeviation: 0,
           ));
         }
       },
@@ -100,6 +150,7 @@ class ParallelismService {
     _subscription?.cancel();
     _subscription = null;
     _currentStatus = ParallelismStatus.unknown;
+    _currentPose = null;
   }
 
   void dispose() {
@@ -110,12 +161,18 @@ class ParallelismService {
   void _onAccelerometerEvent(AccelerometerEvent event) {
     if (_controller.isClosed) return;
 
-    final double gx = event.x;
+    final data = evaluate(event.x, event.y, event.z);
-    final double gy = event.y;
+    if (data != null) _controller.add(data);
-    final double gz = event.z;
+  }
 
+  /// Calcule la pose et le statut depuis une mesure d'accéléromètre.
+  ///
+  /// Met à jour l'état d'hystérésis, donc l'ordre des appels compte.
+  /// Retourne null sur une mesure aberrante, qu'il faut alors ignorer.
+  @visibleForTesting
+  ParallelismData? evaluate(double gx, double gy, double gz) {
     final double magnitude = math.sqrt(gx * gx + gy * gy + gz * gz);
-    if (magnitude < 1.0) return; // Données aberrantes
+    if (magnitude < 1.0) return null; // Données aberrantes
 
     // Normalisation par la magnitude réelle (indépendant de g exact)
     final double nx = gx / magnitude;
@@ -125,10 +182,39 @@ class ParallelismService {
     final double pitchDeg = math.asin(nz.clamp(-1.0, 1.0)) * (180.0 / math.pi);
     final double rollDeg = math.asin(nx.clamp(-1.0, 1.0)) * (180.0 / math.pi);
 
-    // Le critère de couleur = le PIRE des deux angles affichés à l'écran.
+    // ── Choix de la pose ────────────────────────────────────────────────────
-    // Ainsi ce que voit l'utilisateur (Pitch / Roll) correspond exactement
+    // Cible au mur : le tangage idéal est 0°. Formule d'origine, inchangée.
-    // à la décision vert/orange : à 2° d'écart, on est largement dans le vert.
+    final double wallPitchDeviation = pitchDeg;
-    final double worstAngle = math.max(pitchDeg.abs(), rollDeg.abs());
+    final double wallWorst = math.max(pitchDeg.abs(), rollDeg.abs());
+
+    // Cible au sol : le tangage idéal est +90° (caméra vers le bas). Écran vers
+    // le haut, le tangage vaut -90° et l'écart atteint 180° : la pose au sol ne
+    // peut alors jamais gagner, ce qui est exactement le comportement voulu.
+    final double groundPitchDeviation = pitchDeg - 90.0;
+    final double groundWorst =
+    math.max(groundPitchDeviation.abs(), rollDeg.abs());
+
+    if (_currentPose == null) {
+      _currentPose =
+      groundWorst < wallWorst ? TargetPose.ground : TargetPose.wall;
+    } else if (_currentPose == TargetPose.wall) {
+      if (groundWorst + poseSwitchMargin < wallWorst) {
+        _currentPose = TargetPose.ground;
+      }
+    } else {
+      if (wallWorst + poseSwitchMargin < groundWorst) {
+        _currentPose = TargetPose.wall;
+      }
+    }
+
+    final bool isGround = _currentPose == TargetPose.ground;
+    final double pitchDeviation =
+    isGround ? groundPitchDeviation : wallPitchDeviation;
+
+    // Le critère de couleur = le PIRE des deux écarts affichés à l'écran.
+    // Ainsi ce que voit l'utilisateur correspond exactement à la décision
+    // vert/orange : à 2° d'écart, on est largement dans le vert.
+    final double worstAngle = isGround ? groundWorst : wallWorst;
 
     // ── Hystérésis ──────────────────────────────────────────────────────────
     // Premier appel : on décide selon alignThreshold uniquement
@@ -152,10 +238,12 @@ class ParallelismService {
     }
     // ────────────────────────────────────────────────────────────────────────
 
-    _controller.add(ParallelismData(
+    return ParallelismData(
       status: _currentStatus,
+      pose: _currentPose!,
       pitchDegrees: pitchDeg,
       rollDegrees: rollDeg,
-    ));
+      pitchDeviation: pitchDeviation,
+    );
   }
 }

lib/services/wallet_identity_service.dart

@@ -1,6 +1,7 @@
 import 'dart:math';
 import 'dart:convert';
 import 'package:crypto/crypto.dart';
+import 'package:http/http.dart' as http;
 import 'package:shared_preferences/shared_preferences.dart';
 import 'package:device_info_plus/device_info_plus.dart';
 import 'dart:io';
@@ -9,6 +10,9 @@ import 'package:flutter/foundation.dart';
 class WalletIdentityService {
   static const String _prefsKey = 'wallet_identity_phrase';
   static const String _uploadEnabledKey = 'is_ai_upload_enabled';
+  static const String _bannedKey = 'wallet_is_banned';
+  static const String _banReasonKey = 'wallet_ban_reason';
+  static const String _serverUrlKey = 'ai_server_url';
   
   // A standard list of 256 words (8 bits of entropy per word)
   static const List<String> _wordList = [
@@ -40,18 +44,102 @@ class WalletIdentityService {
     'bulk', 'bullet', 'bundle', 'bunker', 'burden', 'burger', 'burst', 'bus', 'business', 'butter'
   ];
 
-  /// Vérifie si l'utilisateur a accepté l'envoi de données à l'IA
+  /// URL par défaut du serveur de production
+  static const String defaultServerUrl = 'https://backendia.kevlar.cloud';
+
+  /// Clé d'authentification API secrète pour le backend
+  static const String apiKey = 'bully_secret_api_key_2026_x89';
+
+  /// Retourne l'URL de base du serveur configuré (par défaut: https://backendia.kevlar.cloud)
+  Future<String> getServerBaseUrl() async {
+    final prefs = await SharedPreferences.getInstance();
+    final customUrl = prefs.getString(_serverUrlKey);
+    if (customUrl != null && customUrl.trim().isNotEmpty) {
+      return customUrl.trim().replaceAll(RegExp(r'/api/upload/?$'), '');
+    }
+    return defaultServerUrl;
+  }
+
+  /// Définit une URL personnalisée pour le serveur IA
+  Future<void> setServerBaseUrl(String url) async {
+    final prefs = await SharedPreferences.getInstance();
+    final cleanUrl = url.trim().replaceAll(RegExp(r'/api/upload/?$'), '');
+    await prefs.setString(_serverUrlKey, cleanUrl);
+  }
+
+  /// Vérifie si l'utilisateur a accepté l'envoi de données à l'IA (et n'est pas banni)
   Future<bool> isUploadEnabled() async {
     final prefs = await SharedPreferences.getInstance();
+    final isBanned = prefs.getBool(_bannedKey) ?? false;
+    if (isBanned) return false;
     return prefs.getBool(_uploadEnabledKey) ?? false;
   }
 
   /// Active ou désactive l'envoi de données
   Future<void> setUploadEnabled(bool enabled) async {
     final prefs = await SharedPreferences.getInstance();
+    final isBanned = prefs.getBool(_bannedKey) ?? false;
+    if (isBanned) {
+      await prefs.setBool(_uploadEnabledKey, false);
+      return;
+    }
     await prefs.setBool(_uploadEnabledKey, enabled);
   }
 
+  /// Vérifie si ce wallet/utilisateur est banni en local
+  Future<bool> isBanned() async {
+    final prefs = await SharedPreferences.getInstance();
+    return prefs.getBool(_bannedKey) ?? false;
+  }
+
+  /// Récupère le motif de bannissement enregistré
+  Future<String?> getBanReason() async {
+    final prefs = await SharedPreferences.getInstance();
+    return prefs.getString(_banReasonKey);
+  }
+
+  /// Enregistre l'état de bannissement et le motif
+  Future<void> setBanned(bool banned, {String? reason}) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setBool(_bannedKey, banned);
+    if (banned) {
+      await prefs.setString(_banReasonKey, reason ?? 'Photos non conformes aux règles de tir');
+      await prefs.setBool(_uploadEnabledKey, false);
+    } else {
+      await prefs.remove(_banReasonKey);
+    }
+  }
+
+  /// Synchronise le statut de modération/bannissement avec le serveur backend
+  Future<bool> syncBanStatus() async {
+    try {
+      final phrase = await getIdentityPhrase();
+      final phraseBytes = utf8.encode(phrase);
+      final walletHash = sha256.convert(phraseBytes).toString();
+      final baseUrl = await getServerBaseUrl();
+      
+      final res = await http.get(
+        Uri.parse('$baseUrl/api/stats/$walletHash'),
+        headers: {'X-API-KEY': apiKey},
+      ).timeout(
+        const Duration(seconds: 4),
+      );
+      if (res.statusCode == 200) {
+        final data = jsonDecode(res.body);
+        final isBannedOnServer = data['is_banned'] == true;
+        if (isBannedOnServer) {
+          await setBanned(true, reason: data['ban_reason']);
+        } else {
+          await setBanned(false);
+        }
+        return isBannedOnServer;
+      }
+    } catch (e) {
+      debugPrint('Erreur synchro ban: $e');
+    }
+    return await isBanned();
+  }
+
   /// Gets the unique 15-word identity phrase
   Future<String> getIdentityPhrase() async {
     final prefs = await SharedPreferences.getInstance();

linux/flutter/generated_plugin_registrant.cc

@@ -7,9 +7,13 @@
 #include "generated_plugin_registrant.h"
 
 #include <file_selector_linux/file_selector_plugin.h>
+#include <url_launcher_linux/url_launcher_plugin.h>
 
 void fl_register_plugins(FlPluginRegistry* registry) {
   g_autoptr(FlPluginRegistrar) file_selector_linux_registrar =
       fl_plugin_registry_get_registrar_for_plugin(registry, "FileSelectorPlugin");
   file_selector_plugin_register_with_registrar(file_selector_linux_registrar);
+  g_autoptr(FlPluginRegistrar) url_launcher_linux_registrar =
+      fl_plugin_registry_get_registrar_for_plugin(registry, "UrlLauncherPlugin");
+  url_launcher_plugin_register_with_registrar(url_launcher_linux_registrar);
 }

linux/flutter/generated_plugins.cmake

@@ -4,6 +4,7 @@
 
 list(APPEND FLUTTER_PLUGIN_LIST
   file_selector_linux
+  url_launcher_linux
 )
 
 list(APPEND FLUTTER_FFI_PLUGIN_LIST

macos/Flutter/GeneratedPluginRegistrant.swift

@@ -7,12 +7,14 @@ import Foundation
 
 import device_info_plus
 import file_selector_macos
+import share_plus
 import shared_preferences_foundation
 import sqflite_darwin
 
 func RegisterGeneratedPlugins(registry: FlutterPluginRegistry) {
   DeviceInfoPlusMacosPlugin.register(with: registry.registrar(forPlugin: "DeviceInfoPlusMacosPlugin"))
   FileSelectorPlugin.register(with: registry.registrar(forPlugin: "FileSelectorPlugin"))
+  SharePlusMacosPlugin.register(with: registry.registrar(forPlugin: "SharePlusMacosPlugin"))
   SharedPreferencesPlugin.register(with: registry.registrar(forPlugin: "SharedPreferencesPlugin"))
   SqflitePlugin.register(with: registry.registrar(forPlugin: "SqflitePlugin"))
 }

pubspec.lock

@@ -201,6 +201,30 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "7.0.1"
+  file_selector:
+    dependency: "direct main"
+    description:
+      name: file_selector
+      sha256: bd15e43e9268db636b53eeaca9f56324d1622af30e5c34d6e267649758c84d9a
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.1.0"
+  file_selector_android:
+    dependency: transitive
+    description:
+      name: file_selector_android
+      sha256: "89243030ea4b3463fb402b44d5eeacc4ccb1c46a88870cb2a5080d693200c1ed"
+      url: "https://pub.dev"
+    source: hosted
+    version: "0.5.2+6"
+  file_selector_ios:
+    dependency: transitive
+    description:
+      name: file_selector_ios
+      sha256: e2ecf2885c121691ce13b60db3508f53c01f869fb6e8dc5c1cfa771e4c46aeca
+      url: "https://pub.dev"
+    source: hosted
+    version: "0.5.3+5"
   file_selector_linux:
     dependency: transitive
     description:
@@ -225,6 +249,14 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "2.7.0"
+  file_selector_web:
+    dependency: transitive
+    description:
+      name: file_selector_web
+      sha256: "73181fbc5257776d8ecaa6a94ab3c8e920ad143b9132a6d984a9271dfc6928d3"
+      url: "https://pub.dev"
+    source: hosted
+    version: "0.9.5"
   file_selector_windows:
     dependency: transitive
     description:
@@ -709,6 +741,22 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "1.2.0"
+  share_plus:
+    dependency: "direct main"
+    description:
+      name: share_plus
+      sha256: "34f00f9becd2743c1fb05363d624f9f70d37f7ccdcdda47450bc0b8c9d327b8c"
+      url: "https://pub.dev"
+    source: hosted
+    version: "13.3.0"
+  share_plus_platform_interface:
+    dependency: transitive
+    description:
+      name: share_plus_platform_interface
+      sha256: "365ef7379fc22507256adda3385152942ffce08935452bc972c2e52a0bebae41"
+      url: "https://pub.dev"
+    source: hosted
+    version: "7.2.0"
   shared_preferences:
     dependency: "direct main"
     description:
@@ -898,6 +946,38 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "1.4.0"
+  url_launcher_linux:
+    dependency: transitive
+    description:
+      name: url_launcher_linux
+      sha256: d5e14138b3bc193a0f63c10a53c94b91d399df0512b1f29b94a043db7482384a
+      url: "https://pub.dev"
+    source: hosted
+    version: "3.2.2"
+  url_launcher_platform_interface:
+    dependency: transitive
+    description:
+      name: url_launcher_platform_interface
+      sha256: "552f8a1e663569be95a8190206a38187b531910283c3e982193e4f2733f01029"
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.3.2"
+  url_launcher_web:
+    dependency: transitive
+    description:
+      name: url_launcher_web
+      sha256: "85c81589622fbc87c1c683aaea164d3604a7777495a79d91e39ffcdec39ddb34"
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.4.3"
+  url_launcher_windows:
+    dependency: transitive
+    description:
+      name: url_launcher_windows
+      sha256: "712c70ab1b99744ff066053cbe3e80c73332b38d46e5e945c98689b2e66fc15f"
+      url: "https://pub.dev"
+    source: hosted
+    version: "3.1.5"
   uuid:
     dependency: "direct main"
     description:

pubspec.yaml

@@ -70,6 +70,8 @@ dependencies:
   shared_preferences: ^2.5.5
   crypto: ^3.0.7
   camera: ^0.12.0+1
+  share_plus: ^13.3.0
+  file_selector: ^1.1.0
 
 dev_dependencies:
   flutter_test:
@@ -93,10 +95,8 @@ flutter:
   # the material Icons class.
   uses-material-design: true
 
-  # To add assets to your application, add an assets section, like this:
+  assets:
-  # assets:
+    - assets/icons/
-  #   - images/a_dot_burr.jpeg
-  #   - images/a_dot_ham.jpeg
 
   # An image asset can refer to one or more resolution-specific "variants", see
   # https://flutter.dev/to/resolution-aware-images

test/services/ai_export_service_test.dart

@@ -0,0 +1,61 @@
+import 'dart:typed_data';
+
+import 'package:flutter_test/flutter_test.dart';
+import 'package:image/image.dart' as img;
+
+import 'package:bully/services/ai_export_service.dart';
+
+/// Construit un JPEG porteur de métadonnées EXIF comme le ferait un téléphone :
+/// position GPS, modèle d'appareil et orientation.
+Uint8List _photoWithExif({int orientation = 1}) {
+  final image = img.Image(width: 40, height: 20);
+  img.fill(image, color: img.ColorRgb8(120, 120, 120));
+
+  image.exif.imageIfd['Model'] = 'Pixel 8';
+  image.exif.imageIfd.orientation = orientation;
+  image.exif.gpsIfd['GPSLatitude'] = 48.8584;
+  image.exif.gpsIfd['GPSLongitude'] = 2.2945;
+
+  return img.encodeJpg(image);
+}
+
+void main() {
+  final service = AiExportService();
+
+  group('stripMetadata', () {
+    test('supprime le GPS et les autres métadonnées EXIF', () {
+      final original = _photoWithExif();
+
+      // Garde-fou : sans EXIF au départ, le test ne prouverait rien.
+      expect(img.decodeImage(original)!.exif.isEmpty, isFalse);
+
+      final stripped = service.stripMetadata(original);
+      final result = img.decodeImage(stripped!)!;
+
+      expect(result.exif.isEmpty, isTrue);
+      expect(result.exif.gpsIfd.isEmpty, isTrue);
+    });
+
+    test('applique l\'orientation aux pixels avant de retirer le tag', () {
+      // Orientation 6 = rotation de 90°, donc les dimensions s'inversent.
+      final original = _photoWithExif(orientation: 6);
+
+      final result = img.decodeImage(service.stripMetadata(original)!)!;
+
+      expect(result.width, 20);
+      expect(result.height, 40);
+      expect(result.exif.isEmpty, isTrue);
+    });
+
+    test('conserve les dimensions quand il n\'y a pas d\'orientation', () {
+      final result = img.decodeImage(service.stripMetadata(_photoWithExif())!)!;
+
+      expect(result.width, 40);
+      expect(result.height, 20);
+    });
+
+    test('retourne null sur une image illisible', () {
+      expect(service.stripMetadata(Uint8List.fromList([1, 2, 3, 4])), isNull);
+    });
+  });
+}

test/services/backup_service_test.dart

@@ -0,0 +1,372 @@
+import 'dart:convert';
+import 'dart:io';
+
+import 'package:flutter_test/flutter_test.dart';
+
+import 'package:bully/data/models/maintenance.dart';
+import 'package:bully/data/models/session.dart';
+import 'package:bully/data/models/shot.dart';
+import 'package:bully/data/models/target_analysis.dart';
+import 'package:bully/data/models/target_type.dart';
+import 'package:bully/data/models/weapon.dart';
+import 'package:bully/data/repositories/session_repository.dart';
+import 'package:bully/services/backup_service.dart';
+
+/// Dépôt en mémoire : évite d'ouvrir une vraie base SQLite dans les tests.
+class _FakeRepository extends SessionRepository {
+  final List<Session> sessions;
+  final List<Weapon> weapons;
+  final List<MaintenanceEntry> maintenance;
+  final List<List<int>> savedImages = [];
+
+  _FakeRepository({
+    List<Session>? sessions,
+    List<Weapon>? weapons,
+    List<MaintenanceEntry>? maintenance,
+  })  : sessions = sessions ?? [],
+        weapons = weapons ?? [],
+        maintenance = maintenance ?? [];
+
+  @override
+  Future<List<Session>> getAllSessions({int? limit, int? offset}) async =>
+      sessions;
+
+  @override
+  Future<List<Weapon>> getWeapons() async => weapons;
+
+  @override
+  Future<List<MaintenanceEntry>> getAllMaintenance() async => maintenance;
+
+  @override
+  Future<void> saveSession(Session session) async {
+    sessions.removeWhere((s) => s.id == session.id);
+    sessions.add(session);
+  }
+
+  @override
+  Future<void> saveWeapon(Weapon weapon) async {
+    weapons.removeWhere((w) => w.id == weapon.id);
+    weapons.add(weapon);
+  }
+
+  @override
+  Future<void> saveMaintenanceEntry(MaintenanceEntry entry) async {
+    maintenance.removeWhere((e) => e.id == entry.id);
+    maintenance.add(entry);
+  }
+
+  @override
+  Future<String> saveImageBytes(List<int> bytes, String extension) async {
+    savedImages.add(bytes);
+    return '/imported/image_${savedImages.length}$extension';
+  }
+}
+
+Session _session({String id = 's1', String weapon = 'Glock 17'}) {
+  return Session(
+    id: id,
+    weapon: weapon,
+    weaponId: 'w1',
+    maxShotsPerTarget: 5,
+    createdAt: DateTime(2026, 3, 14, 10, 30),
+    notes: 'Entraînement',
+    distance: 25,
+    analyses: [
+      TargetAnalysis(
+        id: '$id-a1',
+        sessionId: id,
+        targetType: TargetType.concentric,
+        imagePath: '/photos/$id.jpg',
+        totalScore: 18,
+        groupingDiameter: 0.12,
+        groupingCenterX: 0.5,
+        groupingCenterY: 0.48,
+        createdAt: DateTime(2026, 3, 14, 10, 35),
+        targetCenterX: 0.5,
+        targetCenterY: 0.5,
+        targetRadius: 0.4,
+        shots: [
+          Shot(id: '$id-t1', x: 0.5, y: 0.5, score: 10, analysisId: '$id-a1'),
+          Shot(id: '$id-t2', x: 0.55, y: 0.52, score: 8, analysisId: '$id-a1'),
+        ],
+      ),
+    ],
+  );
+}
+
+Weapon _weapon() => Weapon(
+      id: 'w1',
+      name: 'Glock 17',
+      type: WeaponType.handgun,
+      caliber: '9mm',
+      magazineCount: 3,
+      magazineCapacity: 17,
+      createdAt: DateTime(2025, 1, 5),
+      optic: 'Point rouge',
+      customName: 'La bleue',
+    );
+
+MaintenanceEntry _maintenance() => MaintenanceEntry(
+      id: 'm1',
+      weaponId: 'w1',
+      type: MaintenanceType.cleaning,
+      description: 'Nettoyage complet',
+      date: DateTime(2026, 2, 1),
+      roundsSinceLastMaintenance: 500,
+    );
+
+/// Sérialise puis relit la sauvegarde comme le ferait un vrai fichier partagé.
+Future<BackupPreview> _roundTrip(
+  Map<String, dynamic> json,
+  BackupService service,
+) async {
+  final dir = await Directory.systemTemp.createTemp('impact_backup_test');
+  addTearDown(() => dir.delete(recursive: true));
+  final file = File('${dir.path}/backup.json');
+  await file.writeAsString(jsonEncode(json));
+  return service.readBackup(file);
+}
+
+void main() {
+  group('export', () {
+    test('la sauvegarde contient sessions, armurerie et stats', () async {
+      final source = _FakeRepository(
+        sessions: [_session()],
+        weapons: [_weapon()],
+        maintenance: [_maintenance()],
+      );
+      final json = await BackupService(repository: source).buildBackupJson();
+
+      expect(json['format'], BackupService.formatId);
+      expect(json['counts'], {
+        'sessions': 1,
+        'targets': 1,
+        'shots': 2,
+        'weapons': 1,
+        'maintenance': 1,
+      });
+
+      // Les stats sont recalculées et écrites telles quelles dans le fichier.
+      final stats = json['statistics'] as Map<String, dynamic>;
+      expect(stats['total_shots'], 2);
+      expect(stats['total_score'], 18);
+
+      // L'entretien voyage avec son arme.
+      final weapon = (json['weapons'] as List).single as Map<String, dynamic>;
+      expect((weapon['maintenance'] as List), hasLength(1));
+      expect(json['orphan_maintenance'], isEmpty);
+    });
+
+    test('sans photos, aucune image n\'est encodée', () async {
+      final source = _FakeRepository(sessions: [_session()]);
+      final json = await BackupService(repository: source).buildBackupJson();
+
+      final session = (json['sessions'] as List).single as Map<String, dynamic>;
+      final analysis = (session['analyses'] as List).single as Map<String, dynamic>;
+      expect(analysis.containsKey('image_base64'), isFalse);
+    });
+
+    test('l\'entretien d\'une arme supprimée n\'est pas perdu', () async {
+      final source = _FakeRepository(maintenance: [_maintenance()]);
+      final json = await BackupService(repository: source).buildBackupJson();
+
+      expect(json['orphan_maintenance'], hasLength(1));
+    });
+  });
+
+  group('import', () {
+    test('aller-retour complet : tout est restauré à l\'identique', () async {
+      final source = _FakeRepository(
+        sessions: [_session()],
+        weapons: [_weapon()],
+        maintenance: [_maintenance()],
+      );
+      final json = await BackupService(repository: source).buildBackupJson();
+
+      final target = _FakeRepository();
+      final service = BackupService(repository: target);
+      final preview = await _roundTrip(json, service);
+
+      expect(preview.sessionCount, 1);
+      expect(preview.shotCount, 2);
+      expect(preview.weaponCount, 1);
+      expect(preview.maintenanceCount, 1);
+      expect(preview.hasImages, isFalse);
+
+      final result = await service.applyBackup(preview);
+      expect(result.errors, isEmpty);
+      expect(result.sessions, 1);
+      expect(result.weapons, 1);
+      expect(result.maintenance, 1);
+
+      final session = target.sessions.single;
+      expect(session.id, 's1');
+      expect(session.weapon, 'Glock 17');
+      expect(session.distance, 25);
+      expect(session.createdAt, DateTime(2026, 3, 14, 10, 30));
+      expect(session.totalShots, 2);
+      expect(session.totalScore, 18);
+      expect(session.analyses.single.targetRadius, 0.4);
+      expect(session.analyses.single.shots.first.score, 10);
+
+      expect(target.weapons.single.customName, 'La bleue');
+      expect(target.weapons.single.magazineCapacity, 17);
+      expect(target.maintenance.single.roundsSinceLastMaintenance, 500);
+    });
+
+    test('réimporter deux fois ne crée pas de doublon', () async {
+      final source = _FakeRepository(
+        sessions: [_session()],
+        weapons: [_weapon()],
+      );
+      final json = await BackupService(repository: source).buildBackupJson();
+
+      final target = _FakeRepository();
+      final service = BackupService(repository: target);
+      await service.applyBackup(await _roundTrip(json, service));
+      await service.applyBackup(await _roundTrip(json, service));
+
+      expect(target.sessions, hasLength(1));
+      expect(target.weapons, hasLength(1));
+    });
+
+    test('les photos embarquées sont réécrites sur le disque', () async {
+      final bytes = utf8.encode('fausse-image');
+      final json = {
+        'format': BackupService.formatId,
+        'version': 1,
+        'sessions': [
+          {
+            'id': 's1',
+            'weapon': 'Glock 17',
+            'max_shots_per_target': 5,
+            'created_at': '2026-03-14T10:30:00.000',
+            'distance': 25,
+            'analyses': [
+              {
+                'id': 'a1',
+                'session_id': 's1',
+                'target_type': 'concentric',
+                'image_path': '/ancien/chemin.jpg',
+                'total_score': 10,
+                'created_at': '2026-03-14T10:35:00.000',
+                'image_extension': '.jpg',
+                'image_base64': base64Encode(bytes),
+                'shots': [
+                  {'id': 't1', 'x': 0.5, 'y': 0.5, 'score': 10, 'analysis_id': 'a1'},
+                ],
+              },
+            ],
+          },
+        ],
+      };
+
+      final target = _FakeRepository();
+      final service = BackupService(repository: target);
+      final preview = await _roundTrip(json, service);
+      expect(preview.hasImages, isTrue);
+
+      final result = await service.applyBackup(preview);
+      expect(result.images, 1);
+      expect(target.savedImages.single, bytes);
+      expect(target.sessions.single.analyses.single.imagePath,
+          '/imported/image_1.jpg');
+    });
+
+    test('un nombre entier là où un décimal est attendu ne casse rien', () async {
+      // JSON ne distingue pas 1 de 1.0 : un fichier édité à la main peut
+      // livrer des entiers là où les modèles attendent des doubles.
+      final json = {
+        'format': BackupService.formatId,
+        'version': 1,
+        'sessions': [
+          {
+            'id': 's1',
+            'weapon': 'Glock 17',
+            'max_shots_per_target': 5,
+            'created_at': '2026-03-14T10:30:00.000',
+            'analyses': [
+              {
+                'id': 'a1',
+                'session_id': 's1',
+                'target_type': 'concentric',
+                'image_path': '/photo.jpg',
+                'total_score': 10,
+                'created_at': '2026-03-14T10:35:00.000',
+                'target_radius': 1,
+                'grouping_diameter': 0,
+                'shots': const [],
+              },
+            ],
+          },
+        ],
+      };
+
+      final target = _FakeRepository();
+      final service = BackupService(repository: target);
+      final result = await service.applyBackup(await _roundTrip(json, service));
+
+      expect(result.errors, isEmpty);
+      expect(target.sessions.single.analyses.single.targetRadius, 1.0);
+      expect(target.sessions.single.analyses.single.groupingDiameter, 0.0);
+    });
+
+    test('un fichier étranger est refusé avec un message clair', () async {
+      final service = BackupService(repository: _FakeRepository());
+      final dir = await Directory.systemTemp.createTemp('impact_backup_test');
+      addTearDown(() => dir.delete(recursive: true));
+
+      final notJson = File('${dir.path}/photo.jpg');
+      await notJson.writeAsString('pas du json du tout');
+      expect(
+        () => service.readBackup(notJson),
+        throwsA(isA<BackupFormatException>()),
+      );
+
+      final otherJson = File('${dir.path}/autre.json');
+      await otherJson.writeAsString('{"hello": "world"}');
+      expect(
+        () => service.readBackup(otherJson),
+        throwsA(isA<BackupFormatException>()),
+      );
+    });
+
+    test('une sauvegarde plus récente que l\'app est refusée', () async {
+      final service = BackupService(repository: _FakeRepository());
+      final dir = await Directory.systemTemp.createTemp('impact_backup_test');
+      addTearDown(() => dir.delete(recursive: true));
+
+      final file = File('${dir.path}/futur.json');
+      await file.writeAsString(jsonEncode({
+        'format': BackupService.formatId,
+        'version': BackupService.formatVersion + 1,
+      }));
+
+      expect(
+        () => service.readBackup(file),
+        throwsA(isA<BackupFormatException>()),
+      );
+    });
+
+    test('une session corrompue est ignorée sans bloquer les autres', () async {
+      final valid = await BackupService(
+        repository: _FakeRepository(sessions: [_session()]),
+      ).buildBackupJson();
+      // On injecte une session sans date : elle doit être la seule écartée.
+      (valid['sessions'] as List).add({
+        'id': 'corrompue',
+        'weapon': 'X',
+        'max_shots_per_target': 5,
+        'analyses': const [],
+      });
+
+      final target = _FakeRepository();
+      final service = BackupService(repository: target);
+      final result = await service.applyBackup(await _roundTrip(valid, service));
+
+      expect(result.sessions, 1);
+      expect(result.errors, hasLength(1));
+      expect(target.sessions.single.id, 's1');
+    });
+  });
+}

test/services/parallelism_service_test.dart

@@ -0,0 +1,136 @@
+import 'dart:math' as math;
+
+import 'package:flutter_test/flutter_test.dart';
+
+import 'package:bully/services/parallelism_service.dart';
+
+/// Vecteur de gravité mesuré par l'accéléromètre pour une pose donnée.
+///
+/// [pitch] et [roll] sont exprimés comme dans le service : le tangage vaut 0°
+/// appareil vertical et +90° appareil à plat caméra vers le sol.
+({double x, double y, double z}) gravity({
+  double pitch = 0,
+  double roll = 0,
+}) {
+  const double g = 9.81;
+  final double p = pitch * math.pi / 180.0;
+  final double r = roll * math.pi / 180.0;
+
+  final double nz = math.sin(p);
+  final double nx = math.sin(r);
+  // Ce qui reste va sur y, l'axe vertical de l'écran.
+  final double ny = math.sqrt(math.max(0.0, 1.0 - nz * nz - nx * nx));
+
+  return (x: nx * g, y: ny * g, z: nz * g);
+}
+
+ParallelismData evaluatePose(
+  ParallelismService service, {
+  double pitch = 0,
+  double roll = 0,
+}) {
+  final v = gravity(pitch: pitch, roll: roll);
+  final data = service.evaluate(v.x, v.y, v.z);
+  expect(data, isNotNull, reason: 'mesure jugée aberrante à tort');
+  return data!;
+}
+
+void main() {
+  group('pose cible au mur (comportement existant)', () {
+    test('appareil vertical → aligné', () {
+      final data = evaluatePose(ParallelismService());
+
+      expect(data.pose, TargetPose.wall);
+      expect(data.status, ParallelismStatus.aligned);
+      expect(data.pitchDeviation, closeTo(0, 0.5));
+    });
+
+    test('l\'écart de tangage reste le tangage brut', () {
+      final data = evaluatePose(ParallelismService(), pitch: 10);
+
+      expect(data.pose, TargetPose.wall);
+      expect(data.pitchDeviation, closeTo(data.pitchDegrees, 0.001));
+    });
+
+    test('inclinaison au-delà du seuil → désaligné', () {
+      final data = evaluatePose(ParallelismService(), pitch: 40);
+
+      expect(data.pose, TargetPose.wall);
+      expect(data.status, ParallelismStatus.misaligned);
+    });
+
+    test('roulis excessif → désaligné même si le tangage est bon', () {
+      final data = evaluatePose(ParallelismService(), roll: 35);
+
+      expect(data.status, ParallelismStatus.misaligned);
+    });
+  });
+
+  group('pose cible au sol', () {
+    test('appareil à plat caméra vers le bas → aligné', () {
+      final data = evaluatePose(ParallelismService(), pitch: 90);
+
+      expect(data.pose, TargetPose.ground);
+      expect(data.status, ParallelismStatus.aligned);
+      expect(data.pitchDeviation, closeTo(0, 0.5));
+    });
+
+    test('l\'écart se mesure par rapport à +90°, pas à 0°', () {
+      final data = evaluatePose(ParallelismService(), pitch: 80);
+
+      expect(data.pose, TargetPose.ground);
+      expect(data.pitchDeviation, closeTo(-10, 0.5));
+      expect(data.status, ParallelismStatus.aligned);
+    });
+
+    test('à plat mais trop incliné → désaligné', () {
+      final data = evaluatePose(ParallelismService(), pitch: 50);
+
+      expect(data.status, ParallelismStatus.misaligned);
+    });
+
+    test('à plat écran vers le haut → jamais aligné', () {
+      // La caméra vise le plafond : le vert n'aurait aucun sens.
+      final data = evaluatePose(ParallelismService(), pitch: -90);
+
+      expect(data.pose, TargetPose.wall);
+      expect(data.status, ParallelismStatus.misaligned);
+    });
+  });
+
+  group('hystérésis', () {
+    test('le vert survit à un léger tremblement entre les deux seuils', () {
+      final service = ParallelismService();
+
+      expect(evaluatePose(service).status, ParallelismStatus.aligned);
+      // 28° est au-dessus du seuil d'entrée (25°) mais sous celui de sortie (32°).
+      expect(evaluatePose(service, pitch: 28).status, ParallelismStatus.aligned);
+      expect(evaluatePose(service, pitch: 40).status, ParallelismStatus.misaligned);
+      // Repasser sous 32° ne suffit pas : il faut redescendre sous 25°.
+      expect(evaluatePose(service, pitch: 28).status, ParallelismStatus.misaligned);
+      expect(evaluatePose(service, pitch: 20).status, ParallelismStatus.aligned);
+    });
+
+    test('la pose ne bascule pas pour un écart négligeable', () {
+      final service = ParallelismService();
+
+      expect(evaluatePose(service).pose, TargetPose.wall);
+      // Pile à la frontière des deux poses : on garde celle déjà retenue.
+      expect(evaluatePose(service, pitch: 45).pose, TargetPose.wall);
+      // Franchement du côté du sol : on bascule.
+      expect(evaluatePose(service, pitch: 70).pose, TargetPose.ground);
+    });
+
+    test('stop() remet la pose et le statut à zéro', () {
+      final service = ParallelismService();
+
+      expect(evaluatePose(service, pitch: 90).pose, TargetPose.ground);
+      service.stop();
+      expect(evaluatePose(service).pose, TargetPose.wall);
+    });
+  });
+
+  test('une mesure aberrante est ignorée', () {
+    expect(ParallelismService().evaluate(0, 0, 0), isNull);
+  });
+}

windows/flutter/generated_plugin_registrant.cc

@@ -8,10 +8,16 @@
 
 #include <file_selector_windows/file_selector_windows.h>
 #include <permission_handler_windows/permission_handler_windows_plugin.h>
+#include <share_plus/share_plus_windows_plugin_c_api.h>
+#include <url_launcher_windows/url_launcher_windows.h>
 
 void RegisterPlugins(flutter::PluginRegistry* registry) {
   FileSelectorWindowsRegisterWithRegistrar(
       registry->GetRegistrarForPlugin("FileSelectorWindows"));
   PermissionHandlerWindowsPluginRegisterWithRegistrar(
       registry->GetRegistrarForPlugin("PermissionHandlerWindowsPlugin"));
+  SharePlusWindowsPluginCApiRegisterWithRegistrar(
+      registry->GetRegistrarForPlugin("SharePlusWindowsPluginCApi"));
+  UrlLauncherWindowsRegisterWithRegistrar(
+      registry->GetRegistrarForPlugin("UrlLauncherWindows"));
 }

windows/flutter/generated_plugins.cmake

@@ -5,6 +5,8 @@
 list(APPEND FLUTTER_PLUGIN_LIST
   file_selector_windows
   permission_handler_windows
+  share_plus
+  url_launcher_windows
 )
 
 list(APPEND FLUTTER_FFI_PLUGIN_LIST