More domain model usage

app/src/main/java/eu/kanade/domain/manga/model/Manga.kt

@@ -2,6 +2,7 @@ package eu.kanade.domain.manga.model
 
 import eu.kanade.data.listOfStringsAdapter
 import eu.kanade.tachiyomi.data.cache.CoverCache
+import eu.kanade.tachiyomi.data.database.models.MangaImpl
 import eu.kanade.tachiyomi.data.preference.PreferencesHelper
 import eu.kanade.tachiyomi.source.LocalSource
 import eu.kanade.tachiyomi.source.model.SManga
@@ -145,8 +146,9 @@ fun TriStateFilter.toTriStateGroupState(): ExtendedNavigationView.Item.TriStateG
 }
 
 // TODO: Remove when all deps are migrated
-fun Manga.toDbManga(): DbManga = DbManga.create(source).also {
+fun Manga.toDbManga(): DbManga = MangaImpl().also {
     it.id = id
+    it.source = source
     it.favorite = favorite
     it.last_update = lastUpdate
     it.date_added = dateAdded

app/src/main/java/eu/kanade/tachiyomi/data/coil/MangaCoverKeyer.kt

@@ -6,14 +6,14 @@ import eu.kanade.domain.manga.model.MangaCover
 import eu.kanade.domain.manga.model.hasCustomCover
 import eu.kanade.tachiyomi.data.cache.CoverCache
 import eu.kanade.tachiyomi.data.database.models.Manga
-import eu.kanade.tachiyomi.util.hasCustomCover
+import eu.kanade.tachiyomi.data.database.models.toDomainManga
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
 import eu.kanade.domain.manga.model.Manga as DomainManga
 
 class MangaKeyer : Keyer<Manga> {
     override fun key(data: Manga, options: Options): String {
-        return if (data.hasCustomCover()) {
+        return if (data.toDomainManga()!!.hasCustomCover()) {
             "${data.id};${data.cover_last_modified}"
         } else {
             "${data.thumbnail_url};${data.cover_last_modified}"

app/src/main/java/eu/kanade/tachiyomi/data/database/models/Manga.kt

@@ -25,12 +25,8 @@ interface Manga : SManga {
 
     var cover_last_modified: Long
 
-    fun setChapterOrder(order: Int) {
-        setChapterFlags(order, CHAPTER_SORT_MASK)
-    }
-
     fun sortDescending(): Boolean {
-        return chapter_flags and CHAPTER_SORT_MASK == CHAPTER_SORT_DESC
+        return chapter_flags and DomainManga.CHAPTER_SORT_DIR_MASK.toInt() == DomainManga.CHAPTER_SORT_DESC.toInt()
     }
 
     fun getGenres(): List<String>? {
@@ -48,24 +44,24 @@ interface Manga : SManga {
 
     // Used to display the chapter's title one way or another
     var displayMode: Int
-        get() = chapter_flags and CHAPTER_DISPLAY_MASK
-        set(mode) = setChapterFlags(mode, CHAPTER_DISPLAY_MASK)
+        get() = chapter_flags and DomainManga.CHAPTER_DISPLAY_MASK.toInt()
+        set(mode) = setChapterFlags(mode, DomainManga.CHAPTER_DISPLAY_MASK.toInt())
 
     var readFilter: Int
-        get() = chapter_flags and CHAPTER_READ_MASK
-        set(filter) = setChapterFlags(filter, CHAPTER_READ_MASK)
+        get() = chapter_flags and DomainManga.CHAPTER_UNREAD_MASK.toInt()
+        set(filter) = setChapterFlags(filter, DomainManga.CHAPTER_UNREAD_MASK.toInt())
 
     var downloadedFilter: Int
-        get() = chapter_flags and CHAPTER_DOWNLOADED_MASK
-        set(filter) = setChapterFlags(filter, CHAPTER_DOWNLOADED_MASK)
+        get() = chapter_flags and DomainManga.CHAPTER_DOWNLOADED_MASK.toInt()
+        set(filter) = setChapterFlags(filter, DomainManga.CHAPTER_DOWNLOADED_MASK.toInt())
 
     var bookmarkedFilter: Int
-        get() = chapter_flags and CHAPTER_BOOKMARKED_MASK
-        set(filter) = setChapterFlags(filter, CHAPTER_BOOKMARKED_MASK)
+        get() = chapter_flags and DomainManga.CHAPTER_BOOKMARKED_MASK.toInt()
+        set(filter) = setChapterFlags(filter, DomainManga.CHAPTER_BOOKMARKED_MASK.toInt())
 
     var sorting: Int
-        get() = chapter_flags and CHAPTER_SORTING_MASK
-        set(sort) = setChapterFlags(sort, CHAPTER_SORTING_MASK)
+        get() = chapter_flags and DomainManga.CHAPTER_SORTING_MASK.toInt()
+        set(sort) = setChapterFlags(sort, DomainManga.CHAPTER_SORTING_MASK.toInt())
 
     var readingModeType: Int
         get() = viewer_flags and ReadingModeType.MASK
@@ -76,39 +72,6 @@ interface Manga : SManga {
         set(rotationType) = setViewerFlags(rotationType, OrientationType.MASK)
 
     companion object {
-
-        // Generic filter that does not filter anything
-        const val SHOW_ALL = 0x00000000
-
-        const val CHAPTER_SORT_DESC = 0x00000000
-        const val CHAPTER_SORT_ASC = 0x00000001
-        const val CHAPTER_SORT_MASK = 0x00000001
-
-        const val CHAPTER_SHOW_UNREAD = 0x00000002
-        const val CHAPTER_SHOW_READ = 0x00000004
-        const val CHAPTER_READ_MASK = 0x00000006
-
-        const val CHAPTER_SHOW_DOWNLOADED = 0x00000008
-        const val CHAPTER_SHOW_NOT_DOWNLOADED = 0x00000010
-        const val CHAPTER_DOWNLOADED_MASK = 0x00000018
-
-        const val CHAPTER_SHOW_BOOKMARKED = 0x00000020
-        const val CHAPTER_SHOW_NOT_BOOKMARKED = 0x00000040
-        const val CHAPTER_BOOKMARKED_MASK = 0x00000060
-
-        const val CHAPTER_SORTING_SOURCE = 0x00000000
-        const val CHAPTER_SORTING_NUMBER = 0x00000100
-        const val CHAPTER_SORTING_UPLOAD_DATE = 0x00000200
-        const val CHAPTER_SORTING_MASK = 0x00000300
-
-        const val CHAPTER_DISPLAY_NAME = 0x00000000
-        const val CHAPTER_DISPLAY_NUMBER = 0x00100000
-        const val CHAPTER_DISPLAY_MASK = 0x00100000
-
-        fun create(source: Long): Manga = MangaImpl().apply {
-            this.source = source
-        }
-
         fun create(pathUrl: String, title: String, source: Long = 0): Manga = MangaImpl().apply {
             url = pathUrl
             this.title = title

app/src/main/java/eu/kanade/tachiyomi/data/database/models/MangaCategory.kt

@@ -1,30 +0,0 @@
-package eu.kanade.tachiyomi.data.database.models
-
-import eu.kanade.domain.category.model.Category as DomainCategory
-import eu.kanade.domain.manga.model.Manga as DomainManga
-
-class MangaCategory {
-
-    var id: Long? = null
-
-    var manga_id: Long = 0
-
-    var category_id: Int = 0
-
-    companion object {
-
-        fun create(manga: DomainManga, category: DomainCategory): MangaCategory {
-            val mc = MangaCategory()
-            mc.manga_id = manga.id
-            mc.category_id = category.id.toInt()
-            return mc
-        }
-
-        fun create(manga: Manga, category: Category): MangaCategory {
-            val mc = MangaCategory()
-            mc.manga_id = manga.id!!
-            mc.category_id = category.id!!
-            return mc
-        }
-    }
-}

app/src/main/java/eu/kanade/tachiyomi/data/preference/PreferencesHelper.kt

@@ -24,6 +24,7 @@ import java.io.File
 import java.text.DateFormat
 import java.text.SimpleDateFormat
 import java.util.Locale
+import eu.kanade.domain.manga.model.Manga as DomainManga
 import eu.kanade.tachiyomi.data.preference.PreferenceKeys as Keys
 import eu.kanade.tachiyomi.data.preference.PreferenceValues as Values
 
@@ -295,17 +296,17 @@ class PreferencesHelper(val context: Context) {
 
     fun lastSearchQuerySearchSettings() = flowPrefs.getString("last_search_query", "")
 
-    fun filterChapterByRead() = prefs.getInt(Keys.defaultChapterFilterByRead, Manga.SHOW_ALL)
+    fun filterChapterByRead() = prefs.getInt(Keys.defaultChapterFilterByRead, DomainManga.SHOW_ALL.toInt())
 
-    fun filterChapterByDownloaded() = prefs.getInt(Keys.defaultChapterFilterByDownloaded, Manga.SHOW_ALL)
+    fun filterChapterByDownloaded() = prefs.getInt(Keys.defaultChapterFilterByDownloaded, DomainManga.SHOW_ALL.toInt())
 
-    fun filterChapterByBookmarked() = prefs.getInt(Keys.defaultChapterFilterByBookmarked, Manga.SHOW_ALL)
+    fun filterChapterByBookmarked() = prefs.getInt(Keys.defaultChapterFilterByBookmarked, DomainManga.SHOW_ALL.toInt())
 
-    fun sortChapterBySourceOrNumber() = prefs.getInt(Keys.defaultChapterSortBySourceOrNumber, Manga.CHAPTER_SORTING_SOURCE)
+    fun sortChapterBySourceOrNumber() = prefs.getInt(Keys.defaultChapterSortBySourceOrNumber, DomainManga.CHAPTER_SORTING_SOURCE.toInt())
 
-    fun displayChapterByNameOrNumber() = prefs.getInt(Keys.defaultChapterDisplayByNameOrNumber, Manga.CHAPTER_DISPLAY_NAME)
+    fun displayChapterByNameOrNumber() = prefs.getInt(Keys.defaultChapterDisplayByNameOrNumber, DomainManga.CHAPTER_DISPLAY_NAME.toInt())
 
-    fun sortChapterByAscendingOrDescending() = prefs.getInt(Keys.defaultChapterSortByAscendingOrDescending, Manga.CHAPTER_SORT_DESC)
+    fun sortChapterByAscendingOrDescending() = prefs.getInt(Keys.defaultChapterSortByAscendingOrDescending, DomainManga.CHAPTER_SORT_DESC.toInt())
 
     fun incognitoMode() = flowPrefs.getBoolean("incognito_mode", false)
 
@@ -329,7 +330,7 @@ class PreferencesHelper(val context: Context) {
             putInt(Keys.defaultChapterFilterByBookmarked, manga.bookmarkedFilter)
             putInt(Keys.defaultChapterSortBySourceOrNumber, manga.sorting)
             putInt(Keys.defaultChapterDisplayByNameOrNumber, manga.displayMode)
-            putInt(Keys.defaultChapterSortByAscendingOrDescending, if (manga.sortDescending()) Manga.CHAPTER_SORT_DESC else Manga.CHAPTER_SORT_ASC)
+            putInt(Keys.defaultChapterSortByAscendingOrDescending, if (manga.sortDescending()) DomainManga.CHAPTER_SORT_DESC.toInt() else DomainManga.CHAPTER_SORT_ASC.toInt())
         }
     }
 }

app/src/main/java/eu/kanade/tachiyomi/ui/browse/migration/MigrationFlags.kt

@@ -1,10 +1,10 @@
 package eu.kanade.tachiyomi.ui.browse.migration
 
+import eu.kanade.domain.manga.model.Manga
+import eu.kanade.domain.manga.model.hasCustomCover
 import eu.kanade.domain.track.interactor.GetTracks
 import eu.kanade.tachiyomi.R
 import eu.kanade.tachiyomi.data.cache.CoverCache
-import eu.kanade.tachiyomi.data.database.models.Manga
-import eu.kanade.tachiyomi.util.hasCustomCover
 import kotlinx.coroutines.runBlocking
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
@@ -49,7 +49,7 @@ object MigrationFlags {
     fun titles(manga: Manga?): Array<Int> {
         val titles = arrayOf(R.string.chapters, R.string.categories).toMutableList()
         if (manga != null) {
-            if (runBlocking { getTracks.await(manga.id!!) }.isNotEmpty()) {
+            if (runBlocking { getTracks.await(manga.id) }.isNotEmpty()) {
                 titles.add(R.string.track)
             }
 

app/src/main/java/eu/kanade/tachiyomi/ui/browse/migration/search/SearchController.kt

@@ -109,7 +109,7 @@ class SearchController(
         override fun onCreateDialog(savedViewState: Bundle?): Dialog {
             val prefValue = preferences.migrateFlags().get()
             val enabledFlagsPositions = MigrationFlags.getEnabledFlagsPositions(prefValue)
-            val items = MigrationFlags.titles(manga)
+            val items = MigrationFlags.titles(manga?.toDomainManga())
                 .map { resources?.getString(it) }
                 .toTypedArray()
             val selected = items

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

@@ -4,10 +4,10 @@ import android.app.Dialog
 import android.os.Bundle
 import com.bluelinelabs.conductor.Controller
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import eu.kanade.domain.manga.model.Manga
+import eu.kanade.domain.manga.model.isLocal
 import eu.kanade.tachiyomi.R
-import eu.kanade.tachiyomi.data.database.models.Manga
 import eu.kanade.tachiyomi.ui.base.controller.DialogController
-import eu.kanade.tachiyomi.util.isLocal
 
 class DeleteLibraryMangasDialog<T>(bundle: Bundle? = null) :
     DialogController(bundle) where T : Controller, T : DeleteLibraryMangasDialog.Listener {

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

@@ -18,6 +18,7 @@ import com.jakewharton.rxrelay.PublishRelay
 import eu.kanade.domain.category.model.Category
 import eu.kanade.domain.category.model.toDbCategory
 import eu.kanade.domain.manga.model.Manga
+import eu.kanade.domain.manga.model.toDbManga
 import eu.kanade.tachiyomi.R
 import eu.kanade.tachiyomi.data.database.models.toDomainManga
 import eu.kanade.tachiyomi.data.library.LibraryUpdateService
@@ -586,7 +587,7 @@ class LibraryController(
     }
 
     private fun showDeleteMangaDialog() {
-        DeleteLibraryMangasDialog(this, selectedMangas.toList()).showDialog(router)
+        DeleteLibraryMangasDialog(this, selectedMangas.toList().map { it.toDomainManga()!! }).showDialog(router)
     }
 
     override fun updateCategoriesForMangas(mangas: List<Manga>, addCategories: List<Category>, removeCategories: List<Category>) {
@@ -594,8 +595,8 @@ class LibraryController(
         destroyActionModeIfNeeded()
     }
 
-    override fun deleteMangas(mangas: List<DbManga>, deleteFromLibrary: Boolean, deleteChapters: Boolean) {
-        presenter.removeMangas(mangas, deleteFromLibrary, deleteChapters)
+    override fun deleteMangas(mangas: List<Manga>, deleteFromLibrary: Boolean, deleteChapters: Boolean) {
+        presenter.removeMangas(mangas.map { it.toDbManga() }, deleteFromLibrary, deleteChapters)
         destroyActionModeIfNeeded()
     }
 

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

@@ -15,9 +15,11 @@ import eu.kanade.domain.manga.interactor.GetLibraryManga
 import eu.kanade.domain.manga.interactor.UpdateManga
 import eu.kanade.domain.manga.model.Manga
 import eu.kanade.domain.manga.model.MangaUpdate
+import eu.kanade.domain.manga.model.isLocal
 import eu.kanade.domain.track.interactor.GetTracks
 import eu.kanade.tachiyomi.data.cache.CoverCache
 import eu.kanade.tachiyomi.data.database.models.Chapter
+import eu.kanade.tachiyomi.data.database.models.toDomainManga
 import eu.kanade.tachiyomi.data.download.DownloadManager
 import eu.kanade.tachiyomi.data.preference.PreferencesHelper
 import eu.kanade.tachiyomi.data.track.TrackManager
@@ -27,7 +29,6 @@ import eu.kanade.tachiyomi.source.online.HttpSource
 import eu.kanade.tachiyomi.ui.base.presenter.BasePresenter
 import eu.kanade.tachiyomi.ui.library.setting.SortDirectionSetting
 import eu.kanade.tachiyomi.ui.library.setting.SortModeSetting
-import eu.kanade.tachiyomi.util.isLocal
 import eu.kanade.tachiyomi.util.lang.combineLatest
 import eu.kanade.tachiyomi.util.lang.isNullOrUnsubscribed
 import eu.kanade.tachiyomi.util.lang.launchIO
@@ -150,7 +151,7 @@ class LibraryPresenter(
         val filterFnDownloaded: (LibraryItem) -> Boolean = downloaded@{ item ->
             if (!downloadedOnly && filterDownloaded == State.IGNORE.value) return@downloaded true
             val isDownloaded = when {
-                item.manga.isLocal() -> true
+                item.manga.toDomainManga()!!.isLocal() -> true
                 item.downloadCount != -1 -> item.downloadCount > 0
                 else -> downloadManager.getDownloadCount(item.manga) > 0
             }
@@ -248,7 +249,7 @@ class LibraryPresenter(
                 }
 
                 item.isLocal = if (showLocalBadges) {
-                    item.manga.isLocal()
+                    item.manga.toDomainManga()!!.isLocal()
                 } else {
                     // Hide / Unset local badge if not enabled
                     false

app/src/main/java/eu/kanade/tachiyomi/ui/reader/ReaderPresenter.kt

@@ -63,6 +63,7 @@ import uy.kohesive.injekt.api.get
 import uy.kohesive.injekt.injectLazy
 import java.util.Date
 import java.util.concurrent.TimeUnit
+import eu.kanade.domain.manga.model.Manga as DomainManga
 
 /**
  * Presenter used by the activity to perform background operations.
@@ -136,12 +137,12 @@ class ReaderPresenter(
                     when {
                         preferences.skipRead() && it.read -> true
                         preferences.skipFiltered() -> {
-                            (manga.readFilter == Manga.CHAPTER_SHOW_READ && !it.read) ||
-                                (manga.readFilter == Manga.CHAPTER_SHOW_UNREAD && it.read) ||
-                                (manga.downloadedFilter == Manga.CHAPTER_SHOW_DOWNLOADED && !downloadManager.isChapterDownloaded(it.name, it.scanlator, manga.title, manga.source)) ||
-                                (manga.downloadedFilter == Manga.CHAPTER_SHOW_NOT_DOWNLOADED && downloadManager.isChapterDownloaded(it.name, it.scanlator, manga.title, manga.source)) ||
-                                (manga.bookmarkedFilter == Manga.CHAPTER_SHOW_BOOKMARKED && !it.bookmark) ||
-                                (manga.bookmarkedFilter == Manga.CHAPTER_SHOW_NOT_BOOKMARKED && it.bookmark)
+                            (manga.readFilter == DomainManga.CHAPTER_SHOW_READ.toInt() && !it.read) ||
+                                (manga.readFilter == DomainManga.CHAPTER_SHOW_UNREAD.toInt() && it.read) ||
+                                (manga.downloadedFilter == DomainManga.CHAPTER_SHOW_DOWNLOADED.toInt() && !downloadManager.isChapterDownloaded(it.name, it.scanlator, manga.title, manga.source)) ||
+                                (manga.downloadedFilter == DomainManga.CHAPTER_SHOW_NOT_DOWNLOADED.toInt() && downloadManager.isChapterDownloaded(it.name, it.scanlator, manga.title, manga.source)) ||
+                                (manga.bookmarkedFilter == DomainManga.CHAPTER_SHOW_BOOKMARKED.toInt() && !it.bookmark) ||
+                                (manga.bookmarkedFilter == DomainManga.CHAPTER_SHOW_NOT_BOOKMARKED.toInt() && it.bookmark)
                         }
                         else -> false
                     }
@@ -157,14 +158,14 @@ class ReaderPresenter(
         }
 
         chaptersForReader
+            .sortedWith(getChapterSort(manga.toDomainManga()!!, sortDescending = false))
             .map { it.toDbChapter() }
-            .sortedWith(getChapterSort(manga, sortDescending = false))
             .map(::ReaderChapter)
     }
 
     private var hasTrackers: Boolean = false
-    private val checkTrackers: (Manga) -> Unit = { manga ->
-        val tracks = runBlocking { getTracks.await(manga.id!!) }
+    private val checkTrackers: (DomainManga) -> Unit = { manga ->
+        val tracks = runBlocking { getTracks.await(manga.id) }
         hasTrackers = tracks.isNotEmpty()
     }
 
@@ -262,7 +263,7 @@ class ReaderPresenter(
         this.manga = manga
         if (chapterId == -1L) chapterId = initialChapterId
 
-        checkTrackers(manga)
+        checkTrackers(manga.toDomainManga()!!)
 
         val context = Injekt.get<Application>()
         val source = sourceManager.getOrStub(manga.source)

app/src/main/java/eu/kanade/tachiyomi/util/MangaExtensions.kt

@@ -2,10 +2,12 @@ package eu.kanade.tachiyomi.util
 
 import android.content.Context
 import eu.kanade.domain.manga.interactor.UpdateManga
+import eu.kanade.domain.manga.model.hasCustomCover
 import eu.kanade.domain.manga.model.isLocal
 import eu.kanade.domain.manga.model.toDbManga
 import eu.kanade.tachiyomi.data.cache.CoverCache
 import eu.kanade.tachiyomi.data.database.models.Manga
+import eu.kanade.tachiyomi.data.database.models.toDomainManga
 import eu.kanade.tachiyomi.data.preference.PreferencesHelper
 import eu.kanade.tachiyomi.source.LocalSource
 import eu.kanade.tachiyomi.source.model.SManga
@@ -15,8 +17,6 @@ import java.io.InputStream
 import java.util.Date
 import eu.kanade.domain.manga.model.Manga as DomainManga
 
-fun Manga.isLocal() = source == LocalSource.ID
-
 /**
  * Call before updating [Manga.thumbnail_url] to ensure old cover can be cleared from cache
  */
@@ -30,10 +30,10 @@ fun Manga.prepUpdateCover(coverCache: CoverCache, remoteManga: SManga, refreshSa
     if (!refreshSameUrl && thumbnail_url == newUrl) return
 
     when {
-        isLocal() -> {
+        toDomainManga()!!.isLocal() -> {
             cover_last_modified = Date().time
         }
-        hasCustomCover(coverCache) -> {
+        toDomainManga()!!.hasCustomCover(coverCache) -> {
             coverCache.deleteFromCache(this, false)
         }
         else -> {
@@ -43,12 +43,8 @@ fun Manga.prepUpdateCover(coverCache: CoverCache, remoteManga: SManga, refreshSa
     }
 }
 
-fun Manga.hasCustomCover(coverCache: CoverCache = Injekt.get()): Boolean {
-    return coverCache.getCustomCoverFile(id).exists()
-}
-
 fun Manga.removeCovers(coverCache: CoverCache = Injekt.get()): Int {
-    if (isLocal()) return 0
+    if (toDomainManga()!!.isLocal()) return 0
 
     cover_last_modified = Date().time
     return coverCache.deleteFromCache(this, true)

app/src/main/java/eu/kanade/tachiyomi/util/chapter/ChapterSorter.kt

@@ -1,50 +1,22 @@
 package eu.kanade.tachiyomi.util.chapter
 
-import eu.kanade.tachiyomi.data.database.models.Chapter
-import eu.kanade.tachiyomi.data.database.models.Manga
-import eu.kanade.tachiyomi.util.lang.compareToCaseInsensitiveNaturalOrder
-import eu.kanade.domain.chapter.model.Chapter as DomainChapter
-import eu.kanade.domain.manga.model.Manga as DomainManga
+import eu.kanade.domain.chapter.model.Chapter
+import eu.kanade.domain.manga.model.Manga
 
 fun getChapterSort(manga: Manga, sortDescending: Boolean = manga.sortDescending()): (Chapter, Chapter) -> Int {
     return when (manga.sorting) {
         Manga.CHAPTER_SORTING_SOURCE -> when (sortDescending) {
-            true -> { c1, c2 -> c1.source_order.compareTo(c2.source_order) }
-            false -> { c1, c2 -> c2.source_order.compareTo(c1.source_order) }
-        }
-        Manga.CHAPTER_SORTING_NUMBER -> when (sortDescending) {
-            true -> { c1, c2 -> c2.chapter_number.compareTo(c1.chapter_number) }
-            false -> { c1, c2 -> c1.chapter_number.compareTo(c2.chapter_number) }
-        }
-        Manga.CHAPTER_SORTING_UPLOAD_DATE -> when (sortDescending) {
-            true -> { c1, c2 -> c2.date_upload.compareTo(c1.date_upload) }
-            false -> { c1, c2 -> c1.date_upload.compareTo(c2.date_upload) }
-        }
-        else -> throw NotImplementedError("Invalid chapter sorting method: ${manga.sorting}")
-    }
-}
-
-fun getChapterSort(
-    manga: DomainManga,
-    sortDescending: Boolean = manga.sortDescending(),
-): (DomainChapter, DomainChapter) -> Int {
-    return when (manga.sorting) {
-        DomainManga.CHAPTER_SORTING_SOURCE -> when (sortDescending) {
             true -> { c1, c2 -> c1.sourceOrder.compareTo(c2.sourceOrder) }
             false -> { c1, c2 -> c2.sourceOrder.compareTo(c1.sourceOrder) }
         }
-        DomainManga.CHAPTER_SORTING_NUMBER -> when (sortDescending) {
-            true -> { c1, c2 ->
-                c2.chapterNumber.toString().compareToCaseInsensitiveNaturalOrder(c1.chapterNumber.toString())
-            }
-            false -> { c1, c2 ->
-                c1.chapterNumber.toString().compareToCaseInsensitiveNaturalOrder(c2.chapterNumber.toString())
-            }
+        Manga.CHAPTER_SORTING_NUMBER -> when (sortDescending) {
+            true -> { c1, c2 -> c2.chapterNumber.compareTo(c1.chapterNumber) }
+            false -> { c1, c2 -> c1.chapterNumber.compareTo(c2.chapterNumber) }
         }
-        DomainManga.CHAPTER_SORTING_UPLOAD_DATE -> when (sortDescending) {
+        Manga.CHAPTER_SORTING_UPLOAD_DATE -> when (sortDescending) {
             true -> { c1, c2 -> c2.dateUpload.compareTo(c1.dateUpload) }
             false -> { c1, c2 -> c1.dateUpload.compareTo(c2.dateUpload) }
         }
-        else -> throw NotImplementedError("Unimplemented sorting method")
+        else -> throw NotImplementedError("Invalid chapter sorting method: ${manga.sorting}")
     }
 }