XoxoComics: Fixes (#2229)

.gitignore

@@ -92,3 +92,7 @@ local.properties
 .idea/**/runConfigurations.xml
 .idea/**/AndroidProjectSystem.xml
 .idea/caches/deviceStreaming.xml
+/.idea/copilot.data.migration.agent.xml
+/.idea/copilot.data.migration.ask.xml
+/.idea/copilot.data.migration.ask2agent.xml
+/.idea/copilot.data.migration.edit.xml

src/main/kotlin/org/koitharu/kotatsu/parsers/site/wpcomics/en/XoxoComics.kt

@@ -6,17 +6,38 @@ import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.sync.withLock
 import org.koitharu.kotatsu.parsers.MangaLoaderContext
 import org.koitharu.kotatsu.parsers.MangaSourceParser
-import org.koitharu.kotatsu.parsers.model.*
+import org.koitharu.kotatsu.parsers.model.ContentRating
+import org.koitharu.kotatsu.parsers.model.ContentType
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaChapter
+import org.koitharu.kotatsu.parsers.model.MangaListFilter
+import org.koitharu.kotatsu.parsers.model.MangaPage
+import org.koitharu.kotatsu.parsers.model.MangaParserSource
+import org.koitharu.kotatsu.parsers.model.MangaState
+import org.koitharu.kotatsu.parsers.model.MangaTag
+import org.koitharu.kotatsu.parsers.model.RATING_UNKNOWN
+import org.koitharu.kotatsu.parsers.model.SortOrder
 import org.koitharu.kotatsu.parsers.site.wpcomics.WpComicsParser
-import org.koitharu.kotatsu.parsers.util.*
+import org.koitharu.kotatsu.parsers.util.attrAsRelativeUrl
-import org.koitharu.kotatsu.parsers.Broken
+import org.koitharu.kotatsu.parsers.util.generateUid
+import org.koitharu.kotatsu.parsers.util.host
+import org.koitharu.kotatsu.parsers.util.mapChapters
+import org.koitharu.kotatsu.parsers.util.mapToSet
+import org.koitharu.kotatsu.parsers.util.oneOrThrowIfMany
+import org.koitharu.kotatsu.parsers.util.parseHtml
+import org.koitharu.kotatsu.parsers.util.parseSafe
+import org.koitharu.kotatsu.parsers.util.removeSuffix
+import org.koitharu.kotatsu.parsers.util.selectFirstOrThrow
+import org.koitharu.kotatsu.parsers.util.textOrNull
+import org.koitharu.kotatsu.parsers.util.toAbsoluteUrl
+import org.koitharu.kotatsu.parsers.util.toTitleCase
+import org.koitharu.kotatsu.parsers.util.urlEncoded
 import java.text.SimpleDateFormat
-import java.util.*
+import java.util.EnumSet
 
-@Broken
 @MangaSourceParser("XOXOCOMICS", "XoxoComics", "en", ContentType.COMICS)
 internal class XoxoComics(context: MangaLoaderContext) :
-	WpComicsParser(context, MangaParserSource.XOXOCOMICS, "xoxocomic.com", 50) {
+    WpComicsParser(context, MangaParserSource.XOXOCOMICS, "xoxocomic.com", 36) {
 
     override val listUrl = "/comic-list"
     override val datePattern = "MM/dd/yyyy"
@@ -33,7 +54,6 @@ internal class XoxoComics(context: MangaLoaderContext) :
             append("https://")
             append(domain)
             when {
-
                 !filter.query.isNullOrEmpty() -> {
                     append("/search-comic?keyword=")
                     append(filter.query.urlEncoded())
@@ -42,31 +62,31 @@ internal class XoxoComics(context: MangaLoaderContext) :
                 }
 
                 else -> {
+                    // Handle state filters
+                    val state = filter.states.oneOrThrowIfMany()
+                    val tag = filter.tags.oneOrThrowIfMany()
 
-					if (filter.tags.isNotEmpty()) {
+                    when {
-						filter.tags.oneOrThrowIfMany()?.let {
+                        // Tag filtering (genre pages)
+                        tag != null -> {
                             append("/")
-							append(it.key)
+                            append(tag.key)
-						}
-					}
-
-					filter.states.oneOrThrowIfMany()?.let {
-						append(
-							when (it) {
-								MangaState.ONGOING -> "/ongoing"
-								MangaState.FINISHED -> "/completed"
-								else -> ""
-							},
-						)
-						if (filter.tags.isEmpty()) {
                             append("-comic")
+                            when (order) {
+                                SortOrder.POPULARITY -> append("/popular")
+                                SortOrder.UPDATED -> append("/latest")
+                                SortOrder.NEWEST -> append("/newest")
+                                SortOrder.ALPHABETICAL -> append("")
+                                else -> append("/latest")
                             }
                         }
-
+                        // State filtering (ongoing/completed)
-					if (filter.states.isEmpty() && filter.tags.isEmpty()) {
+                        state != null -> {
-						append(listUrl)
+                            when (state) {
+                                MangaState.ONGOING -> append("/ongoing-comic")
+                                MangaState.FINISHED -> append("/completed-comic")
+                                else -> append(listUrl)
                             }
-
                             when (order) {
                                 SortOrder.POPULARITY -> append("/popular")
                                 SortOrder.UPDATED -> append("/latest")
@@ -74,6 +94,19 @@ internal class XoxoComics(context: MangaLoaderContext) :
                                 SortOrder.ALPHABETICAL -> append("")
                                 else -> append("/latest")
                             }
+                        }
+                        // Default listing
+                        else -> {
+                            when (order) {
+                                SortOrder.UPDATED -> append("/comic-update")
+                                SortOrder.POPULARITY -> append("/popular-comic")
+                                SortOrder.NEWEST -> append("/new-comic")
+                                SortOrder.ALPHABETICAL -> append(listUrl)
+                                else -> append("/comic-update")
+                            }
+                        }
+                    }
+
                     append("?page=")
                     append(page.toString())
                 }
@@ -81,14 +114,36 @@ internal class XoxoComics(context: MangaLoaderContext) :
         }
         val doc = webClient.httpGet(url).parseHtml()
 
-		return doc.select("div.item, #nt_listchapter nav ul li").map { div ->
+        // Handle different page layouts: popular comics (article.item), ongoing/completed (div.item), and list pages (li.row)
-			val href = div.selectFirstOrThrow("a").attrAsRelativeUrl("href")
+        val elements = doc.select("div.items article.item, div.row div.item, li.row")
+
+        return elements.map { element ->
+            // Find the main link - could be in different locations depending on page type
+            val a = element.selectFirst("figure figcaption h3 a")
+                ?: element.selectFirst("figcaption h3 a")
+                ?: element.selectFirst("h3 a")
+                ?: element.selectFirst("a")
+                ?: throw IllegalStateException("Could not find main link in element")
+
+            val href = a.attrAsRelativeUrl("href")
+
+            // Handle different image structures and lazy loading
+            val img = element.selectFirst("img")
+            val coverUrl = when {
+                img?.hasAttr("data-original") == true -> img.attr("data-original")
+                img?.hasAttr("data-src") == true -> img.attr("data-src")
+                img?.hasAttr("src") == true -> img.attr("src")
+                else -> ""
+            }.takeIf { it.isNotBlank() && !it.contains("data:image") } ?: ""
+
+            val title = a.text().trim()
+
             Manga(
                 id = generateUid(href),
                 url = href,
-				publicUrl = href.toAbsoluteUrl(div.host ?: domain),
+                publicUrl = href.toAbsoluteUrl(element.host ?: domain),
-				coverUrl = div.selectFirst("img")?.src().orEmpty(),
+                coverUrl = coverUrl,
-				title = div.selectFirstOrThrow("h3").text().orEmpty(),
+                title = title,
                 altTitles = emptySet(),
                 rating = RATING_UNKNOWN,
                 tags = emptySet(),
@@ -154,9 +209,11 @@ internal class XoxoComics(context: MangaLoaderContext) :
         while (true) {
             ++page
             val doc = webClient.httpGet("$baseUrl?page=$page").parseHtml()
-			doc.selectFirst("#nt_listchapter nav ul li:not(.heading)") ?: break
+            val chapterElements = doc.select("#nt_listchapter nav ul li:not(.heading)")
+            if (chapterElements.isEmpty()) break
+
             chapters.addAll(
-				doc.select("#nt_listchapter nav ul li:not(.heading)").mapChapters { _, li ->
+                chapterElements.mapChapters { _, li ->
                     val a = li.selectFirstOrThrow("a")
                     val href = a.attr("href")
                     val dateText = li.selectFirst("div.col-xs-3")?.text()
@@ -171,7 +228,6 @@ internal class XoxoComics(context: MangaLoaderContext) :
                         branch = null,
                         source = source,
                     )
-
                 },
             )
         }
@@ -182,11 +238,11 @@ internal class XoxoComics(context: MangaLoaderContext) :
     override suspend fun getPages(chapter: MangaChapter): List<MangaPage> {
         val fullUrl = chapter.url.toAbsoluteUrl(domain) + "/all"
         val doc = webClient.httpGet(fullUrl).parseHtml()
-		return doc.select(selectPage).mapNotNull { url ->
+        return doc.select("img[data-original]").mapNotNull { img ->
-			val img = url.src()?.toRelativeUrl(domain) ?: return@mapNotNull null
+            val imgUrl = img.attr("data-original").takeIf { it.isNotBlank() } ?: return@mapNotNull null
-			val originalImage = img.replace("[", "").replace("]", "")
+            val originalImage = imgUrl.replace("[", "").replace("]", "")
             MangaPage(
-				id = generateUid(img),
+                id = generateUid(originalImage),
                 url = originalImage,
                 preview = null,
                 source = source,