Improve chapter parsing + fix filters

src/all/kavita/src/eu/kanade/tachiyomi/extension/all/kavita/Kavita.kt

@@ -618,38 +618,57 @@ class Kavita(private val suffix: String = "") : ConfigurableSource, UnmeteredSou
                             }
                         }
                         is CollectionFilterGroup -> {
-                            filter.state.forEach { collectionFilter ->
+                            val included = filter.state
-                                val collection = collectionsListMeta.find { it.title == (collectionFilter as Filter.TriState).name }
+                                .filter { it.state == STATE_INCLUDE }
-                                collection?.let {
+                                .mapNotNull { collectionFilter ->
-                                    when (collectionFilter.state) {
+                                    collectionsListMeta.find { it.title == collectionFilter.name }?.id?.toString()
-                                        STATE_INCLUDE -> filterV2.addStatement(
-                                            FilterComparison.Contains,
-                                            FilterField.CollectionTags,
-                                            collection.id.toString(),
-                                        )
-                                        STATE_EXCLUDE -> filterV2.addStatement(
-                                            FilterComparison.NotContains,
-                                            FilterField.CollectionTags,
-                                            collection.id.toString(),
-                                        )
-                                    }
                                 }
+                            val excluded = filter.state
+                                .filter { it.state == STATE_EXCLUDE }
+                                .mapNotNull { collectionFilter ->
+                                    collectionsListMeta.find { it.title == collectionFilter.name }?.id?.toString()
+                                }
+
+                            if (included.isNotEmpty()) {
+                                filterV2.addStatement(
+                                    FilterComparison.Contains,
+                                    FilterField.CollectionTags,
+                                    included.joinToString(","),
+                                )
+                            }
+                            if (excluded.isNotEmpty()) {
+                                filterV2.addStatement(
+                                    FilterComparison.NotContains,
+                                    FilterField.CollectionTags,
+                                    excluded.joinToString(","),
+                                )
                             }
                         }
                         is LanguageFilterGroup -> {
-                            filter.state.forEach { languageFilter ->
+                            val included = filter.state
-                                when ((languageFilter as Filter.TriState).state) {
+                                .filter { it.state == STATE_INCLUDE }
-                                    STATE_INCLUDE -> filterV2.addStatement(
+                                .mapNotNull { languageFilter ->
-                                        FilterComparison.Contains,
+                                    languagesListMeta?.find { it.title == languageFilter.name }?.isoCode
-                                        FilterField.Languages,
-                                        languageFilter.name,
-                                    )
-                                    STATE_EXCLUDE -> filterV2.addStatement(
-                                        FilterComparison.NotContains,
-                                        FilterField.Languages,
-                                        languageFilter.name,
-                                    )
                                 }
+                            val excluded = filter.state
+                                .filter { it.state == STATE_EXCLUDE }
+                                .mapNotNull { languageFilter ->
+                                    languagesListMeta?.find { it.title == languageFilter.name }?.isoCode
+                                }
+
+                            if (included.isNotEmpty()) {
+                                filterV2.addStatement(
+                                    FilterComparison.Contains,
+                                    FilterField.Languages,
+                                    included.joinToString(","),
+                                )
+                            }
+                            if (excluded.isNotEmpty()) {
+                                filterV2.addStatement(
+                                    FilterComparison.NotContains,
+                                    FilterField.Languages,
+                                    excluded.joinToString(","),
+                                )
                             }
                         }
                         is LibrariesFilterGroup -> {

src/all/kavita/src/eu/kanade/tachiyomi/extension/all/kavita/KavitaHelper.kt

@@ -76,16 +76,14 @@ class KavitaHelper {
 
             name = when (type) {
                 ChapterType.Regular -> {
-                    val volumeNum = volume.number.toString().toIntOrNull()?.let {
-                        it.toString().padStart(2, '0')
-                    } ?: volume.number.toString()
                     val chapterNum = chapter.number.toIntOrNull()?.let {
                         it.toString().padStart(2, '0')
                     } ?: chapter.number
                     when {
-                        chapter.titleName.isBlank() -> "Volume $volumeNum Chapter $chapterNum"
+                        chapter.titleName.isBlank() -> "Vol.${volume.number} Ch.$chapterNum"
-                        chapter.titleName.trim().matches(Regex("^\\d+$")) -> "Volume $volumeNum Chapter ${chapter.titleName.trim().padStart(2, '0')}"
+                        chapter.titleName.trim().matches(Regex("^\\d+$")) ->
-                        else -> "Volume $volumeNum $chapterNum - ${chapter.titleName}"
+                            "Vol.${volume.number} Ch.${chapter.titleName.trim().padStart(2, '0')}"
+                        else -> "Vol.${volume.number} Ch.$chapterNum - ${chapter.titleName}"
                     }
                 }
                 ChapterType.SingleFileVolume -> {
@@ -95,7 +93,13 @@ class KavitaHelper {
                         else -> "${volume.number} - ${volume.name}"
                     }
                 }
-                ChapterType.Special -> chapter.titleName.takeIf { it.isNotBlank() } ?: chapter.range
+                ChapterType.Special -> {
+                    when {
+                        chapter.title.isNotBlank() -> chapter.title
+                        chapter.range.isNotBlank() -> chapter.range
+                        else -> "Special"
+                    }
+                }
                 ChapterType.Chapter -> {
                     val chapterNum = chapter.number.toIntOrNull()?.let {
                         it.toString().padStart(2, '0')
@@ -121,11 +125,9 @@ class KavitaHelper {
             }
 
             chapter_number = when {
-                // If this is a SingleFileVolume and we have an explicit number (from single-file processing)
                 type == ChapterType.SingleFileVolume && singleFileVolumeNumber != null ->
                     singleFileVolumeNumber.toFloat()
 
-                // If this is a regular chapter (not a volume)
                 type != ChapterType.SingleFileVolume ->
                     chapter.number.toFloatOrNull() ?: 0f
 
@@ -159,6 +161,7 @@ class KavitaHelper {
                 ChapterType.Issue -> "Issue"
                 ChapterType.Chapter -> "Chapter"
                 ChapterType.Regular -> "Chapter"
+                else -> "Chapter"
             }
         }
 

src/all/kavita/src/eu/kanade/tachiyomi/extension/all/kavita/dto/MangaDto.kt

@@ -216,16 +216,17 @@ enum class ChapterType {
 
         fun of(chapter: ChapterDto, volume: VolumeDto, libraryType: LibraryTypeEnum? = null): ChapterType =
             when {
-                // Special cases
+                // Special
                 volume.number == SPECIAL_NUMBER -> Special
+                // Issue
                 volume.number == UNNUMBERED_VOLUME_NUMBER -> when (libraryType) {
                     LibraryTypeEnum.Comic, LibraryTypeEnum.ComicVine -> Issue
                     else -> Chapter
                 }
-                // Single file volumes
+                // SingleFileVolume
                 chapter.number == KavitaConstants.UNNUMBERED_VOLUME_STR -> SingleFileVolume
-                // Regular volumes
+                // Regular
-                volume.number > 0 -> SingleFileVolume
+                volume.number > 0 -> Regular
                 // Everything else depends on library type
                 else -> when (libraryType) {
                     LibraryTypeEnum.Comic, LibraryTypeEnum.ComicVine -> Issue