package zed.rainxch.core.domain.model

enum class MirrorStatus { OK, DEGRADED, DOWN, UNKNOWN }

package zed.rainxch.core.domain.model

enum class MirrorType { OFFICIAL, COMMUNITY }

package zed.rainxch.core.domain.model

import kotlinx.datetime.Instant

data class MirrorConfig(
    val id: String,
    val name: String,
    val urlTemplate: String?,
    val type: MirrorType,
    val status: MirrorStatus,
    val latencyMs: Int?,
    val lastCheckedAt: Instant?,
)

package zed.rainxch.core.domain.model

sealed interface MirrorPreference {
    data object Direct : MirrorPreference

    data class Selected(val id: String) : MirrorPreference

    data class Custom(val template: String) : MirrorPreference
}

package zed.rainxch.core.data.mirror

import zed.rainxch.core.domain.model.MirrorConfig
import zed.rainxch.core.domain.model.MirrorStatus
import zed.rainxch.core.domain.model.MirrorType

object BundledMirrors {
    val ALL: List<MirrorConfig> =
        listOf(
            entry("direct", "Direct GitHub", null, MirrorType.OFFICIAL),
            entry("ghfast_top", "ghfast.top", "https://ghfast.top/{url}", MirrorType.COMMUNITY),
            entry("moeyy_xyz", "github.moeyy.xyz", "https://github.moeyy.xyz/{url}", MirrorType.COMMUNITY),
            entry("gh_proxy_com", "gh-proxy.com", "https://gh-proxy.com/{url}", MirrorType.COMMUNITY),
            entry("ghps_cc", "ghps.cc", "https://ghps.cc/{url}", MirrorType.COMMUNITY),
            entry("gh_99988866_xyz", "gh.api.99988866.xyz", "https://gh.api.99988866.xyz/{url}", MirrorType.COMMUNITY),
        )

    private fun entry(
        id: String,
        name: String,
        template: String?,
        type: MirrorType,
    ) = MirrorConfig(
        id = id,
        name = name,
        urlTemplate = template,
        type = type,
        status = MirrorStatus.UNKNOWN,
        latencyMs = null,
        lastCheckedAt = null,
    )
}

package zed.rainxch.core.data.mirror

import androidx.datastore.preferences.core.booleanPreferencesKey
import androidx.datastore.preferences.core.longPreferencesKey
import androidx.datastore.preferences.core.stringPreferencesKey

internal object MirrorPersistence {
    val PREFERRED_MIRROR_KEY = stringPreferencesKey("mirror_preferred_id")
    val CUSTOM_MIRROR_TEMPLATE_KEY = stringPreferencesKey("mirror_custom_template")
    val CACHED_MIRROR_LIST_JSON_KEY = stringPreferencesKey("mirror_cached_list_json")
    val CACHED_MIRROR_LIST_AT_KEY = longPreferencesKey("mirror_cached_list_at")
    val AUTO_SUGGEST_SNOOZE_UNTIL_KEY = longPreferencesKey("mirror_auto_suggest_snooze_until")
    val AUTO_SUGGEST_DISMISSED_KEY = booleanPreferencesKey("mirror_auto_suggest_dismissed")

    /** Sentinel value stored when the user picks the Custom mirror entry. */
    const val CUSTOM_MIRROR_ID_SENTINEL = "__custom__"

    /** Default sentinel — Direct GitHub. */
    const val DIRECT_MIRROR_ID = "direct"
}

git add core/domain/src/commonMain/kotlin/zed/rainxch/core/domain/model/Mirror*.kt \
        core/data/src/commonMain/kotlin/zed/rainxch/core/data/mirror/BundledMirrors.kt \
        core/data/src/commonMain/kotlin/zed/rainxch/core/data/mirror/MirrorPersistence.kt
git commit -m "Add mirror domain types, bundled fallback list, and DataStore keys"

package zed.rainxch.core.data.dto

import kotlinx.serialization.SerialName
import kotlinx.serialization.Serializable

@Serializable
data class MirrorListResponse(
    @SerialName("mirrors") val mirrors: List<MirrorEntry>,
    @SerialName("generated_at") val generatedAt: String,
)

@Serializable
data class MirrorEntry(
    @SerialName("id") val id: String,
    @SerialName("name") val name: String,
    @SerialName("url_template") val urlTemplate: String?,
    @SerialName("type") val type: String,
    @SerialName("status") val status: String,
    @SerialName("latency_ms") val latencyMs: Int? = null,
    @SerialName("last_checked_at") val lastCheckedAt: String? = null,
)

package zed.rainxch.core.data.network

import io.ktor.client.call.body
import io.ktor.client.request.get
import io.ktor.client.statement.bodyAsText
import zed.rainxch.core.data.dto.MirrorListResponse
import zed.rainxch.core.data.network.BackendEndpoints.BACKEND_BASE_URL

class MirrorApiClient(
    private val backendApiClient: BackendApiClient,
) {
    /**
     * Fetches the mirror catalog from the backend. Uses the existing
     * [BackendApiClient] HttpClient — which routes through the discovery
     * proxy scope but never through `MirrorRewriteInterceptor` (the
     * interceptor lives on the GitHub-bound client only).
     */
    suspend fun fetchList(): Result<MirrorListResponse> =
        runCatching {
            backendApiClient.client
                .get("$BACKEND_BASE_URL/v1/mirrors/list")
                .body<MirrorListResponse>()
        }
}

git add core/data/src/commonMain/kotlin/zed/rainxch/core/data/dto/MirrorListResponse.kt \
        core/data/src/commonMain/kotlin/zed/rainxch/core/data/network/MirrorApiClient.kt
git commit -m "Add MirrorListResponse DTO and MirrorApiClient backed by BackendApiClient"

package zed.rainxch.core.domain.repository

import kotlinx.coroutines.flow.Flow
import zed.rainxch.core.domain.model.MirrorConfig
import zed.rainxch.core.domain.model.MirrorPreference

interface MirrorRepository {
    /**
     * Emits the cached catalog immediately, then fresh entries on each
     * successful refresh. Falls back to the bundled list when the cache
     * is empty and the backend is unreachable.
     */
    fun observeCatalog(): Flow<List<MirrorConfig>>

    /** Forces a backend fetch ignoring the 24h cache. */
    suspend fun refreshCatalog(): Result<Unit>

    fun observePreference(): Flow<MirrorPreference>

    suspend fun setPreference(pref: MirrorPreference)

    /**
     * Emits a one-shot notice when the user's previously-selected mirror
     * disappears from a freshly-fetched catalog and the repository
     * auto-falls-back to Direct. UI surfaces a toast.
     */
    fun observeRemovedNotices(): Flow<MirrorRemoved>
}

// Note: synchronous "current template" reads live on ProxyManager
// (see Task 8). Keeping that out of the repository interface avoids
// spreading the snapshot responsibility across two layers.

data class MirrorRemoved(
    val displayName: String,
)

git add core/domain/src/commonMain/kotlin/zed/rainxch/core/domain/repository/MirrorRepository.kt
git commit -m "Define MirrorRepository contract for catalog, preference, and removed-notice flows"

package zed.rainxch.core.data.mirror

import androidx.datastore.core.DataStore
import androidx.datastore.preferences.core.Preferences
import androidx.datastore.preferences.core.edit
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.channels.BufferOverflow
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.MutableSharedFlow
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.asSharedFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.launch
import kotlinx.datetime.Clock
import kotlinx.datetime.Instant
import kotlinx.serialization.json.Json
import zed.rainxch.core.data.dto.MirrorEntry
import zed.rainxch.core.data.dto.MirrorListResponse
import zed.rainxch.core.data.network.MirrorApiClient
import zed.rainxch.core.domain.model.MirrorConfig
import zed.rainxch.core.domain.model.MirrorPreference
import zed.rainxch.core.domain.model.MirrorStatus
import zed.rainxch.core.domain.model.MirrorType
import zed.rainxch.core.domain.repository.MirrorRemoved
import zed.rainxch.core.domain.repository.MirrorRepository

