Simplify filter logic (#9141)

* Remove unnecessary else branch

* Add TriStateFilter applyFilter

* Simplify filterFnTracking filter logic

(cherry picked from commit ed6809fa2835831b8d5739d195eff1dbf74df801)

# Conflicts:
#	app/src/main/java/eu/kanade/domain/chapter/model/ChapterFilter.kt
#	app/src/main/java/eu/kanade/tachiyomi/ui/library/LibraryScreenModel.kt
#	app/src/main/java/eu/kanade/tachiyomi/ui/manga/MangaScreenModel.kt

app/src/main/java/eu/kanade/domain/chapter/model/ChapterFilter.kt

@@ -3,13 +3,12 @@ package eu.kanade.domain.chapter.model
 import eu.kanade.domain.manga.model.downloadedFilter
 import eu.kanade.domain.manga.model.isLocal
 import eu.kanade.tachiyomi.data.download.DownloadManager
-import eu.kanade.tachiyomi.data.download.model.Download
 import eu.kanade.tachiyomi.ui.manga.ChapterItem
 import exh.md.utils.MdUtil
 import tachiyomi.domain.chapter.model.Chapter
 import tachiyomi.domain.chapter.service.getChapterSort
 import tachiyomi.domain.manga.model.Manga
-import tachiyomi.domain.manga.model.TriStateFilter
+import tachiyomi.domain.manga.model.applyFilter
 
 /**
  * Applies the view filters to the list of chapters obtained from the database.
@@ -21,30 +20,12 @@ fun List<Chapter>.applyFilters(manga: Manga, downloadManager: DownloadManager):
     val downloadedFilter = manga.downloadedFilter
     val bookmarkedFilter = manga.bookmarkedFilter
 
-    return filter { chapter ->
+    return filter { chapter -> applyFilter(unreadFilter) { !chapter.read } }
-        when (unreadFilter) {
+        .filter { chapter -> applyFilter(bookmarkedFilter) { chapter.bookmark } }
-            TriStateFilter.DISABLED -> true
-            TriStateFilter.ENABLED_IS -> !chapter.read
-            TriStateFilter.ENABLED_NOT -> chapter.read
-        }
-    }
         .filter { chapter ->
-            when (bookmarkedFilter) {
+            applyFilter(downloadedFilter) {
-                TriStateFilter.DISABLED -> true
+                val downloaded = downloadManager.isChapterDownloaded(chapter.name, chapter.scanlator, /* SY --> */ manga.ogTitle /* SY <-- */, manga.source)
-                TriStateFilter.ENABLED_IS -> chapter.bookmark
+                downloaded || isLocalManga
-                TriStateFilter.ENABLED_NOT -> !chapter.bookmark
-            }
-        }
-        .filter { chapter ->
-            val downloaded = downloadManager.isChapterDownloaded(chapter.name, chapter.scanlator, /* SY --> */ manga.ogTitle /* SY <-- */, manga.source)
-            val downloadState = when {
-                downloaded -> Download.State.DOWNLOADED
-                else -> Download.State.NOT_DOWNLOADED
-            }
-            when (downloadedFilter) {
-                TriStateFilter.DISABLED -> true
-                TriStateFilter.ENABLED_IS -> downloadState == Download.State.DOWNLOADED || isLocalManga
-                TriStateFilter.ENABLED_NOT -> downloadState != Download.State.DOWNLOADED && !isLocalManga
             }
         }
         // SY -->
