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

import android.os.IBinder

import io.oxygenhub.android.MainActivity

import io.oxygenhub.android.R

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 and on Wi-Fi.

 * Leaving the charger or the network drains it: it claims nothing more,

 * finishes and reports the job it holds, and the service stops.

 */

class RunnerService : Service() {

    private var serving: Thread? = null

    private var connectivity: ConnectivityManager.NetworkCallback? = null

    private val power = object : BroadcastReceiver() {

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

            PhoneRunner.drain("taken off charge")

            notify("Draining: taken off charge")

        }

    }

    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 (serving != null) return START_NOT_STICKY

        val blocked = PhoneRunner.blockedBy(this)

        if (blocked != null) {

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

            stopSelf()

            return START_NOT_STICKY

        }

        registerReceiver(power, IntentFilter(Intent.ACTION_POWER_DISCONNECTED))

        watchNetwork()

        val home = PhoneRunner.home(this).path

        PhoneRunner.set(PhoneRunner.State.Running)

        notify("Waiting for WASM jobs, on charge and Wi-Fi")

        serving = Thread {

            try {

                runnerServe(home)

                if (PhoneRunner.state.value !is PhoneRunner.State.Waiting) PhoneRunner.set(PhoneRunner.State.Stopped)

            } catch (e: Exception) {

                PhoneRunner.set(PhoneRunner.State.Failed(e.message ?: "the runner stopped"))

            } finally {

                serving = null

                stopSelf()

            }

        }.apply {

            name = "oxygenflow-runner"

            start()

        }

        return START_NOT_STICKY

    }

    /** Off Wi-Fi (or onto a metered network): drain. */

    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.drain("off Wi-Fi")

                    notify("Draining: off Wi-Fi")

                }

            }

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

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

                    PhoneRunner.drain("on a metered network")

                    notify("Draining: on a metered network")

                }

            }

        }

        net.registerDefaultNetworkCallback(callback)

        connectivity = callback

    }

    override fun onDestroy() {

        runCatching { unregisterReceiver(power) }

        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

    }

}