mangayomi-mirror/lib/views/library/providers/library_state_provider.dart

import 'dart:developer';

import 'package:mangayomi/models/manga.dart';
import 'package:mangayomi/providers/hive_provider.dart';
import 'package:riverpod_annotation/riverpod_annotation.dart';
part 'library_state_provider.g.dart';

@riverpod
class LibraryReverseListState extends _$LibraryReverseListState {
  @override
  bool build() {
    return ref
        .watch(hiveBoxSettingsProvider)
        .get('libraryReverseList', defaultValue: false)!;
  }

  void set(bool value) {
    state = value;
    ref.watch(hiveBoxSettingsProvider).put('libraryReverseList', value);
  }
}

@riverpod
class LibraryDisplayTypeState extends _$LibraryDisplayTypeState {
  @override
  String build() {
    return ref
        .watch(hiveBoxSettingsProvider)
        .get('displayType', defaultValue: DisplayType.coverOnlyGrid.name)!;
  }

  DisplayType getLibraryDisplayTypeValue(String value) {
    return value == DisplayType.compactGrid.name
        ? DisplayType.compactGrid
        : value == DisplayType.list.name
            ? DisplayType.list
            : value == DisplayType.comfortableGrid.name
                ? DisplayType.comfortableGrid
                : DisplayType.coverOnlyGrid;
  }

  String getLibraryDisplayTypeName(String displayType) {
    return displayType == DisplayType.compactGrid.name
        ? 'Compact grid'
        : displayType == DisplayType.list.name
            ? 'List'
            : displayType == DisplayType.comfortableGrid.name
                ? 'Comfortable grid'
                : 'Cover-only grid';
  }

  void setLibraryDisplayType(DisplayType displayType) {
    state = displayType.name;
    ref.watch(hiveBoxSettingsProvider).put('displayType', displayType.name);
  }
}

enum DisplayType {
  compactGrid,
  comfortableGrid,
  coverOnlyGrid,
  list,
}

@riverpod
class MangaFilterDownloadedState extends _$MangaFilterDownloadedState {
  @override
  int build({required List<Manga> mangaList}) {
    state = getType();
    return getType();
  }

  int getType() {
    return ref
        .watch(hiveBoxSettingsProvider)
        .get("filterMangasDownload", defaultValue: 0);
  }

  void setType(int type) {
    ref.watch(hiveBoxSettingsProvider).put("filterMangasDownload", type);
    state = type;
  }

  update() {
    if (state == 0) {
      setType(1);
    } else if (state == 1) {
      setType(2);
    } else {
      setType(0);
    }
  }
}

@riverpod
class MangaFilterUnreadState extends _$MangaFilterUnreadState {
  @override
  int build({required List<Manga> mangaList}) {
    state = getType();
    return getType();
  }

  int getType() {
    return ref
        .watch(hiveBoxSettingsProvider)
        .get("filterMangasUnread", defaultValue: 0);
  }

  void setType(int type) {
    ref.watch(hiveBoxSettingsProvider).put("filterMangasUnread", type);
    state = type;
  }

  List<Manga> getData() {
    if (getType() == 1) {
      final data = mangaList.where((element) {
        List list = [];
        for (var chap in element.chapters) {
          if (!chap.isRead!) {
            list.add(true);
          }
        }
        return list.isNotEmpty;
      }).toList();
      return data;
    } else if (getType() == 2) {
      final data = mangaList.where((element) {
        List list = [];
        for (var chap in element.chapters) {
          if (chap.isRead!) {
            list.add(true);
          }
        }
        return list.length == element.chapters.length;
      }).toList();
      return data;
    } else {
      return mangaList;
    }
  }

   update() {
    if (state == 0) {
      final data = mangaList.where((element) {
        List list = [];
        for (var chap in element.chapters) {
          if (!chap.isRead!) {
            list.add(true);
          }
        }
        return list.isNotEmpty;
      }).toList();
      setType(1);
      return data;
    } else if (state == 1) {
      final data = mangaList.where((element) {
        List list = [];
        for (var chap in element.chapters) {
          if (chap.isRead!) {
            list.add(true);
          }
        }
        return list.length == element.chapters.length;
      }).toList();
      setType(2);
      return data;
    } else {
      setType(0);
      return mangaList;
    }
  }
}

@riverpod
class MangaFilterStartedState extends _$MangaFilterStartedState {
  @override
  int build({required List<Manga> mangaList}) {
    state = getType();
    return getType();
  }

  int getType() {
    return ref
        .watch(hiveBoxSettingsProvider)
        .get("filterMangasStarted", defaultValue: 0);
  }

  void setType(int type) {
    ref.watch(hiveBoxSettingsProvider).put("filterMangasStarted", type);
    state = type;
  }

  List<Manga> getData() {
    if (getType() == 1) {
      final data = mangaList.where((element) {
        List list = [];
        for (var chap in element.chapters) {
          if (!chap.isRead!) {
            list.add(true);
          }
        }
        return list.isNotEmpty;
      }).toList();
      return data;
    } else if (getType() == 2) {
      final data = mangaList.where((element) {
        List list = [];
        for (var chap in element.chapters) {
          if (chap.isRead!) {
            list.add(true);
          }
        }
        return list.length == element.chapters.length;
      }).toList();
      return data;
    } else {
      return mangaList;
    }
  }

