#!/usr/bin/env python3
"""
Agent 群聊协作系统 - Agent 管理模块
负责 Agent 的注册、登录、状态管理等
"""

from datetime import datetime
from typing import Optional, List, Dict, Any
import sqlite3
import sys
import os
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))

try:
    from database import db
except ImportError:
    from .database import db


class Agent:
    """Agent 类"""
    
    def __init__(self, id: int = None, agent_id: int = None, name: str = "", role: str = "", 
                 description: str = "", status: str = "offline", created_at: str = "", 
                 last_active: str = "", **kwargs):
        self.id = id if id is not None else agent_id
        self.name = name
        self.role = role
        self.description = description
        self.status = status
        self.created_at = created_at
        self.last_active = last_active
    
    def to_dict(self) -> Dict[str, Any]:
        return {
            'id': self.id,
            'name': self.name,
            'role': self.role,
            'description': self.description,
            'status': self.status,
            'created_at': self.created_at,
            'last_active': self.last_active
        }
    
    def __repr__(self):
        return f"Agent({self.name} - {self.role})"


class AgentManager:
    """Agent 管理器"""
    
    @staticmethod
    def register(name: str, role: str, description: str = "") -> Optional[Agent]:
        """注册新 Agent"""
        try:
            agent_id = db.insert(
                "INSERT INTO agents (name, role, description, status, last_active) VALUES (?, ?, ?, 'offline', ?)",
                (name, role, description, datetime.now().isoformat())
            )
            return AgentManager.get_by_id(agent_id)
        except sqlite3.IntegrityError:
            print(f"Agent '{name}' 已存在")
            return None
    
    @staticmethod
    def get_by_id(agent_id: int) -> Optional[Agent]:
        """通过 ID 获取 Agent"""
        row = db.fetch_one("SELECT * FROM agents WHERE id = ?", (agent_id,))
        if row:
            return Agent(**row)
        return None
    
    @staticmethod
    def get_by_name(name: str) -> Optional[Agent]:
        """通过名称获取 Agent"""
        row = db.fetch_one("SELECT * FROM agents WHERE name = ?", (name,))
        if row:
            return Agent(**row)
        return None
    
    @staticmethod
    def get_all() -> List[Agent]:
        """获取所有 Agent"""
        rows = db.fetch_all("SELECT * FROM agents ORDER BY created_at")
        return [Agent(**row) for row in rows]
    
    @staticmethod
    def update_status(agent_id: int, status: str) -> bool:
        """更新 Agent 状态"""
        valid_status = ['online', 'offline', 'busy']
        if status not in valid_status:
            return False
        
        affected = db.execute(
            "UPDATE agents SET status = ?, last_active = ? WHERE id = ?",
            (status, datetime.now().isoformat(), agent_id)
        )
        return affected > 0
    
    @staticmethod
    def go_online(agent_id: int) -> bool:
        """Agent 上线"""
        return AgentManager.update_status(agent_id, 'online')
    
    @staticmethod
    def go_offline(agent_id: int) -> bool:
        """Agent 下线"""
        return AgentManager.update_status(agent_id, 'offline')
    
    @staticmethod
    def set_busy(agent_id: int) -> bool:
        """设置 Agent 忙碌状态"""
        return AgentManager.update_status(agent_id, 'busy')
    
    @staticmethod
    def delete(agent_id: int) -> bool:
        """删除 Agent"""
        affected = db.execute("DELETE FROM agents WHERE id = ?", (agent_id,))
        return affected > 0
    
    @staticmethod
    def get_online_agents() -> List[Agent]:
        """获取在线 Agent 列表"""
        rows = db.fetch_all("SELECT * FROM agents WHERE status = 'online' ORDER BY last_active DESC")
        return [Agent(**row) for row in rows]


# 初始化默认 Agent 列表
def init_default_agents():
    """初始化默认 Agent"""
    default_agents = [
        ("老邢", "总管", "负责整体协调和决策"),
        ("小邢", "开发运维", "负责系统开发和运维"),
        ("小金", "金融市场分析", "负责金融市场分析和研究"),
        ("小陈", "美股交易", "负责美股交易执行"),
        ("小影", "设计/短视频", "负责设计和短视频内容"),
        ("小视频", "视频制作", "负责视频制作和后期"),
    ]
    
    for name, role, desc in default_agents:
        agent = AgentManager.get_by_name(name)
        if not agent:
            AgentManager.register(name, role, desc)
            print(f"已创建 Agent: {name} ({role})")


if __name__ == "__main__":
    init_default_agents()
    print("\n所有 Agent 列表:")
    for agent in AgentManager.get_all():
        print(f"  - {agent}")

#!/usr/bin/env python3
"""
Agent 群聊协作系统 - 中央协调器
负责系统整体协调、消息路由、Agent 调度等
"""

import os
import sys
import json
import time
import threading
from datetime import datetime
from typing import Optional, List, Dict, Any, Callable
from dataclasses import dataclass, field

# 添加父目录到路径
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))

from database import Database, db
from agent_manager import AgentManager, Agent
from message_manager import MessageManager, Message, MessageFormatter
from group_manager import GroupManager, Group
from task_manager import TaskManager, TaskStatus, TaskPriority
from decision_manager import DecisionManager, DecisionStatus, VoteType


@dataclass
class AgentSession:
    """Agent 会话状态"""
    agent: Agent
    last_heartbeat: float = field(default_factory=time.time)
    is_active: bool = True
    current_group_id: Optional[int] = None
    handler: Optional[Callable] = None


