import 'package:dio/dio.dart';
import 'package:injectable/injectable.dart';
import '../models/membre_model.dart';
import '../models/cotisation_model.dart';
import '../models/evenement_model.dart';
import '../models/wave_checkout_session_model.dart';
import '../models/payment_model.dart';
import '../network/dio_client.dart';

/// Service API principal pour communiquer avec le serveur UnionFlow
@singleton
class ApiService {
  final DioClient _dioClient;

  ApiService(this._dioClient);

  Dio get _dio => _dioClient.dio;

  // ========================================
  // MEMBRES
  // ========================================

  /// Récupère la liste de tous les membres actifs
  Future<List<MembreModel>> getMembres() async {
    try {
      final response = await _dio.get('/api/membres');
      
      if (response.data is List) {
        return (response.data as List)
            .map((json) => MembreModel.fromJson(json as Map<String, dynamic>))
            .toList();
      }
      
      throw Exception('Format de réponse invalide pour la liste des membres');
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors de la récupération des membres');
    }
  }

  /// Récupère un membre par son ID
  Future<MembreModel> getMembreById(String id) async {
    try {
      final response = await _dio.get('/api/membres/$id');
      return MembreModel.fromJson(response.data as Map<String, dynamic>);
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors de la récupération du membre');
    }
  }

  /// Crée un nouveau membre
  Future<MembreModel> createMembre(MembreModel membre) async {
    try {
      final response = await _dio.post(
        '/api/membres',
        data: membre.toJson(),
      );
      return MembreModel.fromJson(response.data as Map<String, dynamic>);
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors de la création du membre');
    }
  }

  /// Met à jour un membre existant
  Future<MembreModel> updateMembre(String id, MembreModel membre) async {
    try {
      final response = await _dio.put(
        '/api/membres/$id',
        data: membre.toJson(),
      );
      return MembreModel.fromJson(response.data as Map<String, dynamic>);
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors de la mise à jour du membre');
    }
  }

  /// Désactive un membre
  Future<void> deleteMembre(String id) async {
    try {
      await _dio.delete('/api/membres/$id');
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors de la suppression du membre');
    }
  }

  /// Recherche des membres par nom ou prénom
  Future<List<MembreModel>> searchMembres(String query) async {
    try {
      final response = await _dio.get(
        '/api/membres/recherche',
        queryParameters: {'q': query},
      );

      if (response.data is List) {
        return (response.data as List)
            .map((json) => MembreModel.fromJson(json as Map<String, dynamic>))
            .toList();
      }

      throw Exception('Format de réponse invalide pour la recherche');
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors de la recherche de membres');
    }
  }

  /// Recherche avancée des membres avec filtres multiples
  Future<List<MembreModel>> advancedSearchMembres(Map<String, dynamic> filters) async {
    try {
      // Nettoyer les filtres vides
      final cleanFilters = <String, dynamic>{};
      filters.forEach((key, value) {
        if (value != null && value.toString().isNotEmpty) {
          cleanFilters[key] = value;
        }
      });

      final response = await _dio.get(
        '/api/membres/recherche-avancee',
        queryParameters: cleanFilters,
      );

      if (response.data is List) {
        return (response.data as List)
            .map((json) => MembreModel.fromJson(json as Map<String, dynamic>))
            .toList();
      }

      throw Exception('Format de réponse invalide pour la recherche avancée');
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors de la recherche avancée de membres');
    }
  }

  /// Récupère les statistiques des membres
  Future<Map<String, dynamic>> getMembresStats() async {
    try {
      final response = await _dio.get('/api/membres/stats');
      return response.data as Map<String, dynamic>;
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors de la récupération des statistiques');
    }
  }

  // ========================================
  // PAIEMENTS WAVE
  // ========================================