class MirrorRepositoryImpl(
    private val preferences: DataStore<Preferences>,
    private val apiClient: MirrorApiClient,
    private val appScope: CoroutineScope,
) : MirrorRepository {
    private val json = Json { ignoreUnknownKeys = true }
    private val cacheTtlMs = 24L * 60 * 60 * 1000

    private val _catalog = MutableStateFlow<List<MirrorConfig>>(emptyList())
    private val _removedNotices =
        MutableSharedFlow<MirrorRemoved>(
            replay = 0,
            extraBufferCapacity = 4,
            onBufferOverflow = BufferOverflow.DROP_OLDEST,
        )

    init {
        appScope.launch {
            // Seed the catalog flow from cache (or bundled fallback) so
            // first subscribers see something immediately.
            _catalog.value = readCachedCatalogOrBundled()
            // Then kick off a refresh if the cache is older than 24h.
            val cachedAt = preferences.data.first()[MirrorPersistence.CACHED_MIRROR_LIST_AT_KEY] ?: 0L
            if (Clock.System.now().toEpochMilliseconds() - cachedAt > cacheTtlMs) {
                refreshCatalog()
            }
        }
    }

    override fun observeCatalog(): Flow<List<MirrorConfig>> = _catalog.asStateFlow()

    override suspend fun refreshCatalog(): Result<Unit> =
        apiClient
            .fetchList()
            .onSuccess { response ->
                val configs = response.mirrors.map { it.toDomain() }
                _catalog.value = configs
                preferences.edit { prefs ->
                    prefs[MirrorPersistence.CACHED_MIRROR_LIST_JSON_KEY] = json.encodeToString(MirrorListResponse.serializer(), response)
                    prefs[MirrorPersistence.CACHED_MIRROR_LIST_AT_KEY] = Clock.System.now().toEpochMilliseconds()
                }
                checkSelectedMirrorStillExists(configs)
            }.map { }

    override fun observePreference(): Flow<MirrorPreference> =
        preferences.data.map { prefs ->
            val id = prefs[MirrorPersistence.PREFERRED_MIRROR_KEY] ?: MirrorPersistence.DIRECT_MIRROR_ID
            when (id) {
                MirrorPersistence.DIRECT_MIRROR_ID -> MirrorPreference.Direct
                MirrorPersistence.CUSTOM_MIRROR_ID_SENTINEL -> {
                    val template = prefs[MirrorPersistence.CUSTOM_MIRROR_TEMPLATE_KEY].orEmpty()
                    if (template.isBlank()) MirrorPreference.Direct else MirrorPreference.Custom(template)
                }
                else -> MirrorPreference.Selected(id)
            }
        }

    override suspend fun setPreference(pref: MirrorPreference) {
        preferences.edit { prefs ->
            when (pref) {
                MirrorPreference.Direct -> {
                    prefs[MirrorPersistence.PREFERRED_MIRROR_KEY] = MirrorPersistence.DIRECT_MIRROR_ID
                    prefs.remove(MirrorPersistence.CUSTOM_MIRROR_TEMPLATE_KEY)
                }
                is MirrorPreference.Selected -> {
                    prefs[MirrorPersistence.PREFERRED_MIRROR_KEY] = pref.id
                    prefs.remove(MirrorPersistence.CUSTOM_MIRROR_TEMPLATE_KEY)
                }
                is MirrorPreference.Custom -> {
                    prefs[MirrorPersistence.PREFERRED_MIRROR_KEY] = MirrorPersistence.CUSTOM_MIRROR_ID_SENTINEL
                    prefs[MirrorPersistence.CUSTOM_MIRROR_TEMPLATE_KEY] = pref.template
                }
            }
        }
    }

    override fun observeRemovedNotices(): Flow<MirrorRemoved> = _removedNotices.asSharedFlow()

    private suspend fun readCachedCatalogOrBundled(): List<MirrorConfig> {
        val cachedJson = preferences.data.first()[MirrorPersistence.CACHED_MIRROR_LIST_JSON_KEY]
        return if (cachedJson.isNullOrBlank()) {
            BundledMirrors.ALL
        } else {
            runCatching {
                json.decodeFromString(MirrorListResponse.serializer(), cachedJson).mirrors.map { it.toDomain() }
            }.getOrElse { BundledMirrors.ALL }
        }
    }

    private suspend fun checkSelectedMirrorStillExists(fresh: List<MirrorConfig>) {
        val pref = observePreference().first()
        if (pref !is MirrorPreference.Selected) return
        val match = fresh.firstOrNull { it.id == pref.id }
        if (match == null) {
            // Find the previous name from the cache for the toast message
            val previousName =
                _catalog.value.firstOrNull { it.id == pref.id }?.name ?: pref.id
            setPreference(MirrorPreference.Direct)
            _removedNotices.tryEmit(MirrorRemoved(displayName = previousName))
        }
    }

    private fun MirrorEntry.toDomain(): MirrorConfig =
        MirrorConfig(
            id = id,
            name = name,
            urlTemplate = urlTemplate,
            type =
                when (type) {
                    "official" -> MirrorType.OFFICIAL
                    else -> MirrorType.COMMUNITY
                },
            status =
                when (status) {
                    "ok" -> MirrorStatus.OK
                    "degraded" -> MirrorStatus.DEGRADED
                    "down" -> MirrorStatus.DOWN
                    else -> MirrorStatus.UNKNOWN
                },
            latencyMs = latencyMs,
            lastCheckedAt = lastCheckedAt?.let { runCatching { Instant.parse(it) }.getOrNull() },
        )
}

import zed.rainxch.core.data.mirror.MirrorRepositoryImpl
import zed.rainxch.core.data.network.MirrorApiClient
import zed.rainxch.core.domain.repository.MirrorRepository

        single<MirrorApiClient> {
            MirrorApiClient(
                backendApiClient = get(),
            )
        }

        single<MirrorRepository> {
            MirrorRepositoryImpl(
                preferences = get(),
                apiClient = get(),
                appScope = get(),
            )
        }

git add core/data/src/commonMain/kotlin/zed/rainxch/core/data/mirror/MirrorRepositoryImpl.kt \
        core/data/src/commonMain/kotlin/zed/rainxch/core/data/di/SharedModule.kt
git commit -m "Add MirrorRepositoryImpl with 24h cache, bundled fallback, and removed-notice flow"

    <!-- Tweaks feature - Mirror -->
    <string name="mirror_tweaks_entry_label">Download Mirror</string>
    <string name="mirror_picker_title">Download Mirror</string>
    <string name="mirror_picker_description">Used for downloading release assets and proxying GitHub API calls. Most users should leave this on Direct GitHub.</string>

    <!-- Mirror - Sections -->
    <string name="mirror_section_official">Official</string>
    <string name="mirror_section_community">Community</string>

    <!-- Mirror - Statuses -->
    <string name="mirror_status_ok">%1$dms</string>
    <string name="mirror_status_degraded">%1$dms</string>
    <string name="mirror_status_down">(down)</string>
    <string name="mirror_status_unknown">?</string>

    <!-- Mirror - Custom -->
    <string name="mirror_custom_label">Custom mirror…</string>
    <string name="mirror_custom_dialog_title">Custom mirror</string>
    <string name="mirror_custom_dialog_hint">https://your-mirror.example/{url}</string>
    <string name="mirror_custom_validation_https">Template must start with https://</string>
    <string name="mirror_custom_validation_template">Template must contain {url} exactly once</string>
    <string name="mirror_custom_save">Save</string>

    <!-- Mirror - Test connection -->
    <string name="mirror_test_button">Test selected</string>
    <string name="mirror_test_in_progress">Testing…</string>
    <string name="mirror_test_success">Reached in %1$dms</string>
    <string name="mirror_test_http_error">Mirror returned %1$d</string>
    <string name="mirror_test_timeout">Timed out after 5s</string>
    <string name="mirror_test_dns_fail">Could not resolve host</string>
    <string name="mirror_test_other">Failed: %1$s</string>

    <!-- Mirror - Footer hint -->
    <string name="mirror_deploy_your_own_hint">All mirrors broken? You can host your own in 5 minutes — see docs.</string>

    <!-- Mirror - Removed notice + verification -->
    <string name="mirror_removed_toast">%1$s is no longer available, switched to Direct GitHub.</string>
    <string name="mirror_digest_mismatch_error">Checksum mismatch — file may have been tampered with</string>

    <!-- Mirror - Auto-suggest -->
    <string name="mirror_auto_suggest_title">Try a faster mirror?</string>
    <string name="mirror_auto_suggest_body">Some users on slow networks have better luck with a community proxy.</string>
    <string name="mirror_auto_suggest_pick_one">Pick one</string>
    <string name="mirror_auto_suggest_maybe_later">Maybe later</string>
    <string name="mirror_auto_suggest_dont_ask_again">Don\'t ask again</string>

git add core/presentation/src/commonMain/composeResources/values/strings.xml
git commit -m "Add string resources for mirror picker, dialog, auto-suggest, and verification"

package zed.rainxch.core.data.dto

import kotlinx.serialization.SerialName
import kotlinx.serialization.Serializable

@Serializable
data class AssetNetwork(
    @SerialName("id") val id: Long,
    @SerialName("name") val name: String,
    @SerialName("content_type") val contentType: String,
    @SerialName("size") val size: Long,
    @SerialName("browser_download_url") val downloadUrl: String,
    @SerialName("uploader") val uploader: OwnerNetwork? = null,
    @SerialName("download_count") val downloadCount: Long = 0,
    @SerialName("digest") val digest: String? = null,
)

data class GithubAsset(
    val id: Long,
    val name: String,
    val contentType: String,
    val size: Long,
    val downloadUrl: String,
    val downloadCount: Long,
)

data class GithubAsset(
    val id: Long,
    val name: String,
    val contentType: String,
    val size: Long,
    val downloadUrl: String,
    val downloadCount: Long,
    val digest: String? = null,
)

fun AssetNetwork.toGithubAsset(): GithubAsset =
    GithubAsset(
        id = id,
        name = name,
        contentType = contentType,
        size = size,
        downloadUrl = downloadUrl,
        downloadCount = downloadCount,
        digest = digest,
    )

git add core/data/src/commonMain/kotlin/zed/rainxch/core/data/dto/AssetNetwork.kt \
        core/domain/src/commonMain/kotlin/zed/rainxch/core/domain/model/GithubAsset.kt \
        core/data/src/commonMain/kotlin/zed/rainxch/core/data/mappers/