class Coordinator:
    """
    Agent 群聊协作系统中央协调器
    负责：
    1. Agent 生命周期管理
    2. 消息路由和分发
    3. @提及通知处理
    4. 任务调度
    5. 决策流程管理
    """
    
    _instance = None
    
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            cls._instance._initialized = False
        return cls._instance
    
    def __init__(self):
        if self._initialized:
            return
        
        self._initialized = True
        self.sessions: Dict[int, AgentSession] = {}  # agent_id -> session
        self.message_handlers: Dict[int, List[Callable]] = {}  # agent_id -> handlers
        self.running = False
        self.coordinator_thread = None
        self.check_interval = 5  # 心跳检查间隔（秒）
        
        # 确保默认 Agent 存在
        self._init_default_agents()
    
    def _init_default_agents(self):
        """初始化默认 Agent"""
        default_agents = [
            ("老邢", "总管", "负责整体协调和决策"),
            ("小邢", "开发运维", "负责系统开发和运维"),
            ("小金", "金融市场分析", "负责金融市场分析和研究"),
            ("小陈", "美股交易", "负责美股交易执行"),
            ("小影", "设计/短视频", "负责设计和短视频内容"),
            ("小视频", "视频制作", "负责视频制作和后期"),
        ]
        
        for name, role, desc in default_agents:
            agent = AgentManager.get_by_name(name)
            if not agent:
                AgentManager.register(name, role, desc)
                print(f"[协调器] 已创建 Agent: {name} ({role})")
    
    def register_agent(self, agent_id: int, message_handler: Optional[Callable] = None) -> bool:
        """注册 Agent 到协调器"""
        agent = AgentManager.get_by_id(agent_id)
        if not agent:
            print(f"[协调器] Agent {agent_id} 不存在")
            return False
        
        # 更新状态为在线
        AgentManager.go_online(agent_id)
        
        # 创建会话
        session = AgentSession(agent=agent, handler=message_handler)
        self.sessions[agent_id] = session
        
        # 注册消息处理器
        if message_handler:
            if agent_id not in self.message_handlers:
                self.message_handlers[agent_id] = []
            self.message_handlers[agent_id].append(message_handler)
        
        print(f"[协调器] Agent '{agent.name}' 已注册并上线")
        
        # 发送系统通知
        self.broadcast_system_message(f"Agent '{agent.name}' 已上线")
        
        return True
    
    def unregister_agent(self, agent_id: int) -> bool:
        """从协调器注销 Agent"""
        if agent_id not in self.sessions:
            return False
        
        agent_name = self.sessions[agent_id].agent.name
        
        # 更新状态为离线
        AgentManager.go_offline(agent_id)
        
        # 移除会话
        del self.sessions[agent_id]
        if agent_id in self.message_handlers:
            del self.message_handlers[agent_id]
        
        print(f"[协调器] Agent '{agent_name}' 已注销")
        
        # 发送系统通知
        self.broadcast_system_message(f"Agent '{agent_name}' 已下线")
        
        return True
    
    def send_message(self, from_agent_id: int, content: str,
                     group_id: Optional[int] = None,
                     to_agent_id: Optional[int] = None,
                     msg_type: str = "chat") -> Optional[Message]:
        """发送消息"""
        # 验证发送者
        if from_agent_id not in self.sessions:
            print(f"[协调器] Agent {from_agent_id} 未注册")
            return None
        
        # 发送消息
        msg = MessageManager.send_message(
            from_agent_id=from_agent_id,
            content=content,
            group_id=group_id,
            to_agent_id=to_agent_id,
            msg_type=msg_type
        )
        
        if msg:
            # 触发消息处理
            self._route_message(msg)
        
        return msg
    
    def _route_message(self, msg: Message):
        """路由消息到相关 Agent"""
        # 获取消息中 @提及的 Agent
        mentioned_agents = MessageManager.detect_mentions(msg.content)
        
        # 通知被 @提及的 Agent
        for agent in mentioned_agents:
            if agent.id in self.sessions:
                self._notify_agent(agent.id, msg)
        
        # 如果是私信，通知接收者
        if msg.to_agent_id and msg.to_agent_id in self.sessions:
            self._notify_agent(msg.to_agent_id, msg)
        
        # 触发处理器
        handlers_to_call = []
        
        # 收集相关处理器
        for agent_id, handlers in self.message_handlers.items():
            if agent_id == msg.from_agent_id:
                continue  # 不通知发送者自己
            
            # 检查是否是目标接收者
            should_notify = False
            
            if msg.to_agent_id and msg.to_agent_id == agent_id:
                should_notify = True
            elif any(a.id == agent_id for a in mentioned_agents):
                should_notify = True
            elif msg.group_id:
                # 群组消息 - 通知所有在线的群组成员
                should_notify = True
            
            if should_notify:
                handlers_to_call.extend(handlers)
        
        # 异步调用处理器
        for handler in handlers_to_call:
            try:
                threading.Thread(target=handler, args=(msg.to_dict(),), daemon=True).start()
            except Exception as e:
                print(f"[协调器] 消息处理器错误: {e}")
    
    def _notify_agent(self, agent_id: int, msg: Message):
        """通知特定 Agent"""
        if agent_id in self.sessions:
            session = self.sessions[agent_id]
            session.last_heartbeat = time.time()
            
            # 标记消息为已读（如果 Agent 在线）
            MessageManager.mark_as_read(agent_id, msg.id)
    
    def broadcast_system_message(self, content: str, group_id: Optional[int] = None):
        """广播系统消息"""
        # 获取系统 Agent（老邢作为总管）
        system_agent = AgentManager.get_by_name("老邢")
        if not system_agent:
            return
        
        MessageManager.send_message(
            from_agent_id=system_agent.id,
            content=f"[系统] {content}",
            group_id=group_id,
            msg_type="system"
        )
    
    def create_group(self, name: str, owner_id: int, description: str = "") -> Optional[Group]:
        """创建群组"""
        return GroupManager.create(name, owner_id, description)
    
    def join_group(self, agent_id: int, group_id: int) -> bool:
        """Agent 加入群组"""
        return GroupManager.add_member(group_id, agent_id)
    
    def leave_group(self, agent_id: int, group_id: int) -> bool:
        """Agent 离开群组"""
        return GroupManager.remove_member(group_id, agent_id)
    
    def assign_task(self, title: str, description: str,
                    assigner_id: int, assignee_id: int,
                    group_id: Optional[int] = None,
                    priority: str = "normal",
                    due_date: Optional[str] = None) -> Optional[Dict]:
        """指派任务"""
        task = TaskManager.create(
            title=title,
            description=description,
            assigner_id=assigner_id,
            assignee_id=assignee_id,
            group_id=group_id,
            priority=priority,
            due_date=due_date
        )
        return task.to_dict() if task else None
    
    def complete_task(self, task_id: str, agent_id: int, result: str = "") -> bool:
        """完成任务"""
        return TaskManager.complete_task(task_id, agent_id, result)
    
    def propose_decision(self, title: str, description: str,
                         proposer_id: int,
                         group_id: Optional[int] = None) -> Optional[Dict]:
        """提出决策"""
        decision = DecisionManager.propose(title, description, proposer_id, group_id)
        return decision.to_dict() if decision else None
    
    def vote_decision(self, decision_id: str, agent_id: int,
                      vote: str, comment: str = "") -> bool:
        """投票决策"""
        return DecisionManager.vote(decision_id, agent_id, vote, comment)
    
    def finalize_decision(self, decision_id: str) -> Optional[Dict]:
        """结束决策投票"""
        decision = DecisionManager.finalize(decision_id)
        return decision.to_dict() if decision else None
    
    def get_agent_inbox(self, agent_id: int, only_unread: bool = False) -> List[Dict]:
        """获取 Agent 收件箱"""
        return MessageManager.get_agent_inbox(agent_id, only_unread)
    
    def get_unread_count(self, agent_id: int) -> int:
        """获取未读消息数"""
        return MessageManager.get_unread_count(agent_id)
    
    def get_online_agents(self) -> List[Dict]:
        """获取在线 Agent 列表"""
        agents = AgentManager.get_online_agents()
        return [a.to_dict() for a in agents]
    
    def start(self):
        """启动协调器"""
        if self.running:
            return
        
        self.running = True
        self.coordinator_thread = threading.Thread(target=self._run, daemon=True)
        self.coordinator_thread.start()
        print("[协调器] 已启动")
    
    def stop(self):
        """停止协调器"""
        self.running = False
        if self.coordinator_thread:
            self.coordinator_thread.join(timeout=5)
        print("[协调器] 已停止")
    
    def _run(self):
        """协调器主循环"""
        while self.running:
            time.sleep(self.check_interval)
            self._check_heartbeats()
    
    def _check_heartbeats(self):
        """检查 Agent 心跳"""
        current_time = time.time()
        timeout = 60  # 60秒无心跳视为离线
        
        for agent_id, session in list(self.sessions.items()):
            if current_time - session.last_heartbeat > timeout:
                print(f"[协调器] Agent '{session.agent.name}' 心跳超时，标记为离线")
                AgentManager.go_offline(agent_id)
                session.is_active = False


# 便捷函数
def get_coordinator() -> Coordinator:
    """获取协调器单例"""
    return Coordinator()


# 用于演示的示例 Agent 处理器
def demo_message_handler(agent_name: str):
    """创建示例消息处理器"""
    def handler(msg_dict: Dict):
        print(f"\n[{agent_name} 收到消息]")
        print(f"  来自: {msg_dict.get('from_agent_name', 'Unknown')}")
        print(f"  内容: {msg_dict.get('content', '')[:50]}...")
        print(f"  类型: {msg_dict.get('type', 'chat')}")
        print()
    
    return handler


if __name__ == "__main__":
    # 简单测试
    coord = get_coordinator()
    coord.start()
    
    # 获取 Agent
    lao_xing = AgentManager.get_by_name("老邢")
    xiao_xing = AgentManager.get_by_name("小邢")
    
    if lao_xing and xiao_xing:
        # 注册 Agent
        coord.register_agent(lao_xing.id, demo_message_handler("老邢"))
        coord.register_agent(xiao_xing.id, demo_message_handler("小邢"))
        
        # 发送测试消息
        coord.send_message(lao_xing.id, "@小邢 测试一下系统", msg_type="chat")
        
        # 创建任务
        task = coord.assign_task(
            title="检查服务器状态",
            description="请检查所有服务器的运行状态",
            assigner_id=lao_xing.id,
            assignee_id=xiao_xing.id,
            priority="high"
        )
        print(f"创建任务: {task}")
        
        time.sleep(2)
    
    coord.stop()

