#!/usr/bin/env python3
"""
多源交叉验证工具
遵循"真实溯源"与"多源验证"原则
"""

import json
import sys
from typing import Dict, List, Any, Set
from collections import defaultdict

class MultiSourceVerifier:
    """多源信息交叉验证"""

    def __init__(self, min_sources: int = 2):
        self.min_sources = min_sources
        self.verification_log = []

    def verify(self, items: List[Dict[str, Any]]) -> Dict[str, Any]:
        """
        对多条信息进行交叉验证

        Args:
            items: 待验证的信息列表，每条应包含 content, source, url 等

        Returns:
            验证报告
        """
        # 提取关键实体（简化版：基于文本相似度）
        # 实际应用中应使用 NER（命名实体识别）+ 相似度计算

        clusters = self._cluster_similar_items(items)

        verification_results = []
        for cluster in clusters:
            result = self._verify_cluster(cluster)
            verification_results.append(result)

        return {
            "clusters": verification_results,
            "summary": self._generate_summary(verification_results),
            "metadata": {
                "verifier": "瞰宇-MultiSourceVerifier",
                "version": "1.0",
                "min_sources_required": self.min_sources
            }
        }

    def _cluster_similar_items(self, items: List[Dict]) -> List[List[Dict]]:
        """
        将相似信息聚类

        简化实现：基于标题或关键字匹配
        生产环境应使用文本相似度算法（如 TF-IDF + cosine similarity）
        """
        clusters = []
        used_indices = set()

        for i, item in enumerate(items):
            if i in used_indices:
                continue

            cluster = [item]
            used_indices.add(i)

            # 查找相似项
            for j, other_item in enumerate(items):
                if j > i and j not in used_indices:
                    similarity = self._calculate_similarity(item, other_item)
                    if similarity > 0.7:  # 相似度阈值
                        cluster.append(other_item)
                        used_indices.add(j)

            clusters.append(cluster)

        return clusters

    def _calculate_similarity(self, item1: Dict, item2: Dict) -> float:
        """
        计算两条信息的相似度

        简化实现：基于标题重合度
        """
        title1 = item1.get("title", "").lower()
        title2 = item2.get("title", "").lower()

        if not title1 or not title2:
            return 0.0

        # 简单的词重叠计算
        words1 = set(title1.split())
        words2 = set(title2.split())
        intersection = words1 & words2
        union = words1 | words2

        return len(intersection) / len(union) if union else 0.0

    def _verify_cluster(self, cluster: List[Dict]) -> Dict[str, Any]:
        """
        验证一个信息簇
        """
        source_count = len(cluster)
        sources = [item.get("source", "unknown") for item in cluster]
        urls = [item.get("url", "") for item in cluster]

        # 合规性检查
        all_public = all(item.get("access_type", "public") == "public" for item in cluster)

        # 交叉验证结果
        verification = {
            "cluster_id": self._generate_cluster_id(cluster),
            "item_count": source_count,
            "sources": sources,
            "urls": urls,
            "verified": source_count >= self.min_sources,
            "consistency_score": self._calculate_consistency(cluster),
            "all_sources_public": all_public,
            "sample_content": cluster[0].get("title", "") if cluster else ""
        }

        return verification

    def _generate_cluster_id(self, cluster: List[Dict]) -> str:
        """生成簇ID"""
        if not cluster:
            return "empty"
        # 使用第一个URL作为基础ID的简化实现
        return f"cluster_{hash(cluster[0].get('url', '')) % 10000}"

    def _calculate_consistency(self, cluster: List[Dict]) -> float:
        """
        计算簇内信息一致性评分

        简化实现：基于来源多样性
        """
        unique_sources = len(set(item.get("source", "") for item in cluster))
        total_items = len(cluster)

        # 来源多样性越高，一致性评分可能越低（表示不同来源报道同一事件）
        # 但这里我们定义"一致性"为信息的可信度
        return min(1.0, unique_sources / self.min_sources) if total_items > 0 else 0.0

    def _generate_summary(self, results: List[Dict]) -> Dict[str, Any]:
        """生成验证摘要"""
        verified_count = sum(1 for r in results if r["verified"])
        total_count = len(results)

        return {
            "total_clusters": total_count,
            "verified_clusters": verified_count,
            "verification_rate": verified_count / total_count if total_count > 0 else 0.0,
            "min_sources_met": all(r["item_count"] >= self.min_sources for r in results)
        }

def main():
    """命令行接口"""
    if len(sys.argv) < 2:
        print("Usage: verify.py <input_json>")
        sys.exit(1)

    with open(sys.argv[1], 'r', encoding='utf-8') as f:
        data = json.load(f)

    verifier = MultiSourceVerifier(min_sources=2)
    result = verifier.verify(data.get("items", []))

    print(json.dumps(result, indent=2, ensure_ascii=False))

if __name__ == "__main__":
    main()