git commit -m "Propagate GitHub asset digest through DTO, domain model, and mapper"

package zed.rainxch.core.domain.network

import io.ktor.http.Url

object MirrorRewriter {
    private val rewriteHosts =
        setOf(
            "github.com",
            "api.github.com",
            "raw.githubusercontent.com",
            "objects.githubusercontent.com",
        )

    /**
     * True iff the URL host is one of the GitHub-owned hosts that should
     * be routed through a community mirror. Returns false for all other
     * hosts including `api.github-store.org` (our backend).
     */
    fun shouldRewrite(url: String): Boolean =
        runCatching {
            val host = Url(url).host.lowercase()
            host in rewriteHosts
        }.getOrDefault(false)

    /**
     * Substitutes the literal `{url}` in the template with the full
     * GitHub URL. Caller is responsible for ensuring the template
     * contains exactly one `{url}` placeholder; that validation happens
     * at custom-mirror entry time.
     */
    fun applyTemplate(
        template: String,
        githubUrl: String,
    ): String = template.replace("{url}", githubUrl)
}

git add core/domain/src/commonMain/kotlin/zed/rainxch/core/domain/network/MirrorRewriter.kt
git commit -m "Add MirrorRewriter pure helper for host check and template substitution"

package zed.rainxch.core.data.network

import kotlinx.atomicfu.atomic
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.Job
import kotlinx.coroutines.SupervisorJob
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.collect
import kotlinx.coroutines.launch
import zed.rainxch.core.domain.model.MirrorPreference
import zed.rainxch.core.domain.model.ProxyConfig
import zed.rainxch.core.domain.model.ProxyScope
import zed.rainxch.core.domain.repository.MirrorRepository

/**
 * Live in-memory cache of the three per-scope proxy configurations
 * **and** the resolved mirror URL template. Writers (the proxy
 * repository and the mirror collector) push updates here; consumers
 * (HTTP clients, the MirrorRewriteInterceptor) read synchronously
 * via [configFlow] / [currentMirrorTemplate].
 */
object ProxyManager {
    private val flows: Map<ProxyScope, MutableStateFlow<ProxyConfig>> =
        ProxyScope.entries.associateWith { MutableStateFlow<ProxyConfig>(ProxyConfig.System) }

    private val mirrorTemplate = atomic<String?>(null)
    private var mirrorCollectorJob: Job? = null

    fun configFlow(scope: ProxyScope): StateFlow<ProxyConfig> = flows.getValue(scope).asStateFlow()

    fun currentConfig(scope: ProxyScope): ProxyConfig = flows.getValue(scope).value

    fun setConfig(
        scope: ProxyScope,
        config: ProxyConfig,
    ) {
        flows.getValue(scope).value = config
    }

    /**
     * Effective mirror template for the current preference, or null
     * when Direct. Read by [MirrorRewriteInterceptor] on every outbound
     * GitHub request — must be hot-path safe (atomic, no I/O).
     */
    fun currentMirrorTemplate(): String? = mirrorTemplate.value

    /**
     * Starts a long-lived collector that mirrors [MirrorRepository.observePreference]
     * into the atomic snapshot used by [currentMirrorTemplate]. Idempotent —
     * subsequent calls are no-ops as long as the previous job is alive.
     *
     * Looks up the catalog via [MirrorRepository.observeCatalog] to resolve
     * `Selected(id)` → template string. If the catalog is empty (cold start
     * before bundled fallback emits) the template stays null until the
     * first emission lands.
     */
    fun startMirrorCollector(
        repository: MirrorRepository,
        scope: CoroutineScope,
    ) {
        if (mirrorCollectorJob?.isActive == true) return
        mirrorCollectorJob =
            scope.launch {
                kotlinx.coroutines.flow
                    .combine(
                        repository.observePreference(),
                        repository.observeCatalog(),
                    ) { pref, catalog ->
                        when (pref) {
                            MirrorPreference.Direct -> null
                            is MirrorPreference.Custom -> pref.template
                            is MirrorPreference.Selected ->
                                catalog.firstOrNull { it.id == pref.id }?.urlTemplate
                        }
                    }.collect { template ->
                        mirrorTemplate.value = template
                    }
            }
    }
}

        single<MirrorRepository> {
            val repo =
                MirrorRepositoryImpl(
                    preferences = get(),
                    apiClient = get(),
                    appScope = get(),
                )
            // Kick off the ProxyManager mirror-template snapshot collector
            // so the Ktor interceptor can resolve the template synchronously.
            ProxyManager.startMirrorCollector(repo, get())
            repo
        }

git add core/data/src/commonMain/kotlin/zed/rainxch/core/data/network/ProxyManager.kt \
        core/data/src/commonMain/kotlin/zed/rainxch/core/data/di/SharedModule.kt
git commit -m "Snapshot the resolved mirror template into ProxyManager for hot-path interceptor reads"

package zed.rainxch.core.data.network

import io.ktor.client.HttpClient
import io.ktor.client.plugins.HttpSend
import io.ktor.client.plugins.plugin
import io.ktor.client.request.HttpRequestBuilder
import io.ktor.client.request.url
import io.ktor.client.statement.HttpResponse
import io.ktor.http.Url
import io.ktor.http.takeFrom
import io.ktor.util.AttributeKey
import zed.rainxch.core.domain.network.MirrorRewriter

/**
 * Marks a request to bypass [MirrorRewriteInterceptor] — used by the
 * direct branch of the multi-source download race.
 */
val NO_MIRROR_REWRITE: AttributeKey<Boolean> = AttributeKey("NoMirrorRewrite")

/**
 * Installs the mirror-rewrite hook on a Ktor [HttpClient]. Call after
 * the client is built but before any request is fired.
 *
 * The hook checks (in order):
 *  1. `NO_MIRROR_REWRITE` attribute — bypass if true.
 *  2. [MirrorRewriter.shouldRewrite] — only rewrite GitHub-owned hosts.
 *  3. [ProxyManager.currentMirrorTemplate] — only rewrite when a
 *     non-Direct preference resolves to a non-null template.
 */
fun HttpClient.installMirrorRewrite() {
    plugin(HttpSend).intercept { request ->
        if (!request.attributes.contains(NO_MIRROR_REWRITE)) {
            val original = request.url.buildString()
            if (MirrorRewriter.shouldRewrite(original)) {
                val template = ProxyManager.currentMirrorTemplate()
                if (template != null) {
                    val rewritten = MirrorRewriter.applyTemplate(template, original)
                    request.url.takeFrom(Url(rewritten))
                }
            }
        }
        execute(request)
    }
}

return createPlatformHttpClient(proxyConfig).config {
    // ... existing installs ...
}.also { it.installMirrorRewrite() }

        install(HttpRedirect) {
            checkHttpMethod = false
        }

git add core/data/src/commonMain/kotlin/zed/rainxch/core/data/network/MirrorRewriteInterceptor.kt \
        core/data/src/commonMain/kotlin/zed/rainxch/core/data/network/HttpClientFactory.kt
git commit -m "Install MirrorRewriteInterceptor on the GitHub HttpClient with NO_MIRROR_REWRITE bypass"

package zed.rainxch.core.domain.network

interface DigestVerifier {
    /**
     * Streams the file at [filePath] through SHA-256 and compares against
     * [expectedDigest] (which may carry a `sha256:` prefix or be raw hex).
     *
     * @return null on match, a non-null human-readable reason on
     *   mismatch / IO error.
     */
    suspend fun verify(
        filePath: String,
        expectedDigest: String,
    ): String?
}

package zed.rainxch.core.data.network

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import zed.rainxch.core.domain.network.DigestVerifier
import java.io.File
import java.security.MessageDigest

class AndroidDigestVerifier : DigestVerifier {
    override suspend fun verify(
        filePath: String,
        expectedDigest: String,
    ): String? =
        withContext(Dispatchers.IO) {
            val file = File(filePath)
            if (!file.exists()) return@withContext "File not found: $filePath"
            val expected = expectedDigest.removePrefix("sha256:").lowercase()
            val actual =
                runCatching {
                    val digest = MessageDigest.getInstance("SHA-256")
                    file.inputStream().use { stream ->
                        val buf = ByteArray(8 * 1024)
                        while (true) {
                            val read = stream.read(buf)
                            if (read <= 0) break
                            digest.update(buf, 0, read)
                        }
                    }
                    digest.digest().joinToString("") { "%02x".format(it) }
                }.getOrElse { return@withContext "Digest computation failed: ${it.message}" }
            if (actual == expected) null else "Digest mismatch (expected $expected, got $actual)"
        }
}

package zed.rainxch.core.data.network

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import zed.rainxch.core.domain.network.DigestVerifier
import java.io.File
import java.security.MessageDigest