#!/usr/bin/env python3
"""
Agent 群聊协作系统 - 数据库管理模块
负责数据库连接、初始化和基本操作
"""

import sqlite3
import os
from datetime import datetime
from typing import Optional, List, Dict, Any
from contextlib import contextmanager


class Database:
    """数据库管理类"""
    
    def __init__(self, db_path: str = "data/agent_network.db"):
        self.db_path = db_path
        # 确保目录存在
        os.makedirs(os.path.dirname(db_path), exist_ok=True)
        self.init_database()
    
    @contextmanager
    def get_connection(self):
        """获取数据库连接上下文管理器"""
        conn = sqlite3.connect(self.db_path)
        conn.row_factory = sqlite3.Row  # 使结果可以通过列名访问
        try:
            yield conn
            conn.commit()
        except Exception as e:
            conn.rollback()
            raise e
        finally:
            conn.close()
    
    def init_database(self):
        """初始化数据库，执行 schema.sql"""
        # Try multiple possible locations for schema.sql
        possible_paths = [
            os.path.join(os.path.dirname(__file__), '..', '..', 'references', 'schema.sql'),  # Skill structure
            os.path.join(os.path.dirname(__file__), '..', 'schema.sql'),  # Local dev
            os.path.join(os.path.dirname(__file__), '..', '..', 'schema.sql'),  # Alternate
        ]
        
        schema_path = None
        for path in possible_paths:
            if os.path.exists(path):
                schema_path = path
                break
        
        if os.path.exists(schema_path):
            with open(schema_path, 'r', encoding='utf-8') as f:
                schema = f.read()
            
            with self.get_connection() as conn:
                conn.executescript(schema)
        else:
            print(f"警告: 未找到 schema.sql 文件: {schema_path}")
    
    def execute(self, query: str, params: tuple = ()) -> int:
        """执行 SQL 语句，返回影响的行数"""
        with self.get_connection() as conn:
            cursor = conn.execute(query, params)
            return cursor.rowcount
    
    def execute_many(self, query: str, params_list: List[tuple]) -> int:
        """批量执行 SQL 语句"""
        with self.get_connection() as conn:
            cursor = conn.executemany(query, params_list)
            return cursor.rowcount
    
    def fetch_one(self, query: str, params: tuple = ()) -> Optional[Dict[str, Any]]:
        """查询单条记录"""
        with self.get_connection() as conn:
            cursor = conn.execute(query, params)
            row = cursor.fetchone()
            if row:
                return dict(row)
            return None
    
    def fetch_all(self, query: str, params: tuple = ()) -> List[Dict[str, Any]]:
        """查询多条记录"""
        with self.get_connection() as conn:
            cursor = conn.execute(query, params)
            rows = cursor.fetchall()
            return [dict(row) for row in rows]
    
    def insert(self, query: str, params: tuple = ()) -> int:
        """插入记录，返回自增ID"""
        with self.get_connection() as conn:
            cursor = conn.execute(query, params)
            return cursor.lastrowid


# 全局数据库实例
db = Database()

#!/usr/bin/env python3
"""
Agent 群聊协作系统 - 决策投票模块
负责决策提议的创建、投票、结果统计等
"""

from datetime import datetime
from typing import Optional, List, Dict, Any
import sys
import os
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))

try:
    from database import db
    from agent_manager import AgentManager
    from message_manager import MessageManager
except ImportError:
    from .database import db
    from .agent_manager import AgentManager
    from .message_manager import MessageManager


class DecisionStatus:
    """决策状态常量"""
    PROPOSED = "proposed"
    DISCUSSING = "discussing"
    APPROVED = "approved"
    REJECTED = "rejected"
    IMPLEMENTED = "implemented"


class VoteType:
    """投票类型常量"""
    FOR = "for"
    AGAINST = "against"
    ABSTAIN = "abstain"


class Decision:
    """决策类"""
    
    def __init__(self, id: int = None, decision_db_id: int = None, decision_id: str = "",
                 title: str = "", description: str = "", group_id: Optional[int] = None,
                 proposer_id: int = None, status: str = "proposed", votes_for: int = 0,
                 votes_against: int = 0, decided_at: Optional[str] = None,
                 created_at: str = "", **kwargs):
        self.id = id if id is not None else decision_db_id
        self.decision_id = decision_id
        self.title = title
        self.description = description
        self.group_id = group_id
        self.proposer_id = proposer_id
        self.status = status
        self.votes_for = votes_for
        self.votes_against = votes_against
        self.decided_at = decided_at
        self.created_at = created_at
        
        # 额外字段
        self.proposer_name: Optional[str] = kwargs.get('proposer_name')
        self.group_name: Optional[str] = kwargs.get('group_name')
        self.votes: List[Dict] = []
    
    def to_dict(self) -> Dict[str, Any]:
        return {
            'id': self.id,
            'decision_id': self.decision_id,
            'title': self.title,
            'description': self.description,
            'group_id': self.group_id,
            'group_name': self.group_name,
            'proposer_id': self.proposer_id,
            'proposer_name': self.proposer_name,
            'status': self.status,
            'votes_for': self.votes_for,
            'votes_against': self.votes_against,
            'decided_at': self.decided_at,
            'created_at': self.created_at,
            'votes': self.votes
        }
    
    @property
    def total_votes(self) -> int:
        """获取总投票数"""
        return self.votes_for + self.votes_against
    
    @property
    def pass_rate(self) -> float:
        """获取通过率"""
        total = self.total_votes
        if total == 0:
            return 0.0
        return (self.votes_for / total) * 100
    
    def __repr__(self):
        return f"Decision({self.decision_id}: {self.title})"


