import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:url_launcher/url_launcher.dart';
import 'package:geosector_app/core/services/api_service.dart';
import 'package:geosector_app/core/data/models/amicale_model.dart';
import 'package:geosector_app/core/data/models/payment_link_result.dart';

/// Service pour gérer Stripe Connect dans l'application
class StripeConnectService {
  final ApiService apiService;
  
  StripeConnectService({required this.apiService});
  
  /// Créer un compte Stripe Connect pour une amicale
  /// ✅ VERSION OPTIMISÉE : 1 seule requête qui crée tout
  /// - Compte Stripe Connect
  /// - Location Terminal
  /// - Lien d'onboarding
  Future<String?> createStripeAccount(AmicaleModel amicale) async {
    try {
      debugPrint('🏢 Création compte Stripe pour ${amicale.name}...');
      debugPrint('   Amicale ID: ${amicale.id}');

      // URLs de retour après onboarding
      final baseUrl = apiService.getFrontendUrl();
      final returnUrl = Uri.encodeFull('$baseUrl/stripe/success');
      final refreshUrl = Uri.encodeFull('$baseUrl/stripe/refresh');

      debugPrint('   Return URL: $returnUrl');
      debugPrint('   Refresh URL: $refreshUrl');

      // ✅ UNE SEULE REQUÊTE qui crée :
      // 1. Le compte Stripe Connect
      // 2. La Location Terminal
      // 3. Le lien d'onboarding
      final response = await apiService.post(
        '/stripe/accounts',
        data: {
          'fk_entite': amicale.id,
          'return_url': returnUrl,
          'refresh_url': refreshUrl,
        },
      );

      debugPrint('   Response status: ${response.statusCode}');
      debugPrint('   Response data: ${response.data}');

      if (response.statusCode != 200 && response.statusCode != 201) {
        final error = response.data?['message'] ?? 'Erreur création compte';
        debugPrint('❌ Erreur création compte: $error');
        throw Exception(error);
      }

      // Récupérer toutes les données de la réponse
      final data = response.data;
      final accountId = data['account_id'];
      final locationId = data['location_id'];
      final onboardingUrl = data['onboarding_url'];
      final isExisting = data['existing'] ?? false;
      final chargesEnabled = data['charges_enabled'] ?? false;
      final payoutsEnabled = data['payouts_enabled'] ?? false;

      if (accountId == null) {
        throw Exception('account_id non retourné par l\'API');
      }

      debugPrint('✅ Compte Stripe créé: $accountId');
      debugPrint('✅ Location Terminal créée: $locationId');

      if (isExisting) {
        debugPrint('   Compte existant détecté');

        // Si le compte est déjà complètement configuré
        if (chargesEnabled && payoutsEnabled) {
          debugPrint('✅ Compte déjà configuré et actif');
          return null; // Pas besoin de lien d'onboarding
        }
        debugPrint('   Compte existant mais configuration incomplète');
      }

      if (onboardingUrl == null || onboardingUrl.isEmpty) {
        throw Exception('onboarding_url non retourné par l\'API');
      }

      debugPrint('✅ Lien onboarding généré');
      return onboardingUrl;

    } catch (e) {
      debugPrint('❌ Erreur StripeConnect: $e');
      return null;
    }
  }
  
  /// Obtenir le lien d'onboarding pour finaliser la configuration
  /// ⚠️ DÉPRÉCIÉ : L'onboarding URL est maintenant retournée par createStripeAccount
  /// Conservé pour compatibilité temporaire
  Future<String?> getOnboardingLink(String accountId) async {
    try {
      debugPrint('📋 Génération du lien d\'onboarding pour account: $accountId');
      
      // URLs de retour après onboarding - utilise l'environnement détecté
      final baseUrl = apiService.getFrontendUrl();
      final returnUrl = Uri.encodeFull('$baseUrl/stripe/success');
      final refreshUrl = Uri.encodeFull('$baseUrl/stripe/refresh');
      
      debugPrint('   Return URL: $returnUrl');
      debugPrint('   Refresh URL: $refreshUrl');
      
      final response = await apiService.post(
        '/stripe/accounts/$accountId/onboarding-link',
        data: {
          'return_url': returnUrl,
          'refresh_url': refreshUrl,
        },
      );
      
      debugPrint('   Response status: ${response.statusCode}');
      debugPrint('   Response data: ${response.data}');
      
      if (response.statusCode == 200) {
        final url = response.data['url'];
        debugPrint('✅ Lien onboarding généré: $url');
        return url;
      }
      
      final errorMessage = response.data?['message'] ?? 'Erreur inconnue';
      throw Exception('Impossible de générer le lien: $errorMessage');
    } catch (e) {
      debugPrint('❌ Erreur onboarding link: $e');
      return null;
    }
  }
  
