Fix FlixScansOrg and add filter

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

@@ -1,6 +1,8 @@
 package org.koitharu.kotatsu.parsers.site.en
 
+import kotlinx.coroutines.async
 import kotlinx.coroutines.coroutineScope
+import org.json.JSONArray
 import org.koitharu.kotatsu.parsers.ErrorMessages
 import org.koitharu.kotatsu.parsers.MangaLoaderContext
 import org.koitharu.kotatsu.parsers.MangaSourceParser
@@ -9,7 +11,7 @@ import org.koitharu.kotatsu.parsers.config.ConfigKey
 import org.koitharu.kotatsu.parsers.model.*
 import org.koitharu.kotatsu.parsers.util.*
 import org.koitharu.kotatsu.parsers.util.json.mapJSON
-import java.text.DateFormat
+import org.koitharu.kotatsu.parsers.util.json.toJSONList
 import java.text.SimpleDateFormat
 import java.util.*
 
@@ -18,6 +20,7 @@ internal class FlixScansOrg(context: MangaLoaderContext) : PagedMangaParser(cont
 
 	override val availableSortOrders: Set<SortOrder> = EnumSet.of(SortOrder.UPDATED)
 	override val availableStates: Set<MangaState> = EnumSet.allOf(MangaState::class.java)
+	override val availableContentRating: Set<ContentRating> = EnumSet.of(ContentRating.ADULT)
 	override val configKeyDomain = ConfigKey.Domain("flixscans.org")
 	override val isSearchSupported = false
 
@@ -29,17 +32,45 @@ internal class FlixScansOrg(context: MangaLoaderContext) : PagedMangaParser(cont
 			}
 
 			is MangaListFilter.Advanced -> {
+
 				val url = buildString {
 					append("https://api.")
 					append(domain)
-					append("/api/v1/webtoon/homepage/latest/home?page=")
+					append("/api/v1/search/advance?=&serie_type=webtoon&page=")
 					append(page.toString())
+
+					append("&genres=")
+					append(filter.tags.joinToString(separator = ",") { it.key })
+
+					filter.states.oneOrThrowIfMany()?.let {
+						append("&status=")
+						append(
+							when (it) {
+								MangaState.ONGOING -> "ongoing"
+								MangaState.FINISHED -> "completed"
+								MangaState.ABANDONED -> "droped"
+								MangaState.PAUSED -> "onhold"
+								MangaState.UPCOMING -> "soon"
+							},
+						)
+					}
+
+					filter.contentRating.oneOrThrowIfMany()?.let {
+						append("&adult=")
+						append(
+							when (it) {
+								ContentRating.ADULT -> "true"
+								else -> ""
+							},
+						)
+					}
+					append("&serie_type=webtoon")
 				}
 				webClient.httpGet(url).parseJson().getJSONArray("data")
 			}
 
 			null -> {
-				val url = "https://api.$domain/api/v1/webtoon/homepage/latest/home?page=$page"
+				val url = "https://api.$domain/api/v1/search/advance?=&serie_type=webtoon&page=$page"
 				webClient.httpGet(url).parseJson().getJSONArray("data")
 			}
 		}
@@ -69,80 +100,100 @@ internal class FlixScansOrg(context: MangaLoaderContext) : PagedMangaParser(cont
 		}
 	}
 
