from collections import defaultdict
from mrra.persist.cache import CacheManager, compute_tb_hash

cm = CacheManager()
tb_hash = compute_tb_hash(tb)
acts = cm.load_activities(tb_hash, "default") or acts

# 按用户分组活动
user_groups = defaultdict(list)
for a in sorted(acts, key=lambda r: (r.user_id, r.start)):
    user_groups[a.user_id].append(a)

# 生成链记录
chain_records = []
for uid, seq in user_groups.items():
    for i in range(1, len(seq)):
        prev, cur = seq[i-1], seq[i]
        chain_records.append({
            "user_id": uid,
            "from_place": prev.place_id,
            "to_place": cur.place_id,
            "from_purpose": getattr(prev, "purpose", "Other"),
            "to_purpose": getattr(cur, "purpose", "Other"),
            "at": str(cur.start),
        })

# 缓存结果
cm.save_json(
    tb_hash, 
    "chains_default", 
    {"count": len(chain_records), "records": chain_records[:1000]}, 
    kind="chains"
)

from collections import Counter
import pandas as pd

# 目的转换分析
purpose_transitions = Counter()
location_transitions = Counter()

for record in chain_records:
    purpose_transitions[(record["from_purpose"], record["to_purpose"])] += 1
    location_transitions[(record["from_place"], record["to_place"])] += 1

# 转换为DataFrame进行分析
purpose_df = pd.DataFrame([
    {"from": k[0], "to": k[1], "count": v} 
    for k, v in purpose_transitions.items()
])

print("顶级目的转换:")
print(purpose_df.sort_values("count", ascending=False).head(10))

import pandas as pd

# 转换时间戳用于时间分析
chain_df = pd.DataFrame(chain_records)
chain_df["timestamp"] = pd.to_datetime(chain_df["at"])
chain_df["hour"] = chain_df["timestamp"].dt.hour
chain_df["dow"] = chain_df["timestamp"].dt.dayofweek

# 分析时间模式
temporal_patterns = chain_df.groupby(["hour", "from_purpose", "to_purpose"]).size()
print("峰值转换时间:")
print(temporal_patterns.sort_values(ascending=False).head(10))

from mrra.retriever.graph_rag import GraphRAGGenerate

# 带链上下文的增强检索器
class ChainEnhancedRetriever(GraphRAGGenerate):
    def __init__(self, *args, chain_records=None, **kwargs):
        super().__init__(*args, **kwargs)
        self.chain_records = chain_records or []
    
    def get_recent_chains(self, user_id, purpose=None, limit=5):
        """获取最近的活动链用于上下文"""
        user_chains = [
            c for c in self.chain_records 
            if c["user_id"] == user_id
        ]
        
        if purpose:
            user_chains = [
                c for c in user_chains 
                if purpose in [c["from_purpose"], c["to_purpose"]]
            ]
        
        return sorted(user_chains, key=lambda x: x["at"])[-limit:]
    
    def get_relevant_documents(self, query):
        """带链上下文的增强检索"""
        docs = super().get_relevant_documents(query)
        
        # 如果提供了user_id，添加链上下文
        if "user_id" in query:
            recent_chains = self.get_recent_chains(
                query["user_id"], 
                query.get("purpose")
            )
            
            # 将链上下文添加到第一个文档
            if docs and recent_chains:
                chain_text = f"最近的活动转换: {recent_chains[-3:]}"
                docs[0].page_content = f"{chain_text}\n\n{docs[0].page_content}"
        
        return docs

def validate_prediction_with_chains(prediction, user_chains, current_purpose):
    """根据历史转换模式验证预测"""
    
    # 从链中获取常见的下一个目的
    next_purposes = [
        c["to_purpose"] for c in user_chains 
        if c["from_purpose"] == current_purpose
    ]
    
    if not next_purposes:
        return True  # 没有历史数据，允许预测
    
    # 检查预测目的是否合理
    purpose_frequency = Counter(next_purposes)
    common_purposes = [p for p, count in purpose_frequency.most_common(3)]
    
    predicted_purpose = getattr(prediction, 'purpose', None)
    
    if predicted_purpose and predicted_purpose not in common_purposes:
        # 对不寻常的转换添加置信度惩罚
        confidence_penalty = 0.3
        prediction.confidence *= (1 - confidence_penalty)
        prediction.rationale += f" (不寻常的转换: {current_purpose}→{predicted_purpose})"
    
    return prediction

# 带时间窗口的高效链存储
def store_chains_with_window(chain_records, days_back=30):
    from datetime import datetime, timedelta
    
    cutoff = datetime.now() - timedelta(days=days_back)
    
    recent_chains = [
        c for c in chain_records 
        if datetime.fromisoformat(c["at"]) > cutoff
    ]
    
    return {
        "count": len(recent_chains),
        "records": recent_chains,
        "window_days": days_back,
        "cutoff": cutoff.isoformat()
    }