import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import nu.shel.wldroid.ui.CompositorSurface
import nu.shel.wldroid.ui.CompositorKeyboardController
import nu.shel.wldroid.ui.rememberCompositorSurfaceState
import nu.shel.wldroid.compositor.CompositorConfig
import nu.shel.wldroid.compositor.CompositorState

@Composable
fun MyScreen() {
    val config = CompositorConfig(
        cacheDir = context.cacheDir.absolutePath,
        xwaylandEnabled = true,
        gpuMode = "AUTO",
    )
    val surfaceState = rememberCompositorSurfaceState(config)
    var keyboardController by remember { mutableStateOf<CompositorKeyboardController?>(null) }

    CompositorSurface(
        modifier = Modifier.fillMaxSize(),
        config = config,
        surfaceState = surfaceState,
        onStateChange = { state ->
            when (state) {
                CompositorState.RUNNING -> Log.d("WLDroid", "Compositor ready")
                CompositorState.ERROR -> Log.e("WLDroid", "Compositor failed")
                else -> {}
            }
        },
        onClientCountChange = { count ->
            Log.d("WLDroid", "$count Wayland clients connected")
        },
        onKeyboardControllerChange = { keyboardController = it },
        // Optional host-side pinch/pan. Defaults off to preserve guest multi-touch.
        // This transforms only the Android viewport; guest output size/DPI stays fixed.
        enableViewportGestures = true,
    )
}

import nu.shel.wldroid.launcher.*

// DesktopLauncher is typically injected or constructed with all four
// library modules (compositor, proot, virgl, shims).

// Launch a preset application in a rootfs environment:
launcher.launchPreset(
    environment = myRootfsEnvironment,
    preset = DesktopAppPreset.XTERM,
    scope = lifecycleScope,
)

// Or launch an arbitrary command:
launcher.launch(
    environment = myRootfsEnvironment,
    command = listOf("weston-terminal"),
    requiredPackages = listOf("weston"),
    scope = lifecycleScope,
)

// Observe launch progress through sealed-class states:
launcher.state.collect { state ->
    when (state) {
        is DesktopLauncherState.Running -> Log.d("WLDroid", "App running")
        is DesktopLauncherState.Error -> Log.e("WLDroid", state.message)
        else -> {}
    }
}

import nu.shel.wldroid.compositor.*

val session = CompositorSession(
    CompositorConfig(
        cacheDir = cacheDir,
        gpuMode = "VIRGL_GLES",
        xwaylandEnabled = true,
    )
)

session.start(surface)

session.state.collect { state -> /* IDLE, STARTING, RUNNING, STOPPING, STOPPED, ERROR */ }
session.clientCount.collect { count -> /* connected Wayland clients */ }
session.socketPath.collect { path -> /* Wayland socket for clients to connect to */ }

session.stop()