import 'package:cloud_firestore/cloud_firestore.dart';
import 'package:firebase_storage/firebase_storage.dart';
import 'dart:io';
import '../data/models/expense.dart';

class CountRepository {
  final FirebaseFirestore _firestore;
  final FirebaseStorage _storage;

  CountRepository({
    FirebaseFirestore? firestore,
    FirebaseStorage? storage,
  })  : _firestore = firestore ?? FirebaseFirestore.instance,
        _storage = storage ?? FirebaseStorage.instance;

  // Créer une dépense
  Future<String> createExpense(Expense expense) async {
    final docRef = await _firestore
        .collection('groups')
        .doc(expense.groupId)
        .collection('expenses')
        .add(expense.toMap());
    
    return docRef.id;
  }

  // Mettre à jour une dépense
  Future<void> updateExpense(String groupId, Expense expense) async {
    await _firestore
        .collection('groups')
        .doc(groupId)
        .collection('expenses')
        .doc(expense.id)
        .update(expense.toMap());
  }

  // Supprimer une dépense
  Future<void> deleteExpense(String groupId, String expenseId) async {
    final expense = await _firestore
        .collection('groups')
        .doc(groupId)
        .collection('expenses')
        .doc(expenseId)
        .get();

    final data = expense.data();
    if (data != null && data['receiptUrl'] != null) {
      await deleteReceipt(data['receiptUrl']);
    }

    await _firestore
        .collection('groups')
        .doc(groupId)
        .collection('expenses')
        .doc(expenseId)
        .delete();
  }

  // Archiver une dépense
  Future<void> archiveExpense(String groupId, String expenseId) async {
    await _firestore
        .collection('groups')
        .doc(groupId)
        .collection('expenses')
        .doc(expenseId)
        .update({'isArchived': true});
  }

  // Marquer une split comme payée
  Future<void> markSplitAsPaid({
    required String groupId,
    required String expenseId,
    required String userId,
  }) async {
    final doc = await _firestore
        .collection('groups')
        .doc(groupId)
        .collection('expenses')
        .doc(expenseId)
        .get();

    final expense = Expense.fromFirestore(doc);
    final updatedSplits = expense.splits.map((split) {
      if (split.userId == userId) {
        return ExpenseSplit(
          userId: split.userId,
          userName: split.userName,
          amount: split.amount,
          isPaid: true,
        );
      }
      return split;
    }).toList();

    await _firestore
        .collection('groups')
        .doc(groupId)
        .collection('expenses')
        .doc(expenseId)
        .update({
      'splits': updatedSplits.map((s) => s.toMap()).toList(),
    });
  }

  // Stream des dépenses d'un groupe
  Stream<List<Expense>> getExpensesStream(String groupId, {bool includeArchived = false}) {
    Query query = _firestore
        .collection('groups')
        .doc(groupId)
        .collection('expenses')
        .orderBy('date', descending: true);

    if (!includeArchived) {
      query = query.where('isArchived', isEqualTo: false);
    }

    return query.snapshots().map((snapshot) {
      return snapshot.docs.map((doc) => Expense.fromFirestore(doc)).toList();
    });
  }

  // Uploader un reçu
  Future<String> uploadReceipt(String groupId, String expenseId, File imageFile) async {
    final fileName = 'receipts/$groupId/$expenseId/${DateTime.now().millisecondsSinceEpoch}.jpg';
    final ref = _storage.ref().child(fileName);
    
    final uploadTask = await ref.putFile(imageFile);
    return await uploadTask.ref.getDownloadURL();
  }

  // Supprimer un reçu
  Future<void> deleteReceipt(String receiptUrl) async {
    try {
      final ref = _storage.refFromURL(receiptUrl);
      await ref.delete();
    } catch (e) {
      // Le fichier n'existe peut-être plus
      print('Erreur lors de la suppression du reçu: $e');
    }
  }

  // Obtenir les taux de change (API externe ou valeurs fixes)
  Future<Map<ExpenseCurrency, double>> getExchangeRates() async {
    // TODO: Intégrer une API de taux de change réels
    // Pour l'instant, valeurs approximatives
    return {
      ExpenseCurrency.eur: 1.0,
      ExpenseCurrency.usd: 0.92,
      ExpenseCurrency.gbp: 1.17,
      ExpenseCurrency.jpy: 0.0062,
      ExpenseCurrency.chf: 1.05,
      ExpenseCurrency.cad: 0.68,
      ExpenseCurrency.aud: 0.61,
    };
  }

  // Convertir un montant en EUR
  Future<double> convertToEur(double amount, ExpenseCurrency currency) async {
    if (currency == ExpenseCurrency.eur) return amount;
    
    final rates = await getExchangeRates();
    final rate = rates[currency] ?? 1.0;
    return amount * rate;
  }
}