class DesktopDigestVerifier : DigestVerifier {
    override suspend fun verify(
        filePath: String,
        expectedDigest: String,
    ): String? =
        withContext(Dispatchers.IO) {
            val file = File(filePath)
            if (!file.exists()) return@withContext "File not found: $filePath"
            val expected = expectedDigest.removePrefix("sha256:").lowercase()
            val actual =
                runCatching {
                    val digest = MessageDigest.getInstance("SHA-256")
                    file.inputStream().use { stream ->
                        val buf = ByteArray(8 * 1024)
                        while (true) {
                            val read = stream.read(buf)
                            if (read <= 0) break
                            digest.update(buf, 0, read)
                        }
                    }
                    digest.digest().joinToString("") { "%02x".format(it) }
                }.getOrElse { return@withContext "Digest computation failed: ${it.message}" }
            if (actual == expected) null else "Digest mismatch (expected $expected, got $actual)"
        }
}

import zed.rainxch.core.data.network.AndroidDigestVerifier
import zed.rainxch.core.domain.network.DigestVerifier

        single<DigestVerifier> {
            AndroidDigestVerifier()
        }

import zed.rainxch.core.data.network.DesktopDigestVerifier
import zed.rainxch.core.domain.network.DigestVerifier

        single<DigestVerifier> {
            DesktopDigestVerifier()
        }

git add core/domain/src/commonMain/kotlin/zed/rainxch/core/domain/network/DigestVerifier.kt \
        core/data/src/androidMain/kotlin/zed/rainxch/core/data/network/AndroidDigestVerifier.kt \
        core/data/src/jvmMain/kotlin/zed/rainxch/core/data/network/DesktopDigestVerifier.kt \
        core/data/src/androidMain/kotlin/zed/rainxch/core/data/di/PlatformModule.android.kt \
        core/data/src/jvmMain/kotlin/zed/rainxch/core/data/di/PlatformModule.jvm.kt
git commit -m "Add streaming SHA-256 DigestVerifier for Android and Desktop"

package zed.rainxch.core.domain.system

import kotlinx.coroutines.flow.Flow
import zed.rainxch.core.domain.model.DownloadProgress

interface MultiSourceDownloader {
    /**
     * Downloads a release asset honouring the current mirror preference.
     *
     * - When [zed.rainxch.core.data.network.ProxyManager.currentMirrorTemplate] is null,
     *   delegates to the underlying [zed.rainxch.core.domain.network.Downloader].
     * - Otherwise launches both Direct and Mirror downloads in parallel,
     *   cancels the loser at the first valid stream, and returns the
     *   winner's progress flow.
     *
     * Only release-asset downloads should call this — API calls go
     * through the mirror-only path.
     */
    fun download(
        githubUrl: String,
        suggestedFileName: String? = null,
    ): Flow<DownloadProgress>
}

package zed.rainxch.core.data.download

import kotlinx.coroutines.CompletableDeferred
import kotlinx.coroutines.cancelAndJoin
import kotlinx.coroutines.channels.BufferOverflow
import kotlinx.coroutines.coroutineScope
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.MutableSharedFlow
import kotlinx.coroutines.flow.asSharedFlow
import kotlinx.coroutines.flow.catch
import kotlinx.coroutines.flow.collect
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.flow.flowOn
import kotlinx.coroutines.launch
import kotlinx.coroutines.Dispatchers
import zed.rainxch.core.data.network.ProxyManager
import zed.rainxch.core.domain.model.DownloadProgress
import zed.rainxch.core.domain.network.Downloader
import zed.rainxch.core.domain.network.MirrorRewriter
import zed.rainxch.core.domain.system.MultiSourceDownloader

class MultiSourceDownloaderImpl(
    private val downloader: Downloader,
) : MultiSourceDownloader {
    override fun download(
        githubUrl: String,
        suggestedFileName: String?,
    ): Flow<DownloadProgress> {
        val template = ProxyManager.currentMirrorTemplate()
        if (template == null) {
            return downloader.download(githubUrl, suggestedFileName)
        }
        val mirrorUrl = MirrorRewriter.applyTemplate(template, githubUrl)
        return raceDownloads(githubUrl, mirrorUrl, suggestedFileName)
    }

    private fun raceDownloads(
        directUrl: String,
        mirrorUrl: String,
        suggestedFileName: String?,
    ): Flow<DownloadProgress> =
        flow {
            coroutineScope {
                val winnerSignal = CompletableDeferred<String>()  // resolves with the winner label

                val directJob =
                    launch {
                        try {
                            downloader
                                .download(directUrl, suggestedFileName)
                                .collect { progress ->
                                    if (winnerSignal.complete("direct") || winnerSignal.getCompleted() == "direct") {
                                        emit(progress)
                                    } else {
                                        // Mirror won — stop emitting from direct.
                                        return@collect
                                    }
                                }
                        } catch (t: Throwable) {
                            if (!winnerSignal.isCompleted) {
                                // Ignore — let the mirror try.
                            } else {
                                throw t
                            }
                        }
                    }

                val mirrorJob =
                    launch {
                        try {
                            downloader
                                .download(mirrorUrl, suggestedFileName)
                                .collect { progress ->
                                    if (winnerSignal.complete("mirror") || winnerSignal.getCompleted() == "mirror") {
                                        emit(progress)
                                    } else {
                                        return@collect
                                    }
                                }
                        } catch (t: Throwable) {
                            if (!winnerSignal.isCompleted) {
                                // Ignore — let direct try.
                            } else {
                                throw t
                            }
                        }
                    }

                val winner = winnerSignal.await()
                if (winner == "direct") mirrorJob.cancelAndJoin() else directJob.cancelAndJoin()
            }
        }.flowOn(Dispatchers.IO)
}

package zed.rainxch.core.domain.network

import kotlinx.coroutines.flow.Flow
import zed.rainxch.core.domain.model.DownloadProgress

interface Downloader {
    fun download(
        url: String,
        suggestedFileName: String? = null,
        bypassMirror: Boolean = false,
    ): Flow<DownloadProgress>

    suspend fun saveToFile(
        url: String,
        suggestedFileName: String? = null,
    ): String

    suspend fun getDownloadedFilePath(fileName: String): String?

    suspend fun cancelDownload(fileName: String): Boolean
}

if (bypassMirror) attributes.put(NO_MIRROR_REWRITE, true)

override fun download(
    url: String,
    suggestedFileName: String?,
    bypassMirror: Boolean,
): Flow<DownloadProgress> {
    // bypassMirror is ignored here: this downloader uses Android's
    // DownloadManager which doesn't traverse the Ktor MirrorRewriteInterceptor.
    // ...
}

downloader.download(directUrl, suggestedFileName, bypassMirror = true)

import zed.rainxch.core.data.download.MultiSourceDownloaderImpl
import zed.rainxch.core.domain.system.MultiSourceDownloader

        single<MultiSourceDownloader> {
            MultiSourceDownloaderImpl(
                downloader = get(),
            )
        }

git add core/domain/src/commonMain/kotlin/zed/rainxch/core/domain/system/MultiSourceDownloader.kt \
        core/domain/src/commonMain/kotlin/zed/rainxch/core/domain/network/Downloader.kt \
        core/data/src/commonMain/kotlin/zed/rainxch/core/data/download/MultiSourceDownloaderImpl.kt \
        core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/AndroidDownloader.kt \
        core/data/src/jvmMain/kotlin/zed/rainxch/core/data/services/DesktopDownloader.kt \
        core/data/src/commonMain/kotlin/zed/rainxch/core/data/di/SharedModule.kt
git commit -m "Race direct and mirror downloads through MultiSourceDownloader with NO_MIRROR_REWRITE bypass"

import zed.rainxch.core.domain.network.DigestVerifier
import zed.rainxch.core.domain.system.MultiSourceDownloader
import zed.rainxch.githubstore.core.presentation.res.Res
import zed.rainxch.githubstore.core.presentation.res.mirror_digest_mismatch_error
import org.jetbrains.compose.resources.getString

val asset = spec.asset
if (asset.digest != null) {
    val verifyError = digestVerifier.verify(filePath, asset.digest)
    if (verifyError != null) {
        runCatching { java.io.File(filePath).delete() }
        // Transition to Failed with the localized error message.
        update(packageName) {
            it.copy(
                stage = DownloadStage.Failed,
                errorMessage = getString(Res.string.mirror_digest_mismatch_error),
            )
        }
        return
    }
}

_downloads.update { map ->
    map.toMutableMap().apply {
        this[packageName]?.let {
            this[packageName] = it.copy(
                stage = DownloadStage.Failed,
                errorMessage = getString(Res.string.mirror_digest_mismatch_error),
            )
        }
    }
}

} else {
    logger.i { "No digest for ${asset.name}, skipping SHA-256 verification" }
}

        single<DownloadOrchestrator> {
            DefaultDownloadOrchestrator(
                downloader = get(),
                installer = get(),
                installedAppsRepository = get(),
                pendingInstallNotifier = get(),
                appScope = get(),
            )
        }

        single<DownloadOrchestrator> {
            DefaultDownloadOrchestrator(
                multiSourceDownloader = get(),
                digestVerifier = get(),
                installer = get(),
                installedAppsRepository = get(),
                pendingInstallNotifier = get(),
                appScope = get(),
            )
        }

git add core/data/src/commonMain/kotlin/zed/rainxch/core/data/services/DefaultDownloadOrchestrator.kt \
        core/data/src/commonMain/kotlin/zed/rainxch/core/data/di/SharedModule.kt
