import 'package:flutter/foundation.dart';

import '../models/recompense.dart';
import '../pocketbase_config.dart';

/// Source de vérité du catalogue de récompenses (collection `recompenses`).
class RecompenseRepository extends ChangeNotifier {
  RecompenseRepository._();
  static final RecompenseRepository instance = RecompenseRepository._();

  final List<Recompense> _recompenses = [];
  bool _charge = false;
  bool _abonne = false;

  List<Recompense> get recompenses => List.unmodifiable(_recompenses);

  List<Recompense> get actives {
    final l = _recompenses.where((r) => r.actif).toList()
      ..sort((a, b) => a.coutPoints.compareTo(b.coutPoints));
    return l;
  }

  bool get charge => _charge;

  Future<void> charger() async {
    try {
      final rows =
          await pb.collection('recompenses').getFullList(sort: 'cout_points');
      _recompenses
        ..clear()
        ..addAll(rows.map((r) => Recompense.fromMap(r.toJson())));
      _charge = true;
      notifyListeners();
      await _sabonner();
    } catch (_) {
      // Ignoré si non connecté ; rechargé après connexion.
    }
  }

  /// Abonnement temps réel au catalogue (synchronisé entre appareils).
  Future<void> _sabonner() async {
    if (_abonne) return;
    _abonne = true;
    try {
      await pb.collection('recompenses').subscribe('*', (e) {
        final rec = e.record;
        if (rec == null) return;
        if (e.action == 'delete') {
          _recompenses.removeWhere((x) => x.id == rec.id);
        } else {
          final r = Recompense.fromMap(rec.toJson());
          final i = _recompenses.indexWhere((x) => x.id == r.id);
          if (i == -1) {
            _recompenses.add(r);
          } else {
            _recompenses[i] = r;
          }
          _trier();
        }
        notifyListeners();
      });
    } catch (_) {
      _abonne = false;
    }
  }

  Future<Recompense> creer(
      {required String nom, required double coutPoints}) async {
    final rec = await pb.collection('recompenses').create(body: {
      'nom': nom.trim(),
      'cout_points': coutPoints,
      'actif': true,
    });
    final cree = Recompense.fromMap(rec.toJson());
    _recompenses.add(cree);
    _trier();
    notifyListeners();
    return cree;
  }

  Future<void> modifier(Recompense r) async {
    await pb.collection('recompenses').update(r.id, body: {
      'nom': r.nom.trim(),
      'cout_points': r.coutPoints,
      'actif': r.actif,
    });
    final i = _recompenses.indexWhere((e) => e.id == r.id);
    if (i != -1) _recompenses[i] = r;
    _trier();
    notifyListeners();
  }

  Future<void> supprimer(String id) async {
    await pb.collection('recompenses').delete(id);
    _recompenses.removeWhere((e) => e.id == id);
    notifyListeners();
  }

  void _trier() =>
      _recompenses.sort((a, b) => a.coutPoints.compareTo(b.coutPoints));
}