Update random manga selecting

app/src/main/java/org/koitharu/kotatsu/explore/domain/ExploreRepository.kt

@@ -4,8 +4,12 @@ import org.koitharu.kotatsu.core.parser.MangaRepository
 import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.history.domain.HistoryRepository
 import org.koitharu.kotatsu.parsers.model.Manga
-import org.koitharu.kotatsu.parsers.model.SortOrder
+import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.suggestions.domain.TagsBlacklist
+import org.koitharu.kotatsu.utils.ext.almostEquals
+import org.koitharu.kotatsu.utils.ext.asArrayList
+import org.koitharu.kotatsu.utils.ext.printStackTraceDebug
+import org.koitharu.kotatsu.utils.ext.runCatchingCancellable
 import javax.inject.Inject
 
 class ExploreRepository @Inject constructor(
@@ -16,28 +20,46 @@ class ExploreRepository @Inject constructor(
 
 	suspend fun findRandomManga(tagsLimit: Int): Manga {
 		val blacklistTagRegex = TagsBlacklist(settings.suggestionsTagsBlacklist, 0.4f)
-		val allTags = historyRepository.getPopularTags(tagsLimit).filterNot {
+		val tags = historyRepository.getPopularTags(tagsLimit).mapNotNull {
-			it in blacklistTagRegex
+			if (it in blacklistTagRegex) null else it.title
 		}
-		val tag = allTags.randomOrNull()
+		val sources = settings.getMangaSources(includeHidden = false)
-		val source = checkNotNull(tag?.source ?: settings.getMangaSources(includeHidden = false).randomOrNull()) {
+		check(sources.isNotEmpty()) { "No sources available" }
-			"No sources found"
+		for (i in 0..4) {
-		}
+			val list = getList(sources.random(), tags, blacklistTagRegex)
-		val repo = mangaRepositoryFactory.create(source)
+			val manga = list.randomOrNull() ?: continue
-		val list = repo.getList(
+			val details = runCatchingCancellable {
-			offset = 0,
+				mangaRepositoryFactory.create(manga.source).getDetails(manga)
-			sortOrder = if (SortOrder.UPDATED in repo.sortOrders) SortOrder.UPDATED else null,
+			}.getOrNull() ?: continue
-			tags = setOfNotNull(tag),
+			if ((settings.isSuggestionsExcludeNsfw && details.isNsfw) || details in blacklistTagRegex) {
-		).shuffled()
-		for (item in list) {
-			if (settings.isSuggestionsExcludeNsfw && item.isNsfw) {
-				continue
-			}
-			if (item in blacklistTagRegex) {
 				continue
 			}
-			return item
+			return details
 		}
-		return list.random()
+		throw NoSuchElementException()
 	}
+
+	private suspend fun getList(
+		source: MangaSource,
+		tags: List<String>,
+		blacklist: TagsBlacklist,
+	): List<Manga> = runCatchingCancellable {
+		val repository = mangaRepositoryFactory.create(source)
+		val order = repository.sortOrders.random()
+		val availableTags = repository.getTags()
+		val tag = tags.firstNotNullOfOrNull { title ->
+			availableTags.find { x -> x.title.almostEquals(title, 0.4f) }
+		}
+		val list = repository.getList(0, setOfNotNull(tag), order).asArrayList()
+		if (settings.isSuggestionsExcludeNsfw) {
+			list.removeAll { it.isNsfw }
+		}
+		if (blacklist.isNotEmpty()) {
+			list.removeAll { manga -> manga in blacklist }
+		}
+		list.shuffle()
+		list
+	}.onFailure {
+		it.printStackTraceDebug()
+	}.getOrDefault(emptyList())
 }

app/src/main/java/org/koitharu/kotatsu/explore/ui/ExploreViewModel.kt

@@ -6,7 +6,6 @@ import androidx.lifecycle.viewModelScope
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.combine
-import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.filter
 import kotlinx.coroutines.flow.flatMapLatest
 import kotlinx.coroutines.flow.flowOf
@@ -96,7 +95,6 @@ class ExploreViewModel @Inject constructor(
 		}
 		.onStart { emit("") }
 		.map { settings.getMangaSources(includeHidden = false) }
-		.distinctUntilChanged()
 		.combine(gridMode) { content, grid -> buildList(content, grid) }
 
 	private fun buildList(sources: List<MangaSource>, isGrid: Boolean): List<ExploreItem> {