git commit -m "Route asset downloads through MultiSourceDownloader and verify SHA-256 after completion"

package zed.rainxch.core.domain.network

import kotlinx.coroutines.flow.Flow
import zed.rainxch.core.domain.model.DownloadProgress

interface SlowDownloadDetector {
    /**
     * Emits Unit when the user should be prompted to try a faster mirror.
     * Conditions: 3+ sustained-slow events (<100KB/s for 30s) within a
     * 10-minute rolling window AND the current mirror preference is Direct
     * AND auto-suggest is not snoozed/dismissed.
     */
    val suggestMirror: Flow<Unit>

    /**
     * Observe a download's progress. Side-effecting — the detector
     * updates internal state on every emission and may emit a suggestion.
     */
    fun observe(progress: Flow<DownloadProgress>)
}

package zed.rainxch.core.data.download

import androidx.datastore.core.DataStore
import androidx.datastore.preferences.core.Preferences
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.channels.BufferOverflow
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.MutableSharedFlow
import kotlinx.coroutines.flow.asSharedFlow
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.flow.collect
import kotlinx.coroutines.launch
import kotlinx.datetime.Clock
import zed.rainxch.core.data.mirror.MirrorPersistence
import zed.rainxch.core.data.network.ProxyManager
import zed.rainxch.core.domain.model.DownloadProgress
import zed.rainxch.core.domain.network.SlowDownloadDetector

class SlowDownloadDetectorImpl(
    private val preferences: DataStore<Preferences>,
    private val appScope: CoroutineScope,
) : SlowDownloadDetector {
    private val windowMs = 10L * 60 * 1000
    private val sustainedMs = 30L * 1000
    private val thresholdBytesPerSec = 100L * 1024
    private val triggerCount = 3

    private val recentSlowEvents: ArrayDeque<Long> = ArrayDeque()
    private val _suggestMirror =
        MutableSharedFlow<Unit>(
            replay = 0,
            extraBufferCapacity = 1,
            onBufferOverflow = BufferOverflow.DROP_OLDEST,
        )

    override val suggestMirror: Flow<Unit> = _suggestMirror.asSharedFlow()

    override fun observe(progress: Flow<DownloadProgress>) {
        appScope.launch {
            // Bytes-per-second window: collect (timestampMs, bytes) samples.
            // When 30s of samples averages below threshold, record a slow event.
            val samples = ArrayDeque<Pair<Long, Long>>()
            progress.collect { p ->
                val now = Clock.System.now().toEpochMilliseconds()
                samples.addLast(now to p.bytesDownloaded)
                while (samples.isNotEmpty() && samples.first().first < now - sustainedMs) {
                    samples.removeFirst()
                }
                if (samples.size >= 2) {
                    val first = samples.first()
                    val last = samples.last()
                    val elapsedSec = (last.first - first.first).coerceAtLeast(1L) / 1000.0
                    val deltaBytes = (last.second - first.second).coerceAtLeast(0L)
                    val bytesPerSec = (deltaBytes / elapsedSec).toLong()
                    val windowFull = (last.first - first.first) >= sustainedMs - 500
                    if (windowFull && bytesPerSec < thresholdBytesPerSec) {
                        recordSlowEvent(now)
                    }
                }
            }
        }
    }

    private suspend fun recordSlowEvent(timestampMs: Long) {
        // Add this event, prune old ones.
        recentSlowEvents.addLast(timestampMs)
        while (recentSlowEvents.isNotEmpty() && recentSlowEvents.first() < timestampMs - windowMs) {
            recentSlowEvents.removeFirst()
        }
        if (recentSlowEvents.size < triggerCount) return

        // Check gates: must be Direct, not snoozed, not dismissed.
        if (ProxyManager.currentMirrorTemplate() != null) return
        val prefs = preferences.data.first()
        if (prefs[MirrorPersistence.AUTO_SUGGEST_DISMISSED_KEY] == true) return
        val snoozeUntil = prefs[MirrorPersistence.AUTO_SUGGEST_SNOOZE_UNTIL_KEY] ?: 0L
        if (snoozeUntil > timestampMs) return

        recentSlowEvents.clear()
        _suggestMirror.tryEmit(Unit)
    }
}

val sharedFlow = multiSourceDownloader
    .download(asset.downloadUrl, fileName)
    .shareIn(appScope, SharingStarted.Eagerly, replay = 1)
slowDownloadDetector.observe(sharedFlow)
sharedFlow.collect { progress -> /* existing logic */ }

import zed.rainxch.core.data.download.SlowDownloadDetectorImpl
import zed.rainxch.core.domain.network.SlowDownloadDetector

        single<SlowDownloadDetector> {
            SlowDownloadDetectorImpl(
                preferences = get(),
                appScope = get(),
            )
        }

git add core/domain/src/commonMain/kotlin/zed/rainxch/core/domain/network/SlowDownloadDetector.kt \
        core/data/src/commonMain/kotlin/zed/rainxch/core/data/download/SlowDownloadDetectorImpl.kt \
        core/data/src/commonMain/kotlin/zed/rainxch/core/data/services/DefaultDownloadOrchestrator.kt \
        core/data/src/commonMain/kotlin/zed/rainxch/core/data/di/SharedModule.kt
git commit -m "Detect sustained slow downloads to drive the mirror auto-suggest nudge"

package zed.rainxch.tweaks.presentation.mirror

import androidx.datastore.core.DataStore
import androidx.datastore.preferences.core.Preferences
import androidx.datastore.preferences.core.edit
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.launch
import kotlinx.datetime.Clock
import zed.rainxch.core.data.mirror.MirrorPersistence
import zed.rainxch.core.domain.network.SlowDownloadDetector

class AutoSuggestMirrorViewModel(
    private val detector: SlowDownloadDetector,
    private val preferences: DataStore<Preferences>,
) : ViewModel() {
    private val _isVisible = MutableStateFlow(false)
    val isVisible = _isVisible.asStateFlow()

    init {
        viewModelScope.launch {
            detector.suggestMirror.collect {
                _isVisible.value = true
            }
        }
    }

    fun onMaybeLater() {
        _isVisible.value = false
        viewModelScope.launch {
            preferences.edit { prefs ->
                prefs[MirrorPersistence.AUTO_SUGGEST_SNOOZE_UNTIL_KEY] =
                    Clock.System.now().toEpochMilliseconds() + 24L * 60 * 60 * 1000
            }
        }
    }

    fun onDontAskAgain() {
        _isVisible.value = false
        viewModelScope.launch {
            preferences.edit { prefs ->
                prefs[MirrorPersistence.AUTO_SUGGEST_DISMISSED_KEY] = true
            }
        }
    }

    fun onPickOneClicked() {
        _isVisible.value = false
        // Navigation handled by the host composable.
    }

    fun dismiss() {
        _isVisible.value = false
    }
}

package zed.rainxch.tweaks.presentation.mirror.components

import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Button
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.ModalBottomSheet
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.material3.rememberModalBottomSheetState
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import org.jetbrains.compose.resources.stringResource
import zed.rainxch.githubstore.core.presentation.res.Res
import zed.rainxch.githubstore.core.presentation.res.mirror_auto_suggest_body
import zed.rainxch.githubstore.core.presentation.res.mirror_auto_suggest_dont_ask_again
import zed.rainxch.githubstore.core.presentation.res.mirror_auto_suggest_maybe_later
import zed.rainxch.githubstore.core.presentation.res.mirror_auto_suggest_pick_one
import zed.rainxch.githubstore.core.presentation.res.mirror_auto_suggest_title

@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun AutoSuggestMirrorSheet(
    onDismiss: () -> Unit,
    onPickOne: () -> Unit,
    onMaybeLater: () -> Unit,
    onDontAskAgain: () -> Unit,
) {
    val sheetState = rememberModalBottomSheetState()
    ModalBottomSheet(
        onDismissRequest = onDismiss,
        sheetState = sheetState,
    ) {
        Column(
            modifier = Modifier.fillMaxWidth().padding(24.dp),
            verticalArrangement = Arrangement.spacedBy(12.dp),
        ) {
            Text(
                text = stringResource(Res.string.mirror_auto_suggest_title),
                style = MaterialTheme.typography.titleLarge,
                fontWeight = FontWeight.SemiBold,
                color = MaterialTheme.colorScheme.onSurface,
            )
            Text(
                text = stringResource(Res.string.mirror_auto_suggest_body),
                style = MaterialTheme.typography.bodyMedium,
                color = MaterialTheme.colorScheme.onSurfaceVariant,
            )
            Button(
                onClick = onPickOne,
                modifier = Modifier.fillMaxWidth(),
            ) {
                Text(stringResource(Res.string.mirror_auto_suggest_pick_one))
            }
            OutlinedButton(
                onClick = onMaybeLater,
                modifier = Modifier.fillMaxWidth(),
            ) {
                Text(stringResource(Res.string.mirror_auto_suggest_maybe_later))
            }
            TextButton(
                onClick = onDontAskAgain,
                modifier = Modifier.fillMaxWidth(),
            ) {
                Text(stringResource(Res.string.mirror_auto_suggest_dont_ask_again))
            }
        }
    }
}

