# 钉钉机器人监听群消息的简化示例
from dingtalk_stream import AckMessage, ChatbotHandler

class VOCCollector(ChatbotHandler):
    async def process(self, callback):
        message = callback.data
        
        # 过滤：只采集客户消息，忽略内部员工
        if self.is_internal_user(message.sender_id):
            return AckMessage.STATUS_OK
        
        # 标准化写入
        voc_record = {
            "source": "dingtalk_group",
            "source_id": message.message_id,
            "timestamp": message.create_at,
            "content": {"raw_text": message.text.content},
            "metadata": {
                "group_id": message.conversation_id,
                "group_name": message.conversation_title
            }
        }
        
        await self.save_to_db(voc_record)
        return AckMessage.STATUS_OK

FILTER_PROMPT = """
你是一个 VOC（用户声音）分析专家。判断以下消息是否包含有价值的产品反馈。

有价值的反馈包括：功能建议、Bug 报告、使用困难、体验抱怨、竞品对比、流失预警。
无价值的包括：闲聊、问好、纯操作指令、已有答案的咨询。

消息内容：
{message}

请用 JSON 返回：
{
  "is_feedback": true/false,
  "confidence": 0.0-1.0,
  "reason": "简要说明"
}
"""

EXTRACT_PROMPT = """
分析以下用户反馈，提取结构化信息：

反馈内容：{feedback}
客户信息：{customer_context}

请返回 JSON：
{
  "intent": "feature_request|bug_report|usability_issue|performance|churn_risk|praise",
  "sentiment": "positive|neutral|negative|urgent",
  "severity": 1-5,
  "product_area": "具体功能模块",
  "summary": "一句话概括",
  "user_pain": "用户真正的痛点是什么",
  "desired_outcome": "用户期望的结果",
  "frequency_hint": "这个问题出现频率的线索",
  "business_impact": "对客户业务的影响",
  "tags": ["标签1", "标签2"]
}
"""

import numpy as np
from sklearn.cluster import DBSCAN

async def cluster_feedbacks(feedbacks, embeddings_model):
    # 1. 生成 embedding
    texts = [f["summary"] + " " + f["user_pain"] for f in feedbacks]
    embeddings = await embeddings_model.encode(texts)
    
    # 2. DBSCAN 聚类（不需要预设簇数）
    clustering = DBSCAN(eps=0.3, min_samples=3, metric='cosine')
    labels = clustering.fit_predict(embeddings)
    
    # 3. 为每个簇生成主题摘要
    clusters = {}
    for i, label in enumerate(labels):
        if label == -1:  # 噪音点，单独处理
            continue
        if label not in clusters:
            clusters[label] = []
        clusters[label].append(feedbacks[i])
    
    # 4. 用 LLM 为每个簇生成结构化需求
    for label, items in clusters.items():
        cluster_summary = await generate_cluster_summary(items)
        clusters[label] = {
            "feedbacks": items,
            "count": len(items),
            "summary": cluster_summary
        }
    
    return clusters

def calculate_priority(cluster):
    """
    优先级 = 频次权重 × 严重性 × 客户价值 × 时效性
    """
    # 频次：同类反馈数量
    freq_score = min(cluster["count"] / 10, 1.0) * 30
    
    # 严重性：平均 severity
    severity_score = np.mean([f["severity"] for f in cluster["feedbacks"]]) * 20
    
    # 客户价值：涉及大客户加权
    enterprise_count = sum(1 for f in cluster["feedbacks"] 
                          if f["customer"]["tier"] == "enterprise")
    value_score = min(enterprise_count / 3, 1.0) * 30
    
    # 时效性：最近 7 天的反馈占比
    recent = sum(1 for f in cluster["feedbacks"] 
                 if f["age_days"] <= 7)
    recency_score = (recent / cluster["count"]) * 20
    
    return freq_score + severity_score + value_score + recency_score

BACKLOG_PROMPT = """
基于以下聚类分析结果，生成一个产品需求 Backlog 条目。

聚类主题：{cluster_summary}
相关反馈数量：{count}
优先级得分：{priority_score}
代表性原始反馈：
{sample_feedbacks}

请生成：
{
  "title": "需求标题（简洁、可执行）",
  "description": "需求描述",
  "user_stories": ["作为...我希望...以便于..."],
  "acceptance_criteria": ["验收标准1", "验收标准2"],
  "priority": "P0|P1|P2|P3",
  "estimated_impact": "影响评估",
  "evidence": "数据支撑（反馈数、客户分布等）",
  "source_feedback_ids": ["id1", "id2"]
}
"""

