import 'dart:math' as math;
import 'dart:ui' as ui;
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import 'package:fl_chart/fl_chart.dart'; // La librairie pour les courbes
import '../../core/widgets/metric_info_button.dart';
import '../../data/models/session.dart';
import '../../data/repositories/session_repository.dart';
import '../../services/statistics_service.dart';

class StatisticsScreen extends StatefulWidget {
  final Session? singleSession;

  const StatisticsScreen({super.key, this.singleSession});

  @override
  State<StatisticsScreen> createState() => _StatisticsScreenState();
}

class _StatisticsScreenState extends State<StatisticsScreen> {
  final StatisticsService _statisticsService = StatisticsService();
  StatsPeriod _selectedPeriod = StatsPeriod.all;
  SessionStatistics? _statistics;
  bool _isLoading = true;
  List<Session> _allSessions = [];

  // Valeurs pour les Dropdowns (Filtres)
  String _selectedWeapon = 'Toutes';
  String _selectedDistance = 'Toutes';
  List<String> _availableWeapons = ['Toutes'];
  List<String> _availableDistances = ['Toutes'];

  @override
  void initState() {
    super.initState();
    WidgetsBinding.instance.addPostFrameCallback((_) => _loadStatistics());
  }

  Future<void> _loadStatistics() async {
    if (!mounted) return;
    setState(() => _isLoading = true);
    try {
      final repository = context.read<SessionRepository>();
      _allSessions = await repository.getAllSessions();
      
      // Extraire les armes et distances uniques pour les filtres
      final weaponsFromSessions = _allSessions.map((s) => s.weapon).toSet();
      
      // Récupérer aussi les armes de l'armurerie pour s'assurer qu'elles sont présentes
      final armoryWeapons = await repository.getWeapons();
      final weaponsFromArmory = armoryWeapons.map((w) => w.displayName).toSet();
      
      // Combiner et trier
      final allWeaponsList = {...weaponsFromSessions, ...weaponsFromArmory}.toList()..sort();
      
      final distances = _allSessions.map((s) => '${s.distance}m').toSet().toList()
        ..sort((a, b) {
          final distA = int.tryParse(a.replaceAll('m', '')) ?? 0;
          final distB = int.tryParse(b.replaceAll('m', '')) ?? 0;
          return distA.compareTo(distB);
        });

      _availableWeapons = ['Toutes', ...allWeaponsList];
      _availableDistances = ['Toutes', ...distances];

      // Sécurité : si l'arme sélectionnée n'est plus disponible, on reset
      if (!_availableWeapons.contains(_selectedWeapon)) {
        _selectedWeapon = 'Toutes';
      }
      if (!_availableDistances.contains(_selectedDistance)) {
        _selectedDistance = 'Toutes';
      }

      _calculateStats();
    } catch (e) {
      debugPrint('Error: $e');
    } finally {
      if (mounted) setState(() => _isLoading = false);
    }
  }

  void _calculateStats() {
    // Filtrer les sessions avant calcul
    final filteredSessions = _allSessions.where((s) {
      final weaponMatch = _selectedWeapon == 'Toutes' || s.weapon == _selectedWeapon;
      final distanceMatch = _selectedDistance == 'Toutes' || '${s.distance}m' == _selectedDistance;
      return weaponMatch && distanceMatch;
    }).toList();

    _statistics = _statisticsService.calculateStatistics(
      filteredSessions,
      period: _selectedPeriod,
    );
  }

  List<double> _getScoreHistory() {
    if (_statistics == null || _statistics!.sessions.isEmpty) return [0];
    // Sort sessions by date and take last 10
    final sortedSessions = List<Session>.from(_statistics!.sessions)
      ..sort((a, b) => a.createdAt.compareTo(b.createdAt));
    return sortedSessions.map((s) => s.totalScore.toDouble()).toList();
  }