val autoSuggestVm: AutoSuggestMirrorViewModel = koinViewModel()
val isAutoSuggestVisible by autoSuggestVm.isVisible.collectAsStateWithLifecycle()
if (isAutoSuggestVisible) {
    AutoSuggestMirrorSheet(
        onDismiss = autoSuggestVm::dismiss,
        onPickOne = {
            autoSuggestVm.onPickOneClicked()
            navController.navigate(GithubStoreGraph.MirrorPickerScreen)
        },
        onMaybeLater = autoSuggestVm::onMaybeLater,
        onDontAskAgain = autoSuggestVm::onDontAskAgain,
    )
}

import zed.rainxch.tweaks.presentation.mirror.AutoSuggestMirrorViewModel

        viewModelOf(::AutoSuggestMirrorViewModel)

git add feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/mirror/AutoSuggestMirrorViewModel.kt \
        feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/mirror/components/AutoSuggestMirrorSheet.kt \
        composeApp/src/commonMain/kotlin/zed/rainxch/githubstore/app/AppNavigation.kt \
        composeApp/src/commonMain/kotlin/zed/rainxch/githubstore/app/di/ViewModelsModule.kt
git commit -m "Add auto-suggest mirror sheet driven by SlowDownloadDetector at app root"

package zed.rainxch.tweaks.presentation.mirror

import org.jetbrains.compose.resources.StringResource
import zed.rainxch.core.domain.model.MirrorConfig
import zed.rainxch.core.domain.model.MirrorPreference

data class MirrorPickerState(
    val mirrors: List<MirrorConfig> = emptyList(),
    val preference: MirrorPreference = MirrorPreference.Direct,
    val isCustomDialogVisible: Boolean = false,
    val customDraft: String = "",
    val customDraftError: StringResource? = null,
    val isTesting: Boolean = false,
    val testResult: TestResult? = null,
    val isRefreshing: Boolean = false,
)

sealed interface TestResult {
    data class Success(val latencyMs: Long) : TestResult

    data class HttpError(val code: Int) : TestResult

    data object Timeout : TestResult

    data object DnsFailure : TestResult

    data class Other(val message: String) : TestResult
}

package zed.rainxch.tweaks.presentation.mirror

import zed.rainxch.core.domain.model.MirrorConfig

sealed interface MirrorPickerAction {
    data object OnNavigateBack : MirrorPickerAction

    data class OnSelectMirror(val mirror: MirrorConfig) : MirrorPickerAction

    data object OnCustomMirrorClicked : MirrorPickerAction

    data class OnCustomDraftChanged(val value: String) : MirrorPickerAction

    data object OnCustomMirrorConfirm : MirrorPickerAction

    data object OnCustomMirrorDismiss : MirrorPickerAction

    data object OnTestConnection : MirrorPickerAction

    data object OnRefreshCatalog : MirrorPickerAction

    data object OnDeployYourOwnClicked : MirrorPickerAction
}

package zed.rainxch.tweaks.presentation.mirror

sealed interface MirrorPickerEvent {
    data class MirrorRemovedNotice(val displayName: String) : MirrorPickerEvent

    data class OpenUrl(val url: String) : MirrorPickerEvent
}

git add feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/mirror/MirrorPickerState.kt \
        feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/mirror/MirrorPickerAction.kt \
        feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/mirror/MirrorPickerEvent.kt
git commit -m "Add MirrorPickerState, Action, and Event for the picker MVI"

package zed.rainxch.tweaks.presentation.mirror

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import io.ktor.client.HttpClient
import io.ktor.client.plugins.HttpRedirect
import io.ktor.client.plugins.HttpTimeout
import io.ktor.client.request.get
import io.ktor.util.network.UnresolvedAddressException
import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.combine
import kotlinx.coroutines.flow.receiveAsFlow
import kotlinx.coroutines.flow.update
import kotlinx.coroutines.launch
import kotlinx.coroutines.withTimeoutOrNull
import zed.rainxch.core.domain.model.MirrorPreference
import zed.rainxch.core.domain.network.MirrorRewriter
import zed.rainxch.core.domain.repository.MirrorRepository
import zed.rainxch.githubstore.core.presentation.res.Res
import zed.rainxch.githubstore.core.presentation.res.mirror_custom_validation_https
import zed.rainxch.githubstore.core.presentation.res.mirror_custom_validation_template
import kotlin.time.TimeSource

class MirrorPickerViewModel(
    private val mirrorRepository: MirrorRepository,
    private val testHttpClient: HttpClient,
) : ViewModel() {
    private val _state = MutableStateFlow(MirrorPickerState())
    val state = _state.asStateFlow()

    private val _events = Channel<MirrorPickerEvent>()
    val events = _events.receiveAsFlow()

    init {
        viewModelScope.launch {
            combine(
                mirrorRepository.observeCatalog(),
                mirrorRepository.observePreference(),
            ) { catalog, pref ->
                catalog to pref
            }.collect { (catalog, pref) ->
                _state.update { it.copy(mirrors = catalog, preference = pref) }
            }
        }
        viewModelScope.launch {
            mirrorRepository.observeRemovedNotices().collect { notice ->
                _events.send(MirrorPickerEvent.MirrorRemovedNotice(notice.displayName))
            }
        }
    }

    fun onAction(action: MirrorPickerAction) {
        when (action) {
            MirrorPickerAction.OnNavigateBack -> { /* host handles via callback */ }
            is MirrorPickerAction.OnSelectMirror -> selectMirror(action.mirror)
            MirrorPickerAction.OnCustomMirrorClicked ->
                _state.update { it.copy(isCustomDialogVisible = true, customDraft = "", customDraftError = null) }
            is MirrorPickerAction.OnCustomDraftChanged -> updateDraft(action.value)
            MirrorPickerAction.OnCustomMirrorConfirm -> confirmCustom()
            MirrorPickerAction.OnCustomMirrorDismiss ->
                _state.update { it.copy(isCustomDialogVisible = false) }
            MirrorPickerAction.OnTestConnection -> runTest()
            MirrorPickerAction.OnRefreshCatalog -> refresh()
            MirrorPickerAction.OnDeployYourOwnClicked ->
                viewModelScope.launch {
                    _events.send(MirrorPickerEvent.OpenUrl("https://github.com/hunshcn/gh-proxy"))
                }
        }
    }

    private fun selectMirror(mirror: zed.rainxch.core.domain.model.MirrorConfig) {
        viewModelScope.launch {
            val pref =
                if (mirror.id == "direct") MirrorPreference.Direct else MirrorPreference.Selected(mirror.id)
            mirrorRepository.setPreference(pref)
        }
    }

    private fun updateDraft(value: String) {
        val error =
            when {
                value.isBlank() -> null
                !value.startsWith("https://") -> Res.string.mirror_custom_validation_https
                value.split("{url}").size - 1 != 1 -> Res.string.mirror_custom_validation_template
                else -> null
            }
        _state.update { it.copy(customDraft = value, customDraftError = error) }
    }

    private fun confirmCustom() {
        val draft = state.value.customDraft
        val error = state.value.customDraftError
        if (draft.isBlank() || error != null) return
        viewModelScope.launch {
            mirrorRepository.setPreference(MirrorPreference.Custom(draft))
            _state.update { it.copy(isCustomDialogVisible = false, customDraft = "", customDraftError = null) }
        }
    }

    private fun runTest() {
        viewModelScope.launch {
            _state.update { it.copy(isTesting = true, testResult = null) }
            val pref = state.value.preference
            val template =
                when (pref) {
                    MirrorPreference.Direct -> null
                    is MirrorPreference.Custom -> pref.template
                    is MirrorPreference.Selected ->
                        state.value.mirrors.firstOrNull { it.id == pref.id }?.urlTemplate
                }
            val targetUrl =
                if (template == null) "https://api.github.com/zen"
                else MirrorRewriter.applyTemplate(template, "https://api.github.com/zen")
            val result =
                withTimeoutOrNull(5_000L) {
                    runCatching {
                        val mark = TimeSource.Monotonic.markNow()
                        val response = testHttpClient.get(targetUrl)
                        val elapsedMs = mark.elapsedNow().inWholeMilliseconds
                        response.status.value to elapsedMs
                    }
                }
            val testResult: TestResult =
                when {
                    result == null -> TestResult.Timeout
                    result.isSuccess -> {
                        val (status, ms) = result.getOrThrow()
                        if (status in 200..299) TestResult.Success(ms) else TestResult.HttpError(status)
                    }
                    result.exceptionOrNull() is UnresolvedAddressException -> TestResult.DnsFailure
                    else -> TestResult.Other(result.exceptionOrNull()?.message ?: "Unknown error")
                }
            _state.update { it.copy(isTesting = false, testResult = testResult) }
        }
    }

    private fun refresh() {
        viewModelScope.launch {
            _state.update { it.copy(isRefreshing = true) }
            mirrorRepository.refreshCatalog()
            _state.update { it.copy(isRefreshing = false) }
        }
    }
}

git add feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/mirror/MirrorPickerViewModel.kt
git commit -m "Add MirrorPickerViewModel with selection, custom-mirror, test, and refresh logic"

package zed.rainxch.tweaks.presentation.mirror.components

