import 'package:em2rp/utils/debug_log.dart';
import 'package:flutter/material.dart';
import 'package:intl/intl.dart';
import 'package:em2rp/utils/colors.dart';
import 'package:em2rp/utils/price_helpers.dart';
import 'package:em2rp/services/data_service.dart';
import 'package:em2rp/services/api_service.dart';

class EventOptionsDisplayWidget extends StatelessWidget {
  final List<Map<String, dynamic>> optionsData;
  final bool canViewPrices;
  final bool showPriceCalculation;

  const EventOptionsDisplayWidget({
    super.key,
    required this.optionsData,
    this.canViewPrices = true,
    this.showPriceCalculation = true,
  });

  @override
  Widget build(BuildContext context) {
    if (optionsData.isEmpty) {
      return const SizedBox.shrink();
    }

    final currencyFormat = NumberFormat.currency(locale: 'fr_FR', symbol: '€');

    return Column(
      crossAxisAlignment: CrossAxisAlignment.start,
      children: [
        const SizedBox(height: 8),
        Text(
          'Options sélectionnées',
          style: Theme.of(context).textTheme.titleLarge?.copyWith(
            color: AppColors.noir,
            fontWeight: FontWeight.bold,
          ),
        ),
        const SizedBox(height: 4),
        FutureBuilder<List<Map<String, dynamic>>>(
          future: _loadOptionsWithDetails(optionsData),
          builder: (context, snapshot) {
            if (snapshot.connectionState == ConnectionState.waiting) {
              return const Padding(
                padding: EdgeInsets.all(16.0),
                child: Center(child: CircularProgressIndicator()),
              );
            }

            if (snapshot.hasError) {
              return Padding(
                padding: const EdgeInsets.all(16.0),
                child: Text(
                  'Erreur lors du chargement des options: ${snapshot.error}',
                  style: const TextStyle(color: Colors.red),
                ),
              );
            }

            final enrichedOptions = snapshot.data ?? [];

            return Column(
              crossAxisAlignment: CrossAxisAlignment.start,
              children: [
                ...enrichedOptions.map((opt) {
                  final priceTTC = (opt['price'] ?? 0.0) as num;
                  final quantity = (opt['quantity'] ?? 1) as int;
                  final totalPriceTTC = priceTTC * quantity;
                  final isNegative = totalPriceTTC < 0;

                  // Calculer le prix HT
                  final priceHT = PriceHelpers.calculateHT(priceTTC.toDouble());
                  final totalPriceHT = priceHT * quantity;

                  return ListTile(
                    leading: Icon(Icons.tune, color: AppColors.rouge),
                    title: Text(
                      opt['code'] != null && opt['code'].toString().isNotEmpty
                          ? '${opt['code']} - ${opt['name'] ?? ''}'
                          : opt['name'] ?? '',
                      style: const TextStyle(fontWeight: FontWeight.bold),
                    ),
                    subtitle: Column(
                      crossAxisAlignment: CrossAxisAlignment.start,
                      children: [
                        if (opt['details'] != null && opt['details'].toString().trim().isNotEmpty)
                          Text(
                            opt['details'].toString().trim(),
                            style: const TextStyle(
                              fontWeight: FontWeight.normal,
                              color: Colors.black87,
                              fontSize: 13,
                              fontStyle: FontStyle.italic,
                            ),
                          )
                        else
                          Text(
                            'Aucun détail disponible',
                            style: TextStyle(
                              fontWeight: FontWeight.normal,
                              color: Colors.grey[600],
                              fontSize: 12,
                              fontStyle: FontStyle.italic,
                            ),
                          ),
                        if (quantity > 1 && canViewPrices) ...[
                          Padding(
                            padding: const EdgeInsets.only(top: 4.0),
                            child: Text(
                              'HT: ${currencyFormat.format(priceHT)} × $quantity',
                              style: TextStyle(
                                color: Colors.grey[700],
                                fontSize: 11,
                                fontWeight: FontWeight.w400,
                              ),
                            ),
                          ),
                          Text(
                            'TTC: ${currencyFormat.format(priceTTC)} × $quantity',
                            style: TextStyle(
                              color: Colors.grey[700],
                              fontSize: 11,
                              fontWeight: FontWeight.w500,
                            ),
                          ),
                        ] else if (canViewPrices) ...[
                          Padding(
                            padding: const EdgeInsets.only(top: 4.0),
                            child: Text(
                              'HT: ${currencyFormat.format(priceHT)}',
                              style: TextStyle(
                                color: Colors.grey[600],
                                fontSize: 10,
                                fontStyle: FontStyle.italic,
                              ),
                            ),
                          ),
                        ],
                      ],
                    ),
                    trailing: canViewPrices
                        ? Column(
                            mainAxisSize: MainAxisSize.min,
                            crossAxisAlignment: CrossAxisAlignment.end,
                            children: [
                              Text(
                                (isNegative ? '- ' : '+ ') +
                                    currencyFormat.format(totalPriceTTC.abs()),
                                style: TextStyle(
                                  color: isNegative ? Colors.red : AppColors.noir,
                                  fontWeight: FontWeight.bold,
                                  fontSize: 14,
                                ),
                              ),
                              Text(
                                'HT: ${currencyFormat.format(totalPriceHT.abs())}',
                                style: TextStyle(
                                  color: Colors.grey[600],
                                  fontSize: 10,
                                  fontStyle: FontStyle.italic,
                                ),
                              ),
                            ],
                          )
                        : null,
                    contentPadding: EdgeInsets.zero,
                    dense: true,
                  );
                }),
                if (canViewPrices && showPriceCalculation) ...[
                  const SizedBox(height: 4),
                  _buildTotalPrice(context, enrichedOptions, currencyFormat),
                ],
              ],
            );
          },
        ),
      ],
    );
  }