class DecisionManager:
    """决策管理器"""
    
    _decision_counter = 0
    
    @staticmethod
    def generate_decision_id() -> str:
        """生成决策唯一标识"""
        DecisionManager._decision_counter += 1
        return f"DEC-{datetime.now().strftime('%Y%m%d')}-{DecisionManager._decision_counter:03d}"
    
    @staticmethod
    def create(title: str, description: str, proposer_id: int,
               group_id: Optional[int] = None) -> Optional[Decision]:
        """创建决策提议"""
        decision_id = DecisionManager.generate_decision_id()
        
        try:
            db_id = db.insert(
                """INSERT INTO decisions (decision_id, title, description, group_id, proposer_id,
                    status, votes_for, votes_against, created_at)
                   VALUES (?, ?, ?, ?, ?, 'proposed', 0, 0, ?)""",
                (decision_id, title, description, group_id, proposer_id, datetime.now().isoformat())
            )
            
            # 发送决策提议消息
            proposer = AgentManager.get_by_id(proposer_id)
            if proposer:
                content = f"📊 新决策提议\n\n**{title}**\n{description}\n\n请投票: for/against/abstain\n决策ID: {decision_id}"
                MessageManager.send_message(
                    from_agent_id=proposer_id,
                    content=content,
                    group_id=group_id,
                    msg_type="decision"
                )
            
            return DecisionManager.get_by_id(db_id)
        except Exception as e:
            print(f"创建决策提议失败: {e}")
            return None
    
    @staticmethod
    def get_by_id(decision_db_id: int) -> Optional[Decision]:
        """通过 ID 获取决策"""
        row = db.fetch_one(
            """SELECT d.*, 
                      a.name as proposer_name,
                      g.name as group_name
               FROM decisions d
               LEFT JOIN agents a ON d.proposer_id = a.id
               LEFT JOIN groups g ON d.group_id = g.id
               WHERE d.id = ?""",
            (decision_db_id,)
        )
        if row:
            decision = Decision(**row)
            decision.proposer_name = row.get('proposer_name')
            decision.group_name = row.get('group_name')
            decision.votes = DecisionManager.get_votes(decision_db_id)
            return decision
        return None
    
    @staticmethod
    def get_by_decision_id(decision_id: str) -> Optional[Decision]:
        """通过决策标识获取决策"""
        row = db.fetch_one(
            """SELECT d.*, 
                      a.name as proposer_name,
                      g.name as group_name
               FROM decisions d
               LEFT JOIN agents a ON d.proposer_id = a.id
               LEFT JOIN groups g ON d.group_id = g.id
               WHERE d.decision_id = ?""",
            (decision_id,)
        )
        if row:
            decision = Decision(**row)
            decision.proposer_name = row.get('proposer_name')
            decision.group_name = row.get('group_name')
            decision.votes = DecisionManager.get_votes(row['id'])
            return decision
        return None
    
    @staticmethod
    def get_all(status: Optional[str] = None, group_id: Optional[int] = None) -> List[Decision]:
        """获取所有决策提议"""
        query = """SELECT d.*, 
                          a.name as proposer_name,
                          g.name as group_name
                   FROM decisions d
                   LEFT JOIN agents a ON d.proposer_id = a.id
                   LEFT JOIN groups g ON d.group_id = g.id"""
        params = []
        conditions = []
        
        if status:
            conditions.append("d.status = ?")
            params.append(status)
        if group_id:
            conditions.append("d.group_id = ?")
            params.append(group_id)
        
        if conditions:
            query += " WHERE " + " AND ".join(conditions)
        
        query += " ORDER BY d.created_at DESC"
        
        rows = db.fetch_all(query, tuple(params))
        decisions = []
        for row in rows:
            decision = Decision(**row)
            decision.proposer_name = row.get('proposer_name')
            decision.group_name = row.get('group_name')
            decision.votes = DecisionManager.get_votes(row['id'])
            decisions.append(decision)
        return decisions
    
    @staticmethod
    def vote(decision_db_id: int, agent_id: int, vote: str, comment: str = "") -> bool:
        """投票"""
        valid_votes = ['for', 'against', 'abstain']
        if vote not in valid_votes:
            print(f"无效的投票选项: {vote}. 请使用 for/against/abstain")
            return False
        
        decision = DecisionManager.get_by_id(decision_db_id)
        if not decision:
            print("决策不存在")
            return False
        
        if decision.status not in ['proposed', 'discussing']:
            print(f"决策已关闭，无法投票 (当前状态: {decision.status})")
            return False
        
        # 检查是否已经投过票
        existing = db.fetch_one(
            "SELECT id FROM decision_votes WHERE decision_id = ? AND agent_id = ?",
            (decision_db_id, agent_id)
        )
        
        if existing:
            # 更新投票
            db.execute(
                "UPDATE decision_votes SET vote = ?, comment = ? WHERE id = ?",
                (vote, comment, existing['id'])
            )
        else:
            # 新增投票
            db.execute(
                """INSERT INTO decision_votes (decision_id, agent_id, vote, comment, created_at)
                   VALUES (?, ?, ?, ?, ?)""",
                (decision_db_id, agent_id, vote, comment, datetime.now().isoformat())
            )
        
        # 更新决策的投票计数
        if vote == 'for':
            db.execute(
                "UPDATE decisions SET votes_for = votes_for + 1 WHERE id = ?",
                (decision_db_id,)
            )
        elif vote == 'against':
            db.execute(
                "UPDATE decisions SET votes_against = votes_against + 1 WHERE id = ?",
                (decision_db_id,)
            )
        
        # 发送投票通知
        agent = AgentManager.get_by_id(agent_id)
        vote_text = {'for': '✅ 赞成', 'against': '❌ 反对', 'abstain': '⚪ 弃权'}.get(vote, vote)
        
        content = f"🗳️ {agent.name if agent else 'Agent'} 投票: {vote_text}\n决策: {decision.title}"
        if comment:
            content += f"\n意见: {comment}"
        
        MessageManager.send_message(
            from_agent_id=agent_id,
            content=content,
            group_id=decision.group_id,
            msg_type="chat"
        )
        
        return True
    
    @staticmethod
    def update_status(decision_db_id: int, new_status: str, updater_id: int) -> bool:
        """更新决策状态"""
        valid_status = ['proposed', 'discussing', 'approved', 'rejected', 'implemented']
        if new_status not in valid_status:
            print(f"无效的状态: {new_status}")
            return False
        
        decision = DecisionManager.get_by_id(decision_db_id)
        if not decision:
            return False
        
        decided_at = datetime.now().isoformat() if new_status in ['approved', 'rejected'] else None
        
        affected = db.execute(
            "UPDATE decisions SET status = ?, decided_at = ? WHERE id = ?",
            (new_status, decided_at, decision_db_id)
        )
        
        if affected > 0:
            status_text = {
                'proposed': '提议中',
                'discussing': '讨论中',
                'approved': '已通过',
                'rejected': '已否决',
                'implemented': '已实施'
            }.get(new_status, new_status)
            
            updater = AgentManager.get_by_id(updater_id)
            content = f"📊 决策状态更新\n\n**{decision.title}**\n新状态: {status_text}"
            
            MessageManager.send_message(
                from_agent_id=updater_id,
                content=content,
                group_id=decision.group_id,
                msg_type="decision"
            )
            
            return True
        return False
    
    @staticmethod
    def get_votes(decision_db_id: int) -> List[Dict]:
        """获取决策的所有投票"""
        rows = db.fetch_all(
            """SELECT dv.*, a.name as agent_name
               FROM decision_votes dv
               JOIN agents a ON dv.agent_id = a.id
               WHERE dv.decision_id = ?
               ORDER BY dv.created_at""",
            (decision_db_id,)
        )
        return [dict(row) for row in rows]
    
    @staticmethod
    def has_voted(decision_db_id: int, agent_id: int) -> bool:
        """检查 Agent 是否已经投票"""
        result = db.fetch_one(
            "SELECT 1 FROM decision_votes WHERE decision_id = ? AND agent_id = ?",
            (decision_db_id, agent_id)
        )
        return result is not None
    
    @staticmethod
    def delete(decision_db_id: int) -> bool:
        """删除决策"""
        affected = db.execute("DELETE FROM decisions WHERE id = ?", (decision_db_id,))
        return affected > 0
    
    @staticmethod
    def format_decision_for_display(decision: Decision, show_votes: bool = False) -> str:
        """格式化决策用于显示"""
        status_emoji = {
            'proposed': '📝',
            'discussing': '💬',
            'approved': '✅',
            'rejected': '❌',
            'implemented': '🚀'
        }.get(decision.status, '⚪')
        
        lines = [
            f"{status_emoji} [{decision.decision_id}] {decision.title}",
            f"   提案人: {decision.proposer_name} | 状态: {decision.status}",
            f"   投票: ✅ {decision.votes_for} 票 | ❌ {decision.votes_against} 票 | 通过率: {decision.pass_rate:.1f}%"
        ]
        
        if decision.description:
            lines.append(f"   描述: {decision.description[:60]}{'...' if len(decision.description) > 60 else ''}")
        
        if show_votes and decision.votes:
            lines.append("   投票详情:")
            for v in decision.votes:
                vote_emoji = {'for': '✅', 'against': '❌', 'abstain': '⚪'}.get(v['vote'], '⚪')
                lines.append(f"     {vote_emoji} {v['agent_name']}: {v['vote']}")
        
        return "\n".join(lines)

#!/usr/bin/env python3
"""
Agent 群聊协作系统 - 群组管理模块
负责群组的创建、成员管理等
"""

from datetime import datetime
from typing import Optional, List, Dict, Any
import sys
import os
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))

try:
    from database import db
    from agent_manager import AgentManager, Agent
except ImportError:
    from .database import db
    from .agent_manager import AgentManager, Agent


