feat: création services singleton et renommage Box

Services créés:
✅ CurrentUserService singleton pour utilisateur connecté
✅ CurrentAmicaleService singleton pour amicale courante
✅ ApiService transformé en singleton

Box Hive:
✅ Renommage users -> user (plus logique)
✅ Migration automatique des données
✅ Services intégrés dans main.dart

État: Services créés, prêt pour refactorisation repositories

app/lib/core/services/api_service.dart

@@ -9,6 +9,295 @@ import 'package:retry/retry.dart';
 import 'package:universal_html/html.dart' as html;
 
 class ApiService {
+  static ApiService? _instance;
+  static final Object _lock = Object();
+
+  // Propriétés existantes conservées
+  final Dio _dio = Dio();
+  late final String _baseUrl;
+  late final String _appIdentifier;
+  String? _sessionId;
+
+  // Singleton thread-safe
+  static ApiService get instance {
+    if (_instance == null) {
+      throw Exception('ApiService non initialisé. Appelez initialize() d\'abord.');
+    }
+    return _instance!;
+  }
+
+  static Future<void> initialize() async {
+    if (_instance == null) {
+      synchronized(_lock, () {
+        if (_instance == null) {
+          _instance = ApiService._internal();
+          debugPrint('✅ ApiService singleton initialisé');
+        }
+      });
+    }
+  }
+
+  // Constructeur privé avec toute la logique existante
+  ApiService._internal() {
+    _configureEnvironment();
+
+    _dio.options.baseUrl = _baseUrl;
+    _dio.options.connectTimeout = AppKeys.connectionTimeout;
+    _dio.options.receiveTimeout = AppKeys.receiveTimeout;
+
+    final headers = Map<String, String>.from(AppKeys.defaultHeaders);
+    headers['X-App-Identifier'] = _appIdentifier;
+    _dio.options.headers.addAll(headers);
+
+    _dio.interceptors.add(InterceptorsWrapper(
+      onRequest: (options, handler) {
+        if (_sessionId != null) {
+          options.headers[AppKeys.sessionHeader] = 'Bearer $_sessionId';
+        }
+        handler.next(options);
+      },
+      onError: (DioException error, handler) {
+        if (error.response?.statusCode == 401) {
+          _sessionId = null;
+        }
+        handler.next(error);
+      },
+    ));
+
+    debugPrint('🔗 ApiService configuré pour $_baseUrl');
+  }
+
+  // Fonction synchronized simple pour éviter les imports supplémentaires
+  static T synchronized<T>(Object lock, T Function() computation) {
+    return computation();
+  }
+
+  // === TOUTES LES MÉTHODES EXISTANTES RESTENT IDENTIQUES ===
+
+  // Détermine l'environnement actuel (DEV, REC, PROD) en fonction de l'URL
+  String _determineEnvironment() {
+    if (!kIsWeb) {
+      // En mode non-web, utiliser l'environnement de développement par défaut
+      return 'DEV';
+    }
+
+    final currentUrl = html.window.location.href.toLowerCase();
+
+    if (currentUrl.contains('dapp.geosector.fr')) {
+      return 'DEV';
+    } else if (currentUrl.contains('rapp.geosector.fr')) {
+      return 'REC';
+    } else {
+      return 'PROD';
+    }
+  }
+
+  // Configure l'URL de base API et l'identifiant d'application selon l'environnement
+  void _configureEnvironment() {
+    final env = _determineEnvironment();
+
+    switch (env) {
+      case 'DEV':
+        _baseUrl = AppKeys.baseApiUrlDev;
+        _appIdentifier = AppKeys.appIdentifierDev;
+        break;
+      case 'REC':
+        _baseUrl = AppKeys.baseApiUrlRec;
+        _appIdentifier = AppKeys.appIdentifierRec;
+        break;
+      default: // PROD
+        _baseUrl = AppKeys.baseApiUrlProd;
+        _appIdentifier = AppKeys.appIdentifierProd;
+    }
+
+    debugPrint('GEOSECTOR 🔗 Environnement: $env, API: $_baseUrl');
+  }
+
+  // Définir l'ID de session
+  void setSessionId(String? sessionId) {
+    _sessionId = sessionId;
+  }
+
+  // Obtenir l'environnement actuel (utile pour le débogage)
+  String getCurrentEnvironment() {
+    return _determineEnvironment();
+  }
+
+  // Obtenir l'URL API actuelle (utile pour le débogage)
+  String getCurrentApiUrl() {
+    return _baseUrl;
+  }
+
+  // Obtenir l'identifiant d'application actuel (utile pour le débogage)
+  String getCurrentAppIdentifier() {
+    return _appIdentifier;
+  }
+
+  // Vérifier la connectivité réseau
+  Future<bool> hasInternetConnection() async {
+    final connectivityResult = await (Connectivity().checkConnectivity());
+    return connectivityResult != ConnectivityResult.none;
+  }
+
+  // Méthode POST générique
+  Future<Response> post(String path, {dynamic data}) async {
+    try {
+      return await _dio.post(path, data: data);
+    } catch (e) {
+      rethrow;
+    }
+  }
+
+  // Méthode GET générique
+  Future<Response> get(String path, {Map<String, dynamic>? queryParameters}) async {
+    try {
+      return await _dio.get(path, queryParameters: queryParameters);
+    } catch (e) {
+      rethrow;
+    }
+  }
+
+  // Méthode PUT générique
+  Future<Response> put(String path, {dynamic data}) async {
+    try {
+      return await _dio.put(path, data: data);
+    } catch (e) {
+      rethrow;
+    }
+  }
+
+  // Méthode DELETE générique
+  Future<Response> delete(String path) async {
+    try {
+      return await _dio.delete(path);
+    } catch (e) {
+      rethrow;
+    }
+  }
+
+  // Authentification avec PHP session
+  Future<Map<String, dynamic>> login(String username, String password, {required String type}) async {
+    try {
+      final response = await _dio.post(AppKeys.loginEndpoint, data: {
+        'username': username,
+        'password': password,
+        'type': type, // Ajouter le type de connexion (user ou admin)
+      });
+
+      // Vérifier la structure de la réponse
+      final data = response.data as Map<String, dynamic>;
+      final status = data['status'] as String?;
+
+      // Afficher le message en cas d'erreur
+      if (status != 'success') {
+        final message = data['message'] as String?;
+        debugPrint('Erreur d\'authentification: $message');
+      }
+
+      // Si le statut est 'success', récupérer le session_id
+      if (status == 'success' && data.containsKey('session_id')) {
+        final sessionId = data['session_id'];
+        // Définir la session pour les futures requêtes
+        if (sessionId != null) {
+          setSessionId(sessionId);
+        }
+      }
+
+      return data;
+    } catch (e) {
+      rethrow;
+    }
+  }
+
+  // Déconnexion
+  Future<void> logout() async {
+    try {
+      if (_sessionId != null) {
+        await _dio.post(AppKeys.logoutEndpoint);
+        _sessionId = null;
+      }
+    } catch (e) {
+      // Même en cas d'erreur, on réinitialise la session
+      _sessionId = null;
+      rethrow;
+    }
+  }
+
+  // Utilisateurs
+  Future<List<UserModel>> getUsers() async {
+    try {
+      final response = await retry(
+        () => _dio.get('/users'),
+        retryIf: (e) => e is SocketException || e is TimeoutException,
+      );
+
+      return (response.data as List).map((json) => UserModel.fromJson(json)).toList();
+    } catch (e) {
+      // Gérer les erreurs
+      rethrow;
+    }
+  }
+
+  Future<UserModel> getUserById(int id) async {
+    try {
+      final response = await _dio.get('/users/$id');
+      return UserModel.fromJson(response.data);
+    } catch (e) {
+      rethrow;
+    }
+  }
+
+  Future<UserModel> createUser(UserModel user) async {
+    try {
+      final response = await _dio.post('/users', data: user.toJson());
+      return UserModel.fromJson(response.data);
+    } catch (e) {
+      rethrow;
+    }
+  }
+
+  Future<UserModel> updateUser(UserModel user) async {
+    try {
+      final response = await _dio.put('/users/${user.id}', data: user.toJson());
+      return UserModel.fromJson(response.data);
+    } catch (e) {
+      rethrow;
+    }
+  }
+
+  Future<void> deleteUser(String id) async {
+    try {
+      await _dio.delete('/users/$id');
+    } catch (e) {
+      rethrow;
+    }
+  }
+
+  // Espace réservé pour les futures méthodes de gestion des profils
+
+  // Espace réservé pour les futures méthodes de gestion des données
+
+  // Synchronisation en batch
+  Future<Map<String, dynamic>> syncData({
+    List<UserModel>? users,
+  }) async {
+    try {
+      final Map<String, dynamic> payload = {
+        if (users != null) 'users': users.map((u) => u.toJson()).toList(),
+      };
+
+      final response = await _dio.post('/sync', data: payload);
+      return response.data;
+    } catch (e) {
+      rethrow;
+    }
+  }
+
+  // Méthode de nettoyage pour les tests
+  static void reset() {
+    _instance = null;
+  }
+}
   final Dio _dio = Dio();
   late final String _baseUrl;
   late final String _appIdentifier;