diff --git a/compiler/src/main/kotlin/keiyoushi/processor/SourceProcessor.kt b/compiler/src/main/kotlin/keiyoushi/processor/SourceProcessor.kt
index 50176a0b97e..2a859cd6000 100644
--- a/compiler/src/main/kotlin/keiyoushi/processor/SourceProcessor.kt
+++ b/compiler/src/main/kotlin/keiyoushi/processor/SourceProcessor.kt
@@ -46,12 +46,14 @@ data class BaseUrlSpecData(
     val type: String,
     val defaultUrl: String,
     val mirrors: List<MirrorData> = emptyList(),
+    val withCustom: Boolean = false,
 )
 
 @Serializable
 data class MirrorData(
     val url: String,
     val label: String = "",
+    val value: String = "",
 )
 
 @Serializable
@@ -69,8 +71,7 @@ private fun KSClassDeclaration.derivesFromHttpSource(): Boolean =
 
 private val configurable = ClassName("eu.kanade.tachiyomi.source", "ConfigurableSource")
 private val preferenceScreen = ClassName("androidx.preference", "PreferenceScreen")
-private val mirrorPrefsClass = ClassName("keiyoushi.source", "MirrorPreferences")
-private val customUrlPrefsClass = ClassName("keiyoushi.source", "CustomUrlPreferences")
+private val customAndMirrorPrefsClass = ClassName("keiyoushi.source", "CustomAndMirrorPreferences")
 private val getPreferencesFn = MemberName("keiyoushi.utils", "getPreferences")
 
 class SourceProcessor(
@@ -284,7 +285,7 @@ class SourceProcessor(
         if ("name" !in ctorParams && "name" in overridden) {
             logger.warn("name is provided by $className; the DSL name is used for metadata only.", node)
         }
-        
+
         if ("baseUrl" !in ctorParams && "baseUrl" in overridden) {
             logger.warn("baseUrl is provided by $className; the DSL baseUrl is used for metadata/hosts only.", node)
         }
@@ -362,52 +363,53 @@ class SourceProcessor(
                         .build(),
                 )
             }
-            urlSpec.type == "mirrors" -> {
+            urlSpec.type == "mirrors" || urlSpec.type == "custom" -> {
                 val strings = stringsForLang(source.lang)
-                val prefsName = "mirrorPrefs$suffix"
+                val prefsName = "baseUrlPrefs$suffix"
                 val initializer = CodeBlock.builder()
-                    .add("%T(\n", mirrorPrefsClass)
+                    .add("%T(\n", customAndMirrorPrefsClass)
                     .indent()
                     .add("preferences = %M(%LL),\n", getPreferencesFn, source.id)
-                    .add("mirrors = arrayOf(\n")
+                    .add("mirrors = listOf(\n")
                     .indent()
                     .apply {
                         urlSpec.mirrors.forEach { mirror ->
-                            add("%S to %S,\n", mirror.label, mirror.url)
+                            add("%S,\n", mirror.url)
                         }
                     }
                     .unindent()
                     .add("),\n")
-                    .add("title = %S,\n", strings.mirrorTitle)
-                    .unindent()
-                    .add(")")
-                    .build()
-                fileProps += PropertySpec.builder(prefsName, mirrorPrefsClass)
-                    .addModifiers(KModifier.PRIVATE)
-                    .initializer(initializer)
-                    .build()
-                addProperty(
-                    PropertySpec.builder("baseUrl", String::class.asClassName(), KModifier.OVERRIDE)
-                        .getter(FunSpec.getterBuilder().addStatement("return %N.baseUrl", prefsName).build())
-                        .build(),
-                )
-                addPreferenceScreen(isConfigurable) { addStatement("%N.setupPreferenceScreen(screen)", prefsName) }
-                if (!isConfigurable) addSuperinterface(configurable)
-            }
-            urlSpec.type == "custom" -> {
-                val strings = stringsForLang(source.lang)
-                val prefsName = "customUrlPrefs$suffix"
-                val initializer = CodeBlock.builder()
-                    .add("%T(\n", customUrlPrefsClass)
-                    .indent()
-                    .add("preferences = %M(%LL),\n", getPreferencesFn, source.id)
                     .add("defaultUrl = %S,\n", urlSpec.defaultUrl)
-                    .add("title = %S,\n", strings.customUrlTitle)
-                    .add("dialogMessage = %S,\n", strings.customUrlDialogMessage)
+                    .add("withCustom = %L,\n", urlSpec.withCustom)
+                    .add("mirrorTitle = %S,\n", strings.mirrorTitle)
+                    .add("customTitle = %S,\n", strings.customUrlTitle)
+                    .add("customDialogMessage = %S,\n", strings.customUrlDialogMessage)
+                    .apply {
+                        if (urlSpec.mirrors.any { it.label.isNotBlank() }) {
+                            add("mirrorEntries = listOf(\n")
+                            indent()
+                            urlSpec.mirrors.forEach { mirror ->
+                                val label = mirror.label.takeIf { it.isNotBlank() } ?: mirror.url
+                                add("%S,\n", label)
+                            }
+                            unindent()
+                            add("),\n")
+                        }
+                        if (urlSpec.mirrors.any { it.value.isNotBlank() }) {
+                            add("mirrorEntryValues = listOf(\n")
+                            indent()
+                            urlSpec.mirrors.forEach { mirror ->
+                                val value = mirror.value.takeIf { it.isNotBlank() } ?: urlSpec.mirrors.indexOf(mirror).toString()
+                                add("%S,\n", value)
+                            }
+                            unindent()
+                            add("),\n")
+                        }
+                    }
                     .unindent()
                     .add(")")
                     .build()
-                fileProps += PropertySpec.builder(prefsName, customUrlPrefsClass)
+                fileProps += PropertySpec.builder(prefsName, customAndMirrorPrefsClass)
                     .addModifiers(KModifier.PRIVATE)
                     .initializer(initializer)
                     .build()
diff --git a/core/src/main/kotlin/keiyoushi/source/CustomAndMirrorPreferences.kt b/core/src/main/kotlin/keiyoushi/source/CustomAndMirrorPreferences.kt
new file mode 100644
index 00000000000..c6594c53756
--- /dev/null
+++ b/core/src/main/kotlin/keiyoushi/source/CustomAndMirrorPreferences.kt
@@ -0,0 +1,141 @@
+package keiyoushi.source
+
+import android.content.SharedPreferences
+import android.text.Editable
+import android.text.TextWatcher
+import android.widget.Button
+import androidx.preference.EditTextPreference
+import androidx.preference.ListPreference
+import androidx.preference.PreferenceScreen
+import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
+import java.net.URI
+
+class CustomAndMirrorPreferences(
+    private val preferences: SharedPreferences,
+    private val mirrors: List<String>,
+    val defaultUrl: String,
+    private val withCustom: Boolean,
+    private val mirrorTitle: String,
+    private val customTitle: String,
+    private val customDialogMessage: String,
+    mirrorEntries: List<String>? = null,
+    mirrorEntryValues: List<String>? = null,
+) {
+    private val prefKey: String = "preferred_mirror"
+    private val prefBaseKey: String = "overrideBaseUrl"
+    private val prefDefaultKey: String = "defaultBaseUrl"
+
+    private val entries = (
+        mirrorEntries ?: mirrors.map { url ->
+            runCatching { URI(url).host }.getOrDefault(url)
+        }
+        ).run { if (this@CustomAndMirrorPreferences.withCustom) plus("Custom") else this }
+
+    private val entryValues = (
+        mirrorEntryValues ?: mirrors.indices.map { it.toString() }
+        ).run { if (this@CustomAndMirrorPreferences.withCustom) plus("custom") else this }
+
+    init {
+        if (withCustom) {
+            val storedDefault = preferences.getString(prefDefaultKey, null)
+            if (storedDefault != defaultUrl) {
+                preferences.edit()
+                    .putString(prefBaseKey, defaultUrl)
+                    .putString(prefDefaultKey, defaultUrl)
+                    .apply()
+            }
+        }
+    }
+
+    val baseUrl: String
+        get() {
+            val selected = preferences.getString(prefKey, entryValues.firstOrNull() ?: "0")
+            val url = if (selected == "custom") {
+                preferences.getString(prefBaseKey, defaultUrl) ?: defaultUrl
+            } else {
+                val index = entryValues.indexOf(selected).coerceIn(0, mirrors.size - 1)
+                mirrors.getOrNull(index) ?: defaultUrl
+            }
+            return url.removeSuffix("/")
+        }
+
+    fun setupPreferenceScreen(screen: PreferenceScreen) {
+        val customUrlPref = if (withCustom) {
+            EditTextPreference(screen.context).apply {
+                key = prefBaseKey
+                title = customTitle
+                dialogTitle = customTitle
+                dialogMessage = customDialogMessage
+
+                val currentValue = preferences.getString(prefBaseKey, null)
+                summary = currentValue?.takeIf { it.isNotBlank() } ?: defaultUrl
+                setDefaultValue(defaultUrl)
+
+                setEnabled(preferences.getString(prefKey, entryValues.firstOrNull()) == "custom")
+
+                setOnBindEditTextListener { editText ->
+                    editText.hint = defaultUrl
+                    editText.setHorizontallyScrolling(true)
+                    editText.post { editText.selectAll() }
+                    editText.addTextChangedListener(
+                        object : TextWatcher {
+                            override fun afterTextChanged(editable: Editable?) {
+                                val text = editable?.toString() ?: ""
+                                val isValid = text.isBlank() || text.toHttpUrlOrNull() != null
+                                editText.rootView.findViewById<Button>(android.R.id.button1)?.isEnabled = isValid
+                            }
+
+                            override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {}
+                            override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {}
+                        },
+                    )
+                }
+
+                setOnPreferenceChangeListener { preference, newValue ->
+                    val text = newValue as String
+                    val httpUrl = text.toHttpUrlOrNull()
+                    val isValid = text.isBlank() || httpUrl != null
+                    if (isValid) {
+                        val sanitizedValue = if (text.isBlank()) {
+                            defaultUrl
+                        } else {
+                            val httpUrlParsed = httpUrl!!
+                            val scheme = httpUrlParsed.scheme
+                            val host = httpUrlParsed.host
+                            val port = httpUrlParsed.port
+                            val defaultPort = if (scheme == "https") 443 else 80
+                            val portStr = if (port == defaultPort) "" else ":$port"
+                            "$scheme://$host$portStr"
+                        }
+
+                        (preference as EditTextPreference).text = sanitizedValue
+                        summary = sanitizedValue
+
+                        preferences.edit()
+                            .putString(prefBaseKey, sanitizedValue)
+                            .apply()
+                    }
+                    false
+                }
+            }
+        } else {
+            null
+        }
+
+        ListPreference(screen.context).apply {
+            key = prefKey
+            title = mirrorTitle
+            entries = this@CustomAndMirrorPreferences.entries.toTypedArray()
+            entryValues = this@CustomAndMirrorPreferences.entryValues.toTypedArray()
+            summary = "%s"
+            setDefaultValue(this@CustomAndMirrorPreferences.entryValues.firstOrNull() ?: "0")
+
+            setOnPreferenceChangeListener { _, newValue ->
+                customUrlPref?.setEnabled(newValue == "custom")
+                true
+            }
+        }.also(screen::addPreference)
+
+        customUrlPref?.also(screen::addPreference)
+    }
+}
diff --git a/gradle/build-logic/src/main/kotlin/PluginExtension.kt b/gradle/build-logic/src/main/kotlin/PluginExtension.kt
index 350e8253d3d..382a256b375 100644
--- a/gradle/build-logic/src/main/kotlin/PluginExtension.kt
+++ b/gradle/build-logic/src/main/kotlin/PluginExtension.kt
@@ -275,18 +275,29 @@ private data class BaseUrlSpecData(
     val type: String,
     val defaultUrl: String,
     val mirrors: List<MirrorData> = emptyList(),
+    val withCustom: Boolean = false,
 )
 
 @Serializable
 private data class MirrorData(
     val url: String,
     val label: String = "",
+    val value: String = "",
 )
 
 private fun BaseUrlSpec.toData(): BaseUrlSpecData = when (this) {
     is BaseUrlSpec.Static -> BaseUrlSpecData("static", url)
-    is BaseUrlSpec.Mirrors -> BaseUrlSpecData("mirrors", mirrors.first().url, mirrors.map { MirrorData(it.url, it.label.orEmpty()) })
-    is BaseUrlSpec.Custom -> BaseUrlSpecData("custom", defaultUrl)
+    is BaseUrlSpec.Mirrors -> BaseUrlSpecData(
+        type = "mirrors",
+        defaultUrl = mirrors.first().url,
+        mirrors = mirrors.map { MirrorData(it.url, it.label.orEmpty(), it.value.orEmpty()) },
+    )
+    is BaseUrlSpec.Custom -> BaseUrlSpecData(
+        type = "custom",
+        defaultUrl = defaultUrl,
+        mirrors = mirrors.map { MirrorData(it.url, it.label.orEmpty(), it.value.orEmpty()) },
+        withCustom = true,
+    )
 }
 
 private fun computeSourceId(name: String, lang: String, versionId: Int = 1): Long {
diff --git a/gradle/build-logic/src/main/kotlin/keiyoushi/gradle/extensions/BaseUrlSpec.kt b/gradle/build-logic/src/main/kotlin/keiyoushi/gradle/extensions/BaseUrlSpec.kt
index f25aa32abe6..8123a66742e 100644
--- a/gradle/build-logic/src/main/kotlin/keiyoushi/gradle/extensions/BaseUrlSpec.kt
+++ b/gradle/build-logic/src/main/kotlin/keiyoushi/gradle/extensions/BaseUrlSpec.kt
@@ -2,12 +2,16 @@ package keiyoushi.gradle.extensions
 
 import java.io.Serializable
 
-data class Mirror(val url: String, val label: String? = null) : Serializable
+data class Mirror(
+    val url: String,
+    val label: String? = null,
+    val value: String? = null,
+) : Serializable
 
 sealed interface BaseUrlSpec : Serializable {
     data class Static(val url: String) : BaseUrlSpec
     data class Mirrors(val mirrors: List<Mirror>) : BaseUrlSpec
-    data class Custom(override val defaultUrl: String) : BaseUrlSpec
+    data class Custom(override val defaultUrl: String, val mirrors: List<Mirror> = emptyList()) : BaseUrlSpec
 
     val defaultUrl: String
         get() = when (this) {
@@ -19,37 +23,44 @@ sealed interface BaseUrlSpec : Serializable {
     fun allUrls(): List<String> = when (this) {
         is Static -> listOf(url)
         is Mirrors -> mirrors.map { it.url }
-        is Custom -> listOf(defaultUrl)
+        is Custom -> listOf(defaultUrl) + mirrors.map { it.url }
     }
 }
 
 class BaseUrlDsl {
     private val mirrors = mutableListOf<Mirror>()
-    private var custom: BaseUrlSpec.Custom? = null
+    private var customUrl: String? = null
 
     /** Declares selectable mirror urls; the first is the default and each mirror's host is shown in the picker. */
     fun mirrors(vararg urls: String) {
-        require(urls.isNotEmpty()) { "baseUrl { mirrors(...) } needs at least one url" }
         urls.mapTo(mirrors) { Mirror(it) }
     }
 
     /** Declares selectable mirrors as `"label" to "url"` pairs; the first is the default and its label is shown in the picker. */
     fun mirrors(vararg labeled: Pair<String, String>) {
-        require(labeled.isNotEmpty()) { "baseUrl { mirrors(...) } needs at least one url" }
         labeled.mapTo(mirrors) { (label, url) -> Mirror(url, label) }
     }
 
     /** Declares a user-editable base url; [defaultUrl] is the placeholder shown until the user overrides it. */
     fun custom(defaultUrl: String) {
-        custom = BaseUrlSpec.Custom(defaultUrl)
+        customUrl = defaultUrl
+    }
+
+    val mirrorSpecial = MirrorSpecialSpec()
+
+    inner class MirrorSpecialSpec {
+        fun add(url: String, label: String, value: String) {
+            mirrors.add(Mirror(url, label, value))
+        }
     }
 
     internal fun build(): BaseUrlSpec {
-        check(!(mirrors.isNotEmpty() && custom != null)) {
-            "source { baseUrl { } }: use mirrors(...) or custom(...), not both"
+        val custom = customUrl
+        if (custom != null) {
+            return BaseUrlSpec.Custom(custom, mirrors.toList())
         }
-        return custom
-            ?: mirrors.takeIf { it.isNotEmpty() }?.let { BaseUrlSpec.Mirrors(it.toList()) }
-            ?: error("source { baseUrl { } } is empty — call mirrors(...) or custom(...)")
+        check(mirrors.isNotEmpty()) { "source { baseUrl { } } is empty — call mirrors(...), custom(...) or mirrorSpecial" }
+        return BaseUrlSpec.Mirrors(mirrors.toList())
     }
 }
+
diff --git a/src/vi/goctruyentranhvui/src/eu/kanade/tachiyomi/extension/vi/goctruyentranhvui/GocTruyenTranhVui.kt b/src/vi/goctruyentranhvui/src/eu/kanade/tachiyomi/extension/vi/goctruyentranhvui/GocTruyenTranhVui.kt
index 35ba21401ec..6d359dfbd97 100644
--- a/src/vi/goctruyentranhvui/src/eu/kanade/tachiyomi/extension/vi/goctruyentranhvui/GocTruyenTranhVui.kt
+++ b/src/vi/goctruyentranhvui/src/eu/kanade/tachiyomi/extension/vi/goctruyentranhvui/GocTruyenTranhVui.kt
@@ -1,84 +1,77 @@
 package eu.kanade.tachiyomi.extension.vi.goctruyentranhvui
 
-import android.annotation.SuppressLint
-import android.app.Application
-import android.content.SharedPreferences
-import android.os.Handler
-import android.os.Looper
-import android.webkit.WebView
-import android.webkit.WebViewClient
-import android.widget.Toast
+import android.text.InputType
 import androidx.preference.EditTextPreference
 import androidx.preference.PreferenceScreen
-import eu.kanade.tachiyomi.network.GET
-import eu.kanade.tachiyomi.network.POST
-import eu.kanade.tachiyomi.network.asObservableSuccess
 import eu.kanade.tachiyomi.source.ConfigurableSource
 import eu.kanade.tachiyomi.source.model.FilterList
 import eu.kanade.tachiyomi.source.model.MangasPage
 import eu.kanade.tachiyomi.source.model.Page
 import eu.kanade.tachiyomi.source.model.SChapter
 import eu.kanade.tachiyomi.source.model.SManga
-import eu.kanade.tachiyomi.source.online.HttpSource
+import eu.kanade.tachiyomi.source.model.SMangaUpdate
 import eu.kanade.tachiyomi.util.asJsoup
 import keiyoushi.annotation.Source
+import keiyoushi.network.get
+import keiyoushi.network.post
 import keiyoushi.network.rateLimit
+import keiyoushi.source.KeiSource
+import keiyoushi.utils.getLocalStorage
 import keiyoushi.utils.getPreferences
 import keiyoushi.utils.parseAs
+import kotlinx.serialization.json.JsonElement
 import okhttp3.FormBody
 import okhttp3.Headers
+import okhttp3.HttpUrl
 import okhttp3.HttpUrl.Companion.toHttpUrl
+import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
+import okhttp3.Interceptor
 import okhttp3.OkHttpClient
-import okhttp3.Request
 import okhttp3.Response
-import rx.Observable
-import uy.kohesive.injekt.Injekt
-import uy.kohesive.injekt.api.get
-import java.util.concurrent.CountDownLatch
-import java.util.concurrent.TimeUnit
+import org.jsoup.nodes.Document
+import kotlin.text.isNotBlank
 
 @Source
 abstract class GocTruyenTranhVui :
-    HttpSource(),
+    KeiSource(),
     ConfigurableSource {
-
     private val apiUrl get() = "$baseUrl/api/v2"
 
-    override val supportsLatest: Boolean = true
+    private val preferences = getPreferences()
+
+    override fun OkHttpClient.Builder.configureClient(): OkHttpClient.Builder = apply {
+        rateLimit(3)
+        addInterceptor(::authInterceptor)
+    }
 
-    private val preferences: SharedPreferences = getPreferences()
+    private val xhrHeaders: Headers
+        get() = headersBuilder()
+            .set("X-Requested-With", "XMLHttpRequest")
+            .build()
 
-    override val client: OkHttpClient = network.client.newBuilder()
-        .rateLimit(3)
-        .build()
+    private fun authInterceptor(chain: Interceptor.Chain): Response {
+        val request = chain.request()
 
-    override fun headersBuilder(): Headers.Builder = super.headersBuilder()
-        .add("Referer", "$baseUrl/")
-        .apply {
-            build()["user-agent"]?.let { userAgent ->
-                set("user-agent", removeWebViewToken(userAgent))
-            }
+        if (!request.url.encodedPath.startsWith("/api/")) {
+            return chain.proceed(request)
         }
 
-    private fun removeWebViewToken(userAgent: String): String = userAgent.replace(WEBVIEW_TOKEN_REGEX, ")")
+        val token = tokenCache
 
-    private val xhrHeaders by lazy {
-        headersBuilder()
-            .set("X-Requested-With", "XMLHttpRequest")
-            .add("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7")
-            .add("Accept-Language", "vi-VN,vi;q=0.9,en-US;q=0.8,en;q=0.7")
-            .add("Cache-Control", "max-age=0")
-            .add("Sec-Ch-Ua-Mobile", "?1")
-            .add("Sec-Ch-Ua-Platform", "\"Android\"")
-            .add("Sec-Fetch-Dest", "document")
-            .add("Sec-Fetch-Mode", "navigate")
-            .add("Sec-Fetch-Site", "same-origin")
-            .add("Sec-Fetch-User", "?1")
-            .add("Upgrade-Insecure-Requests", "1")
-            .build()
+        return chain.proceed(
+            request.newBuilder().apply {
+                header("X-Requested-With", "XMLHttpRequest")
+
+                token?.let {
+                    header("Authorization", it)
+                }
+            }.build(),
+        )
     }
 
-    override fun popularMangaRequest(page: Int): Request = searchMangaRequest(
+    // ============================== Popular ===============================
+
+    override suspend fun getPopularManga(page: Int): MangasPage = getSearchMangaList(
         page,
         "",
         FilterList(
@@ -88,13 +81,9 @@ abstract class GocTruyenTranhVui :
         ),
     )
 
-    override fun popularMangaParse(response: Response): MangasPage {
-        val res = response.parseAs<ResultDto<ListingDto>>()
-        val hasNextPage = res.result.next
-        return MangasPage(res.result.data.map { it.toSManga(baseUrl) }, hasNextPage)
-    }
+    // =============================== Latest ===============================
 
-    override fun latestUpdatesRequest(page: Int): Request = searchMangaRequest(
+    override suspend fun getLatestUpdates(page: Int): MangasPage = getSearchMangaList(
         page,
         "",
         FilterList(
@@ -104,74 +93,91 @@ abstract class GocTruyenTranhVui :
         ),
     )
 
-    override fun latestUpdatesParse(response: Response): MangasPage = popularMangaParse(response)
-
-    override fun fetchSearchManga(page: Int, query: String, filters: FilterList): Observable<MangasPage> {
-        if (query.startsWith("https://")) {
-            val url = query.toHttpUrl()
-            val baseHost = baseUrl.toHttpUrl().host
-            if (url.host != baseHost) {
-                throw Exception("Tên miền không được hỗ trợ")
-            }
+    // =============================== Search ===============================
 
-            if (url.pathSegments.size >= 2 && url.pathSegments[0] == "truyen") {
-                // Note: Fetching manga details directly for Deep Links is a temporary workaround
-                // because the website currently restricts browsing/searching.
-                // This allows users to access specific manga via URL as a temporary support measure.
-                return client.newCall(GET(query, headers))
-                    .asObservableSuccess()
-                    .map { response ->
-                        val manga = mangaDetailsParse(response)
-                        MangasPage(listOf(manga), false)
+    override suspend fun getSearchMangaList(page: Int, query: String, filters: FilterList): MangasPage {
+        getToken()
+        val url = apiUrl.toHttpUrl().newBuilder().apply {
+            addPathSegments("search")
+            addQueryParameter("p", (page - 1).toString())
+            if (query.isNotEmpty()) addQueryParameter("searchValue", query)
+            for (filter in filters) {
+                if (filter is FilterGroup) {
+                    for (checkbox in filter.state) {
+                        if (checkbox.state) addQueryParameter(filter.query, checkbox.id)
                     }
+                }
             }
-            return Observable.just(MangasPage(emptyList(), false))
-        }
-        return super.fetchSearchManga(page, query, filters)
+        }.build()
+
+        return parseMangaPage(client.get(url, xhrHeaders))
     }
 
-    override fun getMangaUrl(manga: SManga) = "$baseUrl/truyen/${manga.url.substringAfter(':')}"
+    private fun parseMangaPage(response: Response): MangasPage {
+        val res = response.parseAs<ResultDto<ListingDto>>()
+        val hasNextPage = res.result.next
+        return MangasPage(res.result.data.map { it.toSManga(baseUrl) }, hasNextPage)
+    }
 
-    override fun fetchChapterList(manga: SManga): Observable<List<SChapter>> {
-        // B1: call manga detail url refresh cookie
-        val refreshReq = GET(getMangaUrl(manga), headers)
-
-        return client.newCall(refreshReq)
-            .asObservableSuccess()
-            .flatMap { _ ->
-                // B2: recall chapter list request
-                client.newCall(chapterListRequest(manga))
-                    .asObservableSuccess()
-                    .map(::chapterListParse)
-            }
+    override suspend fun getMangaByUrl(url: HttpUrl): SManga? {
+        if (url.host != baseUrl.toHttpUrlOrNull()?.host) return null
+        if (url.pathSegments.size < 2 || url.pathSegments[0] != "truyen") return null
+        return parseMangaDetails(client.get(url).asJsoup(), url)
     }
 
-    override fun chapterListRequest(manga: SManga): Request {
+    // =========================== Manga Details ============================
+
+    override suspend fun fetchMangaUpdate(
+        manga: SManga,
+        chapters: List<SChapter>,
+        fetchDetails: Boolean,
+        fetchChapters: Boolean,
+    ): SMangaUpdate {
+        getToken()
+        val mangaUrl = getMangaUrl(manga)
         val mangaId = manga.url.substringBefore(':')
         val slug = manga.url.substringAfter(':')
-        return GET("$baseUrl/api/comic/$mangaId/chapter?limit=-1#$slug", xhrHeaders)
-    }
 
-    override fun chapterListParse(response: Response): List<SChapter> {
-        val slug = response.request.url.fragment!!
-        val chapterJson = runCatching { response.parseAs<ResultDto<ChapterListDto>>() }.getOrNull()
-        if (chapterJson == null || chapterJson.result.chapters.isEmpty()) {
-            throw Exception("Có thể: Phiên làm việc đã hết hạn, vui lòng tải lại.")
+        // 1. Xử lý Details (chỉ gọi request khi fetchDetails = true)
+        var updatedDetails: SManga? = null
+        var hasFetchedMangaUrl = false
+
+        if (fetchDetails) {
+            updatedDetails = client.get(mangaUrl).use { response ->
+                parseMangaDetails(response.asJsoup(), response.request.url)
+            }
+            hasFetchedMangaUrl = true
         }
-        return chapterJson.result.chapters.map { it.toSChapter(slug) }
-    }
 
-    override fun getChapterUrl(chapter: SChapter): String {
-        val url = chapter.url
-        val slug = url.substringAfter("/truyen/").substringBefore("/chuong-")
-        val numberChapter = url.substringAfter("/chuong-").substringBefore("#")
-        return "$baseUrl/truyen/$slug/chuong-$numberChapter"
-    }
+        // 2. Xử lý Chapters (chỉ gọi request khi fetchChapters = true)
+        val updatedChapters = if (fetchChapters) {
+            suspend fun requestChapters(): List<SChapter>? {
+                val chapterUrl = "$baseUrl/api/comic/$mangaId/chapter?limit=-1"
+                return client.get(chapterUrl, xhrHeaders).use { response ->
+                    parseChapterList(response, slug)
+                }
+            }
+
+            // Thử lấy chapters lần 1
+            requestChapters() ?: run {
+                // Nếu chưa từng gọi mangaUrl ở bước fetchDetails thì mới gọi mồi cookie ở đây
+                if (!hasFetchedMangaUrl) {
+                    client.get(mangaUrl).close()
+                }
+                // Thử lại lần 2 sau khi mồi/làm mới cookie
+                requestChapters() ?: throw Exception("Phiên làm việc hết hạn. Không thể tải danh sách chương!")
+            }
+        } else {
+            chapters
+        }
 
-    override fun mangaDetailsRequest(manga: SManga) = GET(getMangaUrl(manga), headers)
+        return SMangaUpdate(
+            manga = updatedDetails ?: manga,
+            chapters = updatedChapters,
+        )
+    }
 
-    override fun mangaDetailsParse(response: Response): SManga = SManga.create().apply {
-        val document = response.asJsoup()
+    private fun parseMangaDetails(document: Document, requestUrl: HttpUrl): SManga = SManga.create().apply {
         title = document.select(".v-card-title").text()
         genre = document.select(".group-content > .v-chip-link").joinToString { it.text() }
         thumbnail_url = document.selectFirst("img.image")?.absUrl("src")
@@ -179,18 +185,24 @@ abstract class GocTruyenTranhVui :
         author = document.selectFirst(".mb-1:contains(Tác giả:) span")?.text()
         description = document.select(".v-card-text").joinToString { it.wholeText().trim() }
 
-        // Extract ID and slug for internal use (especially for Deep Links)
         val script = document.select("script").firstOrNull { it.data().contains("const comic = {") }?.data()
         val id = script?.let { COMIC_ID_REGEX.find(it)?.groupValues?.get(1) }
             ?: document.selectFirst("#comic-id-comment")?.attr("value")
         val nameEn = script?.let { COMIC_NAME_EN_REGEX.find(it)?.groupValues?.get(1) }
-            ?: response.request.url.pathSegments.getOrNull(1)
+            ?: requestUrl.pathSegments.getOrNull(1)
 
         if (id != null && nameEn != null) {
-            this.url = "$id:$nameEn"
+            setUrlWithoutDomain("$id:$nameEn")
         }
     }
 
+    private fun parseChapterList(response: Response, slug: String): List<SChapter>? {
+        val chapterJson = response.parseAs<ResultDto<ChapterListDto>>()
+        val chapters = chapterJson.result.chapters
+        if (chapters.isEmpty()) return null
+        return chapters.map { it.toSChapter(slug) }
+    }
+
     private fun parseStatus(status: String?) = when {
         status == null -> SManga.UNKNOWN
         status.contains("Đang thực hiện", ignoreCase = true) -> SManga.ONGOING
@@ -198,7 +210,12 @@ abstract class GocTruyenTranhVui :
         else -> SManga.UNKNOWN
     }
 
-    override fun pageListRequest(chapter: SChapter): Request {
+    override fun getMangaUrl(manga: SManga) = "$baseUrl/truyen/${manga.url.substringAfter(':')}"
+
+    // =============================== Pages ================================
+
+    override suspend fun getPageList(chapter: SChapter): List<Page> {
+        getToken()
         val url = chapter.url
         val slug = url.substringAfter("/truyen/").substringBefore("/chuong-")
         val numberChapter = url.substringAfter("/chuong-").substringBefore("#")
@@ -210,108 +227,81 @@ abstract class GocTruyenTranhVui :
             .add("nameEn", slug)
             .build()
 
-        return POST("$baseUrl/api/chapter/loadAll", pageHeaders, body)
-    }
+        suspend fun requestImages(): List<Page>? {
+            return client.post("$baseUrl/api/chapter/loadAll", body).use { response ->
+                val result = runCatching { response.parseAs<ResultDto<ImageListDto>>() }.getOrNull()
+                val imageList = result?.result?.data ?: return@use null
 
-    override fun pageListParse(response: Response): List<Page> {
-        val jsonResult = runCatching { response.parseAs<ResultDto<ImageListDto>>() }
-        jsonResult.onFailure {
-            throw Exception("Có thể: Phiên làm việc đã hết hạn, vui lòng tải lại")
+                imageList.mapIndexed { i, imgUrl ->
+                    val finalUrl = if (imgUrl.startsWith("/image/")) {
+                        baseUrl + imgUrl
+                    } else {
+                        imgUrl
+                    }
+                    Page(i, imageUrl = finalUrl)
+                }
+            }
         }
-
-        val imageList = jsonResult.getOrThrow().result.data
-        if (imageList.isNullOrEmpty()) {
-            throw Exception("Chưa đăng nhập trong WebView. Hoặc không có ảnh!")
+        // Thử lần 1
+        var pages = requestImages()
+        // Nếu thất bại (do hết hạn cookie/phiên làm việc)
+        if (pages == null) {
+            // Gọi "mồi" đến trang chi tiết để làm mới cookie
+            val mangaUrl = "$baseUrl/truyen/$slug"
+            client.get(mangaUrl).close()
+            // Thử lần 2 sau khi đã có cookie mới
+            pages = requestImages()
         }
 
-        return imageList.mapIndexed { i, url ->
-            val finalUrl = if (url.startsWith("/image/")) {
-                baseUrl + url
-            } else {
-                url
-            }
-            Page(i, imageUrl = finalUrl)
-        }
+        return pages ?: throw Exception("Chưa đăng nhập trong WebView. Hoặc không có ảnh!")
     }
 
-    private val pageHeaders by lazy {
-        token?.let {
-            headersBuilder()
-                .set("X-Requested-With", "XMLHttpRequest")
-                .set("Origin", baseUrl)
-                .set("Authorization", it)
-                .build()
-        } ?: xhrHeaders
-    }
+    private var tokenCache: String? = null
+    private var tokenChecked = false
 
-    private var _token: String? = null
+    private suspend fun getToken(): String? {
+        if (tokenChecked) return tokenCache
 
-    @get:SuppressLint("SetJavaScriptEnabled")
-    val token: String?
-        get() {
-            _token?.also { return it }
-            val handler = Handler(Looper.getMainLooper())
-            val latch = CountDownLatch(1)
-            if (!customToken().isNullOrBlank()) {
-                return customToken()
+        preferences.getString(CUSTOM_TOKEN, null)
+            ?.takeIf(String::isNotBlank)
+            ?.also {
+                tokenCache = it
+                tokenChecked = true
+                return it
             }
-            if (_token != null) return _token
-
-            handler.post {
-                val webview = WebView(Injekt.get<Application>())
-                with(webview.settings) {
-                    javaScriptEnabled = true
-                    domStorageEnabled = true
-                    databaseEnabled = true
-                    blockNetworkImage = true
-                }
-                webview.webViewClient = object : WebViewClient() {
-                    override fun onPageFinished(view: WebView?, url: String?) {
-                        // Get token
-                        view!!.evaluateJavascript("window.localStorage.getItem('Authorization')") { token ->
-                            _token = token.takeUnless { it == "null" }?.removeSurrounding("\"")
-                            latch.countDown()
-                            webview.destroy()
-                        }
-                    }
-                }
-                webview.loadDataWithBaseURL(baseUrl, " ", "text/html", "UTF-8", null)
-            }
-
-            latch.await(10, TimeUnit.SECONDS)
-            return _token
-        }
 
-    override fun imageUrlParse(response: Response): String = throw UnsupportedOperationException()
+        tokenCache = runCatching { getLocalStorage(baseUrl, "Authorization") }.getOrNull()
+            ?.takeIf(String::isNotBlank)
+        tokenChecked = true
+        return tokenCache
+    }
 
-    override fun searchMangaRequest(page: Int, query: String, filters: FilterList): Request {
-        val url = apiUrl.toHttpUrl().newBuilder().apply {
-            addPathSegments("search")
-            addQueryParameter("p", (page - 1).toString())
-            if (query.isNotEmpty()) addQueryParameter("searchValue", query)
-            for (filter in filters) {
-                when (filter) {
-                    is FilterGroup ->
-                        for (checkbox in filter.state) {
-                            if (checkbox.state) addQueryParameter(filter.query, checkbox.id)
-                        }
+    // ============================== Filters ===============================
+    override val supportsFilterFetching get() = true
 
-                    else -> {}
-                }
-            }
-        }.build()
-        return GET(url, xhrHeaders)
+    override suspend fun fetchFilterData(): JsonElement {
+        getToken()
+        return client.get("$baseUrl/api/category", xhrHeaders).parseAs()
     }
 
-    override fun searchMangaParse(response: Response): MangasPage = popularMangaParse(response)
+    override fun getFilterList(data: JsonElement?): FilterList {
+        val genres = data
+            ?.parseAs<ResultDto<List<CategoryDto>>>()
+            ?.result
+            .orEmpty()
+            .map(CategoryDto::toOption)
 
-    override fun getFilterList() = FilterList(
-        StatusList(getStatusList()),
-        SortByList(getSortByList()),
-        GenreList(getGenreList()),
-    )
+        val filters = mutableListOf(
+            StatusList(getStatusList()),
+            SortByList(getSortByList()),
+        )
 
-    private fun customToken(): String? = preferences.getString(CUSTOM_TOKEN, null)
+        if (genres.isNotEmpty()) {
+            filters += GenreList(genres)
+        }
+
+        return FilterList(filters)
+    }
 
     override fun setupPreferenceScreen(screen: PreferenceScreen) {
         EditTextPreference(screen.context).apply {
@@ -319,9 +309,13 @@ abstract class GocTruyenTranhVui :
             title = "Authorization Token"
             summary = "Enter token manually"
             dialogTitle = "Authorization Token"
-            customToken()?.let { dialogMessage = if (it.isNotEmpty()) "Token: ${customToken()}" else "Only show manually entered token, do not show token from WebView" }
-            setOnPreferenceChangeListener { _, _ ->
-                Toast.makeText(screen.context, RESTART_APP, Toast.LENGTH_LONG).show()
+            setOnBindEditTextListener {
+                it.inputType = InputType.TYPE_CLASS_TEXT or InputType.TYPE_TEXT_VARIATION_PASSWORD
+            }
+            setOnPreferenceChangeListener { _, newValue ->
+                val token = newValue as String
+                tokenCache = token.takeIf(String::isNotBlank)
+                tokenChecked = true
                 true
             }
         }.also(screen::addPreference)
@@ -329,8 +323,6 @@ abstract class GocTruyenTranhVui :
 
     companion object {
         private const val CUSTOM_TOKEN = "custom_token"
-        private const val RESTART_APP = "Khởi chạy lại ứng dụng để áp dụng token mới nhập."
-        private val WEBVIEW_TOKEN_REGEX = Regex(""";\s*wv\)""")
         private val COMIC_ID_REGEX = Regex("""id:\s*"([^"]+)"""")
         private val COMIC_NAME_EN_REGEX = Regex("""nameEn:\s*`([^`]+)`""")
     }
diff --git a/src/vi/moetruyen/build.gradle.kts b/src/vi/moetruyen/build.gradle.kts
index e1aea99663e..af620043c72 100644
--- a/src/vi/moetruyen/build.gradle.kts
+++ b/src/vi/moetruyen/build.gradle.kts
@@ -11,10 +11,9 @@ keiyoushi {
     source {
         lang = "vi"
         baseUrl {
-            mirrors(
-                "https://moetruyen.net",
-                "https://truyen.moe",
-            )
+            custom("https://moetruyen.net")
+            mirrorSpecial.add("https://moetruyen.net", "MoeTruyen.net (Trong nước)", "default")
+            mirrorSpecial.add("https://truyen.moe", "Truyen.moe (Quốc tế)", "global")
         }
     }
 }
diff --git a/src/vi/moetruyen/src/eu/kanade/tachiyomi/extension/vi/moetruyen/MoeTruyen.kt b/src/vi/moetruyen/src/eu/kanade/tachiyomi/extension/vi/moetruyen/MoeTruyen.kt
index f4e952f997b..629ade07ca8 100644
--- a/src/vi/moetruyen/src/eu/kanade/tachiyomi/extension/vi/moetruyen/MoeTruyen.kt
+++ b/src/vi/moetruyen/src/eu/kanade/tachiyomi/extension/vi/moetruyen/MoeTruyen.kt
@@ -38,12 +38,13 @@ abstract class MoeTruyen : HttpSource() {
 
     private val imgxGrants = ConcurrentHashMap<String, PageAccessEntry>()
 
-    override val client = network.client.newBuilder()
-        .addNetworkInterceptor(CookieInterceptor("moetruyen.net", "moetruyen_full_web" to "Moetruyen123456"))
-        .addNetworkInterceptor(CookieInterceptor("truyen.moe", "moetruyen_full_web" to "Moetruyen123456"))
-        .addInterceptor(imgxInterceptor())
-        .rateLimit(3)
-        .build()
+    override val client by lazy {
+        network.client.newBuilder()
+            .addNetworkInterceptor(CookieInterceptor(baseUrl.toHttpUrl().host, "moetruyen_full_web" to "Moetruyen123456"))
+            .addInterceptor(imgxInterceptor())
+            .rateLimit(3)
+            .build()
+    }
 
     override fun headersBuilder() = super.headersBuilder()
         .add("Referer", "$baseUrl/")