class Group:
    """群组类"""
    
    def __init__(self, id: int = None, group_id: int = None, name: str = "", description: str = "",
                 owner_id: Optional[int] = None, created_at: str = "", **kwargs):
        self.id = id if id is not None else group_id
        self.name = name
        self.description = description
        self.owner_id = owner_id
        self.created_at = created_at
        
        # 额外字段
        self.owner_name: Optional[str] = kwargs.get('owner_name')
        self.members: List[Agent] = []
    
    def to_dict(self) -> Dict[str, Any]:
        return {
            'id': self.id,
            'name': self.name,
            'description': self.description,
            'owner_id': self.owner_id,
            'owner_name': self.owner_name,
            'created_at': self.created_at,
            'member_count': len(self.members),
            'members': [m.to_dict() for m in self.members]
        }
    
    def __repr__(self):
        return f"Group({self.name}, members={len(self.members)})"


class GroupManager:
    """群组管理器"""
    
    @staticmethod
    def create(name: str, owner_id: int, description: str = "") -> Optional[Group]:
        """创建新群组"""
        try:
            group_id = db.insert(
                "INSERT INTO groups (name, description, owner_id, created_at) VALUES (?, ?, ?, ?)",
                (name, description, owner_id, datetime.now().isoformat())
            )
            # 自动将创建者加入群组
            GroupManager.add_member(group_id, owner_id)
            return GroupManager.get_by_id(group_id)
        except Exception as e:
            print(f"创建群组失败: {e}")
            return None
    
    @staticmethod
    def get_by_id(group_id: int) -> Optional[Group]:
        """通过 ID 获取群组"""
        row = db.fetch_one(
            """SELECT g.*, a.name as owner_name 
               FROM groups g 
               LEFT JOIN agents a ON g.owner_id = a.id 
               WHERE g.id = ?""",
            (group_id,)
        )
        if row:
            group = Group(**row)
            group.owner_name = row.get('owner_name')
            group.members = GroupManager.get_members(group_id)
            return group
        return None
    
    @staticmethod
    def get_by_name(name: str) -> Optional[Group]:
        """通过名称获取群组"""
        row = db.fetch_one(
            """SELECT g.*, a.name as owner_name 
               FROM groups g 
               LEFT JOIN agents a ON g.owner_id = a.id 
               WHERE g.name = ?""",
            (name,)
        )
        if row:
            group = Group(**row)
            group.owner_name = row.get('owner_name')
            group.members = GroupManager.get_members(row['id'])
            return group
        return None
    
    @staticmethod
    def get_all() -> List[Group]:
        """获取所有群组"""
        rows = db.fetch_all(
            """SELECT g.*, a.name as owner_name 
               FROM groups g 
               LEFT JOIN agents a ON g.owner_id = a.id
               ORDER BY g.created_at DESC"""
        )
        groups = []
        for row in rows:
            group = Group(**row)
            group.owner_name = row.get('owner_name')
            group.members = GroupManager.get_members(row['id'])
            groups.append(group)
        return groups
    
    @staticmethod
    def get_agent_groups(agent_id: int) -> List[Group]:
        """获取 Agent 加入的所有群组"""
        rows = db.fetch_all(
            """SELECT g.*, a.name as owner_name 
               FROM groups g 
               JOIN group_members gm ON g.id = gm.group_id
               LEFT JOIN agents a ON g.owner_id = a.id
               WHERE gm.agent_id = ?
               ORDER BY g.created_at DESC""",
            (agent_id,)
        )
        groups = []
        for row in rows:
            group = Group(**row)
            group.owner_name = row.get('owner_name')
            group.members = GroupManager.get_members(row['id'])
            groups.append(group)
        return groups
    
    @staticmethod
    def add_member(group_id: int, agent_id: int) -> bool:
        """添加群组成员"""
        try:
            db.execute(
                "INSERT INTO group_members (group_id, agent_id, joined_at) VALUES (?, ?, ?)",
                (group_id, agent_id, datetime.now().isoformat())
            )
            return True
        except Exception as e:
            print(f"添加成员失败: {e}")
            return False
    
    @staticmethod
    def remove_member(group_id: int, agent_id: int) -> bool:
        """移除群组成员"""
        affected = db.execute(
            "DELETE FROM group_members WHERE group_id = ? AND agent_id = ?",
            (group_id, agent_id)
        )
        return affected > 0
    
    @staticmethod
    def get_members(group_id: int) -> List[Agent]:
        """获取群组成员列表"""
        rows = db.fetch_all(
            """SELECT a.* FROM agents a
               JOIN group_members gm ON a.id = gm.agent_id
               WHERE gm.group_id = ?
               ORDER BY gm.joined_at""",
            (group_id,)
        )
        return [Agent(**row) for row in rows]
    
    @staticmethod
    def is_member(group_id: int, agent_id: int) -> bool:
        """检查 Agent 是否在群组中"""
        result = db.fetch_one(
            "SELECT 1 FROM group_members WHERE group_id = ? AND agent_id = ?",
            (group_id, agent_id)
        )
        return result is not None
    
    @staticmethod
    def update(group_id: int, name: str = None, description: str = None) -> bool:
        """更新群组信息"""
        updates = []
        params = []
        
        if name:
            updates.append("name = ?")
            params.append(name)
        if description:
            updates.append("description = ?")
            params.append(description)
        
        if not updates:
            return False
        
        params.append(group_id)
        affected = db.execute(
            f"UPDATE groups SET {', '.join(updates)} WHERE id = ?",
            tuple(params)
        )
        return affected > 0
    
    @staticmethod
    def delete(group_id: int) -> bool:
        """删除群组（同时删除所有相关记录）"""
        # 数据库外键会处理相关记录的级联删除
        affected = db.execute("DELETE FROM groups WHERE id = ?", (group_id,))
        return affected > 0
    
    @staticmethod
    def transfer_ownership(group_id: int, new_owner_id: int) -> bool:
        """转移群组所有权"""
        # 确保新群主在群组中
        if not GroupManager.is_member(group_id, new_owner_id):
            GroupManager.add_member(group_id, new_owner_id)
        
        affected = db.execute(
            "UPDATE groups SET owner_id = ? WHERE id = ?",
            (new_owner_id, group_id)
        )
        return affected > 0
    
    @staticmethod
    def get_member_count(group_id: int) -> int:
        """获取群组成员数量"""
        result = db.fetch_one(
            "SELECT COUNT(*) as count FROM group_members WHERE group_id = ?",
            (group_id,)
        )
        return result['count'] if result else 0
    
    @staticmethod
    def list_online_members(group_id: int) -> List[Agent]:
        """获取群组在线成员"""
        rows = db.fetch_all(
            """SELECT a.* FROM agents a
               JOIN group_members gm ON a.id = gm.agent_id
               WHERE gm.group_id = ? AND a.status = 'online'
               ORDER BY a.last_active DESC""",
            (group_id,)
        )
        return [Agent(**row) for row in rows]

#!/usr/bin/env python3
"""
Agent 群聊协作系统 - 消息核心模块
负责消息的创建、发送、@提及处理等
"""

import re
import json
from datetime import datetime
from typing import Optional, List, Dict, Any, Tuple
from enum import Enum
import sys
import os
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))

try:
    from database import db
    from agent_manager import AgentManager, Agent
except ImportError:
    from .database import db
    from .agent_manager import AgentManager, Agent


class MessageType(Enum):
    """消息类型枚举"""
    CHAT = "chat"           # 普通聊天
    MENTION = "mention"     # @提及
    TASK_ASSIGN = "task_assign"    # 任务指派
    TASK_COMPLETE = "task_complete"  # 任务完成
    DECISION = "decision"   # 决策提议
    SYSTEM = "system"       # 系统消息
    REPLY = "reply"         # 回复消息


