import asyncio
from openai import AsyncOpenAI

client = AsyncOpenAI()

async def agent_vote(prompt: str, model: str, temperature: float) -> dict:
    """单个Agent独立推理并返回答案+置信度"""
    resp = await client.chat.completions.create(
        model=model,
        messages=[
            {"role": "system", "content": "Answer concisely. End with CONFIDENCE: X%"},
            {"role": "user", "content": prompt}
        ],
        temperature=temperature
    )
    text = resp.choices[0].message.content
    # 提取置信度
    conf = 0.7  # 默认值
    for line in text.split('\n'):
        if 'CONFIDENCE:' in line:
            conf = float(line.split('CONFIDENCE:')[1].strip().replace('%','')) / 100
    return {"answer": text.split('\n')[0], "confidence": conf}

async def weighted_vote(prompt: str, n_agents: int = 5):
    """多Agent加权投票：置信度×历史准确率"""
    # 不同temperature增加多样性
    results = await asyncio.gather(*[
        agent_vote(prompt, "gpt-4o", 0.3 + i * 0.15)
        for i in range(n_agents)
    ])

    # 按答案聚类，累加权重
    from collections import defaultdict
    clusters = defaultdict(float)
    for r in results:
        # 简化：用答案前50字符作为聚类键
        key = r["answer"][:50].strip().lower()
        clusters[key] += r["confidence"]

    # 选出最高加权得分的答案
    winner = max(clusters.items(), key=lambda x: x[1])
    return winner

def adaptive_decision(question: str, agents: list) -> str:
    """自适应决策：先投票，分散度大则触发辩论"""
    votes = [agent.answer(question) for agent in agents]

    # 计算投票分散度
    from collections import Counter
    vote_counts = Counter(v['answer'] for v in votes)
    max_ratio = max(vote_counts.values()) / len(votes)

    if max_ratio >= 0.7:
        # 强共识，直接返回多数票
        return vote_counts.most_common(1)[0][0]
    else:
        # 票数分散，触发辩论
        return debate_round(question, votes, rounds=2)

class EmergenceMonitor:
    """涌现行为监控器——检测异常群体行为"""

    def __init__(self, threshold_variance=0.15):
        self.history = []
        self.threshold = threshold_variance

    def check_collusion_risk(self, agent_outputs: list[str]) -> float:
        """检测串谋风险：输出相似度异常高"""
        from sklearn.metrics.pairwise import cosine_similarity
        embeddings = [self.embed(o) for o in agent_outputs]
        sim_matrix = cosine_similarity(embeddings)

        # 排除对角线，计算平均相似度
        n = len(embeddings)
        avg_sim = (sim_matrix.sum() - n) / (n * (n - 1))

        # 相似度异常高 = 串谋风险
        return min(1.0, max(0, (avg_sim - 0.5) / 0.5))

    def check_cascade_risk(self, round_outputs: list[list[str]]) -> float:
        """检测级联幻觉：错误跨轮次传播"""
        if len(round_outputs) < 2:
            return 0.0
        # 跨轮次相似度增长率
        cross_round_sim = self._cross_similarity(round_outputs)
        return min(1.0, cross_round_sim / self.threshold)

graph TB
    subgraph 六类多Agent故障
        F1[管道延迟<br/>Pipeline Latency]
        F2[级联错误<br/>Cascading Errors]
        F3[上下文污染<br/>Context Pollution]
        F4[Agent死锁<br/>Agent Deadlock]
        F5[成本爆炸<br/>Cost Explosion]
        F6[一致性问题<br/>Consistency Failure]
    end

    F1 --> R1[超时降级<br/>Timeout + Fallback]
    F2 --> R2[语义几何审计<br/>SCCAL]
    F3 --> R3[上下文隔离<br/>Context Sandboxing]
    F4 --> R4[心跳检测<br/>Heartbeat + Watchdog]
    F5 --> R5[Token预算<br/>Token Budget Guard]
    F6 --> R6[向量一致性校验<br/>Embedding Consistency]

    style F1 fill:#ff6b6b,color:#fff
    style F2 fill:#ff6b6b,color:#fff
    style F3 fill:#ffa502,color:#fff
    style F4 fill:#ffa502,color:#fff
    style F5 fill:#7bed9f,color:#333
    style F6 fill:#7bed9f,color:#333

graph LR
    A[Agent-1<br/>数据收集] -->|raw_data| B[Agent-2<br/>数据清洗]
    B -->|clean_data| C[Agent-3<br/>特征提取]
    B -->|quality_report| D[Agent-4<br/>质量检查]
    C -->|features| E[Agent-5<br/>模型推理]
    D -->|qa_flag| E
    E -->|prediction| F[❌ 错误输出]

    style F fill:#ff4757,color:#fff
    style B fill:#ffa502,color:#fff
    style D fill:#ffa502,color:#fff

    B -.->|根因：清洗逻辑<br/>遗漏空值处理| F

class Beacon:
    """Symphony信标：去中心化任务协调"""

    def __init__(self, task_type: str, required_skills: list[str]):
        self.task_type = task_type
        self.required_skills = required_skills
        self.claimed = False
        self.result = None

    def broadcast(self, agent_pool: list):
        """广播信标到所有Agent"""
        for agent in agent_pool:
            if agent.has_skills(self.required_skills):
                agent.receive_beacon(self)

    def claim(self, agent) -> bool:
        """Agent竞争性认领任务"""
        if not self.claimed:
            self.claimed = True
            self.claimed_by = agent.id
            return True
        return False

class SymphonyAgent:
    def __init__(self, id: str, skills: list[str]):
        self.id = id
        self.skills = set(skills)
        self.inbox = []

    def has_skills(self, required: list[str]) -> bool:
        return set(required).issubset(self.skills)

    def receive_beacon(self, beacon: Beacon):
        self.inbox.append(beacon)

    async def process_beacons(self):
        """处理收到的信标，竞争认领"""
        for beacon in self.inbox:
            if beacon.claim(self):
                result = await self.execute(beacon)
                beacon.result = result
                beacon.broadcast_result()  # 发布结果供下游消费

graph TD
    START[多个Agent给出不同答案] --> Q1{任务类型?}

    Q1 -->|有客观正确答案<br/>数学/代码/事实| VOTE[多数投票<br/>+ 置信度加权]
    Q1 -->|开放性判断<br/>伦理/策略/创意| Q2{错误代价?}
    Q1 -->|资源分配<br/>任务分工/定价| NEG[协商机制<br/>VCG/市场机制]

    Q2 -->|"高（医疗/法律）"| DEBATE[辩论+投票<br/>2轮辩论后投票]
    Q2 -->|"低（推荐/分类）"| VOTE

    VOTE --> Q3{投票分散度?}
    Q3 -->|≥70%共识| DONE[输出结果]
    Q3 -->|<70%分散| DEBATE_2[触发1轮辩论<br/>后重新投票]

    DEBATE --> DONE
    NEG --> DONE
    DEBATE_2 --> DONE

    DONE --> MONITOR[涌现监控<br/>串谋/级联检测]
    MONITOR -->|正常| END[✅ 完成]
    MONITOR -->|异常| ALERT[⚠️ 告警<br/>人工介入]

    style START fill:#4ecdc4,color:#fff
    style DONE fill:#45b7d1,color:#fff
    style ALERT fill:#ff6b6b,color:#fff
    style END fill:#7bed9f,color:#333