"""
多智能体竞标调度架构 - 核心数据模型
"""

from dataclasses import dataclass, field
from typing import List, Dict, Optional, Any
from enum import Enum
import time
import uuid


class TaskStatus(Enum):
    """任务状态"""
    PENDING = "pending"           # 待发布
    PUBLISHED = "published"        # 已发布，等待竞标
    BIDDING = "bidding"           # 竞标中
    ASSIGNED = "assigned"         # 已分配
    EXECUTING = "executing"       # 执行中
    VALIDATING = "validating"     # 验证中
    RETRY = "retry"              # 重试中
    COMPLETED = "completed"       # 已完成
    FAILED = "failed"            # 已失败
    TERMINATED = "terminated"     # 已终止


class TaskType(Enum):
    """任务类型"""
    SERIAL = "serial"            # 串行任务
    PARALLEL = "parallel"        # 并行任务
    INDEPENDENT = "independent"  # 独立任务


@dataclass
class Task:
    """任务定义"""
    id: str = field(default_factory=lambda: str(uuid.uuid4())[:8])
    type: TaskType = TaskType.INDEPENDENT
    description: str = ""
    input_data: Dict = field(default_factory=dict)
    output_schema: Dict = field(default_factory=dict)
    validation_criteria: Dict = field(default_factory=dict)
    timeout: int = 300            # 超时时间(秒)
    priority: int = 0             # 优先级
    dependencies: List[str] = field(default_factory=list)  # 依赖的任务ID
    status: TaskStatus = TaskStatus.PENDING
    created_at: float = field(default_factory=time.time)
    parent_request_id: Optional[str] = None  # 原始用户请求ID
    
    def to_dict(self) -> Dict:
        return {
            'id': self.id,
            'type': self.type.value,
            'description': self.description,
            'input_data': self.input_data,
            'output_schema': self.output_schema,
            'validation_criteria': self.validation_criteria,
            'timeout': self.timeout,
            'priority': self.priority,
            'dependencies': self.dependencies,
            'status': self.status.value,
            'created_at': self.created_at,
            'parent_request_id': self.parent_request_id
        }


@dataclass
class Bid:
    """竞标书"""
    id: str = field(default_factory=lambda: str(uuid.uuid4())[:8])
    task_id: str = ""
    agent_id: str = ""
    capability_match: float = 0.5   # 能力匹配度 0-1
    estimated_time: int = 60         # 预估完成时间(秒)
    confidence: float = 0.5          # 自信度 0-1
    approach: str = ""               # 方案描述
    prerequisites: List[str] = field(default_factory=list)  # 前置条件
    alternative_approaches: List[str] = field(default_factory=list)
    created_at: float = field(default_factory=time.time)
    
    def to_dict(self) -> Dict:
        return {
            'id': self.id,
            'task_id': self.task_id,
            'agent_id': self.agent_id,
            'capability_match': self.capability_match,
            'estimated_time': self.estimated_time,
            'confidence': self.confidence,
            'approach': self.approach,
            'prerequisites': self.prerequisites,
            'alternative_approaches': self.alternative_approaches,
            'created_at': self.created_at
        }


@dataclass
class Execution:
    """执行记录"""
    id: str = field(default_factory=lambda: str(uuid.uuid4())[:8])
    task_id: str = ""
    agent_id: str = ""
    bid_id: str = ""
    status: str = "running"          # running | completed | failed | timeout
    start_time: float = field(default_factory=time.time)
    end_time: Optional[float] = None
    result: Optional[Any] = None
    error: Optional[str] = None
    retry_count: int = 0
    
    def to_dict(self) -> Dict:
        return {
            'id': self.id,
            'task_id': self.task_id,
            'agent_id': self.agent_id,
            'bid_id': self.bid_id,
            'status': self.status,
            'start_time': self.start_time,
            'end_time': self.end_time,
            'result': self.result,
            'error': self.error,
            'retry_count': self.retry_count
        }


@dataclass
class ValidationResult:
    """验证结果"""
    passed: bool = False
    checks: List[Dict] = field(default_factory=list)
    issues: List[str] = field(default_factory=list)
    score: float = 0.0              # 质量评分
    
    def to_dict(self) -> Dict:
        return {
            'passed': self.passed,
            'checks': self.checks,
            'issues': self.issues,
            'score': self.score
        }


