package io.oxygenhub.android.runner

import android.app.Notification

import android.app.NotificationChannel

import android.app.NotificationManager

import android.app.PendingIntent

import android.app.Service

import android.content.BroadcastReceiver

import android.content.Context

import android.content.Intent

import android.content.IntentFilter

import android.content.pm.ServiceInfo

import android.net.ConnectivityManager

import android.net.Network

import android.net.NetworkCapabilities

import android.os.BatteryManager

import android.os.Build

import android.os.IBinder

import android.os.PowerManager

import io.oxygenhub.android.MainActivity

import io.oxygenhub.android.R

import uniffi.rust_core.runnerRunning

import uniffi.rust_core.runnerServe

import uniffi.rust_core.runnerStop

/**

 * Runs the phone's OxygenFlow runner (#8) in the foreground, with a

 * notification saying so, while the phone is on charge, on Wi-Fi and cool.

 * Leaving the charger gives it a minute: it claims nothing more, finishes

 * a job the hub expects to end within it and hands back any other, its

 * checkpoint saved; leaving Wi-Fi hands the job back at once

 * (oxygenflow#76). While its owner wants it, the service

 * then waits, and serves again once the phone is back on charge and Wi-Fi.

 */

class RunnerService : Service() {

    private var serving: Thread? = null

    private var connectivity: ConnectivityManager.NetworkCallback? = null

    private var watching = false

    private val power = object : BroadcastReceiver() {

        override fun onReceive(context: Context, intent: Intent) {

            when (intent.action) {

                Intent.ACTION_POWER_DISCONNECTED -> {

                    PhoneRunner.leave("taken off charge", noticeSecs = 60)

                    notify("Leaving: taken off charge")

                }

                Intent.ACTION_POWER_CONNECTED -> serveIfAllowed()

                // The battery's temperature comes with its state (#8).

                Intent.ACTION_BATTERY_CHANGED -> {

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

                    val hot = PhoneRunner.tooWarm(PowerManager.THERMAL_STATUS_NONE, tenths)

                    if (hot != null && PhoneRunner.state.value == PhoneRunner.State.Running) {

                        PhoneRunner.leave(hot, noticeSecs = 60)

                        notify("Resting: $hot")

                    } else if (hot == null && PhoneRunner.state.value is PhoneRunner.State.Waiting) {

                        serveIfAllowed()

                    }

                }

            }

        }

    }

    /** Warming up (#8): leave with a minute's notice, as off charge; cooled down: serve again. */

    private val thermal = PowerManager.OnThermalStatusChangedListener { status ->

        val hot = PhoneRunner.tooWarm(status, null)

        if (hot != null) {

            PhoneRunner.leave(hot, noticeSecs = 60)

            notify("Resting: $hot")

        } else {

            serveIfAllowed()

        }

    }

    override fun onBind(intent: Intent?): IBinder? = null

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {

        // The special-use type is Android 14's; before it, the manifest's type stands.

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {

            startForeground(NOTIFICATION, notification("Starting"), ServiceInfo.FOREGROUND_SERVICE_TYPE_SPECIAL_USE)

        } else {

            startForeground(NOTIFICATION, notification("Starting"))

        }

        if (!watching) {

            watching = true

            registerReceiver(

                power,

                IntentFilter().apply {

                    addAction(Intent.ACTION_POWER_DISCONNECTED)

                    addAction(Intent.ACTION_POWER_CONNECTED)

                    addAction(Intent.ACTION_BATTERY_CHANGED)

                },

            )

            watchNetwork()

            getSystemService(PowerManager::class.java)?.addThermalStatusListener(thermal)

        }

        serveIfAllowed()

        return START_NOT_STICKY

    }

    /**

     * Serve while the policy allows (on charge, on Wi-Fi), else wait for it

     * in the foreground, saying why. Called again when the charger or the

     * network comes back, and when serving ends while the owner still wants it.

     */

    @Synchronized

