import roro.stellar.Stellar

class MainActivity : ComponentActivity() {

    private val binderReceivedListener = Stellar.OnBinderReceivedListener {
        Log.i("MyApp", "Stellar 服务已连接")
        // 服务连接成功，可以开始使用 API
        checkServiceStatus()
    }

    private val binderDeadListener = Stellar.OnBinderDeadListener {
        Log.w("MyApp", "Stellar 服务已断开")
        // 服务断开，更新 UI 状态
    }

    private val permissionResultListener =
        Stellar.OnRequestPermissionResultListener { requestCode, allowed, onetime ->
            if (allowed) {
                Log.i("MyApp", "权限已授予")
                // 权限已授予，可以执行特权操作
                checkServiceStatus()
            } else {
                Log.w("MyApp", "权限被拒绝")
                // 权限被拒绝，提示用户
            }
        }

    private val serviceStartedListener = Stellar.OnServiceStartedListener {
        Log.i("MyApp", "Stellar 服务已启动")
        // 服务启动时执行操作，例如执行跟随启动命令
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // 添加监听器
        // 使用 Sticky 版本：如果服务已连接，会立即触发回调；否则等待服务连接后触发
        Stellar.addBinderReceivedListenerSticky(binderReceivedListener)
        Stellar.addBinderDeadListener(binderDeadListener)
        Stellar.addRequestPermissionResultListener(permissionResultListener)
        Stellar.addServiceStartedListener(serviceStartedListener)
    }

    override fun onDestroy() {
        super.onDestroy()
        // 移除监听器
        Stellar.removeBinderReceivedListener(binderReceivedListener)
        Stellar.removeBinderDeadListener(binderDeadListener)
        Stellar.removeRequestPermissionResultListener(permissionResultListener)
        Stellar.removeServiceStartedListener(serviceStartedListener)
    }

    private fun checkServiceStatus() {
        // 检查服务是否运行
        if (!Stellar.pingBinder()) {
            Log.e("MyApp", "服务未运行")
            return
        }

        // 检查权限
        if (!Stellar.checkSelfPermission()) {
            // 请求权限
            Stellar.requestPermission(requestCode = 1)
            return
        }

        // 服务已连接且权限已授予，可以使用 API
        Log.i("MyApp", "服务版本: ${Stellar.version}")
        Log.i("MyApp", "服务 UID: ${Stellar.uid}")
    }
}

// 检查服务是否运行
Stellar.pingBinder(): Boolean

// 获取服务 UID (0 = root, 2000 = adb)
Stellar.uid: Int

// 获取服务 API 版本
Stellar.version: Int

// 获取最新支持的版本
Stellar.latestServiceVersion: Int

// 获取 SELinux 上下文
Stellar.sELinuxContext: String?

// 获取管理器版本
Stellar.versionName: String?
Stellar.versionCode: Int

// 检查权限是否已授予
Stellar.checkSelfPermission(permission: String = "stellar"): Boolean

// 请求权限
Stellar.requestPermission(permission: String = "stellar", requestCode: Int)

// 检查是否应该显示权限说明
Stellar.shouldShowRequestPermissionRationale(): Boolean

// 检查 Stellar 服务自身是否拥有指定权限
Stellar.checkRemotePermission(permission: String): Int

// 获取支持的权限列表
Stellar.supportedPermissions: Array<String>

// 创建特权进程（以 Stellar 服务的身份执行）
Stellar.newProcess(
    cmd: Array<String?>,      // 命令和参数
    env: Array<String?>?,     // 环境变量（可选）
    dir: String?              // 工作目录（可选）
): StellarRemoteProcess

// 为其他应用授予/撤销运行时权限
Stellar.grantRuntimePermission(
    packageName: String,
    permissionName: String,
    userId: Int
)

Stellar.revokeRuntimePermission(
    packageName: String,
    permissionName: String,
    userId: Int
)

// Binder 事务包装器
Stellar.transactRemote(data: Parcel, reply: Parcel?, flags: Int)

// 检查管理器是否已安装
StellarHelper.isManagerInstalled(context: Context): Boolean

// 打开管理器
StellarHelper.openManager(context: Context): Boolean

// 获取服务信息
val serviceInfo = StellarHelper.serviceInfo
serviceInfo?.let {
    val uid = it.uid
    val version = it.version
    val seContext = it.seLinuxContext
    val isRoot = it.isRoot      // uid == 0
    val isAdb = it.isAdb        // uid == 2000
}

// 读取系统属性
StellarSystemProperties.get(key: String): String
StellarSystemProperties.get(key: String, def: String): String
StellarSystemProperties.getInt(key: String, def: Int): Int
StellarSystemProperties.getLong(key: String, def: Long): Long
StellarSystemProperties.getBoolean(key: String, def: Boolean): Boolean

