import 'package:flutter/material.dart';
import 'package:cloud_firestore/cloud_firestore.dart';
import 'package:firebase_auth/firebase_auth.dart';
import 'package:firebase_storage/firebase_storage.dart';
import 'package:image_picker/image_picker.dart';
import 'dart:io';
import 'training_detail_screen.dart';

class SearchTab extends StatefulWidget {
  final bool selectMode;
  final int? remainingTime;

  const SearchTab({
    super.key,
    this.selectMode = false,
    this.remainingTime,
  });

  @override
  State<SearchTab> createState() => _SearchTabState();
}

class _SearchTabState extends State<SearchTab> {
  final TextEditingController _searchController = TextEditingController();
  final List<String> _categories = [
    'Aufwärmen & Mobilisation',
    'Wurf- & Torabschluss',
    'Torwarttraining',
    'Athletik',
    'Pass',
    'Koordination',
  ];
  String? _selectedCategory;
  String _searchTerm = '';
  bool _isTrainer = false;
  bool _trainerChecked = false;
  Set<String> _favorites = {};

  @override
  void initState() {
    super.initState();
    _searchController.addListener(() {
      setState(() {
        _searchTerm = _searchController.text.trim();
      });
    });
    _checkIfTrainer();
    _loadFavorites();
  }

  Future<void> _checkIfTrainer() async {
    final user = FirebaseAuth.instance.currentUser;
    if (user == null) return;
    final doc = await FirebaseFirestore.instance.collection('User').doc(user.uid).get();
    setState(() {
      _isTrainer = doc.data()?['role'] == 'trainer';
      _trainerChecked = true;
    });
  }

  Future<void> _loadFavorites() async {
    final user = FirebaseAuth.instance.currentUser;
    if (user == null) return;
    final doc = await FirebaseFirestore.instance.collection('User').doc(user.uid).get();
    final data = doc.data();
    if (data != null && data['favorites'] != null) {
      setState(() {
        _favorites = Set<String>.from(data['favorites']);
      });
    }
  }

  void _showCreateTrainingDialog(BuildContext context) {
    showDialog(
      context: context,
      builder: (context) => _CreateTrainingDialog(categories: _categories),
    ).then((_) => setState(() {})); // Refresh nach Hinzufügen
  }