    private fun serveIfAllowed() {

        if (serving != null) return

        val blocked = PhoneRunner.blockedBy(this)

        if (blocked != null) {

            PhoneRunner.set(PhoneRunner.State.Waiting(blocked))

            notify("Waiting: $blocked")

            return

        }

        val home = PhoneRunner.home(this).path

        PhoneRunner.set(PhoneRunner.State.Running)

        notify(PhoneRunner.jobsLine(emptyList()))

        watchJobs()

        serving = Thread {

            val failed = try {

                runnerServe(home)

                null

            } catch (e: Exception) {

                e.message ?: "the runner stopped"

            }

            served(failed)

        }.apply {

            name = "oxygenflow-runner"

            start()

        }

    }

    /** While serving, what it runs (#8): on the card, and in the notification when it changes. */

    private fun watchJobs() {

        Thread {

            var shown: List<String>? = null

            while (serving != null) {

                val now = runnerRunning()

                if (now != shown) {

                    PhoneRunner.setJobs(now)

                    if (PhoneRunner.state.value == PhoneRunner.State.Running) notify(PhoneRunner.jobsLine(now))

                    shown = now

                }

                Thread.sleep(3_000)

            }

            PhoneRunner.setJobs(emptyList())

        }.apply {

            name = "oxygenflow-runner-jobs"

            isDaemon = true

            start()

        }

    }

    /** Serving ended: wait for the charger and Wi-Fi again while the owner wants it, else stop. */

    @Synchronized

    private fun served(failed: String?) {

        serving = null

        when {

            failed != null -> {

                PhoneRunner.set(PhoneRunner.State.Failed(failed))

                stopSelf()

            }

            PhoneRunner.wanted(this) -> serveIfAllowed()

            else -> {

                PhoneRunner.set(PhoneRunner.State.Stopped)

                stopSelf()

            }

        }

    }

    /** Off Wi-Fi (or onto a metered network): leave, handing its job back to another runner (oxygenflow#76). */

    private fun watchNetwork() {

        val net = getSystemService(ConnectivityManager::class.java) ?: return

        val callback = object : ConnectivityManager.NetworkCallback() {

            override fun onLost(network: Network) {

                if (PhoneRunner.blockedBy(this@RunnerService) != null) {

                    PhoneRunner.leave("off Wi-Fi")

                    notify("Off Wi-Fi: handing its job back")

                }

            }

            override fun onCapabilitiesChanged(network: Network, caps: NetworkCapabilities) {

                if (caps.hasCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED)) {

                    serveIfAllowed()

                } else {

                    PhoneRunner.leave("on a metered network")

                    notify("On a metered network: handing its job back")

                }

            }

        }

        net.registerDefaultNetworkCallback(callback)

        connectivity = callback

    }

    override fun onDestroy() {

        runCatching { unregisterReceiver(power) }

        runCatching { getSystemService(PowerManager::class.java)?.removeThermalStatusListener(thermal) }

        connectivity?.let { cb -> runCatching { getSystemService(ConnectivityManager::class.java)?.unregisterNetworkCallback(cb) } }

        // Stopped from outside (the app, the system): drain rather than leave a job behind.

        if (serving != null) runnerStop()

        super.onDestroy()

    }

    private fun notify(text: String) {

        getSystemService(NotificationManager::class.java)?.notify(NOTIFICATION, notification(text))

    }

    private fun notification(text: String): Notification {

        val manager = getSystemService(NotificationManager::class.java)

        manager?.createNotificationChannel(

            NotificationChannel(CHANNEL, "OxygenFlow runner", NotificationManager.IMPORTANCE_LOW).apply {

                description = "While this phone runs OxygenFlow jobs"

            },

        )

        val open = PendingIntent.getActivity(this, 0, Intent(this, MainActivity::class.java), PendingIntent.FLAG_IMMUTABLE)

        return Notification.Builder(this, CHANNEL)

            .setSmallIcon(R.drawable.ic_launcher_monochrome)

            .setContentTitle("OxygenFlow runner")

            .setContentText(text)

            .setContentIntent(open)

            .setOngoing(true)

            .build()

    }

    private companion object {

        const val CHANNEL = "runner"

        const val NOTIFICATION = 8

    }

}