  List<double> _getPrecisionHistory() {
    if (_statistics == null || _statistics!.sessions.isEmpty) return [0];
    // We would need to calculate precision for each session individually to have a history.
    // For now, let's just use the score trend as a proxy if we don't have per-session precision cached.
    // Actually, let's use the scores but normalized if possible.
    final sortedSessions = List<Session>.from(_statistics!.sessions)
      ..sort((a, b) => a.createdAt.compareTo(b.createdAt));
    return sortedSessions.map((s) {
      if (s.totalShots == 0) return 0.0;
      // Simple precision proxy: total score / max possible (assuming 10 is max per shot)
      return (s.totalScore / (s.totalShots * 10)) * 100;
    }).toList();
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('Statistiques'),
        centerTitle: true,
      ),
      body: _isLoading
          ? const Center(child: CircularProgressIndicator())
          : RefreshIndicator(
              onRefresh: _loadStatistics,
              child: SingleChildScrollView(
                physics: const AlwaysScrollableScrollPhysics(),
                padding: const EdgeInsets.all(16),
              child: Column(
                children: [
                  // 1. FILTRES (Arme et Distance)
                  Row(
                    children: [
                      Expanded(
                        child: _buildDropdown(
                          'Arme utilisée', 
                          _selectedWeapon, 
                          _availableWeapons,
                          (val) {
                            setState(() {
                              _selectedWeapon = val!;
                              _calculateStats();
                            });
                          },
                        ),
                      ),
                      const SizedBox(width: 12),
                      Expanded(
                        child: _buildDropdown(
                          'Distance', 
                          _selectedDistance, 
                          _availableDistances,
                          (val) {
                            setState(() {
                              _selectedDistance = val!;
                              _calculateStats();
                            });
                          },
                        ),
                      ),
                    ],
                  ),
                  const SizedBox(height: 20),

                  // 2. DONNÉES RAPIDES (Tirs et Sessions)
                  Row(
                    children: [
                      Expanded(
                        child: _buildQuickStat(
                          'Nbre de tirs',
                          '${_statistics?.totalShots ?? 0}',
                          Icons.gps_fixed,
                        ),
                      ),
                      const SizedBox(width: 12),
                      Expanded(
                        child: _buildQuickStat(
                          'Nbre de sessions',
                          '${_statistics?.sessions.length ?? 0}',
                          Icons.analytics,
                        ),
                      ),
                    ],
                  ),
                  const SizedBox(height: 25),

                  // 3. LES GRAPHIQUES
                  _buildChartSection(
                    'Score',
                    '${_statistics?.totalScore ?? 0}',
                    _getScoreHistory(),
                    explanations: const [
                      MetricExplanation(
                        'Score',
                        'Total des points marqués sur la période sélectionnée.',
                      ),
                    ],
                  ),
                  const SizedBox(height: 20),
                  _buildChartSection(
                    'Précision',
                    '${_statistics?.precision.precisionScore.toStringAsFixed(1)}%',
                    _getPrecisionHistory(),
                    explanations: const [
                      MetricExplanation(
                        'Précision',
                        'Proximité moyenne de vos impacts par rapport au centre '
                            'de la cible (calculée sur les distances).',
                      ),
                      MetricExplanation(
                        'À ne pas confondre',
                        'C\'est différent de la « Réussite » affichée dans une '
                            'session, qui se base sur les points marqués. Les deux '
                            'mesurent des choses distinctes, leurs pourcentages '
                            'ne sont donc pas identiques.',
                      ),
                    ],
                  ),
                  const SizedBox(height: 20),
                  _buildChartSection(
                    'Étalement moyen',
                    '${((_statistics?.precision.groupingDiameter ?? 0) * 100).toStringAsFixed(1)}%',
                    _getScoreHistory().map((e) => e / 10).toList(), // Proxy for grouping history
                    explanations: const [
                      MetricExplanation(
                        'Étalement moyen',
                        'Étalement moyen de vos groupements : distance entre les '
                            'impacts les plus éloignés, en % de la largeur de '
                            'l\'image. Plus c\'est bas, plus vos tirs sont serrés.',
                      ),
                    ],
                  ),

                  const SizedBox(height: 25),

                  // 4. DISTRIBUTION ET BIAIS (Restauré)
                  if (_statistics != null && _statistics!.totalShots > 0) ...[
                    _buildRegionalDistribution(),
                    const SizedBox(height: 20),
                    _buildQuadrantGrid(),
                    const SizedBox(height: 20),
                    _buildHeatMapSection(),
                    const SizedBox(height: 20),
                    if (_statistics!.regional.biasX.abs() > 0.05 ||
                        _statistics!.regional.biasY.abs() > 0.05)
                      _buildBiasWarning(),
                  ],

                  const SizedBox(height: 30),
                ],
              ),
            ),
          ),
    );
  }

  Widget _buildDropdown(
    String label, 
    String value, 
    List<String> items,
    void Function(String?) onChanged,
  ) {
    final theme = Theme.of(context);
    return Container(
      padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 4),
      decoration: BoxDecoration(
        color: theme.colorScheme.surfaceContainerHighest.withValues(alpha: 0.5),
        borderRadius: BorderRadius.circular(8),
        border: Border.all(color: theme.dividerColor),
      ),
      child: Column(
        crossAxisAlignment: CrossAxisAlignment.start,
        children: [
          Text(
            label,
            style: TextStyle(color: theme.textTheme.bodySmall?.color?.withValues(alpha: 0.6), fontSize: 10),
          ),
          DropdownButton<String>(
            value: value,
            isExpanded: true,
            underline: Container(),
            dropdownColor: theme.colorScheme.surfaceContainerHighest,
            style: TextStyle(color: theme.textTheme.bodyMedium?.color, fontSize: 14),
            items: items
                .map(
                  (String val) =>
                      DropdownMenuItem(value: val, child: Text(val)),
                )
                .toList(),
            onChanged: onChanged,
          ),
        ],
      ),
    );
  }

  // Widget pour les petites cartes de stats
  Widget _buildQuickStat(String label, String value, IconData icon) {
    final theme = Theme.of(context);
    return Container(
      padding: const EdgeInsets.all(16),
      decoration: BoxDecoration(
        color: theme.colorScheme.surfaceContainerHighest.withValues(alpha: 0.5),
        borderRadius: BorderRadius.circular(12),
      ),
      child: Column(
        children: [
          Icon(icon, color: const Color(0xFF1A73E8), size: 20),
          const SizedBox(height: 8),
          Text(
            value,
            style: TextStyle(
              color: theme.textTheme.titleLarge?.color,
              fontSize: 20,
              fontWeight: FontWeight.bold,
            ),
          ),
          Text(
            label,
            style: TextStyle(color: theme.textTheme.bodySmall?.color?.withValues(alpha: 0.6), fontSize: 12),
          ),
        ],
      ),
    );
  }

  // Widget pour une section de graphique
  Widget _buildChartSection(
    String title,
    String value,
    List<double> dataPoints, {
    List<MetricExplanation>? explanations,
  }) {
    final theme = Theme.of(context);
    return Container(
      padding: const EdgeInsets.all(16),
      decoration: BoxDecoration(
        color: theme.colorScheme.surfaceContainerHighest.withValues(alpha: 0.5),
        borderRadius: BorderRadius.circular(12),
      ),
      child: Column(
        crossAxisAlignment: CrossAxisAlignment.start,
        children: [
          Row(
            children: [
              Text(
                title,
                style: TextStyle(color: theme.textTheme.bodyMedium?.color?.withValues(alpha: 0.7), fontSize: 14),
              ),
              if (explanations != null) ...[
                const Spacer(),
                MetricInfoButton(title: title, explanations: explanations),
              ],
            ],
          ),
          const SizedBox(height: 10),
          Row(
            children: [
              Text(
                value,
                style: TextStyle(
                  color: theme.textTheme.headlineMedium?.color,
                  fontSize: 24,
                  fontWeight: FontWeight.bold,
                ),
              ),
              const SizedBox(width: 20),
              Expanded(
                child: SizedBox(
                  height: 60,
                  child: LineChart(_mainChartData(dataPoints)),
                ),
              ),
            ],
          ),
        ],
      ),
    );
  }

  LineChartData _mainChartData(List<double> points) {
    if (points.isEmpty) points = [0];
    return LineChartData(
      gridData: const FlGridData(show: false),
      titlesData: const FlTitlesData(show: false),
      borderData: FlBorderData(show: false),
      lineBarsData: [
        LineChartBarData(
          spots: points.length == 1
              ? [const FlSpot(0, 0), FlSpot(1, points[0])]
              : points
                  .asMap()
                  .entries
                  .map((e) => FlSpot(e.key.toDouble(), e.value))
                  .toList(),
          isCurved: true,
          color: const Color(0xFF4CAF50), // Vert comme sur ton design
          barWidth: 3,
          isStrokeCapRound: true,
          dotData: const FlDotData(show: false),
          belowBarData: BarAreaData(
            show: true,
            color: const Color(0xFF4CAF50).withValues(alpha: 0.2),
          ),
        ),
      ],
    );
  }

  // --- NOUVEAUX WIDGETS RESTAURÉS ---

  Widget _buildRegionalDistribution() {
    final regional = _statistics!.regional;
    final theme = Theme.of(context);
    return Container(
      padding: const EdgeInsets.all(16),
      decoration: BoxDecoration(
        color: theme.colorScheme.surfaceContainerHighest.withValues(alpha: 0.5),
        borderRadius: BorderRadius.circular(12),
      ),
      child: Column(
        crossAxisAlignment: CrossAxisAlignment.start,
        children: [
          Text(
            'Distribution Régionale',
            style: TextStyle(
              color: theme.textTheme.titleMedium?.color,
              fontSize: 16,
              fontWeight: FontWeight.bold,
            ),
          ),
          const SizedBox(height: 12),
          Row(
            children: [
              const Icon(Icons.explore, color: Color(0xFF1A73E8), size: 20),
              const SizedBox(width: 8),
              Text(
                'Direction dominante : ${regional.dominantDirection}',
                style: TextStyle(color: theme.textTheme.bodyMedium?.color?.withValues(alpha: 0.7), fontSize: 14),
              ),
            ],
          ),
          const SizedBox(height: 12),
          Wrap(
            spacing: 8,
            runSpacing: 8,
            children: regional.sectorDistribution.entries
                .where((e) => e.value > 0)
                .map((e) {
              final percentage = (e.value / _statistics!.totalShots * 100);
              return Container(
                padding: const EdgeInsets.symmetric(horizontal: 10, vertical: 6),
                decoration: BoxDecoration(
                  color: const Color(0xFF1A73E8).withValues(alpha: 0.1),
                  borderRadius: BorderRadius.circular(20),
                  border: Border.all(color: const Color(0xFF1A73E8).withValues(alpha: 0.3)),
                ),
                child: Text(
                  '${e.key}: ${e.value} (${percentage.toStringAsFixed(0)}%)',
                  style: TextStyle(color: theme.textTheme.bodySmall?.color, fontSize: 12),
                ),
              );
            }).toList(),
          ),
        ],
      ),
    );
  }

  Widget _buildQuadrantGrid() {
    final quadrants = _statistics!.regional.quadrantDistribution;
    final theme = Theme.of(context);
    return Container(
      padding: const EdgeInsets.all(16),
      decoration: BoxDecoration(
        color: theme.colorScheme.surfaceContainerHighest.withValues(alpha: 0.5),
        borderRadius: BorderRadius.circular(12),
      ),
      child: Column(
        crossAxisAlignment: CrossAxisAlignment.start,
        children: [
          Text(
            'Répartition par Quadrant',
            style: TextStyle(
              color: theme.textTheme.titleMedium?.color,
              fontSize: 16,
              fontWeight: FontWeight.bold,
            ),
          ),
          const SizedBox(height: 16),
          AspectRatio(
            aspectRatio: 1,
            child: GridView.count(
              crossAxisCount: 2,
              mainAxisSpacing: 4,
              crossAxisSpacing: 4,
              shrinkWrap: true,
              physics: const NeverScrollableScrollPhysics(),
              children: [
                _buildQuadrantCell('Haut-Gauche', quadrants['Haut-Gauche'] ?? 0),
                _buildQuadrantCell('Haut-Droite', quadrants['Haut-Droite'] ?? 0),
                _buildQuadrantCell('Bas-Gauche', quadrants['Bas-Gauche'] ?? 0),
                _buildQuadrantCell('Bas-Droite', quadrants['Bas-Droite'] ?? 0),
              ],
            ),
          ),
        ],
      ),
    );
  }

  Widget _buildHeatMapSection() {
    final heatMap = _statistics!.heatMap;
    final theme = Theme.of(context);
    
    return Container(
      padding: const EdgeInsets.all(16),
      decoration: BoxDecoration(
        color: theme.colorScheme.surfaceContainerHighest.withValues(alpha: 0.5),
        borderRadius: BorderRadius.circular(12),
      ),
      child: Column(
        crossAxisAlignment: CrossAxisAlignment.start,
        children: [
          Text(
            'Zones de Chaleur (Heatmap)',
            style: TextStyle(
              color: theme.textTheme.titleMedium?.color,
              fontSize: 16,
              fontWeight: FontWeight.bold,
            ),
          ),
          const SizedBox(height: 4),
          Text(
            'Analyse de densité des impacts',
            style: TextStyle(color: theme.textTheme.bodySmall?.color?.withValues(alpha: 0.6), fontSize: 12),
          ),
          const SizedBox(height: 20),
          AspectRatio(
            aspectRatio: 1,
            child: Container(
              decoration: BoxDecoration(
                color: theme.colorScheme.surfaceContainerHighest.withValues(alpha: 0.3),
                borderRadius: BorderRadius.circular(12),
                border: Border.all(color: Colors.white10),
              ),
              child: ClipRRect(
                borderRadius: BorderRadius.circular(12),
                child: CustomPaint(
                  painter: _HeatMapPainter(heatMap: heatMap),
                ),
              ),
            ),
          ),
          const SizedBox(height: 16),
          // Légende dégradée
          Container(
            height: 12,
            width: double.infinity,
            decoration: BoxDecoration(
              borderRadius: BorderRadius.circular(6),
              gradient: const LinearGradient(
                colors: [
                  Colors.blue,
                  Colors.yellow,
                  Colors.orange,
                  Colors.red,
                ],
              ),
            ),
          ),
          const SizedBox(height: 4),
          Row(
            mainAxisAlignment: MainAxisAlignment.spaceBetween,
            children: [
              Text('Faible', style: TextStyle(fontSize: 10, color: Colors.white.withValues(alpha: 0.5))),
              Text('Élevée', style: TextStyle(fontSize: 10, color: Colors.white.withValues(alpha: 0.5))),
            ],
          ),
        ],
      ),
    );
  }

  Widget _buildQuadrantCell(String label, int count) {
    final percentage = (count / _statistics!.totalShots * 100);
    final intensity = count / _statistics!.totalShots;

    return Container(
      decoration: BoxDecoration(
        color: Color.lerp(
          Theme.of(context).colorScheme.surfaceContainerHighest,
          const Color(0xFF1A73E8),
          intensity,
        )!.withValues(alpha: 0.8),
        borderRadius: BorderRadius.circular(8),
      ),
      child: Column(
        mainAxisAlignment: MainAxisAlignment.center,
        children: [
          Text(
            '$count',
            style: TextStyle(
              color: Theme.of(context).textTheme.titleLarge?.color,
              fontSize: 20,
              fontWeight: FontWeight.bold,
            ),
          ),
          Text(
            '${percentage.toStringAsFixed(0)}%',
            style: TextStyle(color: Theme.of(context).textTheme.bodySmall?.color?.withValues(alpha: 0.7), fontSize: 12),
          ),
          Text(
            label,
            style: TextStyle(color: Theme.of(context).textTheme.bodySmall?.color?.withValues(alpha: 0.5), fontSize: 10),
          ),
        ],
      ),
    );
  }

  Widget _buildBiasWarning() {
    final regional = _statistics!.regional;
    String description = '';
    if (regional.biasX.abs() > 0.05) {
      description += regional.biasX > 0 ? 'vers la droite' : 'vers la gauche';
    }
    if (regional.biasY.abs() > 0.05) {
      if (description.isNotEmpty) description += ' et ';
      description += regional.biasY > 0 ? 'vers le bas' : 'vers le haut';
    }

    return Container(
      padding: const EdgeInsets.all(16),
      decoration: BoxDecoration(
        color: Colors.orange.withValues(alpha: 0.1),
        borderRadius: BorderRadius.circular(12),
        border: Border.all(color: Colors.orange.withValues(alpha: 0.3)),
      ),
      child: Row(
        children: [
          const Icon(Icons.warning_amber_rounded, color: Colors.orange),
          const SizedBox(width: 12),
          Expanded(
            child: Column(
              crossAxisAlignment: CrossAxisAlignment.start,
              children: [
                const Text(
                  'Biais détecté',
                  style: TextStyle(
                    color: Colors.orange,
                    fontWeight: FontWeight.bold,
                  ),
                ),
                Text(
                  'Tendance $description',
                  style: TextStyle(color: Theme.of(context).textTheme.bodyMedium?.color?.withValues(alpha: 0.7), fontSize: 13),
                ),
              ],
            ),
          ),
        ],
      ),
    );
  }
}