  Widget _buildTotalPrice(BuildContext context, List<Map<String, dynamic>> options, NumberFormat currencyFormat) {
    final optionsTotalTTC = options.fold<num>(0, (sum, opt) {
      final priceTTC = opt['price'] ?? 0.0;
      final quantity = opt['quantity'] ?? 1;
      return sum + (priceTTC * quantity);
    });

    // Calculer le total HT
    final optionsTotalHT = PriceHelpers.calculateHT(optionsTotalTTC.toDouble());
    final optionsTVA = PriceHelpers.calculateTax(optionsTotalHT);

    return Padding(
      padding: const EdgeInsets.only(top: 8.0, bottom: 8.0),
      child: Column(
        crossAxisAlignment: CrossAxisAlignment.start,
        children: [
          Row(
            children: [
              const Icon(Icons.tune, color: AppColors.rouge, size: 20),
              const SizedBox(width: 8),
              Text(
                'Total options HT : ',
                style: Theme.of(context).textTheme.titleMedium?.copyWith(
                  color: AppColors.noir,
                  fontWeight: FontWeight.w600,
                ),
              ),
              Text(
                currencyFormat.format(optionsTotalHT),
                style: Theme.of(context).textTheme.titleMedium?.copyWith(
                  color: AppColors.noir,
                  fontWeight: FontWeight.w600,
                ),
              ),
            ],
          ),
          Padding(
            padding: const EdgeInsets.only(left: 28.0, top: 2.0),
            child: Text(
              'TVA (20%) : ${currencyFormat.format(optionsTVA)}',
              style: TextStyle(
                fontSize: 11,
                color: Colors.grey[600],
                fontStyle: FontStyle.italic,
              ),
            ),
          ),
          Row(
            children: [
              const Icon(Icons.attach_money, color: AppColors.rouge, size: 20),
              const SizedBox(width: 8),
              Text(
                'Total options TTC : ',
                style: Theme.of(context).textTheme.titleMedium?.copyWith(
                  color: AppColors.noir,
                  fontWeight: FontWeight.bold,
                ),
              ),
              Text(
                currencyFormat.format(optionsTotalTTC),
                style: Theme.of(context).textTheme.titleMedium?.copyWith(
                  color: AppColors.rouge,
                  fontWeight: FontWeight.bold,
                ),
              ),
            ],
          ),
        ],
      ),
    );
  }

  Future<List<Map<String, dynamic>>> _loadOptionsWithDetails(List<Map<String, dynamic>> optionsData) async {
    List<Map<String, dynamic>> enrichedOptions = [];

    // Charger toutes les options via l'API une seule fois
    final dataService = DataService(FirebaseFunctionsApiService());
    final allOptionsData = await dataService.getOptions();

    // Créer une map pour accès rapide par ID
    final optionsMap = {
      for (var opt in allOptionsData) opt['id']: opt
    };

    for (final optionData in optionsData) {
      try {
        // Si l'option a un ID, récupérer les détails complets depuis l'API
        if (optionData['id'] != null) {
          final apiData = optionsMap[optionData['id']];

          if (apiData != null) {
            // Combiner les données API avec le prix choisi
            enrichedOptions.add({
              'id': optionData['id'],
              'code': apiData['code'] ?? optionData['id'],
              'name': apiData['name'],
              'details': apiData['details'] ?? '',
              'price': optionData['price'], // Prix choisi par l'utilisateur
              'quantity': optionData['quantity'] ?? 1, // Quantité
              'isQuantitative': apiData['isQuantitative'] ?? false,
              'valMin': apiData['valMin'],
              'valMax': apiData['valMax'],
            });
          } else {
            // Option supprimée, afficher avec des données par défaut
            enrichedOptions.add({
              'id': optionData['id'],
              'name': 'Option supprimée (ID: ${optionData['id']})',
              'details': 'Cette option n\'existe plus dans la base de données',
              'price': optionData['price'],
              'quantity': optionData['quantity'] ?? 1,
              'isQuantitative': false,
            });
          }
        } else {
          // Ancien format sans ID (rétrocompatibilité)
          // Utiliser les données locales disponibles
          enrichedOptions.add({
            'name': optionData['name'] ?? 'Option inconnue',
            'details': optionData['details'] ?? 'Aucun détail disponible',
            'price': optionData['price'] ?? 0.0,
            'quantity': optionData['quantity'] ?? 1,
            'isQuantitative': false,
          });
        }
      } catch (e) {
        DebugLog.error('Erreur lors du chargement de l\'option ${optionData['id']}', e);
        // En cas d'erreur, créer une entrée avec les données disponibles
        enrichedOptions.add({
          'id': optionData['id'],
          'name': 'Erreur de chargement (ID: ${optionData['id']})',
          'details': 'Impossible de charger les détails de cette option',
          'price': optionData['price'] ?? 0.0,
          'quantity': optionData['quantity'] ?? 1,
          'isQuantitative': false,
        });
      }
    }

    return enrichedOptions;
  }
}