@@ -65,30 +46,12 @@ fun List<ChapterItem>.applyFilters(manga: Manga): Sequence<ChapterItem> {
     val downloadedFilter = manga.downloadedFilter
     val bookmarkedFilter = manga.bookmarkedFilter
     return asSequence()
-        .filter { (chapter) ->
+        .filter { (chapter) -> applyFilter(unreadFilter) { !chapter.read } }
-            when (unreadFilter) {
+        .filter { (chapter) -> applyFilter(bookmarkedFilter) { chapter.bookmark } }
-                TriStateFilter.DISABLED -> true
+        .filter { applyFilter(downloadedFilter) { it.isDownloaded || isLocalManga } }
-                TriStateFilter.ENABLED_IS -> !chapter.read
-                TriStateFilter.ENABLED_NOT -> chapter.read
-            }
-        }
-        .filter { (chapter) ->
-            when (bookmarkedFilter) {
-                TriStateFilter.DISABLED -> true
-                TriStateFilter.ENABLED_IS -> chapter.bookmark
-                TriStateFilter.ENABLED_NOT -> !chapter.bookmark
-            }
-        }
-        .filter {
-            when (downloadedFilter) {
-                TriStateFilter.DISABLED -> true
-                TriStateFilter.ENABLED_IS -> it.isDownloaded || isLocalManga
-                TriStateFilter.ENABLED_NOT -> !it.isDownloaded && !isLocalManga
-            }
-        }
         // SY -->
         .filter { chapter ->
-            manga.filteredScanlators.isNullOrEmpty() || MdUtil.getScanlators(chapter.chapter.scanlator).any { group -> manga.filteredScanlators!!.contains(group) }
+            manga.filteredScanlators.isNullOrEmpty() || MdUtil.getScanlators(chapter.scanlator).any { group -> manga.filteredScanlators!!.contains(group) }
         }
         // SY <--
         .sortedWith { (chapter1), (chapter2) -> getChapterSort(manga).invoke(chapter1, chapter2) }

app/src/main/java/eu/kanade/tachiyomi/ui/browse/source/browse/SourceFilterDialog.kt

@@ -238,6 +238,5 @@ private fun TriStateFilter.toTriStateInt(): Int {
         TriStateFilter.DISABLED -> Filter.TriState.STATE_IGNORE
         TriStateFilter.ENABLED_IS -> Filter.TriState.STATE_INCLUDE
         TriStateFilter.ENABLED_NOT -> Filter.TriState.STATE_EXCLUDE
-        else -> throw IllegalStateException("Unknown TriStateFilter state: $this")
     }
 }

app/src/main/java/eu/kanade/tachiyomi/ui/library/LibraryScreenModel.kt

@@ -100,6 +100,7 @@ import tachiyomi.domain.manga.model.CustomMangaInfo
 import tachiyomi.domain.manga.model.Manga
 import tachiyomi.domain.manga.model.MangaUpdate
 import tachiyomi.domain.manga.model.TriStateFilter
+import tachiyomi.domain.manga.model.applyFilter
 import tachiyomi.domain.track.interactor.GetTracks
 import tachiyomi.domain.track.interactor.GetTracksPerManga
 import tachiyomi.domain.track.model.Track
