import 'package:flutter/foundation.dart';

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

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

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

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

  /// Uniquement les récompenses proposées (actives), triées par coût croissant.
  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 supabase.from('recompenses').select().order('cout_points');
      _recompenses
        ..clear()
        ..addAll((rows as List).map((e) => Recompense.fromMap(e)));
      _charge = true;
      notifyListeners();
    } catch (_) {
      // Ignore si non connecté ; sera rechargé après connexion.
    }
  }

  Future<Recompense> creer(
      {required String nom, required double coutPoints}) async {
    final row = await supabase
        .from('recompenses')
        .insert({'nom': nom.trim(), 'cout_points': coutPoints, 'actif': true})
        .select()
        .single();
    final cree = Recompense.fromMap(row);
    _recompenses.add(cree);
    _trier();
    notifyListeners();
    return cree;
  }

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

  Future<void> supprimer(String id) async {
    await supabase.from('recompenses').delete().eq('id', id);
    _recompenses.removeWhere((e) => e.id == id);
    notifyListeners();
  }

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