  Future<void> _toggleFavorite(String trainingId, bool isFavorite) async {
    final user = FirebaseAuth.instance.currentUser;
    if (user == null) return;
    if (isFavorite) {
      await FirebaseFirestore.instance.collection('User').doc(user.uid).update({
        'favorites': FieldValue.arrayRemove([trainingId]),
      });
    } else {
      await FirebaseFirestore.instance.collection('User').doc(user.uid).update({
        'favorites': FieldValue.arrayUnion([trainingId]),
      });
    }
    await _loadFavorites(); // Aktualisiere die Favoriten nach dem Toggle
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('Übungen'),
        actions: [
          if (widget.selectMode)
            IconButton(
              icon: const Icon(Icons.close),
              onPressed: () => Navigator.pop(context),
            ),
          if (_isTrainer && !widget.selectMode)
            IconButton(
              icon: const Icon(Icons.add),
              onPressed: () => _showCreateTrainingDialog(context),
            ),
        ],
      ),
      body: Column(
        children: [
          Padding(
            padding: const EdgeInsets.all(8.0),
            child: TextField(
              controller: _searchController,
              decoration: InputDecoration(
                hintText: 'Suche nach Übungen...',
                prefixIcon: const Icon(Icons.search),
                border: OutlineInputBorder(
                  borderRadius: BorderRadius.circular(10),
                ),
              ),
            ),
          ),
          if (widget.selectMode && widget.remainingTime != null)
            Padding(
              padding: const EdgeInsets.symmetric(horizontal: 16.0),
              child: Text(
                'Verbleibende Zeit: ${widget.remainingTime} Minuten',
                style: const TextStyle(
                  color: Colors.grey,
                  fontWeight: FontWeight.bold,
                ),
              ),
            ),
          Padding(
            padding: const EdgeInsets.all(16.0),
            child: Column(
              crossAxisAlignment: CrossAxisAlignment.start,
              children: [
                const Text(
                  'Kategorien',
                  style: TextStyle(fontSize: 20, fontWeight: FontWeight.bold),
                ),
                const SizedBox(height: 16),
                Wrap(
                  spacing: 8,
                  runSpacing: 8,
                  children: _categories.map((category) {
                    return FilterChip(
                      label: Text(category),
                      selected: _selectedCategory == category,
                      onSelected: (bool selected) {
                        setState(() {
                          _selectedCategory = selected ? category : null;
                        });
                      },
                    );
                  }).toList(),
                ),
              ],
            ),
          ),
          Expanded(
            child: FutureBuilder<QuerySnapshot>(
              future: FirebaseFirestore.instance.collection('Training').get(),
              builder: (context, snapshot) {
                if (snapshot.connectionState == ConnectionState.waiting) {
                  return const Center(child: CircularProgressIndicator());
                }

                if (snapshot.hasError) {
                  return Center(child: Text('Fehler: ${snapshot.error}'));
                }

                if (!snapshot.hasData || snapshot.data!.docs.isEmpty) {
                  return const Center(child: Text('Keine Übungen gefunden'));
                }

                var exercises = snapshot.data!.docs.where((doc) {
                  final data = doc.data() as Map<String, dynamic>;
                  final title = data['title']?.toString().toLowerCase() ?? '';
                  final description = data['description']?.toString().toLowerCase() ?? '';
                  final category = data['category']?.toString() ?? '';
                  final searchTerm = _searchTerm.toLowerCase();
                  
                  final matchesSearch = title.contains(searchTerm) || description.contains(searchTerm);
                  final matchesCategory = _selectedCategory == null || category == _selectedCategory;
                  
                  return matchesSearch && matchesCategory;
                }).toList();

                if (exercises.isEmpty) {
                  return const Center(child: Text('Keine Übungen gefunden'));
                }

                return GridView.builder(
                  padding: const EdgeInsets.all(8),
                  gridDelegate: const SliverGridDelegateWithMaxCrossAxisExtent(
                    maxCrossAxisExtent: 300,
                    childAspectRatio: 0.75,
                    crossAxisSpacing: 10,
                    mainAxisSpacing: 10,
                  ),
                  itemCount: exercises.length,
                  itemBuilder: (context, index) {
                    final doc = exercises[index];
                    final data = doc.data() as Map<String, dynamic>;
                    final duration = (data['duration'] as num?)?.toInt() ?? 0;
                    final isDisabled = widget.selectMode && duration > (widget.remainingTime ?? 0);

                    return Card(
                      child: Stack(
                        children: [
                          InkWell(
                            onTap: isDisabled
                                ? null
                                : () {
                                    if (widget.selectMode) {
                                      Navigator.pop(context, {
                                        'id': doc.id,
                                        'title': data['title']?.toString() ?? 'Unbekannte Übung',
                                        'description': data['description']?.toString() ?? '',
                                        'duration': duration,
                                      });
                                    } else {
                                      Navigator.push(
                                        context,
                                        MaterialPageRoute(
                                          builder: (context) => TrainingDetailScreen(trainingId: doc.id),
                                        ),
                                      );
                                    }
                                  },
                            child: Column(
                              crossAxisAlignment: CrossAxisAlignment.stretch,
                              children: [
                                Expanded(
                                  child: Container(
                                    color: Colors.grey[200],
                                    child: const Center(
                                      child: Icon(Icons.fitness_center, size: 50),
                                    ),
                                  ),
                                ),
                                Padding(
                                  padding: const EdgeInsets.all(8.0),
                                  child: Column(
                                    crossAxisAlignment: CrossAxisAlignment.start,
                                    children: [
                                      Text(
                                        data['title']?.toString() ?? 'Unbekannte Übung',
                                        style: const TextStyle(
                                          fontWeight: FontWeight.bold,
                                          fontSize: 16,
                                        ),
                                        maxLines: 2,
                                        overflow: TextOverflow.ellipsis,
                                      ),
                                      const SizedBox(height: 4),
                                      Row(
                                        children: [
                                          const Icon(Icons.star, color: Colors.amber, size: 16),
                                          const SizedBox(width: 4),
                                          Text(
                                            (data['rating overall'] ?? 0.0).toStringAsFixed(1),
                                            style: const TextStyle(fontSize: 12),
                                          ),
                                        ],
                                      ),
                                      const SizedBox(height: 4),
                                      Text(
                                        'Dauer: ${duration} Minuten',
                                        style: const TextStyle(fontSize: 12, color: Colors.grey),
                                      ),
                                      if (isDisabled)
                                        const Padding(
                                          padding: EdgeInsets.only(top: 4),
                                          child: Text(
                                            'Passt nicht in die verbleibende Zeit',
                                            style: TextStyle(
                                              color: Colors.orange,
                                              fontSize: 12,
                                            ),
                                          ),
                                        ),
                                    ],
                                  ),
                                ),
                              ],
                            ),
                          ),
                          Positioned(
                            top: 4,
                            right: 4,
                            child: IconButton(
                              icon: Icon(
                                _favorites.contains(doc.id) ? Icons.favorite : Icons.favorite_border,
                                color: _favorites.contains(doc.id) ? Colors.red : Colors.grey,
                              ),
                              onPressed: () => _toggleFavorite(doc.id, _favorites.contains(doc.id)),
                            ),
                          ),
                        ],
                      ),
                    );
                  },
                );
              },
            ),
          ),
        ],
      ),
    );
  }

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