@@ -274,7 +275,8 @@ class LibraryScreenModel(
     ): LibraryMap {
         val prefs = getLibraryItemPreferencesFlow().first()
         val downloadedOnly = prefs.globalFilterDownloaded
-        val filterDownloaded = prefs.filterDownloaded
+        val filterDownloaded =
+            if (downloadedOnly) TriStateFilter.ENABLED_IS else prefs.filterDownloaded
         val filterUnread = prefs.filterUnread
         val filterStarted = prefs.filterStarted
         val filterBookmarked = prefs.filterBookmarked
@@ -290,108 +292,57 @@ class LibraryScreenModel(
         val filterLewd = prefs.filterLewd
         // SY <--
 
-        val filterFnDownloaded: (LibraryItem) -> Boolean = downloaded@{
+        val filterFnDownloaded: (LibraryItem) -> Boolean = {
-            if (!downloadedOnly && filterDownloaded == TriStateFilter.DISABLED) return@downloaded true
+            applyFilter(filterDownloaded) {
-
+                it.libraryManga.manga.isLocal() ||
-            val isDownloaded = it.libraryManga.manga.isLocal() ||
+                    it.downloadCount > 0 ||
-                it.downloadCount > 0 ||
+                    downloadManager.getDownloadCount(it.libraryManga.manga) > 0
-                downloadManager.getDownloadCount(it.libraryManga.manga) > 0
-            return@downloaded if (downloadedOnly || filterDownloaded == TriStateFilter.ENABLED_IS) {
-                isDownloaded
-            } else {
-                !isDownloaded
             }
         }
 
-        val filterFnUnread: (LibraryItem) -> Boolean = unread@{
+        val filterFnUnread: (LibraryItem) -> Boolean = {
-            if (filterUnread == TriStateFilter.DISABLED) return@unread true
+            applyFilter(filterUnread) { it.libraryManga.unreadCount > 0 }
-
-            val isUnread = it.libraryManga.unreadCount > 0
-            return@unread if (filterUnread == TriStateFilter.ENABLED_IS) {
-                isUnread
-            } else {
-                !isUnread
-            }
         }
 
-        val filterFnStarted: (LibraryItem) -> Boolean = started@{
+        val filterFnStarted: (LibraryItem) -> Boolean = {
-            if (filterStarted == TriStateFilter.DISABLED) return@started true
+            applyFilter(filterStarted) { it.libraryManga.hasStarted }
-
-            val hasStarted = it.libraryManga.hasStarted
-            return@started if (filterStarted == TriStateFilter.ENABLED_IS) {
-                hasStarted
-            } else {
-                !hasStarted
-            }
         }
 
-        val filterFnBookmarked: (LibraryItem) -> Boolean = bookmarked@{
+        val filterFnBookmarked: (LibraryItem) -> Boolean = {
-            if (filterBookmarked == TriStateFilter.DISABLED) return@bookmarked true
+            applyFilter(filterBookmarked) { it.libraryManga.hasBookmarks }
-
-            val hasBookmarks = it.libraryManga.hasBookmarks
-            return@bookmarked if (filterBookmarked == TriStateFilter.ENABLED_IS) {
-                hasBookmarks
-            } else {
-                !hasBookmarks
-            }
         }
 
-        val filterFnCompleted: (LibraryItem) -> Boolean = completed@{
+        val filterFnCompleted: (LibraryItem) -> Boolean = {
-            if (filterCompleted == TriStateFilter.DISABLED) return@completed true
+            applyFilter(filterCompleted) { it.libraryManga.manga.status.toInt() == SManga.COMPLETED }
-
-            val isCompleted = it.libraryManga.manga.status.toInt() == SManga.COMPLETED
-            return@completed if (filterCompleted == TriStateFilter.ENABLED_IS) {
-                isCompleted
-            } else {
-                !isCompleted
-            }
         }
 
+        // SY -->
+        val filterFnLewd: (LibraryItem) -> Boolean = {
+            applyFilter(filterLewd) { it.libraryManga.manga.isLewd() }
+        }
+        // SY <--
+
         val filterFnTracking: (LibraryItem) -> Boolean = tracking@{ item ->
             if (isNotLoggedInAnyTrack || trackFiltersIsIgnored) return@tracking true
 
             val mangaTracks = trackMap[item.libraryManga.id].orEmpty()
 
-            val exclude = mangaTracks.fastFilter { it in excludedTracks }
+            val isExcluded = excludedTracks.isNotEmpty() && mangaTracks.fastAny { it in excludedTracks }
-            val include = mangaTracks.fastFilter { it in includedTracks }
+            val isIncluded = includedTracks.isEmpty() || mangaTracks.fastAny { it in includedTracks }
 
-            // TODO: Simplify the filter logic
+            return@tracking !isExcluded && isIncluded
-            if (includedTracks.isNotEmpty() && excludedTracks.isNotEmpty()) {
-                return@tracking if (exclude.isNotEmpty()) false else include.isNotEmpty()
-            }
-
-            if (excludedTracks.isNotEmpty()) return@tracking exclude.isEmpty()
-
-            if (includedTracks.isNotEmpty()) return@tracking include.isNotEmpty()
-
-            return@tracking false
         }
 
-        // SY -->
+        val filterFn: (LibraryItem) -> Boolean = {
-        val filterFnLewd: (LibraryItem) -> Boolean = lewd@{
+            filterFnDownloaded(it) &&
-            if (filterLewd == TriStateFilter.DISABLED) return@lewd true
+                filterFnUnread(it) &&
-            val isLewd = it.libraryManga.manga.isLewd()
+                filterFnStarted(it) &&
-
+                filterFnBookmarked(it) &&
-            return@lewd if (filterLewd == TriStateFilter.ENABLED_IS) {
+                filterFnCompleted(it) &&
-                isLewd
+                filterFnTracking(it) &&
-            } else {
+                // SY -->
-                !isLewd
+                filterFnLewd(it)
-            }
+            // SY <--
-        }
-        // SY <--
-
-        val filterFn: (LibraryItem) -> Boolean = filter@{
-            return@filter !(
-                !filterFnDownloaded(it) ||
-                    !filterFnUnread(it) ||
-                    !filterFnStarted(it) ||
-                    !filterFnBookmarked(it) ||
-                    !filterFnCompleted(it) ||
-                    !filterFnTracking(it) ||
-                    // SY -->
-                    !filterFnLewd(it)
-                // SY <--
-                )
         }
 
         return this.mapValues { entry -> entry.value.fastFilter(filterFn) }

app/src/main/java/eu/kanade/tachiyomi/ui/manga/MangaScreenModel.kt

@@ -113,6 +113,7 @@ import tachiyomi.domain.manga.model.MangaUpdate
 import tachiyomi.domain.manga.model.MergeMangaSettingsUpdate
 import tachiyomi.domain.manga.model.MergedMangaReference
 import tachiyomi.domain.manga.model.TriStateFilter
+import tachiyomi.domain.manga.model.applyFilter
 import tachiyomi.domain.track.interactor.GetTracks
 import tachiyomi.domain.track.interactor.InsertTrack
 import uy.kohesive.injekt.Injekt
@@ -1575,27 +1576,9 @@ sealed class MangaScreenState {
             val downloadedFilter = manga.downloadedFilter
             val bookmarkedFilter = manga.bookmarkedFilter
             return asSequence()
-                .filter { (chapter) ->
+                .filter { (chapter) -> applyFilter(unreadFilter) { !chapter.read } }
-                    when (unreadFilter) {
+                .filter { (chapter) -> applyFilter(bookmarkedFilter) { chapter.bookmark } }
-                        TriStateFilter.DISABLED -> true
+                .filter { applyFilter(downloadedFilter) { it.isDownloaded || isLocalManga } }
-                        TriStateFilter.ENABLED_IS -> !chapter.read
-                        TriStateFilter.ENABLED_NOT -> chapter.read
-                    }
-                }
-                .filter { (chapter) ->
-                    when (bookmarkedFilter) {
-                        TriStateFilter.DISABLED -> true
-                        TriStateFilter.ENABLED_IS -> chapter.bookmark
-                        TriStateFilter.ENABLED_NOT -> !chapter.bookmark
-                    }
-                }
-                .filter {
-                    when (downloadedFilter) {
-                        TriStateFilter.DISABLED -> true
-                        TriStateFilter.ENABLED_IS -> it.isDownloaded || isLocalManga
-                        TriStateFilter.ENABLED_NOT -> !it.isDownloaded && !isLocalManga
-                    }
-                }
                 // SY -->
                 .filter { chapter ->
                     manga.filteredScanlators.isNullOrEmpty() || MdUtil.getScanlators(chapter.chapter.scanlator).any { group -> manga.filteredScanlators!!.contains(group) }

domain/src/main/java/tachiyomi/domain/manga/model/TriStateFilter.kt

@@ -14,3 +14,9 @@ enum class TriStateFilter {
         }
     }
 }
+
+inline fun applyFilter(filter: TriStateFilter, predicate: () -> Boolean): Boolean = when (filter) {
+    TriStateFilter.DISABLED -> true
+    TriStateFilter.ENABLED_IS -> predicate()
+    TriStateFilter.ENABLED_NOT -> !predicate()
+}