Adjust read next history logic

Closes #8454

app/src/main/java/eu/kanade/domain/DomainModule.kt

@@ -32,11 +32,9 @@ import eu.kanade.domain.download.interactor.DeleteDownload
 import eu.kanade.domain.extension.interactor.GetExtensionLanguages
 import eu.kanade.domain.extension.interactor.GetExtensionSources
 import eu.kanade.domain.extension.interactor.GetExtensionsByType
-import eu.kanade.domain.history.interactor.DeleteAllHistory
 import eu.kanade.domain.history.interactor.GetHistory
-import eu.kanade.domain.history.interactor.GetNextUnreadChapters
-import eu.kanade.domain.history.interactor.RemoveHistoryById
-import eu.kanade.domain.history.interactor.RemoveHistoryByMangaId
+import eu.kanade.domain.history.interactor.GetNextChapters
+import eu.kanade.domain.history.interactor.RemoveHistory
 import eu.kanade.domain.history.interactor.UpsertHistory
 import eu.kanade.domain.history.repository.HistoryRepository
 import eu.kanade.domain.manga.interactor.GetDuplicateLibraryManga
@@ -94,7 +92,7 @@ class DomainModule : InjektModule {
         addFactory { GetLibraryManga(get()) }
         addFactory { GetMangaWithChapters(get(), get()) }
         addFactory { GetManga(get()) }
-        addFactory { GetNextUnreadChapters(get(), get(), get()) }
+        addFactory { GetNextChapters(get(), get(), get()) }
         addFactory { ResetViewerFlags(get()) }
         addFactory { SetMangaChapterFlags(get()) }
         addFactory { SetMangaDefaultChapterFlags(get(), get(), get()) }
@@ -119,11 +117,9 @@ class DomainModule : InjektModule {
         addFactory { SyncChaptersWithTrackServiceTwoWay(get(), get()) }
 
         addSingletonFactory<HistoryRepository> { HistoryRepositoryImpl(get()) }
-        addFactory { DeleteAllHistory(get()) }
         addFactory { GetHistory(get()) }
         addFactory { UpsertHistory(get()) }
-        addFactory { RemoveHistoryById(get()) }
-        addFactory { RemoveHistoryByMangaId(get()) }
+        addFactory { RemoveHistory(get()) }
 
         addFactory { DeleteDownload(get(), get()) }
 

app/src/main/java/eu/kanade/domain/history/interactor/DeleteAllHistory.kt

@@ -1,12 +0,0 @@
-package eu.kanade.domain.history.interactor
-
-import eu.kanade.domain.history.repository.HistoryRepository
-
-class DeleteAllHistory(
-    private val repository: HistoryRepository,
-) {
-
-    suspend fun await(): Boolean {
-        return repository.deleteAllHistory()
-    }
-}

app/src/main/java/eu/kanade/domain/history/interactor/GetHistory.kt

@@ -7,6 +7,7 @@ import kotlinx.coroutines.flow.Flow
 class GetHistory(
     private val repository: HistoryRepository,
 ) {
+
     fun subscribe(query: String): Flow<List<HistoryWithRelations>> {
         return repository.getHistory(query)
     }

app/src/main/java/eu/kanade/domain/history/interactor/GetNextChapters.kt

@@ -0,0 +1,52 @@
+package eu.kanade.domain.history.interactor
+
+import eu.kanade.domain.chapter.interactor.GetChapterByMangaId
+import eu.kanade.domain.chapter.model.Chapter
+import eu.kanade.domain.history.repository.HistoryRepository
+import eu.kanade.domain.manga.interactor.GetManga
+import eu.kanade.tachiyomi.util.chapter.getChapterSort
+import kotlin.math.max
+
+class GetNextChapters(
+    private val getChapterByMangaId: GetChapterByMangaId,
+    private val getManga: GetManga,
+    private val historyRepository: HistoryRepository,
+) {
+
+    suspend fun await(onlyUnread: Boolean = true): List<Chapter> {
+        val history = historyRepository.getLastHistory() ?: return emptyList()
+        return await(history.mangaId, history.chapterId, onlyUnread)
+    }
+
+    suspend fun await(mangaId: Long, onlyUnread: Boolean = true): List<Chapter> {
+        val manga = getManga.await(mangaId) ?: return emptyList()
+        val chapters = getChapterByMangaId.await(mangaId)
+            .sortedWith(getChapterSort(manga, sortDescending = false))
+
+        return if (onlyUnread) {
+            chapters.filterNot { it.read }
+        } else {
+            chapters
+        }
+    }
+
+    suspend fun await(mangaId: Long, fromChapterId: Long, onlyUnread: Boolean = true): List<Chapter> {
+        val chapters = await(mangaId, onlyUnread)
+        val currChapterIndex = chapters.indexOfFirst { it.id == fromChapterId }
+        val nextChapters = chapters.subList(max(0, currChapterIndex), chapters.size)
+
+        if (onlyUnread) {
+            return nextChapters
+        }
+
+        // The "next chapter" is either:
+        // - The current chapter if it isn't completely read
+        // - The chapters after the current chapter if the current one is completely read
+        val fromChapter = chapters.getOrNull(currChapterIndex)
+        return if (fromChapter != null && !fromChapter.read) {
+            nextChapters
+        } else {
+            nextChapters.drop(1)
+        }
+    }
+}

app/src/main/java/eu/kanade/domain/history/interactor/GetNextUnreadChapters.kt

@@ -1,33 +0,0 @@
-package eu.kanade.domain.history.interactor
-
-import eu.kanade.domain.chapter.interactor.GetChapterByMangaId
-import eu.kanade.domain.chapter.model.Chapter
-import eu.kanade.domain.history.repository.HistoryRepository
-import eu.kanade.domain.manga.interactor.GetManga
-import eu.kanade.tachiyomi.util.chapter.getChapterSort
-import kotlin.math.max
-
-class GetNextUnreadChapters(
-    private val getChapterByMangaId: GetChapterByMangaId,
-    private val getManga: GetManga,
-    private val historyRepository: HistoryRepository,
-) {
-
-    suspend fun await(): Chapter? {
-        val history = historyRepository.getLastHistory() ?: return null
-        return await(history.mangaId, history.chapterId).firstOrNull()
-    }
-
-    suspend fun await(mangaId: Long): List<Chapter> {
-        val manga = getManga.await(mangaId) ?: return emptyList()
-        return getChapterByMangaId.await(mangaId)
-            .sortedWith(getChapterSort(manga, sortDescending = false))
-            .filterNot { it.read }
-    }
-
-    suspend fun await(mangaId: Long, fromChapterId: Long): List<Chapter> {
-        val unreadChapters = await(mangaId)
-        val currChapterIndex = unreadChapters.indexOfFirst { it.id == fromChapterId }
-        return unreadChapters.subList(max(0, currChapterIndex), unreadChapters.size)
-    }
-}

app/src/main/java/eu/kanade/domain/history/interactor/RemoveHistory.kt

@@ -3,11 +3,19 @@ package eu.kanade.domain.history.interactor
 import eu.kanade.domain.history.model.HistoryWithRelations
 import eu.kanade.domain.history.repository.HistoryRepository
 
-class RemoveHistoryById(
+class RemoveHistory(
     private val repository: HistoryRepository,
 ) {
 
+    suspend fun awaitAll(): Boolean {
+        return repository.deleteAllHistory()
+    }
+
     suspend fun await(history: HistoryWithRelations) {
         repository.resetHistory(history.id)
     }
+
+    suspend fun await(mangaId: Long) {
+        repository.resetHistoryByMangaId(mangaId)
+    }
 }

app/src/main/java/eu/kanade/domain/history/interactor/RemoveHistoryByMangaId.kt

@@ -1,12 +0,0 @@
-package eu.kanade.domain.history.interactor
-
-import eu.kanade.domain.history.repository.HistoryRepository
-
-class RemoveHistoryByMangaId(
-    private val repository: HistoryRepository,
-) {
-
-    suspend fun await(mangaId: Long) {
-        repository.resetHistoryByMangaId(mangaId)
-    }
-}