feet/lib/api/cache.dart

part of fever_api;

/// Caches items, feeds and groups
class APICache {
  final FeverAPI api;

  late final ItemCache items;
  late final ObjectCache<int, Feed> feeds;
  late final ObjectCache<int, Group> groups;
  late final ObjectCache<int, Favicon> favicons;
  final List<FeedsGroup> feedsGroups = [];

  APICache(this.api) {
    items = ItemCache(api);
    feeds = ObjectCache(api);
    groups = ObjectCache(api);
    favicons = ObjectCache(api);
  }

  /// Returns the ids of all feeds that belong to the given group.
  ///
  /// Falls back to an empty list if the group exists but no feeds have been
  /// fetched yet. Feeds that do not exist in the cache (deleted or not fetched
  /// yet) are skipped, so the result never contains stale feed ids.
  List<int> feedsInGroup(int groupId) {
    final feedIds = <int>{};

    for (final feedsGroup in feedsGroups) {
      if (feedsGroup.groupId != groupId) continue;

      for (final feedId in feedsGroup.feedIds) {
        if (feeds.get(feedId) != null) feedIds.add(feedId);
      }
    }

    return feedIds.toList();
  }

  void clear() {
    items._items.clear();
    feeds._items.clear();
    groups._items.clear();
    favicons._items.clear();
    feedsGroups.clear();
  }
}

class ObjectCache<K, T> {
  final FeverAPI api;
  final Map<K, T> _items = {};

  ObjectCache(this.api);

  /// Returns an item from the cache, or null if it doesn't exist
  T? get(K key) {
    return _items.containsKey(key) ? _items[key] : null;
  }

  /// Returns a copy of the cache content
  Map<K, T> getAll() {
    return {..._items};
  }

  void set(K key, T value) {
    _items[key] = value;
  }

  int get size => _items.length;
}

class ItemCache extends ObjectCache<int, Item> {
  /// Get all items for a given feed
  List<Item> getForFeed(int feed) {
    if (api.cache.feeds.get(feed) == null) {
      throw Exception('Feed $feed doesn\'t exist');
    }
    return _items.values.where((item) => item.feedId == feed).toList();
  }

  ItemCache(FeverAPI api) : super(api);
}