  /// Crée une session de paiement Wave
  Future<WaveCheckoutSessionModel> createWaveSession({
    required double montant,
    required String devise,
    required String successUrl,
    required String errorUrl,
    String? organisationId,
    String? membreId,
    String? typePaiement,
    String? description,
  }) async {
    try {
      final response = await _dio.post(
        '/api/paiements/wave/sessions',
        data: {
          'montant': montant,
          'devise': devise,
          'successUrl': successUrl,
          'errorUrl': errorUrl,
          if (organisationId != null) 'organisationId': organisationId,
          if (membreId != null) 'membreId': membreId,
          if (typePaiement != null) 'typePaiement': typePaiement,
          if (description != null) 'description': description,
        },
      );
      return WaveCheckoutSessionModel.fromJson(response.data as Map<String, dynamic>);
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors de la création de la session Wave');
    }
  }

  /// Récupère une session de paiement Wave par son ID
  Future<WaveCheckoutSessionModel> getWaveSession(String sessionId) async {
    try {
      final response = await _dio.get('/api/paiements/wave/sessions/$sessionId');
      return WaveCheckoutSessionModel.fromJson(response.data as Map<String, dynamic>);
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors de la récupération de la session Wave');
    }
  }

  /// Vérifie le statut d'une session de paiement Wave
  Future<String> checkWaveSessionStatus(String sessionId) async {
    try {
      final response = await _dio.get('/api/paiements/wave/sessions/$sessionId/status');
      return response.data['statut'] as String;
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors de la vérification du statut Wave');
    }
  }

  // ========================================
  // COTISATIONS
  // ========================================

  /// Récupère la liste de toutes les cotisations avec pagination
  Future<List<CotisationModel>> getCotisations({int page = 0, int size = 20}) async {
    try {
      final response = await _dio.get('/api/cotisations', queryParameters: {
        'page': page,
        'size': size,
      });

      if (response.data is List) {
        return (response.data as List)
            .map((json) => CotisationModel.fromJson(json as Map<String, dynamic>))
            .toList();
      }

      throw Exception('Format de réponse invalide pour la liste des cotisations');
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors de la récupération des cotisations');
    }
  }

  /// Récupère une cotisation par son ID
  Future<CotisationModel> getCotisationById(String id) async {
    try {
      final response = await _dio.get('/api/cotisations/$id');
      return CotisationModel.fromJson(response.data as Map<String, dynamic>);
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors de la récupération de la cotisation');
    }
  }

  /// Récupère une cotisation par son numéro de référence
  Future<CotisationModel> getCotisationByReference(String numeroReference) async {
    try {
      final response = await _dio.get('/api/cotisations/reference/$numeroReference');
      return CotisationModel.fromJson(response.data as Map<String, dynamic>);
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors de la récupération de la cotisation');
    }
  }

  /// Crée une nouvelle cotisation
  Future<CotisationModel> createCotisation(CotisationModel cotisation) async {
    try {
      final response = await _dio.post(
        '/api/cotisations',
        data: cotisation.toJson(),
      );
      return CotisationModel.fromJson(response.data as Map<String, dynamic>);
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors de la création de la cotisation');
    }
  }

  /// Met à jour une cotisation existante
  Future<CotisationModel> updateCotisation(String id, CotisationModel cotisation) async {
    try {
      final response = await _dio.put(
        '/api/cotisations/$id',
        data: cotisation.toJson(),
      );
      return CotisationModel.fromJson(response.data as Map<String, dynamic>);
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors de la mise à jour de la cotisation');
    }
  }

  /// Supprime une cotisation
  Future<void> deleteCotisation(String id) async {
    try {
      await _dio.delete('/api/cotisations/$id');
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors de la suppression de la cotisation');
    }
  }

  /// Récupère les cotisations d'un membre
  Future<List<CotisationModel>> getCotisationsByMembre(String membreId, {int page = 0, int size = 20}) async {
    try {
      final response = await _dio.get('/api/cotisations/membre/$membreId', queryParameters: {
        'page': page,
        'size': size,
      });

      if (response.data is List) {
        return (response.data as List)
            .map((json) => CotisationModel.fromJson(json as Map<String, dynamic>))
            .toList();
      }

      throw Exception('Format de réponse invalide pour les cotisations du membre');
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors de la récupération des cotisations du membre');
    }
  }