import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.material3.MaterialTheme
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.unit.dp
import zed.rainxch.core.domain.model.MirrorStatus

@Composable
fun StatusDot(
    status: MirrorStatus,
    modifier: Modifier = Modifier,
) {
    val color =
        when (status) {
            MirrorStatus.OK -> MaterialTheme.colorScheme.primary
            MirrorStatus.DEGRADED -> MaterialTheme.colorScheme.tertiary
            MirrorStatus.DOWN -> MaterialTheme.colorScheme.error
            MirrorStatus.UNKNOWN -> MaterialTheme.colorScheme.outline
        }
    Box(
        modifier =
            modifier
                .size(8.dp)
                .clip(CircleShape)
                .background(color),
    )
}

package zed.rainxch.tweaks.presentation.mirror.components

import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.selection.selectable
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.RadioButton
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.semantics.Role
import androidx.compose.ui.unit.dp
import org.jetbrains.compose.resources.stringResource
import zed.rainxch.core.domain.model.MirrorConfig
import zed.rainxch.core.domain.model.MirrorStatus
import zed.rainxch.githubstore.core.presentation.res.Res
import zed.rainxch.githubstore.core.presentation.res.mirror_status_degraded
import zed.rainxch.githubstore.core.presentation.res.mirror_status_down
import zed.rainxch.githubstore.core.presentation.res.mirror_status_ok
import zed.rainxch.githubstore.core.presentation.res.mirror_status_unknown

@Composable
fun MirrorRow(
    mirror: MirrorConfig,
    selected: Boolean,
    onClick: () -> Unit,
    modifier: Modifier = Modifier,
) {
    Row(
        modifier =
            modifier
                .fillMaxWidth()
                .selectable(selected = selected, onClick = onClick, role = Role.RadioButton)
                .padding(vertical = 8.dp, horizontal = 12.dp),
        verticalAlignment = Alignment.CenterVertically,
        horizontalArrangement = Arrangement.spacedBy(12.dp),
    ) {
        RadioButton(selected = selected, onClick = null)
        StatusDot(status = mirror.status)
        Text(
            text = mirror.name,
            style = MaterialTheme.typography.bodyLarge,
            color = MaterialTheme.colorScheme.onSurface,
            modifier = Modifier.padding(end = 8.dp),
        )
        val label =
            when (mirror.status) {
                MirrorStatus.OK -> mirror.latencyMs?.let { stringResource(Res.string.mirror_status_ok, it) }
                MirrorStatus.DEGRADED -> mirror.latencyMs?.let { stringResource(Res.string.mirror_status_degraded, it) }
                MirrorStatus.DOWN -> stringResource(Res.string.mirror_status_down)
                MirrorStatus.UNKNOWN -> stringResource(Res.string.mirror_status_unknown)
            }
        if (label != null) {
            Text(
                text = label,
                style = MaterialTheme.typography.bodySmall,
                color = MaterialTheme.colorScheme.onSurfaceVariant,
            )
        }
    }
}

package zed.rainxch.tweaks.presentation.mirror.components

import androidx.compose.material3.AlertDialog
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.material3.MaterialTheme
import org.jetbrains.compose.resources.StringResource
import org.jetbrains.compose.resources.stringResource
import zed.rainxch.githubstore.core.presentation.res.Res
import zed.rainxch.githubstore.core.presentation.res.cancel
import zed.rainxch.githubstore.core.presentation.res.mirror_custom_dialog_hint
import zed.rainxch.githubstore.core.presentation.res.mirror_custom_dialog_title
import zed.rainxch.githubstore.core.presentation.res.mirror_custom_save

@Composable
fun CustomMirrorDialog(
    draft: String,
    error: StringResource?,
    onDraftChange: (String) -> Unit,
    onConfirm: () -> Unit,
    onDismiss: () -> Unit,
) {
    AlertDialog(
        onDismissRequest = onDismiss,
        title = { Text(stringResource(Res.string.mirror_custom_dialog_title)) },
        text = {
            Column(modifier = Modifier.fillMaxWidth()) {
                OutlinedTextField(
                    value = draft,
                    onValueChange = onDraftChange,
                    placeholder = { Text(stringResource(Res.string.mirror_custom_dialog_hint)) },
                    isError = error != null,
                    modifier = Modifier.fillMaxWidth(),
                    singleLine = true,
                )
                if (error != null) {
                    Text(
                        text = stringResource(error),
                        color = MaterialTheme.colorScheme.error,
                        style = MaterialTheme.typography.bodySmall,
                    )
                }
            }
        },
        confirmButton = {
            TextButton(
                onClick = onConfirm,
                enabled = draft.isNotBlank() && error == null,
            ) {
                Text(stringResource(Res.string.mirror_custom_save))
            }
        },
        dismissButton = {
            TextButton(onClick = onDismiss) {
                Text(stringResource(Res.string.cancel))
            }
        },
    )
}

package zed.rainxch.tweaks.presentation.mirror.components

import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import org.jetbrains.compose.resources.stringResource
import zed.rainxch.githubstore.core.presentation.res.Res
import zed.rainxch.githubstore.core.presentation.res.mirror_deploy_your_own_hint

@Composable
fun DeployYourOwnHint(
    onClick: () -> Unit,
    modifier: Modifier = Modifier,
) {
    Text(
        text = stringResource(Res.string.mirror_deploy_your_own_hint),
        style = MaterialTheme.typography.bodySmall,
        color = MaterialTheme.colorScheme.primary,
        modifier =
            modifier
                .fillMaxWidth()
                .clickable(onClick = onClick)
                .padding(vertical = 16.dp, horizontal = 12.dp),
    )
}

git add feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/mirror/components/
git commit -m "Add mirror picker building blocks: StatusDot, MirrorRow, CustomMirrorDialog, DeployYourOwnHint"

package zed.rainxch.tweaks.presentation.mirror

import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.lazy.rememberLazyListState
import androidx.compose.foundation.selection.selectable
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.automirrored.filled.ArrowBack
import androidx.compose.material3.Button
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.HorizontalDivider
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.RadioButton
import androidx.compose.material3.Scaffold
import androidx.compose.material3.SnackbarHost
import androidx.compose.material3.SnackbarHostState
import androidx.compose.material3.Text
import androidx.compose.material3.TopAppBar
import androidx.compose.ui.Alignment
import androidx.compose.ui.semantics.Role
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.ui.Modifier
import androidx.compose.ui.platform.LocalUriHandler
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import kotlinx.coroutines.launch
import org.jetbrains.compose.resources.getString
import org.jetbrains.compose.resources.stringResource
import org.koin.compose.viewmodel.koinViewModel
import zed.rainxch.core.domain.model.MirrorConfig
import zed.rainxch.core.domain.model.MirrorPreference
import zed.rainxch.core.domain.model.MirrorType
import zed.rainxch.core.presentation.utils.ObserveAsEvents
import zed.rainxch.githubstore.core.presentation.res.Res
import zed.rainxch.githubstore.core.presentation.res.mirror_custom_label
import zed.rainxch.githubstore.core.presentation.res.mirror_picker_description
import zed.rainxch.githubstore.core.presentation.res.mirror_picker_title
import zed.rainxch.githubstore.core.presentation.res.mirror_removed_toast
import zed.rainxch.githubstore.core.presentation.res.mirror_section_community
import zed.rainxch.githubstore.core.presentation.res.mirror_section_official
import zed.rainxch.githubstore.core.presentation.res.mirror_test_button
import zed.rainxch.githubstore.core.presentation.res.mirror_test_dns_fail
import zed.rainxch.githubstore.core.presentation.res.mirror_test_http_error
import zed.rainxch.githubstore.core.presentation.res.mirror_test_in_progress
import zed.rainxch.githubstore.core.presentation.res.mirror_test_other
import zed.rainxch.githubstore.core.presentation.res.mirror_test_success
import zed.rainxch.githubstore.core.presentation.res.mirror_test_timeout
import zed.rainxch.tweaks.presentation.mirror.components.CustomMirrorDialog
import zed.rainxch.tweaks.presentation.mirror.components.DeployYourOwnHint
import zed.rainxch.tweaks.presentation.mirror.components.MirrorRow

