imitatort 0.0.1-SNAPSHOT-dev.20260302111239

//! 公司运行时组件
//!
//! 将 VirtualCompany 的职责分解为更小的组件

use std::sync::Arc;

use anyhow::Result;
use dashmap::DashMap;
use tokio::sync::RwLock;
use tracing::info;

use super::autonomous::AutonomousAgent;
use crate::core::capability::CapabilityRegistry;
use crate::core::config::CompanyConfig;
use crate::core::messaging::MessageBus;
use crate::core::skill::SkillManager;
use crate::core::store::Store;
use crate::core::tool::ToolRegistry;
use crate::domain::Organization;
use crate::infrastructure::capability::{McpProtocolHandler, McpServer};
use crate::infrastructure::tool::{FrameworkToolExecutor, ToolEnvironment};

/// 组织架构管理器
pub struct OrganizationManager {
    organization: Arc<RwLock<Organization>>,
    config: CompanyConfig,
}

impl OrganizationManager {
    pub fn new(config: CompanyConfig) -> Self {
        let organization = Arc::new(RwLock::new(config.organization.clone()));
        Self {
            organization,
            config,
        }
    }

    /// 获取组织架构（异步读取）
    pub async fn organization(&self) -> tokio::sync::RwLockReadGuard<'_, Organization> {
        self.organization.read().await
    }

    /// 获取组织架构引用
    pub fn organization_arc(&self) -> Arc<RwLock<Organization>> {
        self.organization.clone()
    }

    /// 获取配置引用
    pub fn config(&self) -> &CompanyConfig {
        &self.config
    }
}

/// Agent 管理器
pub struct AgentManager {
    agents: DashMap<String, AutonomousAgent>,
    message_bus: Arc<MessageBus>,
}

impl AgentManager {
    pub fn new(message_bus: Arc<MessageBus>) -> Self {
        Self {
            agents: DashMap::new(),
            message_bus,
        }
    }

    /// 初始化所有 Agent
    pub async fn initialize_agents(
        &self,
        organization: &Organization,
        watchdog_agent: Option<Arc<crate::core::watchdog_agent::WatchdogAgent>>,
    ) -> Result<()> {
        for agent_data in &organization.agents {
            let agent = AutonomousAgent::new(
                agent_data.clone(),
                self.message_bus.clone(),
                watchdog_agent.clone(),
            )
            .await?;
            let agent_id = agent.id().to_string();
            self.agents.insert(agent_id.clone(), agent);
            info!("Created agent: {}", agent_id);
        }
        Ok(())
    }

    /// 获取所有 Agent 列表（用于 Web API）
    /// 注意：由于Agent数据存储在Organization中，这里返回空向量
    /// 实际的Agent列表应通过OrganizationManager获取
    pub async fn get_agents(&self) -> Result<Vec<crate::domain::Agent>> {
        Ok(vec![])
    }
}

/// 工具和功能管理器
pub struct ToolCapabilityManager {
    tool_registry: Arc<ToolRegistry>,
    capability_registry: Arc<CapabilityRegistry>,
    skill_manager: Arc<SkillManager>,
}

impl Default for ToolCapabilityManager {
    fn default() -> Self {
        let tool_registry = Arc::new(ToolRegistry::new());
        let capability_registry = Arc::new(CapabilityRegistry::new());
        let skill_manager = Arc::new(SkillManager::new_with_tool_registry(tool_registry.clone()));

        Self {
            tool_registry,
            capability_registry,
            skill_manager,
        }
    }
}

impl ToolCapabilityManager {
    pub fn new() -> Self {
        let tool_registry = Arc::new(ToolRegistry::new());
        let capability_registry = Arc::new(CapabilityRegistry::new());
        let skill_manager = Arc::new(SkillManager::new_with_tool_registry(tool_registry.clone()));

        Self {
            tool_registry,
            capability_registry,
            skill_manager,
        }
    }

    /// 获取 ToolRegistry 引用
    pub fn tool_registry(&self) -> Arc<ToolRegistry> {
        self.tool_registry.clone()
    }

    /// 注册应用自定义工具
    pub async fn register_app_tool(&self, tool: crate::domain::tool::Tool) -> Result<()> {
        let tool_id = tool.id.clone();
        self.tool_registry.register(tool).await?;
        info!("Registered app tool: {}", tool_id);
        Ok(())
    }

    /// 创建工具执行环境
    pub fn create_tool_environment(
        &self,
        message_bus: Arc<MessageBus>,
        organization: Arc<RwLock<Organization>>,
        store: Arc<dyn Store>,
    ) -> ToolEnvironment {
        ToolEnvironment::new(
            message_bus,
            organization,
            self.tool_registry.clone(),
            store,
            self.skill_manager.clone(),
        )
    }

    /// 获取框架工具执行器
    pub fn get_framework_tool_executor(
        &self,
        message_bus: Arc<MessageBus>,
        organization: Arc<RwLock<Organization>>,
        store: Arc<dyn Store>,
    ) -> FrameworkToolExecutor {
        let env = self.create_tool_environment(message_bus, organization, store);
        FrameworkToolExecutor::new(env)
    }

    /// 获取 CapabilityRegistry 引用
    pub fn capability_registry(&self) -> Arc<CapabilityRegistry> {
        self.capability_registry.clone()
    }

    /// 注册应用自定义功能
    pub async fn register_app_capability(
        &self,
        capability: crate::domain::capability::Capability,
    ) -> Result<()> {
        let cap_id = capability.id.clone();
        self.capability_registry.register(capability).await?;
        info!("Registered app capability: {}", cap_id);
        Ok(())
    }

    /// 创建 MCP 服务器
    pub fn create_mcp_server(&self, bind_addr: String) -> McpServer {
        McpServer::new(bind_addr, self.capability_registry.clone())
    }

    /// 获取 MCP 协议处理器
    pub fn get_mcp_protocol_handler(&self) -> McpProtocolHandler {
        McpProtocolHandler::new(self.capability_registry.clone())
    }

    /// 注册技能
    pub fn register_skill(&self, skill: crate::domain::skill::Skill) -> Result<()> {
        self.skill_manager.register_skill(skill)
    }

    /// 绑定技能和工具
    pub fn bind_skill_tool(&self, binding: crate::domain::skill::SkillToolBinding) -> Result<()> {
        self.skill_manager.bind_skill_tool(binding)
    }

    /// 设置工具访问类型
    pub fn set_tool_access(
        &self,
        tool_id: &str,
        access_type: crate::domain::skill::ToolAccessType,
    ) -> Result<()> {
        self.skill_manager.set_tool_access(tool_id, access_type)
    }

    /// 获取技能管理器引用
    pub fn skill_manager(&self) -> Arc<SkillManager> {
        self.skill_manager.clone()
    }
}