class Message:
    """消息类"""
    
    def __init__(self, id: int = None, msg_id: int = None, group_id: Optional[int] = None,
                 from_agent_id: int = None, to_agent_id: Optional[int] = None,
                 content: str = "", msg_type: str = "", type: str = "",
                 reply_to: Optional[int] = None, created_at: str = "",
                 **kwargs):
        self.id = id if id is not None else msg_id
        self.group_id = group_id
        self.from_agent_id = from_agent_id
        self.to_agent_id = to_agent_id
        self.content = content
        self.type = msg_type if msg_type else type
        self.reply_to = reply_to
        self.created_at = created_at
        
        # 额外字段（通过 JOIN 查询填充）
        self.from_agent_name: Optional[str] = kwargs.get('from_agent_name')
        self.to_agent_name: Optional[str] = kwargs.get('to_agent_name')
        self.group_name: Optional[str] = kwargs.get('group_name')
    
    def to_dict(self) -> Dict[str, Any]:
        return {
            'id': self.id,
            'group_id': self.group_id,
            'group_name': self.group_name,
            'from_agent_id': self.from_agent_id,
            'from_agent_name': self.from_agent_name,
            'to_agent_id': self.to_agent_id,
            'to_agent_name': self.to_agent_name,
            'content': self.content,
            'type': self.type,
            'reply_to': self.reply_to,
            'created_at': self.created_at
        }
    
    def __repr__(self):
        return f"Message({self.id}: {self.from_agent_name} -> {self.to_agent_name or 'all'}: {self.content[:30]}...)"


class MessageManager:
    """消息管理器"""
    
    # 用于匹配 @AgentName 的正则表达式
    MENTION_PATTERN = re.compile(r'@([^\s@]+)')
    
    @staticmethod
    def send_message(from_agent_id: int, content: str, group_id: Optional[int] = None,
                     to_agent_id: Optional[int] = None, msg_type: str = "chat",
                     reply_to: Optional[int] = None) -> Optional[Message]:
        """发送消息"""
        # 检测消息中的 @提及
        mentions = MessageManager.detect_mentions(content)
        
        # 如果消息包含 @提及且没有指定接收者，标记为 mention 类型
        if mentions and msg_type == "chat":
            msg_type = "mention"
        
        # 插入消息
        msg_id = db.insert(
            """INSERT INTO messages (group_id, from_agent_id, to_agent_id, content, type, reply_to, created_at)
               VALUES (?, ?, ?, ?, ?, ?, ?)""",
            (group_id, from_agent_id, to_agent_id, content, msg_type, reply_to, datetime.now().isoformat())
        )
        
        # 为 @提及的 Agent 创建收件箱通知
        for mentioned_agent in mentions:
            MessageManager.create_inbox_notification(mentioned_agent.id, msg_id)
        
        # 如果是私信（指定了接收者），也为接收者创建通知
        if to_agent_id:
            MessageManager.create_inbox_notification(to_agent_id, msg_id)
        
        return MessageManager.get_by_id(msg_id)
    
    @staticmethod
    def detect_mentions(content: str) -> List[Agent]:
        """检测消息中的 @提及"""
        mentioned_agents = []
        matches = MessageManager.MENTION_PATTERN.findall(content)
        
        for name in matches:
            agent = AgentManager.get_by_name(name)
            if agent:
                mentioned_agents.append(agent)
        
        return mentioned_agents
    
    @staticmethod
    def create_inbox_notification(agent_id: int, message_id: int):
        """为 Agent 创建收件箱通知"""
        db.execute(
            "INSERT INTO agent_inbox (agent_id, message_id, is_read, notified_at) VALUES (?, ?, FALSE, ?)",
            (agent_id, message_id, datetime.now().isoformat())
        )
    
    @staticmethod
    def get_by_id(msg_id: int) -> Optional[Message]:
        """通过 ID 获取消息"""
        row = db.fetch_one(
            """SELECT m.*, 
                      fa.name as from_agent_name, 
                      ta.name as to_agent_name,
                      g.name as group_name
               FROM messages m
               LEFT JOIN agents fa ON m.from_agent_id = fa.id
               LEFT JOIN agents ta ON m.to_agent_id = ta.id
               LEFT JOIN groups g ON m.group_id = g.id
               WHERE m.id = ?""",
            (msg_id,)
        )
        if row:
            msg = Message(**row)
            return msg
        return None
    
    @staticmethod
    def get_group_messages(group_id: int, limit: int = 50, offset: int = 0) -> List[Message]:
        """获取群组消息历史"""
        rows = db.fetch_all(
            """SELECT m.*, 
                      fa.name as from_agent_name, 
                      ta.name as to_agent_name,
                      g.name as group_name
               FROM messages m
               LEFT JOIN agents fa ON m.from_agent_id = fa.id
               LEFT JOIN agents ta ON m.to_agent_id = ta.id
               LEFT JOIN groups g ON m.group_id = g.id
               WHERE m.group_id = ?
               ORDER BY m.created_at DESC
               LIMIT ? OFFSET ?""",
            (group_id, limit, offset)
        )
        return [MessageManager._row_to_message(row) for row in rows]
    
    @staticmethod
    def get_agent_inbox(agent_id: int, only_unread: bool = False) -> List[Dict[str, Any]]:
        """获取 Agent 的收件箱"""
        query = """SELECT ai.*, m.content, m.type, m.created_at as msg_created_at,
                          fa.name as from_agent_name, g.name as group_name
                   FROM agent_inbox ai
                   JOIN messages m ON ai.message_id = m.id
                   LEFT JOIN agents fa ON m.from_agent_id = fa.id
                   LEFT JOIN groups g ON m.group_id = g.id
                   WHERE ai.agent_id = ?"""
        
        if only_unread:
            query += " AND ai.is_read = FALSE"
        
        query += " ORDER BY m.created_at DESC"
        
        return db.fetch_all(query, (agent_id,))
    
    @staticmethod
    def mark_as_read(agent_id: int, message_id: int) -> bool:
        """标记消息为已读"""
        affected = db.execute(
            "UPDATE agent_inbox SET is_read = TRUE, read_at = ? WHERE agent_id = ? AND message_id = ?",
            (datetime.now().isoformat(), agent_id, message_id)
        )
        return affected > 0
    
    @staticmethod
    def mark_all_as_read(agent_id: int) -> int:
        """标记所有消息为已读"""
        return db.execute(
            "UPDATE agent_inbox SET is_read = TRUE, read_at = ? WHERE agent_id = ? AND is_read = FALSE",
            (datetime.now().isoformat(), agent_id)
        )
    
    @staticmethod
    def get_unread_count(agent_id: int) -> int:
        """获取未读消息数量"""
        result = db.fetch_one(
            "SELECT COUNT(*) as count FROM agent_inbox WHERE agent_id = ? AND is_read = FALSE",
            (agent_id,)
        )
        return result['count'] if result else 0
    
    @staticmethod
    def search_messages(keyword: str, group_id: Optional[int] = None,
                        from_agent_id: Optional[int] = None) -> List[Message]:
        """搜索消息"""
        query = """SELECT m.*, 
                          fa.name as from_agent_name, 
                          ta.name as to_agent_name,
                          g.name as group_name
                   FROM messages m
                   LEFT JOIN agents fa ON m.from_agent_id = fa.id
                   LEFT JOIN agents ta ON m.to_agent_id = ta.id
                   LEFT JOIN groups g ON m.group_id = g.id
                   WHERE m.content LIKE ?"""
        params = [f"%{keyword}%"]
        
        if group_id:
            query += " AND m.group_id = ?"
            params.append(group_id)
        
        if from_agent_id:
            query += " AND m.from_agent_id = ?"
            params.append(from_agent_id)
        
        query += " ORDER BY m.created_at DESC LIMIT 100"
        
        rows = db.fetch_all(query, tuple(params))
        return [MessageManager._row_to_message(row) for row in rows]
    
    @staticmethod
    def _row_to_message(row: Dict) -> Message:
        """将数据库行转换为 Message 对象"""
        msg = Message(
            msg_id=row['id'],
            group_id=row.get('group_id'),
            from_agent_id=row['from_agent_id'],
            to_agent_id=row.get('to_agent_id'),
            content=row['content'],
            msg_type=row['type'],
            reply_to=row.get('reply_to'),
            created_at=row['created_at']
        )
        msg.from_agent_name = row.get('from_agent_name')
        msg.to_agent_name = row.get('to_agent_name')
        msg.group_name = row.get('group_name')
        return msg
    
    @staticmethod
    def format_message_for_display(msg: Message) -> str:
        """格式化消息用于显示"""
        time_str = msg.created_at[11:19] if len(msg.created_at) > 19 else msg.created_at
        from_name = msg.from_agent_name or f"Agent-{msg.from_agent_id}"
        
        if msg.group_name:
            location = f"[{msg.group_name}]"
        else:
            location = "[私信]"
        
        if msg.to_agent_name:
            target = f" @{msg.to_agent_name}"
        else:
            target = ""
        
        return f"[{time_str}] {location} {from_name}{target}: {msg.content}"