-	override suspend fun getAvailableTags(): Set<MangaTag> = emptySet()
+	override suspend fun getAvailableTags(): Set<MangaTag> {
+		val doc = webClient.httpGet("https://$domain/search/advance").parseHtml()
+		val json = JSONArray(doc.requireElementById("__NUXT_DATA__").data())
+		val tagsList = json.getJSONArray(3).toString().replace("[", "").replace("]", "").split(",")
+		return tagsList.mapNotNullToSet { idTag ->
+			val id = idTag.toInt()
+			val idKey = json.getJSONObject(id).getInt("id")
+			val key = json.getInt(idKey).toString()
+			val idName = json.getJSONObject(id).getInt("name")
+			val name = json.getString(idName)
+			MangaTag(
+				key = key,
+				title = name,
+				source = source,
+			)
+		}
+	}
 
 	override suspend fun getDetails(manga: Manga): Manga = coroutineScope {
 		val doc = webClient.httpGet(manga.url.toAbsoluteUrl(domain)).parseHtml()
-		val dateFormat = SimpleDateFormat("dd/MM/yyyy", sourceLocale)
+		val chaptersDeferred = async { loadChapters(manga.url) }
+		val json = JSONArray(doc.requireElementById("__NUXT_DATA__").data())
+		val descId = json.getJSONObject(6).getInt("story")
+		val desc = json.getString(descId)
+		val tagsId = json.getJSONObject(6).getInt("genres")
+		val tagsList = json.getJSONArray(tagsId).toString().replace("[", "").replace("]", "").split(",")
+		val ratingId = json.getJSONObject(6).getInt("rating")
+		val rating = json.getString(ratingId)
+		val nsfwId = json.getJSONObject(6).getInt("nsfw")
+		val nsfw = json.getBoolean(nsfwId)
 		manga.copy(
-			description = doc.selectFirst("div.text-base")?.text(),
+			description = desc,
-			author = doc.selectFirst("div.gap-1:contains(Authors) span.MuiChip-label")?.text(),
+			tags = tagsList.mapToSet { idTag ->
-			altTitle = doc.select("div.gap-1:contains(Other names) span.MuiChip-label")
+				val id = idTag.toInt()
-				.joinToString(" / ") { it.text() },
+				val idKey = json.getJSONObject(id).getInt("id")
-			chapters = doc.select("div.nox-scrollbar a").mapChapters(reversed = true) { i, a ->
+				val key = json.get(idKey).toString()
-				val url = a.attrAsRelativeUrl("href")
+				val idName = json.getJSONObject(id).getInt("name")
-				val name = a.selectFirstOrThrow("div.font-medium").text()
+				val name = json.get(idName).toString()
-				val dateText = a.selectLastOrThrow("div").text()
+				MangaTag(
-				MangaChapter(
+					key = key,
-					id = generateUid(url),
+					title = name,
-					url = url,
-					name = name,
-					number = i + 1,
-					branch = null,
-					uploadDate = parseChapterDate(
-						dateFormat,
-						dateText,
-					),
-					scanlator = null,
 					source = source,
 				)
 			},
+			rating = rating?.toFloatOrNull()?.div(5f) ?: RATING_UNKNOWN,
+			isNsfw = nsfw,
+			chapters = chaptersDeferred.await(),
 		)
 	}
 
-	private fun parseChapterDate(dateFormat: DateFormat, date: String?): Long {
+	private val dateFormat = SimpleDateFormat("yyyy-MM-dd", sourceLocale)
-		val d = date?.lowercase() ?: return 0
-		return when {
-			d.endsWith(" ago") -> parseRelativeDate(date)
-			else -> dateFormat.tryParse(date)
-		}
-	}
 
-	private fun parseRelativeDate(date: String): Long {
+	private suspend fun loadChapters(baseUrl: String): List<MangaChapter> {
-		val number = Regex("""(\d+)""").find(date)?.value?.toIntOrNull() ?: return 0
+		val key = baseUrl.substringAfter("-").substringBefore("-")
-		val cal = Calendar.getInstance()
+		val seriesKey = baseUrl.substringAfterLast("/").substringBefore("-")
-		return when {
+		val json = JSONArray(
-			WordSet("second").anyWordIn(date) -> cal.apply { add(Calendar.SECOND, -number) }.timeInMillis
+			webClient.httpGet("https://api.$domain/api/v1/webtoon/chapters/$key-desc").parseRaw(),
-			WordSet("minute", "minutes", "mins", "min").anyWordIn(date) -> cal.apply {
+		).toJSONList().reversed()
-				add(
+		return json.mapChapters { i, j ->
-					Calendar.MINUTE,
+			val url = "https://$domain/read/webtoon/$seriesKey-${j.getString("id")}-${j.getString("slug")}"
-					-number,
+			val date = j.getString("createdAt").substringBeforeLast("T")
-				)
+			MangaChapter(
-			}.timeInMillis
+				id = generateUid(url),
-
+				url = url,
-			WordSet("hour", "hours").anyWordIn(date) -> cal.apply { add(Calendar.HOUR, -number) }.timeInMillis
+				name = j.getString("slug").replace('-', ' '),
-			WordSet("day", "days").anyWordIn(date) -> cal.apply { add(Calendar.DAY_OF_MONTH, -number) }.timeInMillis
+				number = i + 1,
-			WordSet("week", "weeks").anyWordIn(date) -> cal.apply { add(Calendar.WEEK_OF_YEAR, -number) }.timeInMillis
+				branch = null,
-			WordSet("month", "months").anyWordIn(date) -> cal.apply { add(Calendar.MONTH, -number) }.timeInMillis
+				uploadDate = dateFormat.tryParse(date),
-			WordSet("year").anyWordIn(date) -> cal.apply { add(Calendar.YEAR, -number) }.timeInMillis
+				scanlator = null,
-			else -> 0
+				source = source,
+			)
 		}
 	}
 
-
 	override suspend fun getPages(chapter: MangaChapter): List<MangaPage> {
 		val fullUrl = chapter.url.toAbsoluteUrl(domain)
 		val doc = webClient.httpGet(fullUrl).parseHtml()
-		val urls = doc.selectFirstOrThrow("script:containsData(chapterData)").data().replace("\\", "")
+		val json = JSONArray(doc.requireElementById("__NUXT_DATA__").data())
-			.substringAfterLast("\"webtoon\":[\"").substringBeforeLast("\"]").split("\",\"")
+		val chapterData = json.getJSONObject(6).getInt("chapterData")
-		return urls.map { url ->
+		val pageLocate = json.getJSONObject(chapterData).getInt("webtoon")
-			val urlImg = "https://media.$domain/$url"
+		val jsonPages = json.getJSONArray(pageLocate)
-			MangaPage(
+		val pages = ArrayList<MangaPage>(jsonPages.length())
-				id = generateUid(urlImg),
+		for (i in 0 until jsonPages.length()) {
-				url = urlImg,
+			val id = jsonPages.getInt(i)
-				preview = null,
+			val url = "https://media.$domain/" + json.getString(id)
-				source = source,
+			pages.add(
+				MangaPage(
+					id = generateUid(url),
+					url = url,
+					preview = null,
+					source = source,
+				),
 			)
 		}
+		return pages
 	}
 }