Fix trash group by tracking code

(cherry picked from commit 4de4992e4eba8f8d508341907225d4ecc55073b8)

# Conflicts:
#	app/src/main/java/eu/kanade/tachiyomi/data/library/LibraryUpdateService.kt
#	app/src/main/java/eu/kanade/tachiyomi/ui/library/LibraryPresenter.kt

app/src/main/java/eu/kanade/tachiyomi/data/library/LibraryUpdateService.kt

@@ -26,6 +26,7 @@ import eu.kanade.tachiyomi.data.preference.PreferencesHelper
 import eu.kanade.tachiyomi.data.track.EnhancedTrackService
 import eu.kanade.tachiyomi.data.track.TrackManager
 import eu.kanade.tachiyomi.data.track.TrackService
+import eu.kanade.tachiyomi.data.track.TrackStatus
 import eu.kanade.tachiyomi.source.SourceManager
 import eu.kanade.tachiyomi.source.UnmeteredSource
 import eu.kanade.tachiyomi.source.model.SManga
@@ -309,17 +310,13 @@ class LibraryUpdateService(
             when (group) {
                 LibraryGroup.BY_TRACK_STATUS -> {
                     val trackingExtra = groupExtra?.toIntOrNull() ?: -1
-                    val loggedServices = trackManager.services.filter { it.isLogged }
                     val tracks = db.getTracks().executeAsBlocking().groupBy { it.manga_id }
-                    val statuses = loggedServices.associate {
-                        it.id to it.getStatusList().associateWith(it::getStatus)
-                    }
 
                     libraryManga.filter { manga ->
                         val status = tracks[manga.id]?.firstNotNullOfOrNull { track ->
-                            statuses[track.sync_id]?.get(track.status)
+                            TrackStatus.parseTrackerStatus(track.sync_id, track.status)
-                        } ?: "not tracked"
+                        } ?: TrackStatus.OTHER
-                        (trackManager.trackMap[status] ?: TrackManager.OTHER) == trackingExtra
+                        status.int == trackingExtra
                     }
                 }
                 LibraryGroup.BY_SOURCE -> {

app/src/main/java/eu/kanade/tachiyomi/data/track/TrackManager.kt

@@ -1,7 +1,6 @@
 package eu.kanade.tachiyomi.data.track
 
 import android.content.Context
-import eu.kanade.tachiyomi.R
 import eu.kanade.tachiyomi.data.track.anilist.Anilist
 import eu.kanade.tachiyomi.data.track.bangumi.Bangumi
 import eu.kanade.tachiyomi.data.track.kitsu.Kitsu
@@ -23,16 +22,6 @@ class TrackManager(context: Context) {
         // SY --> Mangadex from Neko
         const val MDLIST = 60
         // SY <--
-
-        // SY -->
-        const val READING = 1
-        const val REPEATING = 2
-        const val PLAN_TO_READ = 3
-        const val PAUSED = 4
-        const val COMPLETED = 5
-        const val DROPPED = 6
-        const val OTHER = 7
-        // SY <--
     }
 
     val mdList = MdList(context, MDLIST)
@@ -54,17 +43,4 @@ class TrackManager(context: Context) {
     fun getService(id: Int) = services.find { it.id == id }
 
     fun hasLoggedServices() = services.any { it.isLogged }
-
-    // SY -->
-    val trackMap by lazy {
-        mapOf(
-            context.getString(R.string.reading) to READING,
-            context.getString(R.string.repeating) to REPEATING,
-            context.getString(R.string.plan_to_read) to PLAN_TO_READ,
-            context.getString(R.string.paused) to PAUSED,
-            context.getString(R.string.completed) to COMPLETED,
-            context.getString(R.string.dropped) to DROPPED,
-        )
-    }
-    // SY <--
 }

app/src/main/java/eu/kanade/tachiyomi/data/track/TrackStatus.kt

@@ -0,0 +1,101 @@
+package eu.kanade.tachiyomi.data.track
+
+import androidx.annotation.StringRes
+import eu.kanade.tachiyomi.R
+import eu.kanade.tachiyomi.data.track.anilist.Anilist
+import eu.kanade.tachiyomi.data.track.bangumi.Bangumi
+import eu.kanade.tachiyomi.data.track.kitsu.Kitsu
+import eu.kanade.tachiyomi.data.track.komga.Komga
+import eu.kanade.tachiyomi.data.track.myanimelist.MyAnimeList
+import eu.kanade.tachiyomi.data.track.shikimori.Shikimori
+import exh.md.utils.FollowStatus
+
+enum class TrackStatus(val int: Int, @StringRes val res: Int) {
+    READING(1, R.string.reading),
+    REPEATING(2, R.string.repeating),
+    PLAN_TO_READ(3, R.string.plan_to_read),
+    PAUSED(4, R.string.on_hold),
+    COMPLETED(5, R.string.completed),
+    DROPPED(6, R.string.dropped),
+    OTHER(7, R.string.not_tracked);
+
+    companion object {
+        fun parseTrackerStatus(tracker: Int, status: Int): TrackStatus? {
+            return when (tracker) {
+                TrackManager.MDLIST -> {
+                    when (FollowStatus.fromInt(status)) {
+                        FollowStatus.UNFOLLOWED -> null
+                        FollowStatus.READING -> READING
+                        FollowStatus.COMPLETED -> COMPLETED
+                        FollowStatus.ON_HOLD -> PAUSED
+                        FollowStatus.PLAN_TO_READ -> PLAN_TO_READ
+                        FollowStatus.DROPPED -> DROPPED
+                        FollowStatus.RE_READING -> REPEATING
+                    }
+                }
+                TrackManager.MYANIMELIST -> {
+                    when (status) {
+                        MyAnimeList.READING -> READING
+                        MyAnimeList.COMPLETED -> COMPLETED
+                        MyAnimeList.ON_HOLD -> PAUSED
+                        MyAnimeList.PLAN_TO_READ -> PLAN_TO_READ
+                        MyAnimeList.DROPPED -> DROPPED
+                        MyAnimeList.REREADING -> REPEATING
+                        else -> null
+                    }
+                }
+                TrackManager.ANILIST -> {
+                    when (status) {
+                        Anilist.READING -> READING
+                        Anilist.COMPLETED -> COMPLETED
+                        Anilist.ON_HOLD -> PAUSED
+                        Anilist.PLAN_TO_READ -> PLAN_TO_READ
+                        Anilist.DROPPED -> DROPPED
+                        Anilist.REREADING -> REPEATING
+                        else -> null
+                    }
+                }
+                TrackManager.KITSU -> {
+                    when (status) {
+                        Kitsu.READING -> READING
+                        Kitsu.COMPLETED -> COMPLETED
+                        Kitsu.ON_HOLD -> PAUSED
+                        Kitsu.PLAN_TO_READ -> PLAN_TO_READ
+                        Kitsu.DROPPED -> DROPPED
+                        else -> null
+                    }
+                }
+                TrackManager.SHIKIMORI -> {
+                    when (status) {
+                        Shikimori.READING -> READING
+                        Shikimori.COMPLETED -> COMPLETED
+                        Shikimori.ON_HOLD -> PAUSED
+                        Shikimori.PLAN_TO_READ -> PLAN_TO_READ
+                        Shikimori.DROPPED -> DROPPED
+                        Shikimori.REREADING -> REPEATING
+                        else -> null
+                    }
+                }
+                TrackManager.BANGUMI -> {
+                    when (status) {
+                        Bangumi.READING -> READING
+                        Bangumi.COMPLETED -> COMPLETED
+                        Bangumi.ON_HOLD -> PAUSED
+                        Bangumi.PLAN_TO_READ -> PLAN_TO_READ
+                        Bangumi.DROPPED -> DROPPED
+                        else -> null
+                    }
+                }
+                TrackManager.KOMGA -> {
+                    when (status) {
+                        Komga.READING -> READING
+                        Komga.COMPLETED -> COMPLETED
+                        Komga.UNREAD -> null
+                        else -> null
+                    }
+                }
+                else -> null
+            }
+        }
+    }
+}

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

@@ -13,6 +13,7 @@ import eu.kanade.tachiyomi.data.download.DownloadManager
 import eu.kanade.tachiyomi.data.library.CustomMangaManager
 import eu.kanade.tachiyomi.data.preference.PreferencesHelper
 import eu.kanade.tachiyomi.data.track.TrackManager
+import eu.kanade.tachiyomi.data.track.TrackStatus
 import eu.kanade.tachiyomi.source.SourceManager
 import eu.kanade.tachiyomi.source.model.SManga
 import eu.kanade.tachiyomi.source.online.HttpSource
@@ -42,7 +43,6 @@ import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
 import java.text.Collator
 import java.util.Collections
-import java.util.Comparator
 import java.util.Locale
 
 /**
@@ -848,15 +848,9 @@ class LibraryPresenter(
                     .let(grouping::putAll)
             LibraryGroup.BY_TRACK_STATUS -> {
                 grouping.putAll(
-                    listOf(
+                    TrackStatus.values()
-                        TrackManager.READING to context.getString(R.string.reading),
+                        .map { it.int to context.getString(it.res) }
-                        TrackManager.REPEATING to context.getString(R.string.repeating),
+                        .associateBy(Pair<Int, *>::first),
-                        TrackManager.PLAN_TO_READ to context.getString(R.string.plan_to_read),
-                        TrackManager.PAUSED to context.getString(R.string.on_hold),
-                        TrackManager.COMPLETED to context.getString(R.string.completed),
-                        TrackManager.DROPPED to context.getString(R.string.dropped),
-                        TrackManager.OTHER to context.getString(R.string.not_tracked),
-                    ).associateBy(Pair<Int, *>::first),
                 )
             }
         }
@@ -865,21 +859,12 @@ class LibraryPresenter(
         when (groupType) {
             LibraryGroup.BY_TRACK_STATUS -> {
                 val tracks = db.getTracks().executeAsBlocking().groupBy { it.manga_id }
-                val statuses = loggedServices.associate {
-                    it.id to it.getStatusList().associateWith(it::getStatus)
-                }
                 libraryManga.forEach { libraryItem ->
                     val status = tracks[libraryItem.manga.id]?.firstNotNullOfOrNull { track ->
-                        statuses[track.sync_id]?.get(track.status)
+                        TrackStatus.parseTrackerStatus(track.sync_id, track.status)
-                    } ?: "not tracked"
+                    } ?: TrackStatus.OTHER
-                    val group = grouping.values.find { (statusInt) ->
+
-                        statusInt == (trackManager.trackMap[status] ?: TrackManager.OTHER)
+                    map.getOrPut(status.int) { mutableListOf() } += libraryItem
-                    }
-                    if (group != null) {
-                        map.getOrPut(group.first) { mutableListOf() } += libraryItem
-                    } else {
-                        map.getOrPut(7) { mutableListOf() } += libraryItem
-                    }
                 }
             }
             LibraryGroup.BY_SOURCE -> {