class MessageFormatter:
    """消息格式化工具"""
    
    @staticmethod
    def chat(content: str) -> str:
        """普通聊天消息"""
        return content
    
    @staticmethod
    def mention(content: str, agent_names: List[str]) -> str:
        """@提及消息"""
        mentions = " ".join([f"@{name}" for name in agent_names])
        return f"{mentions} {content}"
    
    @staticmethod
    def task_assign(assignee: str, task_title: str, description: str = "", 
                    priority: str = "normal", due_date: str = "") -> str:
        """任务指派消息"""
        lines = [f"@{assignee} 新任务指派", f"标题: {task_title}"]
        if description:
            lines.append(f"描述: {description}")
        lines.append(f"优先级: {priority}")
        if due_date:
            lines.append(f"截止日期: {due_date}")
        return "\n".join(lines)
    
    @staticmethod
    def task_complete(task_id: str, result: str = "") -> str:
        """任务完成消息"""
        lines = [f"任务 {task_id} 已完成"]
        if result:
            lines.append(f"结果: {result}")
        return "\n".join(lines)
    
    @staticmethod
    def decision_proposal(title: str, description: str, options: List[str] = None) -> str:
        """决策提议消息"""
        lines = [f"【决策提议】{title}", f"描述: {description}"]
        if options:
            lines.append("选项:")
            for i, opt in enumerate(options, 1):
                lines.append(f"  {i}. {opt}")
        return "\n".join(lines)

#!/usr/bin/env python3
"""
Agent 群聊协作系统 - 任务管理模块
负责任务的创建、指派、状态更新、评论等
"""

from datetime import datetime
from typing import Optional, List, Dict, Any
import sys
import os
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))

try:
    from database import db
    from agent_manager import AgentManager
    from message_manager import MessageManager
except ImportError:
    from .database import db
    from .agent_manager import AgentManager
    from .message_manager import MessageManager


class TaskStatus:
    """任务状态常量"""
    PENDING = "pending"
    IN_PROGRESS = "in_progress"
    COMPLETED = "completed"
    CANCELLED = "cancelled"


class TaskPriority:
    """任务优先级常量"""
    LOW = "low"
    NORMAL = "normal"
    HIGH = "high"
    URGENT = "urgent"


class Task:
    """任务类"""
    
    def __init__(self, id: int = None, task_db_id: int = None, task_id: str = "", title: str = "",
                 description: str = "", assigner_id: int = None, assignee_id: int = None,
                 group_id: Optional[int] = None, status: str = "pending", priority: str = "normal",
                 due_date: Optional[str] = None, completed_at: Optional[str] = None,
                 created_at: str = "", **kwargs):
        self.id = id if id is not None else task_db_id
        self.task_id = task_id
        self.title = title
        self.description = description
        self.assigner_id = assigner_id
        self.assignee_id = assignee_id
        self.group_id = group_id
        self.status = status
        self.priority = priority
        self.due_date = due_date
        self.completed_at = completed_at
        self.created_at = created_at
        
        # 额外字段
        self.assigner_name: Optional[str] = kwargs.get('assigner_name')
        self.assignee_name: Optional[str] = kwargs.get('assignee_name')
        self.group_name: Optional[str] = kwargs.get('group_name')
        self.comments: List[Dict] = []
    
    def to_dict(self) -> Dict[str, Any]:
        return {
            'id': self.id,
            'task_id': self.task_id,
            'title': self.title,
            'description': self.description,
            'assigner_id': self.assigner_id,
            'assigner_name': self.assigner_name,
            'assignee_id': self.assignee_id,
            'assignee_name': self.assignee_name,
            'group_id': self.group_id,
            'group_name': self.group_name,
            'status': self.status,
            'priority': self.priority,
            'due_date': self.due_date,
            'completed_at': self.completed_at,
            'created_at': self.created_at,
            'comments': self.comments
        }
    
    def __repr__(self):
        return f"Task({self.task_id}: {self.title} -> {self.assignee_name})"


