Pith - spline
package com.vgmlr.spline

import android.app.Activity
import android.content.ActivityNotFoundException
import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.content.IntentFilter
import android.os.Build
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.SystemBarStyle
import androidx.activity.compose.BackHandler
import androidx.activity.compose.rememberLauncherForActivityResult
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.activity.result.contract.ActivityResultContracts
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.platform.LocalContext
import androidx.lifecycle.ViewModelProvider

class MainActivity : ComponentActivity() {
    private lateinit var vm: SplineViewModel

    private val packages = object : BroadcastReceiver() {
        override fun onReceive(c: Context, i: Intent) {
            vm.refresh()
        }
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        enableEdgeToEdge(
            statusBarStyle = SystemBarStyle.dark(android.graphics.Color.TRANSPARENT),
            navigationBarStyle = SystemBarStyle.dark(android.graphics.Color.TRANSPARENT)
        )
        super.onCreate(savedInstanceState)
        window.isNavigationBarContrastEnforced = false
        vm = ViewModelProvider(this)[SplineViewModel::class.java]

        val filter = IntentFilter().apply {
            addAction(Intent.ACTION_PACKAGE_ADDED)
            addAction(Intent.ACTION_PACKAGE_REPLACED)
            addDataScheme("package")
        }
        if (Build.VERSION.SDK_INT >= 33) {
            registerReceiver(packages, filter, RECEIVER_NOT_EXPORTED)
        } else {
            registerReceiver(packages, filter)
        }

        setContent { SplineTheme { SplineRoot(vm) } }
    }

    override fun onStart() {
        super.onStart()
        SplineBadge.visible = true
    }

    override fun onStop() {
        SplineBadge.visible = false
        if (!isChangingConfigurations) SplineBadge.apply(this, vm.updates.value > 0)
        super.onStop()
    }

    override fun onResume() {
        super.onResume()
        vm.refresh()
        SplineNotify.clear(this)
    }

    override fun onDestroy() {
        unregisterReceiver(packages)
        super.onDestroy()
    }
}

private enum class Screen { Home, Settings }

@Composable
private fun SplineRoot(vm: SplineViewModel) {
    val ctx = LocalContext.current
    var screen by rememberSaveable { mutableStateOf(Screen.Home) }
    var permit by remember { mutableStateOf(!SplinePrefs.permitAsked(ctx)) }
    val waiting = remember { ArrayDeque<Long>() }

    val installer = rememberLauncherForActivityResult(
        ActivityResultContracts.StartActivityForResult()
    ) { r ->
        waiting.removeLastOrNull()?.let { vm.installed(it, r.resultCode == Activity.RESULT_OK) }
    }

    LaunchedEffect(vm) {
        vm.ready.collect { r ->
            waiting.addLast(r.dl)
            try {
                installer.launch(r.intent)
            } catch (e: ActivityNotFoundException) {
                waiting.removeLastOrNull()
                vm.installed(r.dl, false)
            }
        }
    }

    BackHandler(enabled = screen != Screen.Home) { screen = Screen.Home }

    when (screen) {
        Screen.Home -> SplineHomeScreen(vm, onSettings = { screen = Screen.Settings })
        Screen.Settings -> SplineSettings(vm, onBack = { screen = Screen.Home })
    }

    if (permit) SplinePermit {
        SplinePrefs.setPermitAsked(ctx)
        permit = false
    }
}