// 写入系统属性（需要相应权限）
StellarSystemProperties.set(key: String, value: String)

val process = Stellar.newProcess(arrayOf("ls", "-la", "/sdcard"), null, null)

// 标准进程方法
process.getInputStream(): InputStream
process.getOutputStream(): OutputStream
process.getErrorStream(): InputStream
process.waitFor(): Int
process.exitValue(): Int
process.destroy()

// 额外方法
process.alive(): Boolean
process.waitForTimeout(timeout: Long, unit: TimeUnit): Boolean

val binder = StellarBinderWrapper.getSystemService("package")
val pm = IPackageManager.Stub.asInterface(StellarBinderWrapper(binder))
// 现在可以使用特权 PackageManager API

// 绑定用户服务
StellarUserService.bindUserService(
    args: UserServiceArgs,           // 服务参数配置
    callback: ServiceCallback,       // 服务回调
    handler: Handler? = mainHandler  // 回调执行的 Handler（可选）
)

// 解绑用户服务
StellarUserService.unbindUserService(args: UserServiceArgs)

// 获取已绑定的服务 Binder（如果存在且存活）
StellarUserService.peekUserService(args: UserServiceArgs): IBinder?

// 获取当前活跃的用户服务数量
StellarUserService.getUserServiceCount(): Int

interface ServiceCallback {
    // 服务连接成功
    fun onServiceConnected(service: IBinder)

    // 服务断开连接
    fun onServiceDisconnected()

    // 服务启动失败（可选实现）
    fun onServiceStartFailed(errorCode: Int, message: String) {}
}

val args = UserServiceArgs.Builder(MyUserService::class.java)
    .processNameSuffix("myservice")  // 进程名后缀，默��� "userservice"
    .debug(BuildConfig.DEBUG)        // 是否启用调试模式
    .versionCode(BuildConfig.VERSION_CODE.toLong())  // 版本号
    .tag("my-tag")                   // 可选标签
    .serviceMode(ServiceMode.DAEMON) // 服务模式
    .build()

// 已临时删除
// val args = UserServiceArgs.Builder(MyUserService::class.java)
//     .useStandaloneDex(BuildConfig.STELLAR_USE_STANDALONE_DEX)
//     .build()

enum class ServiceMode {
    ONE_TIME,  // 一次性服务：客户端断开后服务自动停止
    DAEMON     // 守护进程：服务持续运行，直到显式停止
}

// 销毁用户服务
UserServiceHelper.destroy(binder: IBinder)

// 检查服务是否存活
UserServiceHelper.isAlive(binder: IBinder): Boolean

// 获取服务进程的 UID
UserServiceHelper.getUid(binder: IBinder): Int

// 获取服务进程的 PID
UserServiceHelper.getPid(binder: IBinder): Int

fun checkServiceStatus() {
    if (!Stellar.pingBinder()) {
        println("服务未运行")
        return
    }

    if (!Stellar.checkSelfPermission()) {
        println("权限未授予")
        return
    }

    val version = Stellar.version
    println("服务版本: $version")

    val uid = Stellar.uid
    val mode = when (uid) {
        0 -> "Root"
        2000 -> "ADB"
        else -> "其他 (UID=$uid)"
    }
    println("运行模式: $mode")

    val seContext = Stellar.sELinuxContext
    println("SELinux 上下文: $seContext")
}

fun executeCommand() {
    thread {
        try {
            println("$ ls -la /sdcard")

            val process = Stellar.newProcess(
                arrayOf("ls", "-la", "/sdcard"),
                null,
                null
            )

            val reader = BufferedReader(InputStreamReader(process.inputStream))
            reader.lineSequence().forEach { line ->
                println(line)
            }

            val exitCode = process.waitFor()
            println("退出码: $exitCode")

            process.destroy()
        } catch (e: Exception) {
            println("错误: ${e.message}")
        }
    }
}

fun readSystemProperties() {
    try {
        val brand = StellarSystemProperties.get("ro.product.brand")
        println("品牌: $brand")

        val model = StellarSystemProperties.get("ro.product.model")
        println("型号: $model")

        val androidVersion = StellarSystemProperties.get("ro.build.version.release")
        println("Android 版本: $androidVersion")

        val sdkInt = StellarSystemProperties.getInt("ro.build.version.sdk", 0)
        println("SDK 版本: $sdkInt")
    } catch (e: Exception) {
        println("错误: ${e.message}")
    }
}

fun checkStellarServicePermissions() {
    val permissions = arrayOf(
        "android.permission.WRITE_SECURE_SETTINGS",
        "android.permission.READ_LOGS",
        "android.permission.DUMP",
        "android.permission.PACKAGE_USAGE_STATS"
    )

    permissions.forEach { permission ->
        val result = Stellar.checkRemotePermission(permission)
        val status = if (result == PackageManager.PERMISSION_GRANTED) "已授予" else "未授予"
        val name = permission.substringAfterLast(".")
        println("$name: $status")
    }
}