  /// Récupère les cotisations par statut
  Future<List<CotisationModel>> getCotisationsByStatut(String statut, {int page = 0, int size = 20}) async {
    try {
      final response = await _dio.get('/api/cotisations/statut/$statut', queryParameters: {
        'page': page,
        'size': size,
      });

      if (response.data is List) {
        return (response.data as List)
            .map((json) => CotisationModel.fromJson(json as Map<String, dynamic>))
            .toList();
      }

      throw Exception('Format de réponse invalide pour les cotisations par statut');
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors de la récupération des cotisations par statut');
    }
  }

  /// Récupère les cotisations en retard
  Future<List<CotisationModel>> getCotisationsEnRetard({int page = 0, int size = 20}) async {
    try {
      final response = await _dio.get('/api/cotisations/en-retard', queryParameters: {
        'page': page,
        'size': size,
      });

      if (response.data is List) {
        return (response.data as List)
            .map((json) => CotisationModel.fromJson(json as Map<String, dynamic>))
            .toList();
      }

      throw Exception('Format de réponse invalide pour les cotisations en retard');
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors de la récupération des cotisations en retard');
    }
  }

  /// Recherche avancée de cotisations
  Future<List<CotisationModel>> rechercherCotisations({
    String? membreId,
    String? statut,
    String? typeCotisation,
    int? annee,
    int? mois,
    int page = 0,
    int size = 20,
  }) async {
    try {
      final queryParams = <String, dynamic>{
        'page': page,
        'size': size,
      };

      if (membreId != null) queryParams['membreId'] = membreId;
      if (statut != null) queryParams['statut'] = statut;
      if (typeCotisation != null) queryParams['typeCotisation'] = typeCotisation;
      if (annee != null) queryParams['annee'] = annee;
      if (mois != null) queryParams['mois'] = mois;

      final response = await _dio.get('/api/cotisations/recherche', queryParameters: queryParams);

      if (response.data is List) {
        return (response.data as List)
            .map((json) => CotisationModel.fromJson(json as Map<String, dynamic>))
            .toList();
      }

      throw Exception('Format de réponse invalide pour la recherche de cotisations');
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors de la recherche de cotisations');
    }
  }

  /// Récupère les statistiques des cotisations
  Future<Map<String, dynamic>> getCotisationsStats() async {
    try {
      final response = await _dio.get('/api/cotisations/stats');
      return response.data as Map<String, dynamic>;
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors de la récupération des statistiques des cotisations');
    }
  }

  // ========================================
  // GESTION DES ERREURS
  // ========================================

  /// Gère les exceptions Dio et les convertit en messages d'erreur appropriés
  Exception _handleDioException(DioException e, String defaultMessage) {
    switch (e.type) {
      case DioExceptionType.connectionTimeout:
      case DioExceptionType.sendTimeout:
      case DioExceptionType.receiveTimeout:
        return Exception('Délai d\'attente dépassé. Vérifiez votre connexion internet.');
      
      case DioExceptionType.badResponse:
        final statusCode = e.response?.statusCode;
        final responseData = e.response?.data;
        
        if (statusCode == 400) {
          if (responseData is Map && responseData.containsKey('message')) {
            return Exception(responseData['message']);
          }
          return Exception('Données invalides');
        } else if (statusCode == 401) {
          return Exception('Non autorisé. Veuillez vous reconnecter.');
        } else if (statusCode == 403) {
          return Exception('Accès interdit');
        } else if (statusCode == 404) {
          return Exception('Ressource non trouvée');
        } else if (statusCode == 500) {
          return Exception('Erreur serveur. Veuillez réessayer plus tard.');
        }
        
        return Exception('$defaultMessage (Code: $statusCode)');
      
      case DioExceptionType.cancel:
        return Exception('Requête annulée');
      
      case DioExceptionType.connectionError:
        return Exception('Erreur de connexion. Vérifiez votre connexion internet.');
      
      case DioExceptionType.badCertificate:
        return Exception('Certificat SSL invalide');
      
      case DioExceptionType.unknown:
      default:
        return Exception(defaultMessage);
    }
  }