class _HeatMapPainter extends CustomPainter {
  final HeatMap heatMap;

  _HeatMapPainter({required this.heatMap});

  @override
  void paint(Canvas canvas, Size size) {
    _drawTargetBackground(canvas, size);
    _drawHeatGradient(canvas, size);
  }

  void _drawTargetBackground(Canvas canvas, Size size) {
    final center = Offset(size.width / 2, size.height / 2);
    final maxRadius = math.min(size.width, size.height) * 0.45;
    
    final paint = Paint()
      ..style = PaintingStyle.stroke
      ..strokeWidth = 1
      ..color = Colors.grey.withValues(alpha: 0.2); // Neutre

    // Draw rings
    for (int i = 1; i <= 10; i++) {
      canvas.drawCircle(center, maxRadius * (i / 10), paint);
    }
    
    // Draw crosshair
    canvas.drawLine(Offset(0, center.dy), Offset(size.width, center.dy), paint);
    canvas.drawLine(Offset(center.dx, 0), Offset(center.dx, size.height), paint);
  }

  void _drawHeatGradient(Canvas canvas, Size size) {
    final cellSizeW = size.width / heatMap.gridSize;
    final cellSizeH = size.height / heatMap.gridSize;

    for (var row in heatMap.zones) {
      for (var zone in row) {
        if (zone.intensity <= 0) continue;

        final center = Offset(
          (zone.col + 0.5) * cellSizeW,
          (zone.row + 0.5) * cellSizeH,
        );

        final radius = cellSizeW * 1.2; // Légèrement réduit pour plus de netteté
        
        // Normalisation de l'intensité : on rend le max toujours très visible (rouge)
        final normalizedIntensity = zone.intensity;
        
        final color = _getIntensityColor(normalizedIntensity);

        final paint = Paint()
          ..shader = ui.Gradient.radial(
            center,
            radius,
            [
              color.withValues(alpha: 0.7 * normalizedIntensity.clamp(0.4, 1.0)),
              color.withValues(alpha: 0.0),
            ],
            [0.2, 1.0],
          )
          ..style = PaintingStyle.fill; // srcOver par défaut, plus lisible

        canvas.drawCircle(center, radius, paint);

        // --- AFFICHAGE DU NOMBRE D'IMPACTS ---
        if (zone.shotCount > 0) {
          final textPainter = TextPainter(
            text: TextSpan(
              text: '${zone.shotCount}',
              style: TextStyle(
                color: Colors.white,
                fontSize: 10,
                fontWeight: FontWeight.bold,
                shadows: [
                  Shadow(
                    color: Colors.black.withValues(alpha: 0.8),
                    blurRadius: 2,
                    offset: const Offset(1, 1),
                  ),
                ],
              ),
            ),
            textDirection: TextDirection.ltr,
          );
          textPainter.layout();
          textPainter.paint(
            canvas,
            Offset(center.dx - textPainter.width / 2, center.dy - textPainter.height / 2),
          );
        }
      }
    }
  }

  Color _getIntensityColor(double intensity) {
    if (intensity < 0.2) return Colors.blue;
    if (intensity < 0.5) return Colors.yellow;
    if (intensity < 0.8) return Colors.orange;
    return Colors.red;
  }

  @override
  bool shouldRepaint(covariant _HeatMapPainter oldDelegate) => 
      heatMap != oldDelegate.heatMap;
}