PicMe Agent Capability 注册表

class YourNewCapability : Capability {

    // 1. 定义能力标识
    override val name = "your_feature"
    override val description = "功能的简短描述，用于 System Prompt"

    // 2. 声明活跃场景
    override fun activeScenes() = listOf(
        SceneManager.Scene.YOUR_SCENE
    )

    // 3. 列出支持的命令
    override fun supportedCommands() = listOf(
        "command_1",
        "command_2",
        "text_reply"
    )

    // 4. 实现命令执行逻辑
    override suspend fun execute(
        command: AgentCommand,
        context: AgentContext,
        pageContext: PageContext?
    ): Result<AgentAction> {
        return when (command) {
            is AgentCommand.YourCommand -> {
                // 执行具体逻辑
                performYourAction(command)
                Result.success(AgentAction.Success(command))
            }

            is AgentCommand.TextReply -> {
                Result.success(AgentAction.Text(command.message))
            }

            else -> {
                Result.success(AgentAction.Error("不支持的命令：${command::class.simpleName}"))
            }
        }
    }

    private fun performYourAction(cmd: AgentCommand.YourCommand): AgentAction {
        // TODO: 实现你的业务逻辑
        // 注意：不要直接依赖 UI 层，使用回调注入
    }
}

// 在 Application 或 ViewModel 初始化时
val capabilityRegistry = CapabilityRegistry().apply {
    register(YourNewCapability())
    // 确保 NavigationCapability 始终注册
    register(NavigationCapability(onNavigate = {...}, onBack = {...}))
}

sealed class AgentCommand {
    // ... 现有命令

    // 新增命令
    data class YourCommand(val param1: String, val param2: Int) : AgentCommand()
}

class PromptBuilder(private val sceneManager: SceneManager) {

    fun buildSystemPrompt(
        capabilities: List<Capability>,
        context: AgentContext
    ): String {
        return buildString {
            appendLine(basePrompt)
            appendLine()
            appendLine("当前页面：${sceneManager.currentScene.value.name}")
            appendLine()
            appendLine("可用功能:")

            capabilities.forEach { cap ->
                appendLine("- ${cap.name}: ${cap.description}")
                cap.supportedCommands().forEach { cmd ->
                    appendLine("  • $cmd")
                }
            }
        }
    }
}

object NaturalLanguageMapper {
    fun parseToCommand(input: String): AgentCommand? {
        return when {
            input.contains("你的功能") -> AgentCommand.YourCommand("default", 0)
            input.contains("参数 1") -> AgentCommand.YourCommand("value1", 42)
            else -> null
        }
    }
}

override fun activeScenes() = listOf(
    SceneManager.Scene.CAMERA,
    SceneManager.Scene.DEBUG
)

override fun supportedCommands() = listOf(
    "perform_action",
    "cancel_action",
    "text_reply"
)

sealed class AgentCommand {
    data class YourCommand(
        val param1: String,
        val param2: Int,
        val optionalParam: String? = null
    ) : AgentCommand()
}

import kotlinx.serialization.json.*

fun parseJsonResponse(jsonString: String): List<AgentCommand> {
    return Json.decodeFromString<List<YourCommand>>(jsonString)
        .map { AgentCommand.YourCommand(it.param1, it.param2) }
}

override suspend fun execute(
    command: AgentCommand,
    context: AgentContext,
    pageContext: PageContext?
): Result<AgentAction> {
    return try {
        when (command) {
            is AgentCommand.YourCommand -> {
                // 参数验证
                if (command.param2 < 0 || command.param2 > 100) {
                    return Result.success(AgentAction.Error("param2 必须在 0-100 范围"))
                }

                // 执行逻辑
                performAction(command)
                Result.success(AgentAction.Success(command))
            }

            else -> Result.success(AgentAction.Error("不支持的命令"))
        }
    } catch (e: Exception) {
        Log.e("YourCapability", "执行失败", e)
        Result.success(AgentAction.Error("执行异常：${e.message}"))
    }
}

