package io.oxygenhub.android.runner

import android.Manifest

import android.content.pm.PackageManager

import android.os.Build

import androidx.activity.compose.rememberLauncherForActivityResult

import androidx.activity.result.contract.ActivityResultContracts

import androidx.compose.foundation.layout.Arrangement

import androidx.compose.foundation.layout.Column

import androidx.compose.foundation.layout.Row

import androidx.compose.foundation.layout.fillMaxWidth

import androidx.compose.foundation.layout.padding

import androidx.compose.material3.Button

import androidx.compose.material3.MaterialTheme

import androidx.compose.material3.OutlinedButton

import androidx.compose.material3.Text

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.rememberCoroutineScope

import androidx.compose.runtime.setValue

import androidx.compose.ui.Modifier

import androidx.compose.ui.platform.LocalContext

import androidx.compose.ui.unit.dp

import androidx.core.content.ContextCompat

import androidx.lifecycle.compose.collectAsStateWithLifecycle

import io.oxygenhub.android.api.HubApi

import io.oxygenhub.android.api.userMessage

import io.oxygenhub.android.ui.common.Panel

import io.oxygenhub.android.ui.theme.LocalStatusColors

import kotlinx.coroutines.CancellationException

import kotlinx.coroutines.launch

/**

 * The phone as an OxygenFlow runner (#8), on the Account screen: offer it

 * (one tap: a registration token from the hub, then the runner starts),

 * see what it is doing, stop it.

 */

@Composable

fun RunnerCard(api: HubApi, hub: String, canWrite: Boolean) {

    val context = LocalContext.current

    val state by PhoneRunner.state.collectAsStateWithLifecycle()

    var busy by remember { mutableStateOf(false) }

    var error by remember { mutableStateOf<String?>(null) }

    val scope = rememberCoroutineScope()

    LaunchedEffect(Unit) { PhoneRunner.refresh(context) }

    // The notification that says the runner works; the runner runs without it too.

    val ask = rememberLauncherForActivityResult(ActivityResultContracts.RequestPermission()) { PhoneRunner.start(context) }

    val start = {

        val granted = Build.VERSION.SDK_INT < 33 ||

            ContextCompat.checkSelfPermission(context, Manifest.permission.POST_NOTIFICATIONS) == PackageManager.PERMISSION_GRANTED

        if (granted) PhoneRunner.start(context) else ask.launch(Manifest.permission.POST_NOTIFICATIONS)

    }

    val status = LocalStatusColors.current

    Panel(Modifier.fillMaxWidth()) {

        Column(Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {

            Text("OxygenFlow runner", style = MaterialTheme.typography.titleMedium)

            val (line, colour) = when (val s = state) {

                PhoneRunner.State.Unregistered -> "Run your repositories' WASM jobs on this phone, while it is charging on Wi-Fi." to MaterialTheme.colorScheme.onSurfaceVariant

                PhoneRunner.State.Stopped -> "Registered as ${PhoneRunner.name()}; not running." to MaterialTheme.colorScheme.onSurfaceVariant

                is PhoneRunner.State.Waiting -> "Not running: ${s.why}." to MaterialTheme.colorScheme.onSurfaceVariant

                PhoneRunner.State.Running -> "Running as ${PhoneRunner.name()}: taking WASM jobs." to status.ok

                is PhoneRunner.State.Draining -> "Draining (${s.why}): finishing its job, then stopping." to status.warn

                is PhoneRunner.State.Leaving -> if (s.noticeSecs > 0) {

                    "Leaving (${s.why}): finishing a job due within ${s.noticeSecs} s, handing back any other, then stopping." to status.warn

                } else {

                    "Leaving (${s.why}): handing its job back for another runner, then stopping." to status.warn

                }

                is PhoneRunner.State.Failed -> "Stopped: ${s.message}" to status.bad

            }

            Text(line, style = MaterialTheme.typography.bodyMedium, color = colour)

            error?.let { Text(it, style = MaterialTheme.typography.bodyMedium, color = status.bad) }

            Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {

                when (state) {

                    PhoneRunner.State.Unregistered -> Button(

                        enabled = canWrite && !busy,

                        onClick = {

                            busy = true

                            error = null

                            scope.launch {

                                try {

                                    PhoneRunner.register(context, api, hub)

                                    start()

                                } catch (e: CancellationException) {

                                    throw e

                                } catch (e: Exception) {

                                    error = e.userMessage()

                                } finally {

                                    busy = false

                                }

                            }

                        },

                    ) { Text("Offer this phone as a runner") }

                    PhoneRunner.State.Running, is PhoneRunner.State.Waiting -> OutlinedButton(onClick = { PhoneRunner.stopByOwner(context) }) { Text("Stop") }

                    is PhoneRunner.State.Draining, is PhoneRunner.State.Leaving -> {}

                    else -> Button(onClick = { start() }) { Text("Start") }

                }

            }

            if (!canWrite && state == PhoneRunner.State.Unregistered) {

                Text("Sign in again to allow it: offering a runner needs repo:write.", style = MaterialTheme.typography.bodySmall)

            }

        }

    }

}