@dataclass
class Attempt:
    """一次完整的尝试记录"""
    id: str = field(default_factory=lambda: str(uuid.uuid4())[:8])
    task_id: str = ""
    agent_id: str = ""
    execution: Optional[Execution] = None
    validation: Optional[ValidationResult] = None
    success: bool = False
    failure_type: Optional[str] = None  # timeout | validation | capability | error
    duration: float = 0.0
    feedback: Optional[str] = None      # 给Agent的反馈
    
    def to_dict(self) -> Dict:
        return {
            'id': self.id,
            'task_id': self.task_id,
            'agent_id': self.agent_id,
            'execution': self.execution.to_dict() if self.execution else None,
            'validation': self.validation.to_dict() if self.validation else None,
            'success': self.success,
            'failure_type': self.failure_type,
            'duration': self.duration,
            'feedback': self.feedback
        }


@dataclass
class AgentProfile:
    """Agent档案"""
    id: str = ""
    name: str = ""
    description: str = ""
    capabilities: List[str] = field(default_factory=list)  # 能力标签
    max_concurrent_tasks: int = 1
    preferred_task_types: List[str] = field(default_factory=list)
    
    # 历史表现
    total_tasks: int = 0
    success_tasks: int = 0
    avg_completion_time: float = 0.0
    avg_quality_score: float = 0.0
    
    @property
    def success_rate(self) -> float:
        if self.total_tasks > 0:
            return self.success_tasks / self.total_tasks
        return 0.0
    
    def to_dict(self) -> Dict:
        return {
            'id': self.id,
            'name': self.name,
            'description': self.description,
            'capabilities': self.capabilities,
            'max_concurrent_tasks': self.max_concurrent_tasks,
            'preferred_task_types': self.preferred_task_types,
            'total_tasks': self.total_tasks,
            'success_tasks': self.success_tasks,
            'avg_completion_time': self.avg_completion_time,
            'avg_quality_score': self.avg_quality_score,
            'success_rate': self.success_rate
        }


@dataclass
class TaskGraph:
    """任务依赖图"""
    tasks: Dict[str, Task] = field(default_factory=dict)
    dependencies: Dict[str, List[str]] = field(default_factory=dict)  # task_id -> [dep_task_ids]
    reverse_deps: Dict[str, List[str]] = field(default_factory=dict)  # task_id -> [dependents]
    
    def add_task(self, task: Task):
        """添加任务"""
        self.tasks[task.id] = task
        self.dependencies[task.id] = task.dependencies
        
        # 更新反向依赖
        for dep_id in task.dependencies:
            if dep_id not in self.reverse_deps:
                self.reverse_deps[dep_id] = []
            self.reverse_deps[dep_id].append(task.id)
    
    def get_ready_tasks(self, completed: set) -> List[Task]:
        """获取当前可执行的任务（依赖已满足）"""
        ready = []
        for task_id, deps in self.dependencies.items():
            if task_id not in completed:
                if all(dep in completed for dep in deps):
                    ready.append(self.tasks[task_id])
        return ready
    
    def get_execution_order(self) -> List[List[Task]]:
        """获取分层执行顺序（每层内的任务可并行）"""
        order = []
        completed = set()
        
        while len(completed) < len(self.tasks):
            ready = self.get_ready_tasks(completed)
            if not ready:
                # 可能存在循环依赖
                remaining = [t for t in self.tasks.values() if t.id not in completed]
                if remaining:
                    # 把剩余任务强行加入（可能有问题）
                    order.append(remaining)
                    completed.update(t.id for t in remaining)
                break
            order.append(ready)
            completed.update(t.id for t in ready)
        
        return order
    
    def to_dict(self) -> Dict:
        return {
            'tasks': {k: v.to_dict() for k, v in self.tasks.items()},
            'dependencies': self.dependencies,
            'reverse_deps': self.reverse_deps
        }


@dataclass
class UserRequest:
    """用户请求"""
    id: str = field(default_factory=lambda: str(uuid.uuid4())[:8])
    content: str = ""
    status: str = "pending"          # pending | processing | completed | failed
    created_at: float = field(default_factory=time.time)
    task_graph: Optional[TaskGraph] = None
    final_result: Optional[Any] = None
    error: Optional[str] = None
    
    def to_dict(self) -> Dict:
        return {
            'id': self.id,
            'content': self.content,
            'status': self.status,
            'created_at': self.created_at,
            'task_graph': self.task_graph.to_dict() if self.task_graph else None,
            'final_result': self.final_result,
            'error': self.error
        }