  // ========================================
  // ÉVÉNEMENTS
  // ========================================

  /// Récupère la liste des événements à venir (optimisé mobile)
  Future<List<EvenementModel>> getEvenementsAVenir({
    int page = 0,
    int size = 10,
  }) async {
    try {
      final response = await _dio.get(
        '/api/evenements/a-venir-public',
        queryParameters: {
          'page': page,
          'size': size,
        },
      );

      if (response.data is List) {
        return (response.data as List)
            .map((json) => EvenementModel.fromJson(json as Map<String, dynamic>))
            .toList();
      }

      throw Exception('Format de réponse invalide pour les événements à venir');
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors de la récupération des événements à venir');
    }
  }

  /// Récupère la liste des événements publics (sans authentification)
  Future<List<EvenementModel>> getEvenementsPublics({
    int page = 0,
    int size = 20,
  }) async {
    try {
      final response = await _dio.get(
        '/api/evenements/publics',
        queryParameters: {
          'page': page,
          'size': size,
        },
      );

      if (response.data is List) {
        return (response.data as List)
            .map((json) => EvenementModel.fromJson(json as Map<String, dynamic>))
            .toList();
      }

      throw Exception('Format de réponse invalide pour les événements publics');
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors de la récupération des événements publics');
    }
  }

  /// Récupère tous les événements avec pagination
  Future<List<EvenementModel>> getEvenements({
    int page = 0,
    int size = 20,
    String sortField = 'dateDebut',
    String sortDirection = 'asc',
  }) async {
    try {
      final response = await _dio.get(
        '/api/evenements',
        queryParameters: {
          'page': page,
          'size': size,
          'sort': sortField,
          'direction': sortDirection,
        },
      );

      if (response.data is List) {
        return (response.data as List)
            .map((json) => EvenementModel.fromJson(json as Map<String, dynamic>))
            .toList();
      }

      throw Exception('Format de réponse invalide pour la liste des événements');
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors de la récupération des événements');
    }
  }

