import 'package:geosector_app/app.dart'; // Pour accéder aux instances globales
import 'package:flutter/material.dart';
import 'package:geosector_app/app.dart'; // Pour accéder aux instances globales
import 'package:flutter/foundation.dart' show listEquals, mapEquals;
import 'package:intl/intl.dart';
import 'package:syncfusion_flutter_charts/charts.dart';
import 'package:geosector_app/core/constants/app_keys.dart';
import 'package:geosector_app/core/repositories/passage_repository.dart';
import 'package:geosector_app/core/repositories/user_repository.dart';
import 'package:geosector_app/core/services/passage_data_service.dart';

/// Modèle de données pour le graphique en camembert des passages
class PassageChartData {
  /// Identifiant du type de passage
  final int typeId;

  /// Nombre de passages de ce type
  final int count;

  /// Titre du type de passage
  final String title;

  /// Couleur associée au type de passage
  final Color color;

  /// Icône associée au type de passage
  final IconData icon;

  PassageChartData({
    required this.typeId,
    required this.count,
    required this.title,
    required this.color,
    required this.icon,
  });
}

/// Widget de graphique en camembert pour représenter la répartition des passages par type
class PassagePieChart extends StatefulWidget {
  /// Liste des données de passages par type sous forme de Map avec typeId et count
  /// Si loadFromHive est true, ce paramètre est ignoré
  final Map<int, int> passagesByType;

  /// Taille du graphique
  final double size;

  /// Taille des étiquettes
  final double labelSize;

  /// Afficher les pourcentages
  final bool showPercentage;

  /// Afficher les icônes
  final bool showIcons;

  /// Afficher la légende
  final bool showLegend;

  /// Format donut (anneau)
  final bool isDonut;

  /// Rayon central pour le format donut (en pourcentage)
  final String innerRadius;

  /// Charger les données depuis Hive
  final bool loadFromHive;

  /// ID de l'utilisateur pour filtrer les passages (utilisé seulement si loadFromHive est true)
  final int? userId;

  /// Types de passages à exclure (utilisé seulement si loadFromHive est true)
  final List<int> excludePassageTypes;

  /// Afficher tous les passages sans filtrer par utilisateur (utilisé seulement si loadFromHive est true)
  final bool showAllPassages;

  const PassagePieChart({
    super.key,
    this.passagesByType = const {},
    this.size = 300,
    this.labelSize = 12,
    this.showPercentage = true,
    this.showIcons = true,
    this.showLegend = true,
    this.isDonut = false,
    this.innerRadius = '40%',
    this.loadFromHive = false,
    this.userId,
    this.excludePassageTypes = const [2],
    this.showAllPassages = false,
  });

  @override
  State<PassagePieChart> createState() => _PassagePieChartState();
}

