import 'dart:async';
import 'package:fikoyt_ui/fikoyt_ui.dart';
import 'package:isar/isar.dart';

abstract class IsarKokSinif<T> {
  late Isar isar;

  RxList<T> liste = RxList<T>([]);
  bool yukleniyor = false;
  bool hepsiYuklendi = false;
  int sayi = 3;
  int limit = 3;
  int offset = 0;
  String aramaMetni = '';
  String? siralamaAlani = '';
  bool siralamaTers = false;

  int veriSayisi = 0;

  StreamSubscription<List<T>>? _subscription;

  dynamic get aktifKullanici => null;

  Isar getIsar();
  IsarCollection<T> get koleksiyon;
  QueryBuilder<T, T, QAfterFilterCondition> getQuery();

  QueryBuilder<T, T, QAfterFilterCondition> applyAramaFiltre(QueryBuilder<T, T, QAfterFilterCondition> q, String arama) {
    return q;
  }

  Map<String, QueryBuilder<T, T, QAfterFilterCondition> Function(QueryBuilder<T, T, QAfterFilterCondition>, bool)>
  getSiralamaFonksiyonlari() {
    return {};
  }

  QueryBuilder<T, T, QAfterFilterCondition> applySiralama(QueryBuilder<T, T, QAfterFilterCondition> q) {
    final siralama = siralamaAlani ?? '';
    final ters = siralamaTers;
    final fonksiyonlar = getSiralamaFonksiyonlari();

    if (siralama.isNotEmpty && fonksiyonlar.containsKey(siralama)) {
      return fonksiyonlar[siralama]!(q, ters);
    }

    return q;
  }

  Future<void> iliskileriYukle(List<T> liste) async {}

  IsarKokSinif() {
    isar = getIsar();
    _veriyiIzle();
    ilkYukleme();
  }

  Future<void> _veriyiIzle() async {
    await _subscription?.cancel();
    final q = applySiralama(applyAramaFiltre(getQuery(), aramaMetni));
    _subscription = q.watch(fireImmediately: true).listen((veriler) async {
      final gosterilecek = veriler.take(offset).toList();
      await iliskileriYukle(gosterilecek);
      liste.value = gosterilecek;
      hepsiYuklendi = gosterilecek.length >= veriler.length;
    });
    veriSayisi = await q.count();
  }

  Future<void> ilkYukleme() async {
    offset = limit;
    hepsiYuklendi = false;
    await dahaFazla();
  }

  bool get dahaAzGoster => liste.length > sayi;

  Future<void> dahaAz() async {
    yukleniyor = true;
    offset = liste.length - sayi;
    if (offset < sayi) offset = sayi;
    hepsiYuklendi = false;
    await _veriyiIzle();
    yukleniyor = false;
  }

  bool get dahaSifirlaGoster => liste.length > sayi;

  Future<void> dahaSifirla() async {
    yukleniyor = true;
    offset = sayi;
    hepsiYuklendi = false;
    await _veriyiIzle();
    yukleniyor = false;
  }

  bool get dahaFazlaGoster => veriSayisi > liste.length;

  Future<void> dahaFazla() async {
    if (yukleniyor || hepsiYuklendi) return;
    yukleniyor = true;

    final q = applySiralama(applyAramaFiltre(getQuery(), aramaMetni)).offset(liste.length).limit(sayi);

    final yeniVeri = await q.findAll();
    await iliskileriYukle(yeniVeri);

    liste.addAll(yeniVeri);
    if (yeniVeri.length < sayi) hepsiYuklendi = true;

    offset = liste.length;
    yukleniyor = false;
  }

  Future<void> listeyiYenile() async {
    yukleniyor = true;
    offset = liste.length;
    hepsiYuklendi = false;
    await _veriyiIzle();
    yukleniyor = false;
  }

  Future<void> listeyiSifirla() async {
    yukleniyor = true;
    offset = sayi;
    limit = sayi;
    hepsiYuklendi = false;
    yukleniyor = false;
  }

  Timer? debounceTimer;

  void aramaYap(String yeniMetin) {
    debounceTimer?.cancel();

    debounceTimer = Timer(const Duration(milliseconds: 0), () async {
      aramaMetni = yeniMetin;
      await listeyiYenile();
      await dahaSifirla();
      debounceTimer?.cancel();
    });
  }

  void siralamaAyarla(String alan, {bool ters = false}) {
    siralamaAlani = alan;
    siralamaTers = ters;
    listeyiYenile();
  }

  Future<List<T>> getList({
    int? offset,
    int? limit,
    String? arama,
    String? siralama,
    bool siralamaTers = false,
    bool iliskileriYukle = true,
  }) async {
    var q = getQuery();

    if (arama != null && arama.isNotEmpty) {
      q = applyAramaFiltre(q, arama);
    }

    final fonksiyonlar = getSiralamaFonksiyonlari();
    if (siralama != null && siralama.isNotEmpty && fonksiyonlar.containsKey(siralama)) {
      q = fonksiyonlar[siralama]!(q, siralamaTers);
    }

    if (offset != null) q = q.offset(offset) as QueryBuilder<T, T, QAfterFilterCondition>;
    if (limit != null) q = q.limit(limit) as QueryBuilder<T, T, QAfterFilterCondition>;

    final sonuc = await q.findAll();
    if (iliskileriYukle) await this.iliskileriYukle(sonuc);

    return sonuc;
  }

  Future<dynamic> beforeEkle(T item) async => item;

  Future<void> ekle(T item) async {
    await isar.writeTxn(() async {
      item = await beforeEkle(item);
      if (item == null) {
        await listeyiYenile();
        return;
      }
      await koleksiyon.put(item);
      await afterEkle(item);
    });
    await listeyiYenile();
  }

  Future<void> afterEkle(T item) async {}

  Future<void> guncelle(T item) async {
    await isar.writeTxn(() => koleksiyon.put(item));
    await listeyiYenile();
  }

  Future<void> sil(Id id) async {
    await isar.writeTxn(() => koleksiyon.delete(id));
    await listeyiYenile();
  }

  Future<T?> getir(Id id) async => await koleksiyon.get(id);

  Future<void> topluEkle(List<T> veri) async {
    await isar.writeTxn(() async {
      await koleksiyon.putAll(veri);
    });
    await listeyiYenile();
  }

  Future<void> topluGuncelle(List<T> veri) async {
    await isar.writeTxn(() async {
      await koleksiyon.putAll(veri);
    });
    await listeyiYenile();
  }

  void dispose() {
    _subscription?.cancel();
  }
}