fix getListPage Some sources madara

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/all/Manga18Fx.kt

@@ -19,39 +19,49 @@ internal class Manga18Fx(context: MangaLoaderContext) :
 	override val selectDate = "span.chapter-time"
 	override val selectChapter = "li.a-h"
 	override val selectBodyPage = "div.read-content"
-	override suspend fun getListPage(
+
-		page: Int,
+	init {
-		query: String?,
+		paginator.firstPage = 1
-		tags: Set<MangaTag>?,
+		searchPaginator.firstPage = 1
-		sortOrder: SortOrder,
+	}
-	): List<Manga> {
+
-		val tag = tags.oneOrThrowIfMany()
+	override val availableStates: Set<MangaState> get() = emptySet()
+
+	override suspend fun getListPage(page: Int, filter: MangaListFilter?): List<Manga> {
+
 		val url = buildString {
 			append("https://")
 			append(domain)
-			val pages = page + 1
+			when (filter) {
-			when {
+				is MangaListFilter.Search -> {
-				!query.isNullOrEmpty() -> {
-
 					append("/search?q=")
-					append(query.urlEncoded())
+					append(filter.query.urlEncoded())
 					append("&page=")
-					append(pages)
+					append(page.toString())
 				}
 
-				!tags.isNullOrEmpty() -> {
+				is MangaListFilter.Advanced -> {
-					append("/$tagPrefix")
+
-					append(tag?.key.orEmpty())
+					val tag = filter.tags.oneOrThrowIfMany()
-					if (pages > 1) {
+					if (filter.tags.isNotEmpty()) {
-						append("/")
+						append("/$tagPrefix")
-						append(pages)
+						append(tag?.key.orEmpty())
+						if (page > 1) {
+							append("/")
+							append(page.toString())
+						}
+					} else {
+						if (page > 1) {
+							append("/page/")
+							append(page)
+						}
 					}
 				}
 
-				else -> {
+				null -> {
-					if (pages > 1) {
+					if (page > 1) {
 						append("/page/")
-						append(pages)
+						append(page)
 					}
 				}
 			}

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/all/Manhwa18Cc.kt

@@ -26,48 +26,48 @@ internal class Manhwa18Cc(context: MangaLoaderContext) :
 		searchPaginator.firstPage = 1
 	}
 
-	override suspend fun getListPage(
+	override val availableStates: Set<MangaState> get() = emptySet()
-		page: Int,
+
-		query: String?,
+	override suspend fun getListPage(page: Int, filter: MangaListFilter?): List<Manga> {
-		tags: Set<MangaTag>?,
-		sortOrder: SortOrder,
-	): List<Manga> {
-		val tag = tags.oneOrThrowIfMany()
 		val url = buildString {
 			append("https://")
 			append(domain)
-			when {
+			when (filter) {
-				!query.isNullOrEmpty() -> {
+
+				is MangaListFilter.Search -> {
 					append("/search?q=")
-					append(query.urlEncoded())
+					append(filter.query.urlEncoded())
 					append("&page=")
 					append(page.toString())
 				}
 
-				!tags.isNullOrEmpty() -> {
+				is MangaListFilter.Advanced -> {
-					append("/$tagPrefix")
+
-					append(tag?.key.orEmpty())
+					val tag = filter.tags.oneOrThrowIfMany()
+					if (filter.tags.isNotEmpty()) {
+						append("/$tagPrefix")
+						append(tag?.key.orEmpty())
+					} else {
+						append("/$listUrl")
+					}
+
 					if (page > 1) {
 						append(page.toString())
 					}
-					append("?")
-				}
 
-				else -> {
+					append("?orderby=")
-					append("/$listUrl")
+					when (filter.sortOrder) {
-					if (page > 1) {
+						SortOrder.POPULARITY -> append("trending")
-						append(page)
+						SortOrder.UPDATED -> append("latest")
+						SortOrder.ALPHABETICAL -> append("alphabet")
+						SortOrder.RATING -> append("rating")
+						else -> append("latest")
 					}
-					append("?")
 				}
-			}
+
-			append("m_orderby=")
+				null -> {
-			when (sortOrder) {
+					append("?s&post_type=wp-manga&m_orderby=latest")
-				SortOrder.POPULARITY -> append("trending")
+				}
-				SortOrder.UPDATED -> append("latest")
-				SortOrder.ALPHABETICAL -> append("alphabet")
-				SortOrder.RATING -> append("rating")
-				else -> append("latest")
 			}
 		}
 		val doc = webClient.httpGet(url).parseHtml()

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Hentai4Free.kt

@@ -5,6 +5,7 @@ import org.koitharu.kotatsu.parsers.MangaLoaderContext
 import org.koitharu.kotatsu.parsers.MangaSourceParser
 import org.koitharu.kotatsu.parsers.model.ContentType
 import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaListFilter
 import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.parsers.model.MangaState
 import org.koitharu.kotatsu.parsers.model.MangaTag
@@ -20,48 +21,48 @@ internal class Hentai4Free(context: MangaLoaderContext) :
 	override val listUrl = ""
 	override val withoutAjax = true
 	override val datePattern = "MMMM dd, yyyy"
+	override val selectGenre = "div.tags-content a"
 
+	override val availableStates: Set<MangaState> get() = emptySet()
 
-	override suspend fun getListPage(
+	init {
-		page: Int,
+		paginator.firstPage = 1
-		query: String?,
+		searchPaginator.firstPage = 1
-		tags: Set<MangaTag>?,
+	}
-		sortOrder: SortOrder,
-	): List<Manga> {
-
-		val tag = tags.oneOrThrowIfMany()
 
+	override suspend fun getListPage(page: Int, filter: MangaListFilter?): List<Manga> {
 		val url = buildString {
 			append("https://")
 			append(domain)
-			val pages = page + 1
+			when (filter) {
-			when {
+				is MangaListFilter.Search -> {
-				!query.isNullOrEmpty() -> {
 					append("/page/")
-					append(pages.toString())
+					append(page.toString())
 					append("/?s=")
-					append(query.urlEncoded())
+					append(filter.query.urlEncoded())
-					append("&post_type=wp-manga&")
+					append("&post_type=wp-manga")
 				}
 
-				!tags.isNullOrEmpty() -> {
+				is MangaListFilter.Advanced -> {
-					append("/$tagPrefix")
-					append(tag?.key.orEmpty())
-					append("/")
-					if (pages > 1) {
-						append("page/")
-						append(pages.toString())
-					}
-				}
 
-				else -> {
+					val tag = filter.tags.oneOrThrowIfMany()
-
+					if (filter.tags.isNotEmpty()) {
-					if (pages > 1) {
+						append("/$tagPrefix")
-						append("/page/")
+						append(tag?.key.orEmpty())
-						append(pages.toString())
+						append("/")
+						if (page > 1) {
+							append("page/")
+							append(page.toString())
+						}
+					} else {
+						if (page > 1) {
+							append("/page/")
+							append(page.toString())
+						}
 					}
+
 					append("/?m_orderby=")
-					when (sortOrder) {
+					when (filter.sortOrder) {
 						SortOrder.POPULARITY -> append("views")
 						SortOrder.UPDATED -> append("latest")
 						SortOrder.NEWEST -> append("new-manga")
@@ -69,9 +70,17 @@ internal class Hentai4Free(context: MangaLoaderContext) :
 						SortOrder.RATING -> append("rating")
 					}
 				}
-			}
 
+				null -> {
+					if (page > 1) {
+						append("/page/")
+						append(page.toString())
+					}
+					append("/?m_orderby=latest")
+				}
+			}
 		}
+
 		val doc = webClient.httpGet(url).parseHtml()
 
 		return doc.select("div.row.c-tabs-item__content").ifEmpty {

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/InstaManhwa.kt

@@ -23,46 +23,48 @@ internal class InstaManhwa(context: MangaLoaderContext) :
 		SortOrder.NEWEST,
 	)
 
-	override suspend fun getListPage(
+	override val availableStates: Set<MangaState> get() = emptySet()
-		page: Int,
+
-		query: String?,
+	init {
-		tags: Set<MangaTag>?,
+		paginator.firstPage = 1
-		sortOrder: SortOrder,
+		searchPaginator.firstPage = 1
-	): List<Manga> {
+	}
-		val tag = tags.oneOrThrowIfMany()
+
+	override suspend fun getListPage(page: Int, filter: MangaListFilter?): List<Manga> {
 		val url = buildString {
 			append("https://")
 			append(domain)
-			val pages = page + 1
+			when (filter) {
-
+				is MangaListFilter.Search -> {
-			when {
+					append("/search?q=")
-				!query.isNullOrEmpty() -> {
+					append(filter.query.urlEncoded())
-
-					append("/?search=")
-					append(query.urlEncoded())
 					append("&page=")
-					append(pages.toString())
+					append(page.toString())
-					append("&post_type=wp-manga&post_type=wp-manga")
 				}
 
-				!tags.isNullOrEmpty() -> {
+				is MangaListFilter.Advanced -> {
-					append("/genre/")
-					append(tag?.key.orEmpty())
-					append("?page=")
-					append(pages.toString())
 
+					val tag = filter.tags.oneOrThrowIfMany()
+					if (filter.tags.isNotEmpty()) {
+						append("/genre/")
+						append(tag?.key.orEmpty())
+						append("?page=")
+						append(page.toString())
+					} else {
+						when (filter.sortOrder) {
+							SortOrder.UPDATED -> append("/latest")
+							SortOrder.NEWEST -> append("/new")
+							SortOrder.ALPHABETICAL -> append("/alphabet")
+							else -> append("/latest")
+						}
+						append("?page=")
+						append(page.toString())
+					}
 				}
 
-				else -> {
+				null -> {
-
+					append("/latest?page=")
-					when (sortOrder) {
+					append(page.toString())
-						SortOrder.UPDATED -> append("/latest")
-						SortOrder.NEWEST -> append("/new")
-						SortOrder.ALPHABETICAL -> append("/alphabet")
-						else -> append("/latest")
-					}
-					append("?page=")
-					append(pages.toString())
 				}
 			}
 		}

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/IsekaiScan.kt

@@ -22,50 +22,58 @@ internal class IsekaiScan(context: MangaLoaderContext) :
 		SortOrder.UPDATED,
 	)
 
-	override suspend fun getListPage(
+	override val availableStates: Set<MangaState> get() = emptySet()
-		page: Int,
+
-		query: String?,
+	init {
-		tags: Set<MangaTag>?,
+		paginator.firstPage = 1
-		sortOrder: SortOrder,
+		searchPaginator.firstPage = 1
-	): List<Manga> {
+	}
-		val tag = tags.oneOrThrowIfMany()
+
+	override suspend fun getListPage(page: Int, filter: MangaListFilter?): List<Manga> {
+
 		val url = buildString {
 			append("https://")
 			append(domain)
-			val pages = page + 1
+			when (filter) {
-
+				is MangaListFilter.Search -> {
-			when {
-				!query.isNullOrEmpty() -> {
-
 					append("/?search=")
-					append(query.urlEncoded())
+					append(filter.query.urlEncoded())
 					append("&page=")
-					append(pages.toString())
+					append(page.toString())
 					append("&post_type=wp-manga")
 				}
 
-				!tags.isNullOrEmpty() -> {
+				is MangaListFilter.Advanced -> {
-					append("/mangas/")
+
-					append(tag?.key.orEmpty())
+					val tag = filter.tags.oneOrThrowIfMany()
-					append("?orderby=2&page=")
+					if (filter.tags.isNotEmpty()) {
-					append(pages.toString())
+						append("/$tagPrefix")
-
+						append(tag?.key.orEmpty())
+						append("?orderby=")
+						when (filter.sortOrder) {
+							SortOrder.POPULARITY -> append("2")
+							SortOrder.UPDATED -> append("3")
+							else -> append("3")
+						}
+						append("&page=")
+						append(page.toString())
+					} else {
+						when (filter.sortOrder) {
+							SortOrder.POPULARITY -> append("/popular-manga")
+							SortOrder.UPDATED -> append("/latest-manga")
+							else -> append("/latest-manga")
+						}
+						append("?page=")
+						append(page.toString())
+					}
 				}
 
-				else -> {
+				null -> {
-
+					append("/latest-manga?page=")
-					if (sortOrder == SortOrder.POPULARITY) {
+					append(page.toString())
-						append("/popular-manga")
-					}
-					if (sortOrder == SortOrder.UPDATED) {
-						append("/latest-manga")
-					}
-					append("?page=")
-					append(pages.toString())
 				}
 			}
 		}
-
 		val doc = webClient.httpGet(url).parseHtml()
 
 		return doc.select("div.row.c-tabs-item__content").ifEmpty {
@@ -91,8 +99,8 @@ internal class IsekaiScan(context: MangaLoaderContext) :
 				author = summary?.selectFirst(".mg_author")?.selectFirst("a")?.ownText(),
 				state = when (summary?.selectFirst(".mg_status")?.selectFirst(".summary-content")?.ownText()?.trim()
 					?.lowercase()) {
-					"Ongoing" -> MangaState.ONGOING
+					"ongoing" -> MangaState.ONGOING
-					"Completed " -> MangaState.FINISHED
+					"completed " -> MangaState.FINISHED
 					else -> null
 				},
 				source = source,
@@ -133,8 +141,8 @@ internal class IsekaiScan(context: MangaLoaderContext) :
 	override suspend fun getPages(chapter: MangaChapter): List<MangaPage> {
 		val fullUrl = chapter.url.toAbsoluteUrl(domain)
 		val doc = webClient.httpGet(fullUrl).parseHtml()
-		val urlarray = doc.select("p#arraydata").text().split(",").toTypedArray()
+		val urlArray = doc.select("p#arraydata").text().split(",").toTypedArray()
-		return urlarray.map { url ->
+		return urlArray.map { url ->
 			MangaPage(
 				id = generateUid(url),
 				url = url,

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/IsekaiScanEuParser.kt

@@ -14,50 +14,71 @@ internal class IsekaiScanEuParser(context: MangaLoaderContext) :
 	override val withoutAjax = true
 	override val listUrl = "mangax/"
 
-	override suspend fun getListPage(
+	init {
-		page: Int,
+		paginator.firstPage = 1
-		query: String?,
+		searchPaginator.firstPage = 1
-		tags: Set<MangaTag>?,
+	}
-		sortOrder: SortOrder,
+
-	): List<Manga> {
+	override suspend fun getListPage(page: Int, filter: MangaListFilter?): List<Manga> {
-		val tag = tags.oneOrThrowIfMany()
+
 		val url = buildString {
 			append("https://")
 			append(domain)
-			val pages = page + 1
 
-			when {
+			when (filter) {
-				!query.isNullOrEmpty() -> {
+
-					append("/page/")
+				is MangaListFilter.Search -> {
-					append(pages.toString())
+					if (page > 1) {
+						append("/page/")
+						append(page.toString())
+					}
 					append("/?s=")
-					append(query.urlEncoded())
+					append(filter.query.urlEncoded())
-					append("&post_type=wp-manga&")
+					append("&post_type=wp-manga")
 				}
 
-				!tags.isNullOrEmpty() -> {
+				is MangaListFilter.Advanced -> {
-					append("/$tagPrefix")
-					append(tag?.key.orEmpty())
-					append("/page/")
-					append(pages.toString())
-					append("?")
-				}
 
-				else -> {
+					val tag = filter.tags.oneOrThrowIfMany()
+					if (filter.tags.isNotEmpty()) {
+						append("/$tagPrefix")
+						append(tag?.key.orEmpty())
+						if (page > 1) {
+							append("/page/")
+							append(page.toString())
+						}
+						append("/?")
+					} else {
+						if (page > 1) {
+							append("/page/")
+							append(page.toString())
+						}
+						append("/?s=&post_type=wp-manga")
+						filter.states.forEach {
+							append("&status[]=")
+							when (it) {
+								MangaState.ONGOING -> append("on-going")
+								MangaState.FINISHED -> append("end")
+								MangaState.ABANDONED -> append("canceled")
+								MangaState.PAUSED -> append("on-hold")
+							}
+						}
+						append("&")
+					}
 
-					append("/$listUrl")
+					append("m_orderby=")
-					append("/page/")
+					when (filter.sortOrder) {
-					append(pages.toString())
+						SortOrder.POPULARITY -> append("views")
-					append("?")
+						SortOrder.UPDATED -> append("latest")
+						SortOrder.NEWEST -> append("new-manga")
+						SortOrder.ALPHABETICAL -> append("alphabet")
+						SortOrder.RATING -> append("rating")
+					}
+				}
+
+				null -> {
+					append("/?s&post_type=wp-manga&m_orderby=latest")
 				}
-			}
-			append("m_orderby=")
-			when (sortOrder) {
-				SortOrder.POPULARITY -> append("views")
-				SortOrder.UPDATED -> append("latest")
-				SortOrder.NEWEST -> append("new-manga")
-				SortOrder.ALPHABETICAL -> append("alphabet")
-				SortOrder.RATING -> append("rating")
 			}
 		}
 		val doc = webClient.httpGet(url).parseHtml()

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaDass.kt

@@ -19,55 +19,61 @@ internal class MangaDass(context: MangaLoaderContext) :
 	override val selectChapter = "li.a-h"
 	override val selectDesc = "div.ss-manga"
 
-	override suspend fun getListPage(
+	override val availableStates: Set<MangaState> get() = emptySet()
-		page: Int,
+
-		query: String?,
+	init {
-		tags: Set<MangaTag>?,
+		paginator.firstPage = 1
-		sortOrder: SortOrder,
+		searchPaginator.firstPage = 1
-	): List<Manga> {
+	}
-		val tag = tags.oneOrThrowIfMany()
+
+	override suspend fun getListPage(page: Int, filter: MangaListFilter?): List<Manga> {
+
 		val url = buildString {
 			append("https://")
 			append(domain)
-			val pages = page + 1
+			when (filter) {
-
+				is MangaListFilter.Search -> {
-			when {
+					append("/search?q=")
-				!query.isNullOrEmpty() -> {
+					append(filter.query.urlEncoded())
-
-					append("/?s=")
-					append(query.urlEncoded())
 					append("&page=")
-					append(pages.toString())
+					append(page.toString())
 				}
 
-				!tags.isNullOrEmpty() -> {
+				is MangaListFilter.Advanced -> {
-					append("/$tagPrefix")
+
-					append(tag?.key.orEmpty())
+					val tag = filter.tags.oneOrThrowIfMany()
-					append("/")
+					if (filter.tags.isNotEmpty()) {
-					append(pages.toString())
+						append("/$tagPrefix")
-					append("?")
+						append(tag?.key.orEmpty())
+						append("/")
+						append(page.toString())
+						append("?")
+					} else {
+						append("/$listUrl")
+						append("/")
+						append(page.toString())
+						append("?")
+					}
+
+					append("orderby=")
+					when (filter.sortOrder) {
+						SortOrder.POPULARITY -> append("views")
+						SortOrder.UPDATED -> append("latest")
+						SortOrder.NEWEST -> append("new-manga")
+						SortOrder.ALPHABETICAL -> append("alphabet")
+						SortOrder.RATING -> append("rating")
+					}
 				}
 
-				else -> {
+				null -> {
-
 					append("/$listUrl")
 					append("/")
-					append(pages.toString())
+					append(page.toString())
-					append("?")
+					append("?orderby=latest")
 				}
 			}
-			append("orderby=")
-			when (sortOrder) {
-				SortOrder.POPULARITY -> append("views")
-				SortOrder.UPDATED -> append("latest")
-				SortOrder.NEWEST -> append("new-manga")
-				SortOrder.ALPHABETICAL -> append("alphabet")
-				SortOrder.RATING -> append("rating")
-			}
 		}
 		val doc = webClient.httpGet(url).parseHtml()
-
-
 		return doc.select("div.row.c-tabs-item__content").ifEmpty {
 			doc.select("div.page-item-detail")
 		}.map { div ->

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaDna.kt

@@ -18,53 +18,53 @@ internal class MangaDna(context: MangaLoaderContext) :
 	override val withoutAjax = true
 	override val selectDesc = "div.dsct"
 	override val selectChapter = "li.a-h"
+	override val availableStates: Set<MangaState> get() = emptySet()
 
-	override suspend fun getListPage(
+	override suspend fun getListPage(page: Int, filter: MangaListFilter?): List<Manga> {
-		page: Int,
-		query: String?,
-		tags: Set<MangaTag>?,
-		sortOrder: SortOrder,
-	): List<Manga> {
-		val tag = tags.oneOrThrowIfMany()
 		val url = buildString {
 			append("https://")
 			append(domain)
-			val pages = page + 1
+			when (filter) {
-
+				is MangaListFilter.Search -> {
-			when {
+					append("/search?q=")
-				!query.isNullOrEmpty() -> {
+					append(filter.query.urlEncoded())
-					append("/page/")
+					append("&page=")
-					append(pages.toString())
+					append(page.toString())
-					append("/?s=")
-					append(query.urlEncoded())
-					append("&post_type=wp-manga&")
 				}
 
-				!tags.isNullOrEmpty() -> {
+				is MangaListFilter.Advanced -> {
-					append("/$tagPrefix")
+
-					append(tag?.key.orEmpty())
+					val tag = filter.tags.oneOrThrowIfMany()
-					append("/page/")
+					if (filter.tags.isNotEmpty()) {
-					append(pages.toString())
+						append("/$tagPrefix")
-					append("?")
+						append(tag?.key.orEmpty())
+						append("/")
+						append(page.toString())
+					} else {
+						append("/$listUrl")
+						append("/page/")
+						append(page.toString())
+					}
+
+					append("?orderby=")
+					when (filter.sortOrder) {
+						SortOrder.POPULARITY -> append("trending")
+						SortOrder.UPDATED -> append("latest")
+						SortOrder.ALPHABETICAL -> append("alphabet")
+						SortOrder.RATING -> append("rating")
+						else -> append("latest")
+					}
 				}
 
-				else -> {
+				null -> {
-
 					append("/$listUrl")
 					append("/page/")
-					append(pages.toString())
+					append(page.toString())
-					append("?")
+					append("?orderby=latest")
 				}
 			}
-			append("m_orderby=")
-			when (sortOrder) {
-				SortOrder.POPULARITY -> append("views")
-				SortOrder.UPDATED -> append("latest")
-				SortOrder.NEWEST -> append("new-manga")
-				SortOrder.ALPHABETICAL -> append("alphabet")
-				SortOrder.RATING -> append("rating")
-			}
 		}
+
 		val doc = webClient.httpGet(url).parseHtml()
 
 

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaPure.kt

@@ -21,46 +21,54 @@ internal class MangaPure(context: MangaLoaderContext) :
 		SortOrder.UPDATED,
 	)
 
-	override suspend fun getListPage(
+	override val availableStates: Set<MangaState> get() = emptySet()
-		page: Int,
+
-		query: String?,
+	init {
-		tags: Set<MangaTag>?,
+		paginator.firstPage = 1
-		sortOrder: SortOrder,
+		searchPaginator.firstPage = 1
-	): List<Manga> {
+	}
-		val tag = tags.oneOrThrowIfMany()
+
+	override suspend fun getListPage(page: Int, filter: MangaListFilter?): List<Manga> {
 		val url = buildString {
 			append("https://")
 			append(domain)
-			val pages = page + 1
+			when (filter) {
-
+				is MangaListFilter.Search -> {
-			when {
+					append("/search?s=")
-				!query.isNullOrEmpty() -> {
+					append(filter.query.urlEncoded())
-
-					append("/?search=")
-					append(query.urlEncoded())
 					append("&page=")
-					append(pages.toString())
+					append(page.toString())
 					append("&post_type=wp-manga")
 				}
 
-				!tags.isNullOrEmpty() -> {
+				is MangaListFilter.Advanced -> {
-					append("/mangas/")
+
-					append(tag?.key.orEmpty())
+					val tag = filter.tags.oneOrThrowIfMany()
-					append("?orderby=2&page=")
+					if (filter.tags.isNotEmpty()) {
-					append(pages.toString())
+						append("/$tagPrefix")
-
+						append(tag?.key.orEmpty())
+						append("?orderby=")
+						when (filter.sortOrder) {
+							SortOrder.POPULARITY -> append("2")
+							SortOrder.UPDATED -> append("3")
+							else -> append("3")
+						}
+						append("&page=")
+						append(page.toString())
+					} else {
+						when (filter.sortOrder) {
+							SortOrder.POPULARITY -> append("/popular-manga")
+							SortOrder.UPDATED -> append("/latest-manga")
+							else -> append("/latest-manga")
+						}
+						append("?page=")
+						append(page.toString())
+					}
 				}
 
-				else -> {
+				null -> {
-
+					append("/latest-manga?page=")
-					if (sortOrder == SortOrder.POPULARITY) {
+					append(page.toString())
-						append("/popular-manga")
-					}
-					if (sortOrder == SortOrder.UPDATED) {
-						append("/latest-manga")
-					}
-					append("?page=")
-					append(pages.toString())
 				}
 			}
 		}

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhwaz.kt

@@ -5,6 +5,7 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser
 import org.koitharu.kotatsu.parsers.model.*
 import org.koitharu.kotatsu.parsers.site.madara.MadaraParser
 import org.koitharu.kotatsu.parsers.util.*
+import java.util.EnumSet
 
 @MangaSourceParser("MANHWAZ", "ManhwaZ", "en")
 internal class Manhwaz(context: MangaLoaderContext) :
@@ -15,51 +16,65 @@ internal class Manhwaz(context: MangaLoaderContext) :
 	override val withoutAjax = true
 	override val selectTestAsync = "div.list-chapter"
 
-	override suspend fun getListPage(
+	override val availableStates: Set<MangaState> get() = emptySet()
-		page: Int,
+
-		query: String?,
+	override val availableSortOrders: Set<SortOrder> = EnumSet.of(
-		tags: Set<MangaTag>?,
+		SortOrder.UPDATED,
-		sortOrder: SortOrder,
+		SortOrder.POPULARITY,
-	): List<Manga> {
+		SortOrder.NEWEST,
-		val tag = tags.oneOrThrowIfMany()
+		SortOrder.RATING,
+	)
+
+	init {
+		paginator.firstPage = 1
+		searchPaginator.firstPage = 1
+	}
+
+	override suspend fun getListPage(page: Int, filter: MangaListFilter?): List<Manga> {
 		val url = buildString {
 			append("https://")
 			append(domain)
-			val pages = page + 1
+			when (filter) {
-
+				is MangaListFilter.Search -> {
-			when {
-				!query.isNullOrEmpty() -> {
-
 					append("/search?s=")
-					append(query.urlEncoded())
+					append(filter.query.urlEncoded())
 					append("&page=")
-					append(pages.toString())
+					append(page.toString())
 				}
 
-				!tags.isNullOrEmpty() -> {
+				is MangaListFilter.Advanced -> {
-					append("/$tagPrefix")
-					append(tag?.key.orEmpty())
-					append("?page=")
-					append(pages.toString())
-					append("&")
-				}
 
-				else -> {
+					val tag = filter.tags.oneOrThrowIfMany()
+					if (filter.tags.isNotEmpty()) {
+						append("/$tagPrefix")
+						append(tag?.key.orEmpty())
+						append("?page=")
+						append(page.toString())
+						append("&")
+					} else {
+						append("/$listUrl")
+						append("?page=")
+						append(page.toString())
+						append("&")
+					}
 
+					append("m_orderby=")
+					when (filter.sortOrder) {
+						SortOrder.POPULARITY -> append("views")
+						SortOrder.UPDATED -> append("latest")
+						SortOrder.NEWEST -> append("new")
+						SortOrder.RATING -> append("rating")
+						else -> append("latest")
+					}
+				}
+
+				null -> {
 					append("/$listUrl")
 					append("?page=")
-					append(pages.toString())
+					append(page.toString())
-					append("&")
+					append("&m_orderby=latest")
 				}
 			}
-			append("m_orderby=")
-			when (sortOrder) {
-				SortOrder.POPULARITY -> append("views")
-				SortOrder.UPDATED -> append("latest")
-				SortOrder.NEWEST -> append("new-manga")
-				SortOrder.ALPHABETICAL -> append("alphabet")
-				SortOrder.RATING -> append("rating")
-			}
 		}
 		val doc = webClient.httpGet(url).parseHtml()
 

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/DragonTranslationParser.kt

@@ -3,8 +3,9 @@ package org.koitharu.kotatsu.parsers.site.madara.es
 import org.koitharu.kotatsu.parsers.MangaLoaderContext
 import org.koitharu.kotatsu.parsers.MangaSourceParser
 import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaListFilter
 import org.koitharu.kotatsu.parsers.model.MangaSource
-import org.koitharu.kotatsu.parsers.model.MangaTag
+import org.koitharu.kotatsu.parsers.model.MangaState
 import org.koitharu.kotatsu.parsers.model.SortOrder
 import org.koitharu.kotatsu.parsers.site.madara.MadaraParser
 import org.koitharu.kotatsu.parsers.util.*
@@ -13,48 +14,46 @@ import java.util.*
 @MangaSourceParser("DRAGONTRANSLATION", "Dragon Translation", "es")
 internal class DragonTranslationParser(context: MangaLoaderContext) :
 	MadaraParser(context, MangaSource.DRAGONTRANSLATION, "dragontranslation.net", 30) {
-
-	override val availableSortOrders: Set<SortOrder> = EnumSet.of(SortOrder.UPDATED)
-
 	override val selectPage = "div#chapter_imgs img"
+	override val availableSortOrders: Set<SortOrder> = EnumSet.of(SortOrder.UPDATED)
+	override val availableStates: Set<MangaState> get() = emptySet()
 
-	override suspend fun getListPage(
+	init {
-		page: Int,
+		paginator.firstPage = 1
-		query: String?,
+		searchPaginator.firstPage = 1
-		tags: Set<MangaTag>?,
+	}
-		sortOrder: SortOrder,
-	): List<Manga> {
-
-		val tag = tags.oneOrThrowIfMany()
 
+	override suspend fun getListPage(page: Int, filter: MangaListFilter?): List<Manga> {
 		val url = buildString {
 			append("https://")
 			append(domain)
-			val pages = page + 1
+			when (filter) {
-
+				is MangaListFilter.Search -> {
-			when {
-				!query.isNullOrEmpty() -> {
 					append("/mangas?buscar=")
-					append(query.urlEncoded())
+					append(filter.query.urlEncoded())
 					append("&page=")
-					append(pages.toString())
+					append(page.toString())
 				}
 
-				!tags.isNullOrEmpty() -> {
+				is MangaListFilter.Advanced -> {
-					append("/mangas?tag=")
-					append(tag?.key.orEmpty())
-					append("&page=")
-					append(pages.toString())
-				}
 
-				else -> {
+					append("/mangas?page=")
+					append(page.toString())
 
-					append("/mangas")
+					val tag = filter.tags.oneOrThrowIfMany()
-					append("?page=")
+					if (filter.tags.isNotEmpty()) {
-					append(pages.toString())
+						append("&tag=")
+						append(tag?.key.orEmpty())
+					}
+				}
+
+				null -> {
+					append("/mangas?page=")
+					append(page.toString())
 				}
 			}
 		}
+
 		val doc = webClient.httpGet(url).parseHtml()
 
 		return doc.select("div.video-bg div.col-6 ").map { div ->

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/MonarcaManga.kt

@@ -4,93 +4,9 @@ import org.koitharu.kotatsu.parsers.MangaLoaderContext
 import org.koitharu.kotatsu.parsers.MangaSourceParser
 import org.koitharu.kotatsu.parsers.model.*
 import org.koitharu.kotatsu.parsers.site.madara.MadaraParser
-import org.koitharu.kotatsu.parsers.util.*
 
 @MangaSourceParser("MONARCAMANGA", "MonarcaManga", "es")
 internal class MonarcaManga(context: MangaLoaderContext) :
 	MadaraParser(context, MangaSource.MONARCAMANGA, "monarcamanga.com") {
-
 	override val tagPrefix = "manga-generos/"
-	override val withoutAjax = true
-
-	override suspend fun getListPage(
-		page: Int,
-		query: String?,
-		tags: Set<MangaTag>?,
-		sortOrder: SortOrder,
-	): List<Manga> {
-		val tag = tags.oneOrThrowIfMany()
-		val url = buildString {
-			append("https://")
-			append(domain)
-			val pages = page + 1
-
-			when {
-				!query.isNullOrEmpty() -> {
-					append("/page/")
-					append(pages.toString())
-					append("/?s=")
-					append(query.urlEncoded())
-					append("&post_type=wp-manga&")
-				}
-
-				!tags.isNullOrEmpty() -> {
-					append("/$tagPrefix")
-					append(tag?.key.orEmpty())
-					append("/page/")
-					append(pages.toString())
-					append("?")
-				}
-
-				else -> {
-
-					append("/$listUrl")
-					append("/page/")
-					append(pages.toString())
-					append("?")
-				}
-			}
-			append("m_orderby=")
-			when (sortOrder) {
-				SortOrder.POPULARITY -> append("views")
-				SortOrder.UPDATED -> append("latest")
-				SortOrder.NEWEST -> append("new-manga")
-				SortOrder.ALPHABETICAL -> append("alphabet")
-				SortOrder.RATING -> append("rating")
-			}
-		}
-		val doc = webClient.httpGet(url).parseHtml()
-
-		return doc.select("div.row.c-tabs-item__content").ifEmpty {
-			doc.select("div.page-item-detail")
-		}.map { div ->
-			val href = div.selectFirst("a")?.attrAsRelativeUrlOrNull("href") ?: div.parseFailed("Link not found")
-			val summary = div.selectFirst(".tab-summary") ?: div.selectFirst(".item-summary")
-			Manga(
-				id = generateUid(href),
-				url = href,
-				publicUrl = href.toAbsoluteUrl(div.host ?: domain),
-				coverUrl = div.selectFirst("img")?.src().orEmpty(),
-				title = (div?.selectFirst("h3") ?: div?.selectFirst("h4"))?.text().orEmpty(),
-				altTitle = null,
-				rating = div.selectFirst("span.total_votes")?.ownText()?.toFloatOrNull()?.div(5f) ?: -1f,
-				tags = summary?.selectFirst(".mg_genres")?.select("a")?.mapNotNullToSet { a ->
-					MangaTag(
-						key = a.attr("href").removeSuffix('/').substringAfterLast('/'),
-						title = a.text().ifEmpty { return@mapNotNullToSet null }.toTitleCase(),
-						source = source,
-					)
-				}.orEmpty(),
-				author = summary?.selectFirst(".mg_author")?.selectFirst("a")?.ownText(),
-				state = when (summary?.selectFirst(".mg_status")?.selectFirst(".summary-content")?.ownText()
-					?.lowercase()) {
-					in ongoing -> MangaState.ONGOING
-					in finished -> MangaState.FINISHED
-					else -> null
-				},
-				source = source,
-				isNsfw = isNsfwSource,
-			)
-		}
-	}
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/TmoManga.kt

@@ -16,44 +16,49 @@ internal class TmoManga(context: MangaLoaderContext) :
 	override val listUrl = "biblioteca/"
 	override val selectGenre = "div.summary-content a.tags_manga"
 	override val withoutAjax = true
+	override val availableSortOrders: Set<SortOrder> = EnumSet.of(SortOrder.POPULARITY)
+	override val availableStates: Set<MangaState> get() = emptySet()
 
 	init {
 		paginator.firstPage = 1
 		searchPaginator.firstPage = 1
 	}
 
-	override val availableSortOrders: Set<SortOrder> = EnumSet.of(SortOrder.POPULARITY)
+	override suspend fun getListPage(page: Int, filter: MangaListFilter?): List<Manga> {
-	override suspend fun getListPage(
-		page: Int,
-		query: String?,
-		tags: Set<MangaTag>?,
-		sortOrder: SortOrder,
-	): List<Manga> {
-		val tag = tags.oneOrThrowIfMany()
 		val url = buildString {
 			append("https://")
 			append(domain)
-			when {
+			when (filter) {
-				!query.isNullOrEmpty() -> {
+				is MangaListFilter.Search -> {
 					append("/$listUrl")
 					append("?search=")
-					append(query.urlEncoded())
+					append(filter.query.urlEncoded())
 					if (page > 1) {
 						append("&page=")
 						append(page)
 					}
 				}
 
-				!tags.isNullOrEmpty() -> {
+				is MangaListFilter.Advanced -> {
-					append("/$tagPrefix")
+
-					append(tag?.key.orEmpty())
+					val tag = filter.tags.oneOrThrowIfMany()
-					if (page > 1) {
+					if (filter.tags.isNotEmpty()) {
-						append("?page=")
+						append("/$tagPrefix")
-						append(page)
+						append(tag?.key.orEmpty())
+						if (page > 1) {
+							append("?page=")
+							append(page)
+						}
+					} else {
+						append("/$listUrl")
+						if (page > 1) {
+							append("?page=")
+							append(page)
+						}
 					}
 				}
 
-				else -> {
+				null -> {
 					append("/$listUrl")
 					if (page > 1) {
 						append("?page=")
@@ -62,6 +67,7 @@ internal class TmoManga(context: MangaLoaderContext) :
 				}
 			}
 		}
+
 		val doc = webClient.httpGet(url).parseHtml()
 
 		return doc.select("div.page-item-detail").map { div ->

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/id/ManhwaHub.kt

@@ -17,56 +17,47 @@ internal class ManhwaHub(context: MangaLoaderContext) :
 	override val withoutAjax = true
 	override val listUrl = "genre/manhwa"
 	override val selectTestAsync = "ul.box-list-chapter"
+	override val availableStates: Set<MangaState> get() = emptySet()
+	override val availableSortOrders: Set<SortOrder> = EnumSet.of(SortOrder.UPDATED)
 
 	init {
 		paginator.firstPage = 1
 		searchPaginator.firstPage = 1
 	}
 
-	override suspend fun getListPage(
+	override suspend fun getListPage(page: Int, filter: MangaListFilter?): List<Manga> {
-		page: Int,
-		query: String?,
-		tags: Set<MangaTag>?,
-		sortOrder: SortOrder,
-	): List<Manga> {
-		val tag = tags.oneOrThrowIfMany()
 		val url = buildString {
 			append("https://")
 			append(domain)
-			when {
+			when (filter) {
-				!query.isNullOrEmpty() -> {
+				is MangaListFilter.Search -> {
 					append("/search?s=")
-					append(query.urlEncoded())
+					append(filter.query.urlEncoded())
 					append("&page=")
-					append(page)
+					append(page.toString())
-					append("&")
 				}
 
-				!tags.isNullOrEmpty() -> {
+				is MangaListFilter.Advanced -> {
-					append("/$tagPrefix")
-					append(tag?.key.orEmpty())
-					append("?page=")
-					append(page)
-					append("&")
-				}
 
-				else -> {
+					val tag = filter.tags.oneOrThrowIfMany()
+					if (filter.tags.isNotEmpty()) {
+						append("/$tagPrefix")
+						append(tag?.key.orEmpty())
+						append("?page=")
+						append(page.toString())
+						append("&m_orderby=latest")
+					} else {
+						append("/?page=")
+						append(page.toString())
+					}
 
-					append("/$listUrl")
-					append("?page=")
-					append(page)
-					append("&")
-				}
 
-			}
+				}
 
-			append("m_orderby=")
+				null -> {
-			when (sortOrder) {
+					append("/?page=")
-				SortOrder.POPULARITY -> append("views")
+					append(page.toString())
-				SortOrder.UPDATED -> append("latest")
+				}
-				SortOrder.NEWEST -> append("new-manga")
-				SortOrder.ALPHABETICAL -> append("alphabet")
-				SortOrder.RATING -> append("rating")
 			}
 		}
 		val doc = webClient.httpGet(url).parseHtml()

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/vi/Saytruyenhay.kt

@@ -7,6 +7,7 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser
 import org.koitharu.kotatsu.parsers.model.*
 import org.koitharu.kotatsu.parsers.site.madara.MadaraParser
 import org.koitharu.kotatsu.parsers.util.*
+import java.util.EnumSet
 
 @MangaSourceParser("SAYTRUYENHAY", "Saytruyenhay", "vi")
 internal class Saytruyenhay(context: MangaLoaderContext) :
@@ -15,50 +16,57 @@ internal class Saytruyenhay(context: MangaLoaderContext) :
 	override val tagPrefix = "genre/"
 	override val withoutAjax = true
 	override val listUrl = "public/genre/manga/"
+	override val availableStates: Set<MangaState> get() = emptySet()
+	override val availableSortOrders: Set<SortOrder> =
+		EnumSet.of(SortOrder.POPULARITY, SortOrder.UPDATED, SortOrder.RATING, SortOrder.NEWEST)
 
-	override suspend fun getListPage(
+	init {
-		page: Int,
+		paginator.firstPage = 1
-		query: String?,
+		searchPaginator.firstPage = 1
-		tags: Set<MangaTag>?,
+	}
-		sortOrder: SortOrder,
+
-	): List<Manga> {
+	override suspend fun getListPage(page: Int, filter: MangaListFilter?): List<Manga> {
-		val tag = tags.oneOrThrowIfMany()
 		val url = buildString {
 			append("https://")
 			append(domain)
-			val pages = page + 1
+			when (filter) {
-
+				is MangaListFilter.Search -> {
-			when {
+					append("/search?s=")
-				!query.isNullOrEmpty() -> {
+					append(filter.query.urlEncoded())
-
-					append("/public/search?s=")
-					append(query.urlEncoded())
 					append("&page=")
-					append(pages.toString())
+					append(page.toString())
 				}
 
-				!tags.isNullOrEmpty() -> {
+				is MangaListFilter.Advanced -> {
-					append("/$tagPrefix")
+
-					append(tag?.key.orEmpty())
+					val tag = filter.tags.oneOrThrowIfMany()
+					if (filter.tags.isNotEmpty()) {
+						append("/$tagPrefix")
+						append(tag?.key.orEmpty())
+					} else {
+						append("/$listUrl")
+
+					}
 					append("?page=")
-					append(pages.toString())
+					append(page.toString())
+					append("&m_orderby=")
+					when (filter.sortOrder) {
+						SortOrder.UPDATED -> append("latest")
+						SortOrder.RATING -> append("rating")
+						SortOrder.POPULARITY -> append("views")
+						SortOrder.NEWEST -> append("new")
+						else -> append("latest")
+					}
 				}
 
-				else -> {
+				null -> {
 					append("/$listUrl")
 					append("?page=")
-					append(pages.toString())
+					append(page.toString())
 				}
 			}
-			append("&m_orderby=")
-			when (sortOrder) {
-				SortOrder.POPULARITY -> append("views")
-				SortOrder.UPDATED -> append("latest")
-				SortOrder.NEWEST -> append("new-manga")
-				SortOrder.ALPHABETICAL -> append("alphabet")
-				SortOrder.RATING -> append("rating")
-			}
 		}
+
 		val doc = webClient.httpGet(url).parseHtml()