class TaskManager:
    """任务管理器"""
    
    _task_counter = 0
    
    @staticmethod
    def generate_task_id() -> str:
        """生成任务唯一标识"""
        TaskManager._task_counter += 1
        return f"TASK-{datetime.now().strftime('%Y%m%d')}-{TaskManager._task_counter:03d}"
    
    @staticmethod
    def create(title: str, assigner_id: int, assignee_id: int,
               description: str = "", group_id: Optional[int] = None,
               priority: str = "normal", due_date: Optional[str] = None) -> Optional[Task]:
        """创建新任务"""
        task_id = TaskManager.generate_task_id()
        
        try:
            db_id = db.insert(
                """INSERT INTO tasks (task_id, title, description, assigner_id, assignee_id,
                    group_id, status, priority, due_date, created_at)
                   VALUES (?, ?, ?, ?, ?, ?, 'pending', ?, ?, ?)""",
                (task_id, title, description, assigner_id, assignee_id,
                 group_id, priority, due_date, datetime.now().isoformat())
            )
            
            # 发送任务指派消息
            assigner = AgentManager.get_by_id(assigner_id)
            assignee = AgentManager.get_by_id(assignee_id)
            
            if assigner and assignee:
                content = f"📝 新任务指派给 @{assignee.name}\n\n**{title}**\n{description}\n\n优先级: {priority}"
                if due_date:
                    content += f" | 截止: {due_date}"
                content += f" | 任务ID: {task_id}"
                
                MessageManager.send_message(
                    from_agent_id=assigner_id,
                    content=content,
                    group_id=group_id,
                    to_agent_id=assignee_id,
                    msg_type="task_assign"
                )
            
            return TaskManager.get_by_id(db_id)
        except Exception as e:
            print(f"创建任务失败: {e}")
            return None
    
    @staticmethod
    def get_by_id(task_db_id: int) -> Optional[Task]:
        """通过 ID 获取任务"""
        row = db.fetch_one(
            """SELECT t.*, 
                      a1.name as assigner_name, 
                      a2.name as assignee_name,
                      g.name as group_name
               FROM tasks t
               LEFT JOIN agents a1 ON t.assigner_id = a1.id
               LEFT JOIN agents a2 ON t.assignee_id = a2.id
               LEFT JOIN groups g ON t.group_id = g.id
               WHERE t.id = ?""",
            (task_db_id,)
        )
        if row:
            task = Task(**row)
            task.assigner_name = row.get('assigner_name')
            task.assignee_name = row.get('assignee_name')
            task.group_name = row.get('group_name')
            task.comments = TaskManager.get_comments(task_db_id)
            return task
        return None
    
    @staticmethod
    def get_by_task_id(task_id: str) -> Optional[Task]:
        """通过任务标识获取任务"""
        row = db.fetch_one(
            """SELECT t.*, 
                      a1.name as assigner_name, 
                      a2.name as assignee_name,
                      g.name as group_name
               FROM tasks t
               LEFT JOIN agents a1 ON t.assigner_id = a1.id
               LEFT JOIN agents a2 ON t.assignee_id = a2.id
               LEFT JOIN groups g ON t.group_id = g.id
               WHERE t.task_id = ?""",
            (task_id,)
        )
        if row:
            task = Task(**row)
            task.assigner_name = row.get('assigner_name')
            task.assignee_name = row.get('assignee_name')
            task.group_name = row.get('group_name')
            task.comments = TaskManager.get_comments(row['id'])
            return task
        return None
    
    @staticmethod
    def get_all(status: Optional[str] = None, assignee_id: Optional[int] = None) -> List[Task]:
        """获取所有任务"""
        query = """SELECT t.*, 
                          a1.name as assigner_name, 
                          a2.name as assignee_name,
                          g.name as group_name
                   FROM tasks t
                   LEFT JOIN agents a1 ON t.assigner_id = a1.id
                   LEFT JOIN agents a2 ON t.assignee_id = a2.id
                   LEFT JOIN groups g ON t.group_id = g.id"""
        params = []
        conditions = []
        
        if status:
            conditions.append("t.status = ?")
            params.append(status)
        if assignee_id:
            conditions.append("t.assignee_id = ?")
            params.append(assignee_id)
        
        if conditions:
            query += " WHERE " + " AND ".join(conditions)
        
        query += " ORDER BY t.created_at DESC"
        
        rows = db.fetch_all(query, tuple(params))
        tasks = []
        for row in rows:
            task = Task(**row)
            task.assigner_name = row.get('assigner_name')
            task.assignee_name = row.get('assignee_name')
            task.group_name = row.get('group_name')
            task.comments = TaskManager.get_comments(row['id'])
            tasks.append(task)
        return tasks
    
    @staticmethod
    def update_status(task_db_id: int, new_status: str, updater_id: int, comment: str = "") -> bool:
        """更新任务状态"""
        valid_status = ['pending', 'in_progress', 'completed', 'cancelled']
        if new_status not in valid_status:
            print(f"无效的状态: {new_status}")
            return False
        
        task = TaskManager.get_by_id(task_db_id)
        if not task:
            return False
        
        completed_at = datetime.now().isoformat() if new_status == 'completed' else None
        
        affected = db.execute(
            "UPDATE tasks SET status = ?, completed_at = ? WHERE id = ?",
            (new_status, completed_at, task_db_id)
        )
        
        if affected > 0:
            # 添加评论记录状态变更
            status_text = {
                'pending': '待处理',
                'in_progress': '进行中',
                'completed': '已完成',
                'cancelled': '已取消'
            }.get(new_status, new_status)
            
            updater = AgentManager.get_by_id(updater_id)
            updater_name = updater.name if updater else f"Agent-{updater_id}"
            
            comment_text = f"状态变更为: {status_text}"
            if comment:
                comment_text += f" | 备注: {comment}"
            
            TaskManager.add_comment(task_db_id, updater_id, comment_text)
            
            # 发送状态变更通知
            content = f"✅ 任务 {task.task_id} 状态更新\n\n**{task.title}**\n新状态: {status_text}"
            if comment:
                content += f"\n备注: {comment}"
            
            MessageManager.send_message(
                from_agent_id=updater_id,
                content=content,
                group_id=task.group_id,
                to_agent_id=task.assignee_id if updater_id != task.assignee_id else task.assigner_id,
                msg_type="task_complete" if new_status == 'completed' else "chat"
            )
            
            return True
        return False
    
    @staticmethod
    def start_task(task_db_id: int, agent_id: int) -> bool:
        """开始任务（状态变为 in_progress）"""
        return TaskManager.update_status(task_db_id, 'in_progress', agent_id, "开始处理任务")
    
    @staticmethod
    def complete_task(task_db_id: int, agent_id: int, result: str = "") -> bool:
        """完成任务"""
        return TaskManager.update_status(task_db_id, 'completed', agent_id, result)
    
    @staticmethod
    def add_comment(task_db_id: int, agent_id: int, comment: str) -> bool:
        """添加任务评论"""
        try:
            db.execute(
                "INSERT INTO task_comments (task_id, agent_id, comment, created_at) VALUES (?, ?, ?, ?)",
                (task_db_id, agent_id, comment, datetime.now().isoformat())
            )
            return True
        except Exception as e:
            print(f"添加评论失败: {e}")
            return False
    
    @staticmethod
    def get_comments(task_db_id: int) -> List[Dict]:
        """获取任务评论"""
        rows = db.fetch_all(
            """SELECT tc.*, a.name as agent_name
               FROM task_comments tc
               JOIN agents a ON tc.agent_id = a.id
               WHERE tc.task_id = ?
               ORDER BY tc.created_at""",
            (task_db_id,)
        )
        return [dict(row) for row in rows]
    
    @staticmethod
    def delete(task_db_id: int) -> bool:
        """删除任务"""
        affected = db.execute("DELETE FROM tasks WHERE id = ?", (task_db_id,))
        return affected > 0
    
    @staticmethod
    def get_agent_tasks(agent_id: int, status: Optional[str] = None) -> List[Task]:
        """获取指定 Agent 的任务列表"""
        return TaskManager.get_all(status=status, assignee_id=agent_id)
    
    @staticmethod
    def format_task_for_display(task: Task) -> str:
        """格式化任务用于显示"""
        priority_emoji = {
            'low': '🔵',
            'normal': '🟡',
            'high': '🟠',
            'urgent': '🔴'
        }.get(task.priority, '⚪')
        
        status_emoji = {
            'pending': '⏳',
            'in_progress': '🔄',
            'completed': '✅',
            'cancelled': '❌'
        }.get(task.status, '⚪')
        
        lines = [
            f"{status_emoji} {priority_emoji} [{task.task_id}] {task.title}",
            f"   指派给: {task.assignee_name} | 来自: {task.assigner_name}",
        ]
        
        if task.description:
            lines.append(f"   描述: {task.description[:50]}{'...' if len(task.description) > 50 else ''}")
        
        if task.due_date:
            lines.append(f"   截止: {task.due_date}")
        
        if task.comments:
            lines.append(f"   💬 {len(task.comments)} 条评论")
        
        return "\n".join(lines)

"""
Agent Network - Multi-Agent Group Chat Collaboration System

A complete multi-agent collaboration platform with group chat, @mentions,
task management, and decision voting.

Example:
    >>> from agent_network import AgentManager, GroupManager, init_default_agents
    >>> from agent_network import get_coordinator
    >>> 
    >>> # Initialize
    >>> init_default_agents()
    >>> 
    >>> # Use coordinator
    >>> coord = get_coordinator()
    >>> coord.register_agent(1)
    >>> coord.send_message(1, "Hello team!", group_id=1)
"""

__version__ = "1.0.0"
__author__ = "Agent Network Team"

# Core imports
from .database import Database, db
from .agent_manager import Agent, AgentManager, init_default_agents
from .group_manager import Group, GroupManager
from .message_manager import Message, MessageManager, MessageType, MessageFormatter
from .task_manager import Task, TaskManager
from .decision_manager import Decision, DecisionManager
from .coordinator import Coordinator, get_coordinator, AgentSession

__all__ = [
    # Version
    "__version__",
    
    # Database
    "Database",
    "db",
    
    # Agent
    "Agent",
    "AgentManager",
    "init_default_agents",
    
    # Group
    "Group",
    "GroupManager",
    
    # Message
    "Message",
    "MessageManager",
    "MessageType",
    "MessageFormatter",
    
    # Task
    "Task",
    "TaskManager",
    
    # Decision
    "Decision",
    "DecisionManager",
    
    # Coordinator
    "Coordinator",
    "get_coordinator",
    "AgentSession",
]

# Constants
DEFAULT_AGENTS = [
    ("老邢", "Manager", "Overall coordination and decision making"),
    ("小邢", "DevOps", "Development and operations"),
    ("小金", "Finance Analyst", "Financial market analysis"),
    ("小陈", "Trader", "Trading execution"),
    ("小影", "Designer", "Design and short video content"),
    ("小视频", "Video Producer", "Video production and editing"),
]