@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun MirrorPickerRoot(
    onNavigateBack: () -> Unit,
    viewModel: MirrorPickerViewModel = koinViewModel(),
) {
    val state by viewModel.state.collectAsStateWithLifecycle()
    val snackbarState = remember { SnackbarHostState() }
    val coroutineScope = rememberCoroutineScope()
    val uriHandler = LocalUriHandler.current

    ObserveAsEvents(viewModel.events) { event ->
        when (event) {
            is MirrorPickerEvent.MirrorRemovedNotice ->
                coroutineScope.launch {
                    snackbarState.showSnackbar(getString(Res.string.mirror_removed_toast, event.displayName))
                }
            is MirrorPickerEvent.OpenUrl -> uriHandler.openUri(event.url)
        }
    }

    Scaffold(
        topBar = {
            TopAppBar(
                title = {
                    Text(
                        text = stringResource(Res.string.mirror_picker_title),
                        style = MaterialTheme.typography.titleMediumEmphasized,
                        fontWeight = FontWeight.SemiBold,
                    )
                },
                navigationIcon = {
                    IconButton(onClick = onNavigateBack) {
                        Icon(
                            imageVector = Icons.AutoMirrored.Filled.ArrowBack,
                            contentDescription = null,
                        )
                    }
                },
            )
        },
        snackbarHost = { SnackbarHost(snackbarState) },
    ) { padding ->
        val listState = rememberLazyListState()
        LazyColumn(
            state = listState,
            modifier =
                Modifier
                    .fillMaxSize()
                    .padding(padding)
                    .padding(horizontal = 16.dp),
            verticalArrangement = Arrangement.spacedBy(4.dp),
        ) {
            item {
                Spacer(Modifier.height(8.dp))
                Text(
                    text = stringResource(Res.string.mirror_picker_description),
                    style = MaterialTheme.typography.bodyMedium,
                    color = MaterialTheme.colorScheme.onSurfaceVariant,
                )
                Spacer(Modifier.height(16.dp))
            }

            item {
                Text(
                    text = stringResource(Res.string.mirror_section_official),
                    style = MaterialTheme.typography.titleSmall,
                    color = MaterialTheme.colorScheme.onSurfaceVariant,
                )
            }
            items(
                items = state.mirrors.filter { it.type == MirrorType.OFFICIAL },
                key = { it.id },
            ) { mirror ->
                MirrorRow(
                    mirror = mirror,
                    selected = isMirrorSelected(mirror, state.preference),
                    onClick = { viewModel.onAction(MirrorPickerAction.OnSelectMirror(mirror)) },
                )
            }

            item {
                Spacer(Modifier.height(12.dp))
                Text(
                    text = stringResource(Res.string.mirror_section_community),
                    style = MaterialTheme.typography.titleSmall,
                    color = MaterialTheme.colorScheme.onSurfaceVariant,
                )
            }
            items(
                items = state.mirrors.filter { it.type == MirrorType.COMMUNITY },
                key = { it.id },
            ) { mirror ->
                MirrorRow(
                    mirror = mirror,
                    selected = isMirrorSelected(mirror, state.preference),
                    onClick = { viewModel.onAction(MirrorPickerAction.OnSelectMirror(mirror)) },
                )
            }

            item {
                Spacer(Modifier.height(8.dp))
                CustomMirrorRow(
                    selected = state.preference is MirrorPreference.Custom,
                    onClick = { viewModel.onAction(MirrorPickerAction.OnCustomMirrorClicked) },
                )
            }

            item {
                Spacer(Modifier.height(12.dp))
                HorizontalDivider()
                Spacer(Modifier.height(12.dp))
            }

            item {
                Button(
                    onClick = { viewModel.onAction(MirrorPickerAction.OnTestConnection) },
                    enabled = !state.isTesting,
                    modifier = Modifier.fillMaxWidth(),
                ) {
                    if (state.isTesting) {
                        CircularProgressIndicator(
                            modifier = Modifier.height(18.dp),
                            color = MaterialTheme.colorScheme.onPrimary,
                            strokeWidth = 2.dp,
                        )
                    } else {
                        Text(stringResource(Res.string.mirror_test_button))
                    }
                }
                state.testResult?.let { result ->
                    Spacer(Modifier.height(8.dp))
                    Text(
                        text = formatTestResult(result),
                        style = MaterialTheme.typography.bodyMedium,
                        color = MaterialTheme.colorScheme.onSurface,
                    )
                }
            }

            item {
                Spacer(Modifier.height(16.dp))
                DeployYourOwnHint(
                    onClick = { viewModel.onAction(MirrorPickerAction.OnDeployYourOwnClicked) },
                )
            }

            item {
                Spacer(Modifier.height(32.dp))
            }
        }
    }

    if (state.isCustomDialogVisible) {
        CustomMirrorDialog(
            draft = state.customDraft,
            error = state.customDraftError,
            onDraftChange = { viewModel.onAction(MirrorPickerAction.OnCustomDraftChanged(it)) },
            onConfirm = { viewModel.onAction(MirrorPickerAction.OnCustomMirrorConfirm) },
            onDismiss = { viewModel.onAction(MirrorPickerAction.OnCustomMirrorDismiss) },
        )
    }
}

@Composable
private fun CustomMirrorRow(
    selected: Boolean,
    onClick: () -> Unit,
) {
    Row(
        modifier =
            Modifier
                .fillMaxWidth()
                .selectable(
                    selected = selected,
                    onClick = onClick,
                    role = Role.RadioButton,
                ).padding(vertical = 8.dp, horizontal = 12.dp),
        verticalAlignment = Alignment.CenterVertically,
        horizontalArrangement = Arrangement.spacedBy(12.dp),
    ) {
        RadioButton(selected = selected, onClick = null)
        Text(
            text = stringResource(Res.string.mirror_custom_label),
            style = MaterialTheme.typography.bodyLarge,
            color = MaterialTheme.colorScheme.onSurface,
        )
    }
}

@Composable
private fun formatTestResult(result: TestResult): String =
    when (result) {
        is TestResult.Success -> stringResource(Res.string.mirror_test_success, result.latencyMs)
        is TestResult.HttpError -> stringResource(Res.string.mirror_test_http_error, result.code)
        TestResult.Timeout -> stringResource(Res.string.mirror_test_timeout)
        TestResult.DnsFailure -> stringResource(Res.string.mirror_test_dns_fail)
        is TestResult.Other -> stringResource(Res.string.mirror_test_other, result.message)
    }

private fun isMirrorSelected(
    mirror: MirrorConfig,
    pref: MirrorPreference,
): Boolean =
    when (pref) {
        MirrorPreference.Direct -> mirror.id == "direct"
        is MirrorPreference.Selected -> mirror.id == pref.id
        is MirrorPreference.Custom -> false
    }

@Serializable
data object MirrorPickerScreen : GithubStoreGraph

composable<GithubStoreGraph.MirrorPickerScreen> {
    MirrorPickerRoot(
        onNavigateBack = { navController.popBackStack() },
    )
}

import zed.rainxch.tweaks.presentation.mirror.MirrorPickerViewModel

        viewModelOf(::MirrorPickerViewModel)

import io.ktor.client.HttpClient
import io.ktor.client.plugins.HttpTimeout
import org.koin.core.qualifier.named

        single<HttpClient>(qualifier = named("test")) {
            createPlatformHttpClient(zed.rainxch.core.domain.model.ProxyConfig.System).config {
                install(HttpTimeout) {
                    requestTimeoutMillis = 5_000
                    connectTimeoutMillis = 5_000
                    socketTimeoutMillis = 5_000
                }
            }
        }

        viewModel {
            MirrorPickerViewModel(
                mirrorRepository = get(),
                testHttpClient = get(qualifier = org.koin.core.qualifier.named("test")),
            )
        }

git add feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/mirror/MirrorPickerRoot.kt \
        composeApp/src/commonMain/kotlin/zed/rainxch/githubstore/app/navigation/GithubStoreGraph.kt \
        composeApp/src/commonMain/kotlin/zed/rainxch/githubstore/app/AppNavigation.kt \
        composeApp/src/commonMain/kotlin/zed/rainxch/githubstore/app/di/ViewModelsModule.kt \
        core/data/src/commonMain/kotlin/zed/rainxch/core/data/di/SharedModule.kt
git commit -m "Add MirrorPickerRoot, route, and Koin wiring for the picker and its test client"

    data object OnMirrorPickerClick : TweaksAction

TweaksScreen(
    state = state,
    onAction = { action ->
        when (action) {
            TweaksAction.OnMirrorPickerClick -> onNavigateToMirrorPicker()
            else -> viewModel.onAction(action)
        }
    },
    snackbarState = snackbarState,
)

item {
    OutlinedCard(
        onClick = { onAction(TweaksAction.OnMirrorPickerClick) },
        colors = CardDefaults.outlinedCardColors(
            containerColor = MaterialTheme.colorScheme.surfaceContainerLowest,
        ),
        shape = RoundedCornerShape(32.dp),
        modifier = Modifier.fillMaxWidth(),
    ) {
        Row(
            modifier = Modifier.padding(16.dp),
            verticalAlignment = Alignment.CenterVertically,
            horizontalArrangement = Arrangement.spacedBy(12.dp),
        ) {
            Icon(
                imageVector = Icons.Default.NetworkCheck,
                contentDescription = null,
            )
            Column(modifier = Modifier.weight(1f)) {
                Text(
                    text = stringResource(Res.string.mirror_tweaks_entry_label),
                    style = MaterialTheme.typography.titleMedium,
                )
            }
            Icon(
                imageVector = Icons.AutoMirrored.Filled.KeyboardArrowRight,
                contentDescription = null,
            )
        }
    }
}
item {
    Spacer(Modifier.height(16.dp))
}

TweaksRoot(
    // ... existing args ...
    onNavigateToMirrorPicker = {
        navController.navigate(GithubStoreGraph.MirrorPickerScreen)
    },
)

git add feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/components/sections/Network.kt \
        feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/TweaksAction.kt \
        feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/TweaksRoot.kt \
        composeApp/src/commonMain/kotlin/zed/rainxch/githubstore/app/AppNavigation.kt
git commit -m "Add Download Mirror entry to Tweaks Network section linking to the picker"