package io.oxygenhub.android.runner

import android.content.Context

import android.content.Intent

import android.net.ConnectivityManager

import android.net.NetworkCapabilities

import android.os.BatteryManager

import android.os.Build

import androidx.core.content.ContextCompat

import androidx.core.content.edit

import io.oxygenhub.android.api.HubApi

import kotlinx.coroutines.Dispatchers

import kotlinx.coroutines.flow.MutableStateFlow

import kotlinx.coroutines.flow.StateFlow

import kotlinx.coroutines.flow.asStateFlow

import kotlinx.coroutines.withContext

import uniffi.rust_core.runnerIsRegistered

import uniffi.rust_core.runnerRegister

import uniffi.rust_core.runnerStop

import java.io.File

/**

 * The phone as an OxygenFlow runner (#8): OxygenFlow's own runner, built

 * into the app through rust-core, offering the WASM tier. It runs in

 * [RunnerService] only while the phone is on charge and on an unmetered

 * network (Wi-Fi), and drains when either stops: it claims nothing more

 * and finishes what it holds.

 */

object PhoneRunner {

    sealed interface State {

        data object Unregistered : State

        /** Registered, not running. */

        data object Stopped : State

        /** Not allowed to run now, and why (off charge, off Wi-Fi). */

        data class Waiting(val why: String) : State

        data object Running : State

        /** Told to stop: finishing what it holds. */

        data class Draining(val why: String) : State

        data class Failed(val message: String) : State

    }

    private val _state = MutableStateFlow<State>(State.Unregistered)

    val state: StateFlow<State> = _state.asStateFlow()

    internal fun set(state: State) {

        _state.value = state

    }

    /** Where the runner keeps its credential and its jobs' files. */

    fun home(context: Context): File = File(context.filesDir, "flow").also { it.mkdirs() }

    /** Called when the app starts and the service ends: what the runner is, as far as this process knows. */

    fun refresh(context: Context) {

        val now = _state.value

        if (now is State.Running || now is State.Draining) return

        _state.value = if (runnerIsRegistered(home(context).path)) {

            if (now is State.Waiting || now is State.Failed) now else State.Stopped

        } else {

            State.Unregistered

        }

    }

    /** The runner's name on the hub: the phone's model, as runner names are written. */

    fun name(): String =

        "android-" + Build.MODEL.lowercase().replace(Regex("[^a-z0-9]+"), "-").trim('-').ifEmpty { "phone" }

    /** Ask the hub for a token and register this phone as a runner for the account's repositories. */

    suspend fun register(context: Context, api: HubApi, hub: String): String {

        val token = api.runnerToken()

        val name = withContext(Dispatchers.IO) { runnerRegister(home(context).path, hub, token.token, name()) }

        _state.value = State.Stopped

        return name

    }

    /** Why the runner may not run now, or null when it may: on charge and on Wi-Fi. */

    fun blockedBy(context: Context): String? {

        val battery = context.getSystemService(BatteryManager::class.java)

        if (battery != null && !battery.isCharging) return "the phone is not on charge"

        val net = context.getSystemService(ConnectivityManager::class.java)

        val caps = net?.activeNetwork?.let { net.getNetworkCapabilities(it) }

        if (caps == null || !caps.hasCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED)) {

            return "the phone is not on Wi-Fi (or another unmetered network)"

        }

        return null

    }

    /** Start the runner, and keep it offered across app updates and restarts until the owner stops it. */

    fun start(context: Context) {

        prefs(context).edit { putBoolean(WANTED, true) }

        ContextCompat.startForegroundService(context, Intent(context, RunnerService::class.java))

    }

    /** The owner stopped it: drain, and stay stopped after an update or restart. */

    fun stopByOwner(context: Context) {

        prefs(context).edit { putBoolean(WANTED, false) }

        drain("stopped by you")

    }

    /** After a restart or an app update ([RunnerResume]): offer the phone again if it was offered. */

    fun resume(context: Context) {

        if (prefs(context).getBoolean(WANTED, false) && runnerIsRegistered(home(context).path)) start(context)

    }

    private const val WANTED = "runner.wanted"

    private fun prefs(context: Context) = context.getSharedPreferences("runner", Context.MODE_PRIVATE)

    /** Drain: claim nothing more, finish and report what it holds, then stop. */

    fun drain(why: String) {

        if (_state.value == State.Running) {

            _state.value = State.Draining(why)

            runnerStop()

        }

    }

}