fun grantPermissionToApp(packageName: String) {
    try {
        Stellar.grantRuntimePermission(
            packageName = packageName,
            permissionName = "android.permission.WRITE_EXTERNAL_STORAGE",
            userId = 0
        )
        println("权限已授予")
    } catch (e: Exception) {
        println("授予权限失败: ${e.message}")
    }
}

class FollowStellarStartup : BroadcastReceiver() {
    override fun onReceive(context: Context?, intent: Intent?) {
        Log.i("MyApp", "Stellar 已启动: ${intent?.action}")

        // 在 Stellar 启动时执行操作
        try {
            Stellar.newProcess(
                arrayOf("touch", "/sdcard/stellar_started.log"),
                null,
                null
            )
        } catch (e: Exception) {
            Log.e("MyApp", "执行命令失败", e)
        }
    }
}

// src/main/java/com/example/MyUserService.kt
package com.example

class MyUserService : IMyUserService.Stub() {

    override fun executeCommand(command: String): String {
        return try {
            val process = Runtime.getRuntime().exec(arrayOf("sh", "-c", command))
            val reader = java.io.BufferedReader(
                java.io.InputStreamReader(process.inputStream)
            )
            val output = StringBuilder()
            var line: String?
            while (reader.readLine().also { line = it } != null) {
                output.append(line).append("\n")
            }
            process.waitFor()
            output.toString().trim()
        } catch (e: Exception) {
            "Error: ${e.message}"
        }
    }

    override fun getSystemProperty(name: String): String {
        return try {
            val process = Runtime.getRuntime().exec(arrayOf("getprop", name))
            val reader = java.io.BufferedReader(
                java.io.InputStreamReader(process.inputStream)
            )
            reader.readLine() ?: ""
        } catch (e: Exception) {
            ""
        }
    }
}

import roro.stellar.userservice.StellarUserService
import roro.stellar.userservice.UserServiceArgs
import roro.stellar.userservice.ServiceMode

class MainActivity : ComponentActivity() {

    private var userService: IMyUserService? = null

    private val serviceCallback = object : StellarUserService.ServiceCallback {
        override fun onServiceConnected(service: IBinder) {
            Log.i("MyApp", "用户服务已连接")
            userService = IMyUserService.Stub.asInterface(service)
            // 现在可以使用服务了
            executeCommandViaService()
        }

        override fun onServiceDisconnected() {
            Log.w("MyApp", "用户服务已断开")
            userService = null
        }

        override fun onServiceStartFailed(errorCode: Int, message: String) {
            Log.e("MyApp", "用户服务启动失败: $errorCode - $message")
        }
    }

    private fun bindUserService() {
        val args = UserServiceArgs.Builder(MyUserService::class.java)
            .processNameSuffix("myservice")
            .debug(BuildConfig.DEBUG)
            .versionCode(BuildConfig.VERSION_CODE.toLong())
            .serviceMode(ServiceMode.ONE_TIME)
            .build()

        StellarUserService.bindUserService(args, serviceCallback)
    }

    private fun executeCommandViaService() {
        thread {
            try {
                val result = userService?.executeCommand("ls -la /sdcard")
                Log.i("MyApp", "命令结果: $result")
            } catch (e: Exception) {
                Log.e("MyApp", "执行命令失败", e)
            }
        }
    }
}

// 使用 DAEMON 模式创建持久运行的服务
fun bindDaemonService() {
    val args = UserServiceArgs.Builder(MyUserService::class.java)
        .processNameSuffix("daemon")
        .serviceMode(ServiceMode.DAEMON)  // 守护进程模式
        .versionCode(BuildConfig.VERSION_CODE.toLong())
        .build()

    StellarUserService.bindUserService(args, object : StellarUserService.ServiceCallback {
        override fun onServiceConnected(service: IBinder) {
            Log.i("MyApp", "守护服务已启动")
            // 服务将持续运行，直到显式调用 unbindUserService
        }

        override fun onServiceDisconnected() {
            Log.i("MyApp", "守护服务已停止")
        }
    })
}

// 停止守护服务
fun stopDaemonService() {
    val args = UserServiceArgs.Builder(MyUserService::class.java)
        .processNameSuffix("daemon")
        .serviceMode(ServiceMode.DAEMON)
        .build()

    StellarUserService.unbindUserService(args)
}

// 替换
// import rikka.shizuku.Shizuku
// import rikka.shizuku.ShizukuProvider

// 为
import roro.stellar.Stellar
import roro.stellar.StellarProvider
import roro.stellar.StellarHelper

// 替换
// Shizuku.OnBinderReceivedListener { }
// Shizuku.OnBinderDeadListener { }
// Shizuku.OnRequestPermissionResultListener { requestCode, grantResult -> }