sealed class PageContext {
    data class YourContext(
        val currentData: YourData?,
        val selectedItems: List<YourItem>,
        val extraInfo: Map<String, Any>?
    ) : PageContext()

    object None : PageContext()
}

override suspend fun execute(
    command: AgentCommand,
    context: AgentContext,
    pageContext: PageContext?
): Result<AgentAction> {
    val yourContext = pageContext as? PageContext.YourContext

    return when (command) {
        is AgentCommand.YourCommand -> {
            val data = command.param1?.let { findDataById(it) }
                ?: yourContext?.currentData

            data?.let { performAction(it, command) }
            Result.success(AgentAction.Success(command))
        }

        else -> Result.success(AgentAction.Error("不支持的命令"))
    }
}

@Composable
fun YourScreen(
    viewModel: YourViewModel
) {
    val pageContext by viewModel.pageContext.collectAsState()

    GlobalAgentPanel(
        orchestrator = agentOrchestrator,
        pageContextProvider = { pageContext }
    )
}

class YourCapabilityTest {

    private lateinit var capability: YourCapability

    @Before
    fun setup() {
        capability = YourCapability(
            onPerformAction = { param1, param2 ->
                // Mock 逻辑
            }
        )
    }

    @Test
    fun `test valid command executes successfully`() {
        val command = AgentCommand.YourCommand("valid", 50)
        val context = AgentContext()
        val pageContext = PageContext.None

        val result = capability.execute(command, context, pageContext)

        assert(result.getOrNull() is AgentAction.Success)
    }

    @Test
    fun `test invalid parameter returns error`() {
        val command = AgentCommand.YourCommand("valid", 150) // Out of range
        val context = AgentContext()
        val pageContext = PageContext.None

        val result = capability.execute(command, context, pageContext)

        assert(result.getOrNull() is AgentAction.Error)
        assert(result.getOrNull()?.message?.contains("范围") == true)
    }

    @Test
    fun `test text_reply returns message`() {
        val command = AgentCommand.TextReply("Hello")
        val context = AgentContext()
        val pageContext = PageContext.None

        val result = capability.execute(command, context, pageContext)

        assert(result.getOrNull() is AgentAction.Text)
        assert((result.getOrNull() as AgentAction.Text).message == "Hello")
    }
}

class YourCapabilityIntegrationTest {

    @Test
    fun `test end-to-end command flow`() = runTest {
        // 1. 模拟用户输入
        val userInput = "执行你的功能，参数 1 为 test，参数 2 为 75"

        // 2. 构建 Orchestrator
        val orchestrator = AgentOrchestrator(
            llmEngine = mockLlmEngine,
            capabilityRegistry = registry
        )

        // 3. 执行解析与执行
        val result = orchestrator.processUserInput(userInput, createContext())

        // 4. 验证结果
        assertTrue(result.isSuccess)
        verify(mockService).performAction("test", 75)
    }
}

class YourCapability : Capability {
    private val systemPrompt = """
        你是 PicMe 助手...
        可用功能：your_feature
        • command_1
    """.trimIndent()
}

class PromptBuilder(private val sceneManager: SceneManager) {
    fun buildSystemPrompt(capabilities: List<Capability>): String {
        // 动态构建，支持插件化
    }
}

class YourCapability : Capability {
    override suspend fun execute(..., pageContext: PageContext?) {
        // ❌ 直接调用 UI 方法
        uiController.updateView(data)
    }
}

class YourCapability(
    private val onUpdateView: ((Data) -> Unit)? = null
) : Capability {
    override suspend fun execute(...) {
        // ✅ 通过回调注入
        onUpdateView?.invoke(data)
    }
}

fun parseJson(json: String): YourCommand {
    val param1 = json Regex "\"param1\": \"([^\"]+)\"" groupValues[1]
    // ❌ 无法处理嵌套/转义
}

fun parseJson(json: String): YourCommand {
    return Json.decodeFromString(json)
    // ✅ 类型安全，支持复杂结构
}

// 新增 YourCommand 后未更新 CapabilityRegistry
class CapabilityRegistry {
    fun mapCommand(name: String): AgentCommand? {
        return when (name) {
            "command_1" -> ExistingCommand()
            // ❌ 遗漏 YourCommand
        }
    }
}