class _CreateTrainingDialog extends StatefulWidget {
  final List<String> categories;
  const _CreateTrainingDialog({required this.categories});

  @override
  State<_CreateTrainingDialog> createState() => _CreateTrainingDialogState();
}

class _CreateTrainingDialogState extends State<_CreateTrainingDialog> {
  final _formKey = GlobalKey<FormState>();
  String? _category;
  String? _title;
  String? _description;
  int? _duration;
  String? _year;
  bool _loading = false;
  File? _imageFile;
  final _picker = ImagePicker();

  Future<void> _pickImage() async {
    final pickedFile = await _picker.pickImage(source: ImageSource.gallery);
    if (pickedFile != null) {
      setState(() {
        _imageFile = File(pickedFile.path);
      });
    }
  }

  Future<String?> _uploadImage() async {
    if (_imageFile == null) return null;
    
    final storageRef = FirebaseStorage.instance
        .ref()
        .child('training_images')
        .child('${DateTime.now().millisecondsSinceEpoch}.jpg');
    
    try {
      final uploadTask = await storageRef.putFile(_imageFile!);
      return await uploadTask.ref.getDownloadURL();
    } catch (e) {
      print('Error uploading image: $e');
      return null;
    }
  }

  @override
  Widget build(BuildContext context) {
    return AlertDialog(
      title: const Text('Neues Training erstellen'),
      content: SingleChildScrollView(
        child: Form(
          key: _formKey,
          child: Column(
            mainAxisSize: MainAxisSize.min,
            children: [
              if (_imageFile != null)
                Container(
                  height: 200,
                  width: double.infinity,
                  margin: const EdgeInsets.only(bottom: 16),
                  decoration: BoxDecoration(
                    image: DecorationImage(
                      image: FileImage(_imageFile!),
                      fit: BoxFit.cover,
                    ),
                  ),
                ),
              ElevatedButton.icon(
                onPressed: _pickImage,
                icon: const Icon(Icons.image),
                label: Text(_imageFile == null ? 'Bild auswählen' : 'Bild ändern'),
              ),
              const SizedBox(height: 16),
              DropdownButtonFormField<String>(
                value: _category,
                items: widget.categories
                    .map((cat) => DropdownMenuItem(value: cat, child: Text(cat)))
                    .toList(),
                onChanged: (v) => setState(() => _category = v),
                decoration: const InputDecoration(labelText: 'Kategorie'),
                validator: (v) => v == null ? 'Kategorie wählen' : null,
              ),
              TextFormField(
                decoration: const InputDecoration(labelText: 'Titel'),
                onChanged: (v) => _title = v,
                validator: (v) => v == null || v.isEmpty ? 'Titel angeben' : null,
              ),
              TextFormField(
                decoration: const InputDecoration(labelText: 'Beschreibung'),
                onChanged: (v) => _description = v,
                validator: (v) => v == null || v.isEmpty ? 'Beschreibung angeben' : null,
                maxLines: 2,
              ),
              TextFormField(
                decoration: const InputDecoration(labelText: 'Dauer (Minuten)'),
                keyboardType: TextInputType.number,
                onChanged: (v) => _duration = int.tryParse(v),
                validator: (v) => v == null || int.tryParse(v) == null ? 'Zahl angeben' : null,
              ),
              TextFormField(
                decoration: const InputDecoration(labelText: 'Schwierigkeitslevel'),
                onChanged: (v) => _year = v,
                validator: (v) => v == null || v.isEmpty ? 'Level angeben' : null,
              ),
            ],
          ),
        ),
      ),
      actions: [
        TextButton(
          onPressed: _loading ? null : () => Navigator.pop(context),
          child: const Text('Abbrechen'),
        ),
        ElevatedButton(
          onPressed: _loading
              ? null
              : () async {
                  if (_formKey.currentState!.validate()) {
                    setState(() => _loading = true);
                    try {
                      final imageUrl = await _uploadImage();
                      await FirebaseFirestore.instance.collection('Training').add({
                        'category': _category,
                        'title': _title,
                        'description': _description,
                        'duration': _duration,
                        'picture': imageUrl,
                        'rating overall': 0.0,
                        'year': _year,
                        'ratings': [], // Array für einzelne Bewertungen
                      });
                      Navigator.pop(context);
                    } catch (e) {
                      ScaffoldMessenger.of(context).showSnackBar(
                        SnackBar(content: Text('Fehler beim Erstellen: $e')),
                      );
                    } finally {
                      setState(() => _loading = false);
                    }
                  }
                },
          child: _loading ? const CircularProgressIndicator() : const Text('Erstellen'),
        ),
      ],
    );
  }
}