  /// Vérifier le statut du compte Stripe d'une amicale
  Future<StripeAccountStatus> checkAccountStatus(int amicaleId) async {
    try {
      final response = await apiService.get('/stripe/accounts/$amicaleId/status');
      
      if (response.statusCode == 200) {
        final data = response.data;
        return StripeAccountStatus(
          hasAccount: data['has_account'] ?? false,
          accountId: data['account_id'],
          locationId: data['location_id'],
          chargesEnabled: data['charges_enabled'] ?? false,
          payoutsEnabled: data['payouts_enabled'] ?? false,
          onboardingCompleted: data['onboarding_completed'] ?? false,
        );
      }
      
      return StripeAccountStatus(hasAccount: false);
    } catch (e) {
      debugPrint('❌ Erreur vérification statut: $e');
      return StripeAccountStatus(hasAccount: false);
    }
  }
  
  /// Ouvrir le Dashboard Stripe pour l'amicale
  Future<void> openStripeDashboard(String? accountId) async {
    if (accountId == null || accountId.isEmpty) return;
    
    // URL du dashboard Stripe Express
    final url = Uri.parse('https://dashboard.stripe.com/express/$accountId');
    
    if (await canLaunchUrl(url)) {
      await launchUrl(url, mode: LaunchMode.externalApplication);
    }
  }
  
  /// Créer un Payment Link pour paiement par QRcode
  Future<PaymentLinkResult?> createPaymentLink({
    required int amountInCents,
    required int passageId,
    String? description,
    Map<String, dynamic>? metadata,
  }) async {
    try {
      debugPrint('💰 Création Payment Link pour ${amountInCents / 100}€...');
      debugPrint('   Passage ID: $passageId');

      final response = await apiService.post(
        '/stripe/payment-links',
        data: {
          'amount': amountInCents,
          'currency': 'eur',
          'description': description ?? 'Calendrier pompiers',
          'passage_id': passageId,
          'metadata': metadata ?? {},
        },
      );

      debugPrint('   Response status: ${response.statusCode}');
      debugPrint('   Response data: ${response.data}');

      if (response.statusCode != 200 && response.statusCode != 201) {
        final error = response.data?['message'] ?? 'Erreur création Payment Link';
        debugPrint('❌ Erreur création Payment Link: $error');
        throw Exception(error);
      }

      final result = PaymentLinkResult.fromJson(response.data);
      debugPrint('✅ Payment Link créé: ${result.paymentLinkId}');
      debugPrint('   URL: ${result.url}');

      return result;

    } catch (e) {
      debugPrint('❌ Erreur PaymentLink: $e');
      return null;
    }
  }

  /// Lancer le processus d'onboarding dans un navigateur externe
  Future<bool> launchOnboarding(String url) async {
    try {
      debugPrint('🚀 Lancement onboarding URL: $url');
      debugPrint('   Plateforme: ${kIsWeb ? "Web" : "Mobile"}');
      
      final uri = Uri.parse(url);
      
      // Sur web, on peut directement lancer sans vérification
      if (kIsWeb) {
        final launched = await launchUrl(
          uri,
          webOnlyWindowName: '_blank', // Ouvre dans un nouvel onglet
        );
        debugPrint(launched ? '✅ URL lancée avec succès' : '❌ Échec du lancement');
        return launched;
      } else {
        // Sur mobile, vérifier d'abord si on peut lancer l'URL
        if (await canLaunchUrl(uri)) {
          await launchUrl(
            uri,
            mode: LaunchMode.externalApplication,
          );
          debugPrint('✅ URL lancée avec succès');
          return true;
        } else {
          debugPrint('❌ Impossible de lancer l\'URL sur mobile');
        }
      }
    } catch (e) {
      debugPrint('❌ Erreur lancement onboarding: $e');
      debugPrint('   Détails: $e');
    }
    return false;
  }
}

/// Statut d'un compte Stripe Connect
class StripeAccountStatus {
  final bool hasAccount;
  final String? accountId;
  final String? locationId;
  final bool chargesEnabled;
  final bool payoutsEnabled;
  final bool onboardingCompleted;

  StripeAccountStatus({
    required this.hasAccount,
    this.accountId,
    this.locationId,
    this.chargesEnabled = false,
    this.payoutsEnabled = false,
    this.onboardingCompleted = false,
  });
  
  bool get canAcceptPayments => chargesEnabled && payoutsEnabled;
  
  String get statusMessage {
    if (!hasAccount) return 'Pas de compte Stripe';
    if (!onboardingCompleted) return 'Configuration en cours';
    if (!chargesEnabled) return 'Paiements non activés';
    if (!payoutsEnabled) return 'Virements non activés';
    return 'Compte actif';
  }
  
  Color get statusColor {
    if (canAcceptPayments) return Colors.green;
    if (hasAccount) return Colors.orange;
    return Colors.red;
  }
}