class CapabilityRegistry {
    fun mapCommand(name: String): AgentCommand? {
        return when (name) {
            "command_1" -> ExistingCommand()
            "your_command" -> YourCommand() // ✅ 同步更新
        }
    }
}

class YourCapability : Capability {
    private var counter = 0 // ❌ 非线程安全

    override suspend fun execute(...) {
        counter++ // 并发修改
    }
}

class YourCapability : Capability {
    private val counter = AtomicInteger(0) // ✅ 原子操作

    override suspend fun execute(...) {
        counter.incrementAndGet()
    }
}

// 当前代码（泄漏路径）
class CameraCapability : BaseCapability() {
    companion object {
        private var instance: CameraCapability? = null  // 静态引用，永不释放
        fun getInstance() = instance!!
    }

    private var delegateRef: WeakReference<Delegate>? = null
}

// CameraScreen.kt
DisposableEffect(Unit) {
    val cameraCapability = CameraCapability.getInstance()  // 获取单例
    cameraCapability.bindDelegate(object : CameraCapability.Delegate {
        override fun onSwitchRatio(ratio: String) {
            aspectRatio = ratio  // 匿名类隐式持有 CameraScreen 的 aspectRatio
        }
        // ... 其他方法同样持有 CameraScreen 的状态引用
    })
    // 即使 WeakReference 被清理，单例仍然存活，且匿名类的类加载器引用链复杂
}

// ✅ 新设计: Capability 随页面创建和销毁
@Composable
fun CameraScreen(
    viewModel: MediaViewModel,
    // Capability 通过参数注入，而非全局单例
    cameraCapability: CameraCapability = remember { CameraCapability() }
) {
    // CameraCapability 直接持有状态，无需 delegate 模式
    DisposableEffect(Unit) {
        // 注册到当前页面的 Capability 集合
        LocalCapabilityHost.current.register(cameraCapability)
        onDispose {
            LocalCapabilityHost.current.unregister(cameraCapability)
        }
    }
}

// ❌ 旧设计: 单例访问
val registry = CapabilityRegistry.getInstance()
registry.register(CameraCapability.getInstance())

// ✅ 新设计: 依赖注入
class MainActivity : ComponentActivity() {
    private val navigationCapability = NavigationCapability()  // Activity 级

    override fun onCreate(savedInstanceState: Bundle?) {
        setContent {
            val capabilityHost = rememberCapabilityHost(navigationCapability)
            CompositionLocalProvider(LocalCapabilityHost provides capabilityHost) {
                NavHost(...) { ... }
            }
        }
    }
}

// ❌ 旧设计: 状态分散在 Screen 和 Capability 之间
class CameraScreen {
    var aspectRatio by remember { mutableIntStateOf(AspectRatio.RATIO_FULL) }
    // Capability 通过 delegate 回调修改 Screen 状态
}

// ✅ 新设计: Capability 持有自己的状态
class CameraCapability {
    var aspectRatio by mutableIntStateOf(AspectRatio.RATIO_FULL)
        private set

    fun switchRatio(ratio: String) {
        aspectRatio = parseRatio(ratio)
    }
}

/**
 * Capability 宿主
 *
 * 管理当前作用域内所有 Capability 的注册和查询。
 * 支持层级查找：如果当前宿主找不到，会委托给父宿主。
 */
class CapabilityHost(
    private val parent: CapabilityHost? = null
) {
    private val capabilities = mutableMapOf<String, Capability>()

    fun register(capability: Capability) {
        capabilities[capability.name] = capability
    }

    fun unregister(capability: Capability) {
        capabilities.remove(capability.name)
    }

    fun find(name: String): Capability? {
        return capabilities[name] ?: parent?.find(name)
    }

    fun findForScene(scene: SceneManager.Scene): List<Capability> {
        return capabilities.values.filter {
            it.activeScenes().contains(scene) || it.activeScenes().isEmpty()
        }
    }
}

