import 'dart:async';
import 'dart:developer';

import 'package:mnemo_cards/features/packs/pack_cache_manager.dart';
import 'package:mnemo_cards/features/packs/packs_api.dart';
import 'package:mnemo_cards/features/packs/preview_pack_holder.dart';
import 'package:mnemo_cards/managers/repository/repository.dart';
import 'package:mnemo_cards/utils/iterable_helper.dart';
import 'package:mnemo_cards_common/mnemo_cards_common.dart';
import 'package:rxdart/rxdart.dart';

import 'pack_holder.dart';

class PackManager {
  final Repository _repository;
  final PacksApi _packsApi;
  final PackHolder _packHolder;
  final PreviewPackHolder _previewPackHolder;
  final PackCacheManager _cacheManager;

  PackManager(
    this._repository,
    this._packsApi,
    this._packHolder,
    this._previewPackHolder,
    this._cacheManager,
  );

  Future<void> init() async {
    _packHolder.setPacks(await _cacheManager.loadAllPacks());

    // _repository.userStream.map((u) => u.packs).distinct().listen((packs) async {
    //   final savedPacks = await savedPacksIds;
    //   for (final p in packs) {
    //     if (savedPacks.contains(p)) {
    //       final loaded = await loadPackFromCache(p);
    //       if (loaded.cards.isEmpty) {
    //         await downloadPackById(p);
    //       }
    //     } else {
    //       await downloadPackById(p);
    //     }
    //   }
    // });
  }

  Stream<GetCardPackResponse> getCardPackStream(String id) async* {
    try {
      yield await _cacheManager.loadPackFromCache(id);
    } catch (err) {
      log(err.toString());
      log('Cant load pack from cache, fetching pack');
      try {
        final dto = await _packsApi.getPackDto(id).catchError((_) => null);
        if (dto != null) {
          yield dto;
        } else {
          final buyDto = await _packsApi.getPackBuy(id);
          if (buyDto != null) {
            yield buyDto;
          }
        }
      } catch (err) {
        log(err.toString());
      }
    }
    yield* _packHolder.asStream
        .map((event) =>
            event?.packsWithCards.firstWhereOrNull((p) => p.id == id))
        .whereNotNull();
  }

  Future<void> clearCache() async {
    _packHolder.clear();
    await _cacheManager.clearCache();
  }

  Stream<List<CardPackDto>?> get packsStream =>
      _packHolder.asStream.map((event) => event?.packsWithCards);

  Stream<List<CardPackPreviewDto>?> get packsPreviewStream =>
      _previewPackHolder.asStream
          .map((event) => event?.previewPacks)
          .whereNotNull()
          .distinct((prev, next) {
        if (prev.length != next.length) return false;
        for (int i = 0; i < prev.length; i++) {
          if (prev[i].isAvailable != next[i].isAvailable) return false;
          if (prev[i].id != next[i].id) return false;
          if (prev[i].version != next[i].version) return false;
          if (prev[i].price != next[i].price) return false;
        }
        return true;
      });
}