import 'package:flutter_test/flutter_test.dart';
import 'package:melo/services/cache_manager.dart';

CacheEintrag _e(String pfad, int groesse, int geaendertMs) =>
    CacheEintrag(pfad: pfad, groesse: groesse, geaendertMs: geaendertMs);

/// Der Zwischenspeicher wuchs bisher unbegrenzt — es gab nur „alles löschen".
/// Diese Regel entscheidet, was wegmuss: am längsten nicht gehört zuerst.
void main() {
  group('zuVerdraengen', () {
    test('unter der Grenze fällt nichts weg', () {
      final weg = zuVerdraengen([_e('a', 100, 1), _e('b', 100, 2)], 500);

      expect(weg, isEmpty);
    });

    test('genau auf der Grenze fällt nichts weg', () {
      final weg = zuVerdraengen([_e('a', 200, 1), _e('b', 300, 2)], 500);

      expect(weg, isEmpty);
    });

    test('der älteste Eintrag geht zuerst', () {
      // 3 × 200 = 600 bei Grenze 500: einer muss weg, der mit dem
      // kleinsten Zeitstempel.
      final weg = zuVerdraengen(
        [_e('neu', 200, 30), _e('alt', 200, 10), _e('mittel', 200, 20)],
        500,
      );

      expect(weg, ['alt']);
    });

    test('es fällt so viel weg, bis die Grenze eingehalten ist', () {
      // 4 × 200 = 800 bei Grenze 300: zwei reichen nicht, drei müssen weg.
      final weg = zuVerdraengen(
        [_e('a', 200, 1), _e('b', 200, 2), _e('c', 200, 3), _e('d', 200, 4)],
        300,
      );

      expect(weg, ['a', 'b', 'c']);
    });

    test('Grenze 0 räumt alles weg', () {
      final weg = zuVerdraengen([_e('a', 1, 1), _e('b', 1, 2)], 0);

      expect(weg, ['a', 'b']);
    });

    test('eine negative Grenze wird wie 0 behandelt', () {
      expect(zuVerdraengen([_e('a', 1, 1)], -5), ['a']);
    });

    test('bei gleichem Zeitstempel entscheidet der Pfad — nie zufällig', () {
      final weg = zuVerdraengen([_e('b', 200, 7), _e('a', 200, 7)], 200);

      expect(weg, ['a']);
    });

    test('ein leerer Zwischenspeicher ergibt nichts zu tun', () {
      expect(zuVerdraengen(const [], 100), isEmpty);
    });

    test('lässt die Ausgangsliste unverändert', () {
      final eintraege = [_e('b', 200, 2), _e('a', 200, 1)];

      zuVerdraengen(eintraege, 100);

      expect(eintraege.map((e) => e.pfad), ['b', 'a']);
    });
  });

  group('geschützte Dateien', () {
    test('eine benutzte Datei bleibt liegen, auch wenn sie die älteste ist', () {
      // Der schwerste Fall: die Warteschlange hat den Pfad schon fest als
      // Quelle eingetragen. Wird die Datei gelöscht, bricht die Wiedergabe
      // mitten im Album ab — ohne Rückfall aufs Streamen.
      final weg = zuVerdraengen(
        [_e('laeuft', 200, 1), _e('alt', 200, 2), _e('neu', 200, 3)],
        200,
        geschuetzt: {'laeuft'},
      );

      expect(weg, isNot(contains('laeuft')));
      expect(weg, ['alt', 'neu']);
    });

    test('lieber über der Grenze bleiben als die Wiedergabe abwürgen', () {
      // Alles geschützt: dann wird eben nichts frei. Die Grenze greift beim
      // nächsten Mal wieder.
      final weg = zuVerdraengen(
        [_e('a', 500, 1), _e('b', 500, 2)],
        100,
        geschuetzt: {'a', 'b'},
      );

      expect(weg, isEmpty);
    });

    test('ohne Schutzliste verhält es sich wie zuvor', () {
      final weg = zuVerdraengen([_e('a', 200, 1), _e('b', 200, 2)], 200);

      expect(weg, ['a']);
    });

    test('ein geschützter Pfad, den es gar nicht gibt, stört nicht', () {
      final weg = zuVerdraengen(
        [_e('a', 200, 1), _e('b', 200, 2)],
        200,
        geschuetzt: {'gibtesnicht'},
      );

      expect(weg, ['a']);
    });
  });
}