// Compose 集成
val LocalCapabilityHost = compositionLocalOf<CapabilityHost> {
    error("CapabilityHost not provided")
}

@Composable
fun rememberCapabilityHost(vararg capabilities: Capability): CapabilityHost {
    val parent = LocalCapabilityHost.current
    return remember(capabilities) {
        CapabilityHost(parent).apply {
            capabilities.forEach { register(it) }
        }
    }
}

/**
 * 相机控制 Capability（页面级）
 *
 * 由 CameraScreen 创建和持有，Screen 销毁时自动释放。
 * 不再使用 delegate 模式，状态直接内聚在 Capability 中。
 */
class CameraCapability : BaseCapability() {
    override val name: String = "camera"
    override val description: String = "控制相机拍摄、美颜参数、滤镜..."

    // 状态直接内聚在 Capability 中
    var aspectRatio by mutableIntStateOf(AspectRatio.RATIO_FULL)
        private set
    var lensFacing by mutableIntStateOf(CameraSelector.LENS_FACING_BACK)
        private set
    var beautySettings by mutableStateOf(BeautySettings(enabled = false))
        private set

    // 命令执行直接修改内部状态
    override suspend fun execute(
        command: AgentCommand,
        context: AgentContext,
        pageContext: PageContext?
    ): Result<AgentAction> {
        return when (command) {
            is AgentCommand.SwitchRatio -> {
                aspectRatio = parseRatio(command.ratio)
                Result.success(AgentAction.Success(...))
            }
            // ... 其他命令
        }
    }

    override fun isAvailable(): Boolean = true  // 页面级 Capability 只要存在就可用
}

@Composable
fun CameraScreen(
    viewModel: MediaViewModel,
    onNavigateToGallery: () -> Unit,
    onNavigateToSettings: () -> Unit,
) {
    // 创建页面级 Capability
    val cameraCapability = remember { CameraCapability() }

    // 注册到当前 CapabilityHost
    val host = LocalCapabilityHost.current
    DisposableEffect(cameraCapability) {
        host.register(cameraCapability)
        onDispose { host.unregister(cameraCapability) }
    }

    // 将 Capability 的状态绑定到 UI
    val aspectRatio = cameraCapability.aspectRatio
    val lensFacing = cameraCapability.lensFacing

    // UI 使用 Capability 状态
    CameraPreviewContent(
        aspectRatio = aspectRatio,
        lensFacing = lensFacing,
        // ...
    )
}

/**
 * 跨页面命令由 NavigationCapability 统一处理
 *
 * 导航到目标页面后，目标页面的 Capability 自然可用。
 * 无需复杂的排队和轮询机制。
 */
class NavigationCapability(
    private val navController: NavController
) : BaseCapability() {
    override val name: String = "navigation"

    override suspend fun execute(
        command: AgentCommand,
        context: AgentContext,
        pageContext: PageContext?
    ): Result<AgentAction> {
        return when (command) {
            is AgentCommand.NavigateTo -> {
                // 导航到目标页面
                navController.navigate(command.destination)
                // 导航完成后，目标页面的 Capability 会自动接管后续命令
                Result.success(AgentAction.Success(...))
            }
            // ...
        }
    }
}

// 1. 添加 CapabilityHost 和 CompositionLocal
// 2. 修改 CapabilityRegistry 支持从 CapabilityHost 查询
// 3. CameraScreen 同时注册到单例和 CapabilityHost
class CapabilityRegistry {
    fun dispatch(command: AgentCommand, context: AgentContext): Result<AgentAction> {
        // 优先从 CapabilityHost 查找
        val host = LocalCapabilityHost.currentOrNull
        val capability = host?.findForCommand(command)
            ?: findCapabilityForCommand(command)
        // ...
    }
}

// 1. 移除 CameraCapability.getInstance()
// 2. 移除 Application 中的 initializeCapabilities()
// 3. MainActivity 创建 NavigationCapability 并注入
// 4. 各 Screen 创建自己的 Capability

// 1. 移除 SceneManager 的引用计数机制
// 2. 移除 CapabilityRegistry 的命令队列
// 3. 移除所有 WeakReference delegate 模式