class _PassagePieChartState extends State<PassagePieChart>
    with SingleTickerProviderStateMixin {
  late AnimationController _animationController;

  /// Données de passages par type
  late Map<int, int> _passagesByType;

  /// Variables pour la mise en cache et l'optimisation
  bool _dataLoaded = false;
  bool _isLoading = false;
  List<PassageChartData>? _cachedChartData;
  List<CircularChartAnnotation>? _cachedAnnotations;

  @override
  void initState() {
    super.initState();
    _passagesByType = widget.passagesByType;

    // Initialiser le contrôleur d'animation
    _animationController = AnimationController(
      vsync: this,
      duration: const Duration(milliseconds: 2000),
    );

    _animationController.forward();

    // Si nous n'utilisons pas Hive, préparer les données immédiatement
    if (!widget.loadFromHive) {
      _prepareChartData();
    }
  }

  @override
  void didChangeDependencies() {
    super.didChangeDependencies();
    if (widget.loadFromHive && !_dataLoaded && !_isLoading) {
      _isLoading = true; // Prévenir les chargements multiples
      _loadPassageDataFromHive(context);
    }
  }

  @override
  void didUpdateWidget(PassagePieChart oldWidget) {
    super.didUpdateWidget(oldWidget);

    // Vérifier si les propriétés importantes ont changé
    final bool dataSourceChanged = widget.loadFromHive
        ? false
        : !mapEquals(oldWidget.passagesByType, widget.passagesByType);
    final bool filteringChanged = oldWidget.userId != widget.userId ||
        !listEquals(
            oldWidget.excludePassageTypes, widget.excludePassageTypes) ||
        oldWidget.showAllPassages != widget.showAllPassages;
    final bool visualChanged = oldWidget.size != widget.size ||
        oldWidget.labelSize != widget.labelSize ||
        oldWidget.showPercentage != widget.showPercentage ||
        oldWidget.showIcons != widget.showIcons ||
        oldWidget.showLegend != widget.showLegend ||
        oldWidget.isDonut != widget.isDonut ||
        oldWidget.innerRadius != widget.innerRadius;

    // Si les paramètres de filtrage ou de source de données ont changé, recharger les données
    if (dataSourceChanged || filteringChanged) {
      _cachedChartData = null;
      _cachedAnnotations = null;

      // Relancer l'animation si les données ont changé
      _animationController.reset();
      _animationController.forward();

      if (!widget.loadFromHive) {
        _passagesByType = widget.passagesByType;
        _prepareChartData();
      } else if (!_isLoading) {
        _dataLoaded = false;
        _isLoading = true;
        _loadPassageDataFromHive(context);
      }
    }
    // Si seuls les paramètres visuels ont changé, recalculer les annotations sans recharger les données
    else if (visualChanged) {
      _cachedAnnotations = null;
    }
  }

  /// Charge les données de passage depuis Hive en utilisant le service PassageDataService
  void _loadPassageDataFromHive(BuildContext context) {
    // Éviter les appels multiples pendant le chargement
    if (_isLoading) {
      debugPrint('PassagePieChart: Déjà en cours de chargement, ignoré');
      return;
    }

    // Si les données sont déjà chargées et non vides, ne pas recharger
    if (_dataLoaded && _passagesByType.isNotEmpty) {
      debugPrint('PassagePieChart: Données déjà chargées, ignoré');
      return;
    }

    debugPrint('PassagePieChart: Début du chargement des données');
    setState(() {
      _isLoading = true;
    });

    // Charger les données dans un addPostFrameCallback pour éviter les problèmes de cycle de vie
    WidgetsBinding.instance.addPostFrameCallback((_) {
      // Vérifier si le widget est toujours monté
      if (!mounted) {
        debugPrint('PassagePieChart: Widget démonté, chargement annulé');
        return;
      }

      try {
        debugPrint('PassagePieChart: Création du service de données');
        // Utiliser les instances globales définies dans app.dart

        // Vérifier que les repositories sont disponibles
        if (passageRepository == null) {
          debugPrint('PassagePieChart: ERREUR - passageRepository est null');
          if (mounted) {
            setState(() {
              _isLoading = false;
            });
          }
          return;
        }

        if (userRepository == null) {
          debugPrint('PassagePieChart: ERREUR - userRepository est null');
          if (mounted) {
            setState(() {
              _isLoading = false;
            });
          }
          return;
        }

        // Créer une instance du service de données
        final passageDataService = PassageDataService(
          passageRepository: passageRepository,
          userRepository: userRepository,
        );

        debugPrint(
            'PassagePieChart: Chargement des données avec excludePassageTypes=${widget.excludePassageTypes}, userId=${widget.userId}, showAllPassages=${widget.showAllPassages}');

        // Utiliser le service pour charger les données
        final data = passageDataService.loadPassageDataForPieChart(
          excludePassageTypes: widget.excludePassageTypes,
          userId: widget.userId,
          showAllPassages: widget.showAllPassages,
        );

        debugPrint('PassagePieChart: Données chargées: $data');

        // Mettre à jour les données et les états
        if (mounted) {
          setState(() {
            _passagesByType = data;
            _dataLoaded = true;
            _isLoading = false;
            _cachedChartData =
                null; // Forcer la régénération des données du graphique
            _cachedAnnotations = null;
          });

          // Préparer les données du graphique
          _prepareChartData();
          debugPrint('PassagePieChart: Données préparées pour le graphique');
        }
      } catch (e) {
        // Gérer les erreurs et réinitialiser l'état pour permettre une future tentative
        debugPrint(
            'PassagePieChart: ERREUR lors du chargement des données: $e');
        if (mounted) {
          setState(() {
            _isLoading = false;
          });
        }
      }
    });
  }

  /// Prépare les données pour le graphique en camembert avec mise en cache
  List<PassageChartData> _prepareChartData() {
    // Utiliser les données en cache si disponibles
    if (_cachedChartData != null) {
      debugPrint('PassagePieChart: Utilisation des données en cache');
      return _cachedChartData!;
    }

    debugPrint('PassagePieChart: Préparation des données pour le graphique');
    debugPrint('PassagePieChart: Données brutes: $_passagesByType');

    // Vérifier si les données sont vides
    if (_passagesByType.isEmpty) {
      debugPrint('PassagePieChart: Aucune donnée disponible');
      return [];
    }

    // Vérifier si les données contiennent uniquement des passages de type 2
    bool onlyType2 = true;
    _passagesByType.forEach((typeId, count) {
      if (typeId != 2 && count > 0) {
        onlyType2 = false;
      }
    });

    if (onlyType2) {
      debugPrint(
          'PassagePieChart: Les données contiennent uniquement des passages de type 2');
    }

    final List<PassageChartData> chartData = [];

    // Créer les données du graphique
    _passagesByType.forEach((typeId, count) {
      // Vérifier que le type existe et que le compteur est positif
      if (count > 0 && AppKeys.typesPassages.containsKey(typeId)) {
        // Vérifier si le type est exclu
        bool isExcluded = widget.excludePassageTypes.contains(typeId);
        if (isExcluded) {
          debugPrint('PassagePieChart: Type $typeId exclu');
        } else {
          final typeInfo = AppKeys.typesPassages[typeId]!;
          final typeName = typeInfo['titre'] as String;
          debugPrint(
              'PassagePieChart: Ajout du type $typeId ($typeName) avec $count passages');

          chartData.add(PassageChartData(
            typeId: typeId,
            count: count,
            title: typeName,
            color: Color(typeInfo['couleur2'] as int),
            icon: typeInfo['icon_data'] as IconData,
          ));
        }
      } else {
        if (count <= 0) {
          debugPrint('PassagePieChart: Type $typeId ignoré car count=$count');
        } else if (!AppKeys.typesPassages.containsKey(typeId)) {
          debugPrint(
              'PassagePieChart: Type $typeId ignoré car non défini dans AppKeys.typesPassages');
        }
      }
    });

    debugPrint(
        'PassagePieChart: ${chartData.length} types de passages ajoutés au graphique');

    // Mettre en cache les données générées
    _cachedChartData = chartData;

    return chartData;
  }

  @override
  void dispose() {
    _animationController.dispose();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    // Si les données doivent être chargées depuis Hive mais ne sont pas encore prêtes
    if (widget.loadFromHive && !_dataLoaded) {
      return SizedBox(
        width: widget.size,
        height: widget.size,
        child: const Center(
          child: CircularProgressIndicator(),
        ),
      );
    }

    final chartData = _prepareChartData();

    // Si aucune donnée, afficher un message
    if (chartData.isEmpty) {
      return SizedBox(
        width: widget.size,
        height: widget.size,
        child: const Center(
          child: Text('Aucune donnée disponible'),
        ),
      );
    }

    // Créer des animations pour différents aspects du graphique
    final progressAnimation = CurvedAnimation(
      parent: _animationController,
      curve: Curves.easeOutCubic,
    );

    final explodeAnimation = CurvedAnimation(
      parent: _animationController,
      curve: Interval(0.7, 1.0, curve: Curves.elasticOut),
    );

    final opacityAnimation = CurvedAnimation(
      parent: _animationController,
      curve: Interval(0.1, 0.5, curve: Curves.easeIn),
    );

    return AnimatedBuilder(
      animation: _animationController,
      builder: (context, child) {
        return SizedBox(
          width: widget.size,
          height: widget.size,
          child: SfCircularChart(
            margin: EdgeInsets.zero,
            legend: Legend(
              isVisible: widget.showLegend,
              position: LegendPosition.bottom,
              overflowMode: LegendItemOverflowMode.wrap,
              textStyle: TextStyle(fontSize: widget.labelSize),
            ),
            tooltipBehavior: TooltipBehavior(enable: true),
            series: <CircularSeries>[
              widget.isDonut
                  ? DoughnutSeries<PassageChartData, String>(
                      dataSource: chartData,
                      xValueMapper: (PassageChartData data, _) => data.title,
                      yValueMapper: (PassageChartData data, _) => data.count,
                      pointColorMapper: (PassageChartData data, _) =>
                          data.color,
                      enableTooltip: true,
                      dataLabelMapper: (PassageChartData data, _) {
                        if (widget.showPercentage) {
                          // Calculer le pourcentage avec une décimale
                          final total = chartData.fold(
                              0, (sum, item) => sum + item.count);
                          final percentage = (data.count / total * 100);
                          return '${percentage.toStringAsFixed(1)}%';
                        } else {
                          return data.title;
                        }
                      },
                      dataLabelSettings: DataLabelSettings(
                        isVisible: true,
                        labelPosition: ChartDataLabelPosition.outside,
                        textStyle: TextStyle(fontSize: widget.labelSize),
                        connectorLineSettings: const ConnectorLineSettings(
                          type: ConnectorType.curve,
                          length: '15%',
                        ),
                      ),
                      innerRadius: widget.innerRadius,
                      explode: true,
                      explodeIndex: 0,
                      explodeOffset:
                          '${(5 * explodeAnimation.value).toStringAsFixed(1)}%',
                      opacity: opacityAnimation.value,
                      animationDuration:
                          0, // On désactive l'animation intégrée car nous utilisons notre propre animation
                      startAngle: 270,
                      endAngle: 270 + (360 * progressAnimation.value).toInt(),
                    )
                  : PieSeries<PassageChartData, String>(
                      dataSource: chartData,
                      xValueMapper: (PassageChartData data, _) => data.title,
                      yValueMapper: (PassageChartData data, _) => data.count,
                      pointColorMapper: (PassageChartData data, _) =>
                          data.color,
                      enableTooltip: true,
                      dataLabelMapper: (PassageChartData data, _) {
                        if (widget.showPercentage) {
                          // Calculer le pourcentage avec une décimale
                          final total = chartData.fold(
                              0, (sum, item) => sum + item.count);
                          final percentage = (data.count / total * 100);
                          return '${percentage.toStringAsFixed(1)}%';
                        } else {
                          return data.title;
                        }
                      },
                      dataLabelSettings: DataLabelSettings(
                        isVisible: true,
                        labelPosition: ChartDataLabelPosition.outside,
                        textStyle: TextStyle(fontSize: widget.labelSize),
                        connectorLineSettings: const ConnectorLineSettings(
                          type: ConnectorType.curve,
                          length: '15%',
                        ),
                      ),
                      explode: true,
                      explodeIndex: 0,
                      explodeOffset:
                          '${(5 * explodeAnimation.value).toStringAsFixed(1)}%',
                      opacity: opacityAnimation.value,
                      animationDuration:
                          0, // On désactive l'animation intégrée car nous utilisons notre propre animation
                      startAngle: 270,
                      endAngle: 270 + (360 * progressAnimation.value).toInt(),
                    ),
            ],
            annotations:
                widget.showIcons ? _buildIconAnnotations(chartData) : null,
          ),
        );
      },
    );
  }

  /// Crée les annotations d'icônes pour le graphique avec mise en cache
  List<CircularChartAnnotation> _buildIconAnnotations(
      List<PassageChartData> chartData) {
    // Utiliser les annotations en cache si disponibles
    if (_cachedAnnotations != null) {
      return _cachedAnnotations!;
    }

    final List<CircularChartAnnotation> annotations = [];

    // Calculer le total pour les pourcentages
    int total = chartData.fold(0, (sum, item) => sum + item.count);
    if (total == 0) return []; // Éviter la division par zéro

    // Position angulaire actuelle (en radians)
    double currentAngle = 0;

    for (int i = 0; i < chartData.length; i++) {
      final data = chartData[i];
      final percentage = data.count / total;

      // Calculer l'angle central de ce segment
      final segmentAngle = percentage * 2 * 3.14159;
      final midAngle = currentAngle + (segmentAngle / 2);

      // Ajouter une annotation pour l'icône
      annotations.add(
        CircularChartAnnotation(
          widget: Icon(
            data.icon,
            color: Colors.white,
            size: 16,
          ),
          radius: '50%',
          angle: (midAngle * (180 / 3.14159)).toInt(), // Convertir en degrés
        ),
      );

      // Mettre à jour l'angle actuel
      currentAngle += segmentAngle;
    }

    // Mettre en cache les annotations générées
    _cachedAnnotations = annotations;

    return annotations;
  }
}