  List<Manga> update() {
    if (state == 0) {
      final data = mangaList.where((element) {
        List list = [];
        for (var chap in element.chapters) {
          if (!chap.isRead!) {
            list.add(true);
          }
        }
        return list.isNotEmpty;
      }).toList();
      setType(1);
      return data;
    } else if (state == 1) {
      final data = mangaList.where((element) {
        List list = [];
        for (var chap in element.chapters) {
          if (chap.isRead!) {
            list.add(true);
          }
        }
        return list.length == element.chapters.length;
      }).toList();
      setType(2);
      return data;
    } else {
      setType(0);
      return mangaList;
    }
  }
}

@riverpod
class MangaFilterBookmarkedState extends _$MangaFilterBookmarkedState {
  @override
  int build({required List<Manga> mangaList}) {
    state = getType();
    return getType();
  }

  int getType() {
    return ref
        .watch(hiveBoxSettingsProvider)
        .get("filterMangasBookMarked", defaultValue: 0);
  }

  void setType(int type) {
    ref.watch(hiveBoxSettingsProvider).put("filterMangasBookMarked", type);
    state = type;
  }

  List<Manga> getData() {
    if (getType() == 1) {
      final data = mangaList.where((element) {
        List list = [];
        for (var chap in element.chapters) {
          if (chap.isBookmarked!) {
            list.add(true);
          }
        }
        return list.isNotEmpty;
      }).toList();
      return data;
    } else if (getType() == 2) {
      final data = mangaList.where((element) {
        List list = [];
        for (var chap in element.chapters) {
          if (!chap.isBookmarked!) {
            list.add(true);
          }
        }
        return list.length == element.chapters.length;
      }).toList();
      return data;
    } else {
      return mangaList;
    }
  }

  List<Manga> update() {
    if (state == 0) {
      final data = mangaList.where((element) {
        List list = [];
        for (var chap in element.chapters) {
          if (chap.isBookmarked!) {
            list.add(true);
          }
        }
        return list.isNotEmpty;
      }).toList();
      setType(1);
      return data;
    } else if (state == 1) {
      final data = mangaList.where((element) {
        List list = [];
        for (var chap in element.chapters) {
          if (!chap.isBookmarked!) {
            list.add(true);
          }
        }
        return list.length == element.chapters.length;
      }).toList();
      setType(2);
      return data;
    } else {
      setType(0);
      return mangaList;
    }
  }
}

@riverpod
class MangasFilterResultState extends _$MangasFilterResultState {
  @override
  bool build({required List<Manga> mangaList}) {
    final downloadFilterType =
        ref.watch(mangaFilterDownloadedStateProvider(mangaList: mangaList));
    final unreadFilterType =
        ref.watch(mangaFilterUnreadStateProvider(mangaList: mangaList));
    final startedFilterType =
        ref.watch(mangaFilterStartedStateProvider(mangaList: mangaList));
    final bookmarkedFilterType =
        ref.watch(mangaFilterBookmarkedStateProvider(mangaList: mangaList));
    return downloadFilterType == 0 &&
        unreadFilterType == 0 &&
        startedFilterType == 0 &&
        bookmarkedFilterType == 0;
  }
}

@riverpod
class LibraryShowCategoryTabsState extends _$LibraryShowCategoryTabsState {
  @override
  bool build() {
    return ref
        .watch(hiveBoxSettingsProvider)
        .get('libraryShowCategoryTabs', defaultValue: false)!;
  }

  void set(bool value) {
    state = value;
    ref.watch(hiveBoxSettingsProvider).put('libraryShowCategoryTabs', value);
  }
}

@riverpod
class LibraryDownloadedChaptersState extends _$LibraryDownloadedChaptersState {
  @override
  bool build() {
    return ref
        .watch(hiveBoxSettingsProvider)
        .get('libraryDownloadedChapters', defaultValue: false)!;
  }

  void set(bool value) {
    state = value;
    ref.watch(hiveBoxSettingsProvider).put('libraryDownloadedChapters', value);
  }
}

@riverpod
class LibraryLanguageState extends _$LibraryLanguageState {
  @override
  bool build() {
    return ref
        .watch(hiveBoxSettingsProvider)
        .get('libraryLanguage', defaultValue: false)!;
  }

  void set(bool value) {
    state = value;
    ref.watch(hiveBoxSettingsProvider).put('libraryLanguage', value);
  }
}

@riverpod
class LibraryShowNumbersOfItemsState extends _$LibraryShowNumbersOfItemsState {
  @override
  bool build() {
    return ref
        .watch(hiveBoxSettingsProvider)
        .get('libraryShowNumbersOfItems', defaultValue: false)!;
  }

  void set(bool value) {
    state = value;
    ref.watch(hiveBoxSettingsProvider).put('libraryShowNumbersOfItems', value);
  }
}

@riverpod
class LibraryShowContinueReadingButtonState
    extends _$LibraryShowContinueReadingButtonState {
  @override
  bool build() {
    return ref
        .watch(hiveBoxSettingsProvider)
        .get('libraryShowContinueReadingButton', defaultValue: false)!;
  }

  void set(bool value) {
    state = value;
    ref
        .watch(hiveBoxSettingsProvider)
        .put('libraryShowContinueReadingButton', value);
  }
}