// 为
Stellar.OnBinderReceivedListener { }
Stellar.OnBinderDeadListener { }
Stellar.OnRequestPermissionResultListener { requestCode, allowed, onetime ->
    // 注意：参数从 grantResult 改为 allowed 和 onetime
}

// 替换
// ShizukuProvider.isShizukuInstalled(context)
// ShizukuProvider.openShizuku(context)

// 为
StellarHelper.isManagerInstalled(context)
StellarHelper.openManager(context)

import rikka.shizuku.Shizuku
import rikka.shizuku.ShizukuProvider

class MainActivity : AppCompatActivity() {

    private val binderReceivedListener = Shizuku.OnBinderReceivedListener {
        checkStatus()
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        Shizuku.addBinderReceivedListenerSticky(binderReceivedListener)
    }

    private fun checkStatus() {
        if (!Shizuku.pingBinder()) return

        if (Shizuku.checkSelfPermission() != PackageManager.PERMISSION_GRANTED) {
            Shizuku.requestPermission(1)
            return
        }

        val uid = Shizuku.getUid()
        println("UID: $uid")
    }
}

import roro.stellar.Stellar
import roro.stellar.StellarProvider

class MainActivity : AppCompatActivity() {

    private val binderReceivedListener = Stellar.OnBinderReceivedListener {
        checkStatus()
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        Stellar.addBinderReceivedListenerSticky(binderReceivedListener)
    }

    private fun checkStatus() {
        if (!Stellar.pingBinder()) return

        if (!Stellar.checkSelfPermission()) {
            Stellar.requestPermission(requestCode = 1)
            return
        }

        val uid = Stellar.uid
        println("UID: $uid")
    }
}

val uid = Stellar.uid
when (uid) {
    0 -> println("Root 模式")
    2000 -> println("ADB 模式")
    else -> println("未知模式: $uid")
}

// 或使用 StellarHelper
val serviceInfo = StellarHelper.serviceInfo
if (serviceInfo?.isRoot == true) {
    println("Root 模式")
} else if (serviceInfo?.isAdb == true) {
    println("ADB 模式")
}

private val binderDeadListener = Stellar.OnBinderDeadListener {
    // 服务断开，更新 UI
    runOnUiThread {
        Toast.makeText(this, "Stellar 服务已断开", Toast.LENGTH_SHORT).show()
        // 禁用需要 Stellar 的功能
        updateUIForDisconnectedState()
    }
}

private val permissionResultListener =
    Stellar.OnRequestPermissionResultListener { requestCode, allowed, onetime ->
        if (!allowed) {
            // 权限被拒绝
            if (Stellar.shouldShowRequestPermissionRationale()) {
                // 显示权限说明对话框
                showPermissionRationaleDialog()
            } else {
                // 用户选择了"不再询问"，引导用户到管理器手动授权
                StellarHelper.openManager(this)
            }
        }
    }

class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()

        // 判断当前进程是否是 Provider 进程
        val isProviderProcess = // 你的判断逻辑
        StellarProvider.enableMultiProcessSupport(isProviderProcess)

        // 如果不是 Provider 进程，请求 Binder
        if (!isProviderProcess) {
            StellarProvider.requestBinderForNonProviderProcess(this)
        }
    }
}

fun executeCommandWithTimeout() {
    thread {
        try {
            val process = Stellar.newProcess(
                arrayOf("sleep", "10"),
                null,
                null
            )

            // 等待最多 5 秒
            val finished = process.waitForTimeout(5, TimeUnit.SECONDS)

            if (!finished) {
                println("命令超时，强制终止")
                process.destroy()
            } else {
                println("命令完成，退出码: ${process.exitValue()}")
            }
        } catch (e: Exception) {
            println("错误: ${e.message}")
        }
    }
}

if (!StellarHelper.isManagerInstalled(context)) {
    // 管理器未安装，引导用户安装
    AlertDialog.Builder(context)
        .setTitle("需要 Stellar 管理器")
        .setMessage("此功能需要安装 Stellar 管理器")
        .show()
}

fun executeCommandWithErrorHandling() {
    thread {
        try {
            val process = Stellar.newProcess(
                arrayOf("ls", "/nonexistent"),
                null,
                null
            )

            // 读取标准输出
            val outputReader = BufferedReader(InputStreamReader(process.inputStream))
            outputReader.lineSequence().forEach { line ->
                println("输出: $line")
            }

            // 读取错误输出
            val errorReader = BufferedReader(InputStreamReader(process.errorStream))
            errorReader.lineSequence().forEach { line ->
                println("错误: $line")
            }

            val exitCode = process.waitFor()
            println("退出码: $exitCode")

            process.destroy()
        } catch (e: Exception) {
            println("异常: ${e.message}")
        }
    }
}