async def create_backlog_item(item, tool="jira"):
    if tool == "jira":
        await jira_client.create_issue(
            project="PROD",
            issue_type="Story",
            summary=item["title"],
            description=format_jira_description(item),
            priority=item["priority"],
            labels=["voc-auto-generated"]
        )
    elif tool == "linear":
        await linear_client.create_issue(...)
    elif tool == "dingtalk":
        await dingtalk_client.create_task(...)

ALERT_RULES = [
    {
        "name": "churn_risk",
        "condition": lambda f: f["intent"] == "churn_risk" and f["customer"]["tier"] == "enterprise",
        "channel": "dingtalk_urgent",
        "message_template": "⚠️ 流失预警：{customer_name}（{industry}）表示：{summary}"
    },
    {
        "name": "critical_bug",
        "condition": lambda f: f["intent"] == "bug_report" and f["severity"] >= 4,
        "channel": "oncall_group",
        "message_template": "🔴 严重 Bug 反馈：{summary}（来自 {customer_name}）"
    },
    {
        "name": "trending_spike",
        "condition": lambda cluster: cluster["count"] >= 20 and cluster["age_hours"] <= 24,
        "channel": "product_team",
        "message_template": "📈 反馈激增：{summary}（24h 内 {count} 条）"
    }
]

WEEKLY_REPORT_PROMPT = """
基于本周的 VOC 数据，生成周报：

本周数据概览：
- 总反馈数：{total}
- 新增聚类主题：{new_clusters}
- Top 5 主题及数量：{top_themes}
- 情感分布：{sentiment_dist}
- 与上周对比变化：{week_over_week}

请生成一份结构清晰的周报，包含：
1. 本周关键发现（3-5 条）
2. 需要立即关注的问题
3. 正面反馈亮点
4. 趋势变化分析
5. 建议行动项
"""

import asyncio
from datetime import datetime, timedelta

async def voc_pipeline():
    """VOC 自动化生产线 - 主流程"""
    
    # 1. 拉取未处理的原始反馈
    raw_feedbacks = await db.query(
        "SELECT * FROM voc_raw WHERE processed = false ORDER BY timestamp"
    )
    print(f"待处理反馈：{len(raw_feedbacks)} 条")
    
    # 2. AI 过滤：识别有价值的反馈
    valid_feedbacks = []
    for batch in chunks(raw_feedbacks, 20):  # 批量处理，省 token
        results = await llm.batch_classify(batch, FILTER_PROMPT)
        valid_feedbacks.extend(
            [f for f, r in zip(batch, results) if r["is_feedback"]]
        )
    print(f"有效反馈：{len(valid_feedbacks)} 条")
    
    # 3. AI 提取：结构化分析
    structured = []
    for batch in chunks(valid_feedbacks, 10):
        extracted = await llm.batch_extract(batch, EXTRACT_PROMPT)
        structured.extend(extracted)
    
    # 4. 实时告警检查
    for item in structured:
        await check_and_alert(item, ALERT_RULES)
    
    # 5. 写入已处理表
    await db.bulk_insert("voc_processed", structured)
    
    # 6. 每天执行一次聚类 + Backlog 生成
    if should_run_daily():
        recent = await db.query(
            "SELECT * FROM voc_processed WHERE timestamp > NOW() - INTERVAL '30 days'"
        )
        clusters = await cluster_feedbacks(recent)
        
        for cluster in clusters.values():
            cluster["priority"] = calculate_priority(cluster)
        
        # 按优先级排序，Top N 生成 Backlog
        top_clusters = sorted(clusters.values(), 
                            key=lambda c: c["priority"], reverse=True)[:10]
        
        for cluster in top_clusters:
            if not await backlog_exists(cluster):
                backlog_item = await llm.generate(BACKLOG_PROMPT, cluster)
                await create_backlog_item(backlog_item)
                print(f"已创建 Backlog：{backlog_item['title']}")
    
    # 7. 标记已处理
    await db.update(
        "voc_raw", 
        {"processed": True}, 
        {"id__in": [f["id"] for f in raw_feedbacks]}
    )

# 入口
if __name__ == "__main__":
    asyncio.run(voc_pipeline())

# 需求上线后的闭环通知
async def notify_feedback_resolved(backlog_item):
    source_ids = backlog_item["source_feedback_ids"]
    feedbacks = await db.query(
        "SELECT * FROM voc_processed WHERE id = ANY($1)", source_ids
    )
    
    for feedback in feedbacks:
        await notification.send(
            channel=feedback["source"],
            customer=feedback["customer"],
            message=f"您之前反馈的「{feedback['summary']}」已在最新版本中改进，感谢您的建议！"
        )

QUALITY_METRICS = {
    "filter_precision": "被标记为反馈的消息中，真正是反馈的比例",
    "filter_recall": "所有真实反馈中，被正确识别的比例",
    "extraction_accuracy": "提取的结构化信息与人工标注的一致性",
    "cluster_coherence": "同一聚类内反馈的相关性评分"
}