package io.oxygenhub.android.runner

import android.content.Context

import android.content.Intent

import android.content.IntentFilter

import android.net.ConnectivityManager

import android.net.NetworkCapabilities

import android.os.BatteryManager

import android.os.Build

import android.os.PowerManager

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

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, on an unmetered

 * network (Wi-Fi) and cool, and leaves when any of those stops.

 */

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

        /** Told to leave: handing its job back to the hub for another runner, unless due within [noticeSecs]. */

        data class Leaving(val why: String, val noticeSecs: Long = 0) : State

        data class Failed(val message: String) : State

    }

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

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

    /** The jobs it is running now, "owner/name #run job" (#8), while it serves. */

    private val _jobs = MutableStateFlow<List<String>>(emptyList())

    val jobs: StateFlow<List<String>> = _jobs.asStateFlow()

    internal fun setJobs(jobs: List<String>) {

        _jobs.value = jobs

    }

    /** The notification's line for [jobs]: what it runs, or that it waits for work. */

    fun jobsLine(jobs: List<String>): String = when (jobs.size) {

        0 -> "Waiting for WASM jobs, on charge and Wi-Fi"

        1 -> "Running ${jobs[0]}"

        else -> "Running ${jobs.size} jobs: ${jobs.joinToString(", ")}"

    }

    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 || now is State.Leaving) 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, on Wi-Fi, and cool. */

    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 sticky = context.registerReceiver(null, IntentFilter(Intent.ACTION_BATTERY_CHANGED))

        val tenths = sticky?.getIntExtra(BatteryManager.EXTRA_TEMPERATURE, Int.MIN_VALUE)?.takeIf { it != Int.MIN_VALUE }

        val thermal = context.getSystemService(PowerManager::class.java)?.currentThermalStatus ?: PowerManager.THERMAL_STATUS_NONE

        tooWarm(thermal, tenths)?.let { return it }

        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

    }

    /** The battery temperature, in tenths of a degree, above which the runner rests: 40 °C. */

    const val MAX_BATTERY_TENTHS = 400

    /**

     * Why the phone is too warm to run jobs (#8), or null: the system says

     * it is throttling (moderate or worse), or the battery is above

     * [MAX_BATTERY_TENTHS]. Charging and a busy CPU together are what a

     * phone handles worst; a job waits for it to cool rather than cook it.

     */

    fun tooWarm(thermalStatus: Int, batteryTenths: Int?): String? = when {

        thermalStatus >= PowerManager.THERMAL_STATUS_MODERATE -> "the phone is warm (the system is throttling it)"

        batteryTenths != null && batteryTenths > MAX_BATTERY_TENTHS ->

            "the battery is warm (${batteryTenths / 10}.${batteryTenths % 10} °C, above ${MAX_BATTERY_TENTHS / 10} °C)"

        else -> 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) }

        if (_state.value is State.Waiting) {

            // Not serving: only the service waiting for the charger or Wi-Fi.

            context.stopService(Intent(context, RunnerService::class.java))

            _state.value = State.Stopped

        } else {

            drain("stopped by you")

        }

    }

    /** Whether its owner wants it offered (started and not stopped by them). */

    fun wanted(context: Context): Boolean = prefs(context).getBoolean(WANTED, false)

    /** 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()

        }

    }

    /**

     * Leave (oxygenflow#76): claim nothing more and hand what it holds back

     * to the hub, which gives it to another runner ahead of new work. With

     * [noticeSecs], a job the hub expects to finish within it finishes

     * first: a minute off charge. None off the allowed network, where

     * finishing would use the network the owner ruled out.

     */

    fun leave(why: String, noticeSecs: Long = 0) {

        val now = _state.value

        if (now == State.Running || now is State.Draining) {

            _state.value = State.Leaving(why, noticeSecs)

            runnerLeave(why, noticeSecs.toULong())

        }

    }

}