feat: export/import JSON des sessions, stats et armurerie via partage systeme

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/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/garage/weapon_list_screen.dart

@@ -7,7 +7,12 @@ import '../../data/repositories/session_repository.dart';
 import 'weapon_detail_screen.dart';
 
 class WeaponListScreen extends StatefulWidget {
-  const WeaponListScreen({super.key});
+  /// Incrémenté par la navigation à chaque ouverture de l'onglet Armurerie
+  /// (l'écran est gardé vivant par l'IndexedStack et ne se rafraîchit pas
+  /// seul : sans ça, un import de sauvegarde resterait invisible).
+  final int refreshTick;
+
+  const WeaponListScreen({super.key, this.refreshTick = 0});
 
   @override
   State<WeaponListScreen> createState() => _WeaponListScreenState();
@@ -23,6 +28,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();

lib/features/home/home_screen.dart

@@ -15,7 +15,12 @@ import '../session/session_provider.dart';
 import 'widgets/stats_card.dart';
 
 class HomeScreen extends StatefulWidget {
-  const HomeScreen({super.key});
+  /// Incrémenté par la navigation à chaque ouverture de l'onglet Accueil
+  /// (l'écran est gardé vivant par l'IndexedStack : sans ça, un import de
+  /// sauvegarde resterait invisible sur le dashboard).
+  final int refreshTick;
+
+  const HomeScreen({super.key, this.refreshTick = 0});
 
   @override
   State<HomeScreen> createState() => _HomeScreenState();
@@ -35,6 +40,14 @@ class _HomeScreenState extends State<HomeScreen> {
     _loadStats();
   }
 
+  @override
+  void didUpdateWidget(HomeScreen oldWidget) {
+    super.didUpdateWidget(oldWidget);
+    if (oldWidget.refreshTick != widget.refreshTick) {
+      _loadStats();
+    }
+  }
+
   @override
   void didChangeDependencies() {
     super.didChangeDependencies();

lib/features/statistics/statistics_screen.dart

@@ -1,11 +1,16 @@
+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/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 +48,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();
@@ -374,6 +383,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),
                         ],
                       ),
@@ -882,6 +896,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

@@ -37,23 +37,27 @@ class _MainNavigationHolderState extends State<MainNavigationHolder> {
   // rafraîchissent pas seuls).
   int _statsTick = 0;
   int _historyTick = 0;
+  int _homeTick = 0;
+  int _garageTick = 0;
 
   void selectTab(int index) {
     if (!mounted) return;
     setState(() {
       _selectedIndex = index;
+      if (index == mainTabHome) _homeTick++;
       if (index == mainTabHistory) _historyTick++;
       if (index == mainTabStats) _statsTick++;
+      if (index == mainTabGarage) _garageTick++;
     });
   }
 
   @override
   Widget build(BuildContext context) {
     final screens = [
-      const HomeScreen(),
+      HomeScreen(refreshTick: _homeTick),
       HistoryScreen(refreshTick: _historyTick),
       StatisticsScreen(refreshTick: _statsTick),
-      const WeaponListScreen(),
+      WeaponListScreen(refreshTick: _garageTick),
     ];
     return Scaffold(
       body: IndexedStack(