  /// Récupère un événement par son ID
  Future<EvenementModel> getEvenementById(String id) async {
    try {
      final response = await _dio.get('/api/evenements/$id');
      return EvenementModel.fromJson(response.data as Map<String, dynamic>);
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors de la récupération de l\'événement');
    }
  }

  /// Recherche d'événements par terme
  Future<List<EvenementModel>> rechercherEvenements(
    String terme, {
    int page = 0,
    int size = 20,
  }) async {
    try {
      final response = await _dio.get(
        '/api/evenements/recherche',
        queryParameters: {
          'q': terme,
          'page': page,
          'size': size,
        },
      );

      if (response.data is List) {
        return (response.data as List)
            .map((json) => EvenementModel.fromJson(json as Map<String, dynamic>))
            .toList();
      }

      throw Exception('Format de réponse invalide pour la recherche d\'événements');
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors de la recherche d\'événements');
    }
  }

  /// Récupère les événements par type
  Future<List<EvenementModel>> getEvenementsByType(
    TypeEvenement type, {
    int page = 0,
    int size = 20,
  }) async {
    try {
      final response = await _dio.get(
        '/api/evenements/type/${type.name.toUpperCase()}',
        queryParameters: {
          'page': page,
          'size': size,
        },
      );

      if (response.data is List) {
        return (response.data as List)
            .map((json) => EvenementModel.fromJson(json as Map<String, dynamic>))
            .toList();
      }

      throw Exception('Format de réponse invalide pour les événements par type');
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors de la récupération des événements par type');
    }
  }

  /// Crée un nouvel événement
  Future<EvenementModel> createEvenement(EvenementModel evenement) async {
    try {
      final response = await _dio.post(
        '/api/evenements',
        data: evenement.toJson(),
      );
      return EvenementModel.fromJson(response.data as Map<String, dynamic>);
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors de la création de l\'événement');
    }
  }

  /// Met à jour un événement existant
  Future<EvenementModel> updateEvenement(String id, EvenementModel evenement) async {
    try {
      final response = await _dio.put(
        '/api/evenements/$id',
        data: evenement.toJson(),
      );
      return EvenementModel.fromJson(response.data as Map<String, dynamic>);
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors de la mise à jour de l\'événement');
    }
  }

  /// Supprime un événement
  Future<void> deleteEvenement(String id) async {
    try {
      await _dio.delete('/api/evenements/$id');
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors de la suppression de l\'événement');
    }
  }

  /// Change le statut d'un événement
  Future<EvenementModel> changerStatutEvenement(
    String id,
    StatutEvenement nouveauStatut,
  ) async {
    try {
      final response = await _dio.patch(
        '/api/evenements/$id/statut',
        queryParameters: {
          'statut': nouveauStatut.name.toUpperCase(),
        },
      );
      return EvenementModel.fromJson(response.data as Map<String, dynamic>);
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors du changement de statut');
    }
  }

  /// Récupère les statistiques des événements
  Future<Map<String, dynamic>> getStatistiquesEvenements() async {
    try {
      final response = await _dio.get('/api/evenements/statistiques');
      return response.data as Map<String, dynamic>;
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors de la récupération des statistiques');
    }
  }

  // ========================================
  // PAIEMENTS
  // ========================================

  /// Initie un paiement
  Future<PaymentModel> initiatePayment(Map<String, dynamic> paymentData) async {
    try {
      final response = await _dio.post('/api/paiements/initier', data: paymentData);
      return PaymentModel.fromJson(response.data as Map<String, dynamic>);
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors de l\'initiation du paiement');
    }
  }

  /// Récupère le statut d'un paiement
  Future<PaymentModel> getPaymentStatus(String paymentId) async {
    try {
      final response = await _dio.get('/api/paiements/$paymentId/statut');
      return PaymentModel.fromJson(response.data as Map<String, dynamic>);
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors de la vérification du statut');
    }
  }

  /// Annule un paiement
  Future<bool> cancelPayment(String paymentId) async {
    try {
      final response = await _dio.post('/api/paiements/$paymentId/annuler');
      return response.statusCode == 200;
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors de l\'annulation du paiement');
    }
  }

  /// Récupère l'historique des paiements
  Future<List<PaymentModel>> getPaymentHistory(Map<String, dynamic> filters) async {
    try {
      final response = await _dio.get('/api/paiements/historique', queryParameters: filters);

      if (response.data is List) {
        return (response.data as List)
            .map((json) => PaymentModel.fromJson(json as Map<String, dynamic>))
            .toList();
      }

      throw Exception('Format de réponse invalide pour l\'historique des paiements');
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors de la récupération de l\'historique');
    }
  }

  /// Vérifie le statut d'un service de paiement
  Future<Map<String, dynamic>> checkServiceStatus(String serviceType) async {
    try {
      final response = await _dio.get('/api/paiements/services/$serviceType/statut');
      return response.data as Map<String, dynamic>;
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors de la vérification du service');
    }
  }

  /// Récupère les statistiques de paiement
  Future<Map<String, dynamic>> getPaymentStatistics(Map<String, dynamic> filters) async {
    try {
      final response = await _dio.get('/api/paiements/statistiques', queryParameters: filters);
      return response.data as Map<String, dynamic>;
    } on DioException catch (e) {
      throw _handleDioException(e, 'Erreur lors de la récupération des statistiques');
    }
  }
}