# 需求数据（来自Jira）
requirements = {
    'REQ-001': {
        'title': '用户下单功能',
        'description': '用户可以选择商品并下单购买...',
        'type': 'Story',
        'status': 'Done',
        'acceptance_criteria': [
            '用户可以选择商品',
            '用户可以填写地址',
            '用户可以支付'
        ]
    }
}

# 代码数据（来自GitHub）
code_commits = {
    'commit-abc123': {
        'message': '实现订单创建API',
        'files': ['order_service.py', 'models.py'],
        'author': 'developer@company.com',
        'timestamp': '2025-03-01T10:00:00Z'
    }
}

# 测试数据（来自TestRail）
test_cases = {
    'TEST-001': {
        'title': '验证订单创建成功',
        'steps': [
            '选择商品',
            '填写地址',
            '点击下单'
        ],
        'expected_result': '订单创建成功'
    }
}

# 建立统一数据模型
unified_model = {
    'requirements': requirements,
    'code': code_commits,
    'tests': test_cases
}

class TraceabilityNode:
    """
    可追溯性图中的节点
    可以是需求、代码、测试等
    """
    def __init__(self, id, type, content, metadata):
        self.id = id
        self.type = type  # 'requirement', 'code', 'test', 'design'
        self.content = content
        self.metadata = metadata
        self.embeddings = None  # 语义向量表示
    
    def generate_embedding(self):
        """生成语义向量"""
        text = f"{self.content['title']} {self.content.get('description', '')}"
        self.embeddings = ai_encoder.encode(text)

class TraceabilityGraph:
    """
    可追溯性图
    节点是工件，边是关联关系
    """
    def __init__(self):
        self.nodes = {}  # id -> TraceabilityNode
        self.edges = []  # (source_id, target_id, relation_type, confidence)
    
    def add_node(self, node):
        self.nodes[node.id] = node
    
    def add_edge(self, source_id, target_id, relation_type, confidence):
        self.edges.append((source_id, target_id, relation_type, confidence))
    
    def get_related(self, node_id, relation_type=None):
        """获取关联节点"""
        related = []
        for edge in self.edges:
            if edge[0] == node_id:
                if relation_type is None or edge[2] == relation_type:
                    related.append((self.nodes[edge[1]], edge[2], edge[3]))
        return related

class AIAssociationEngine:
    def __init__(self):
        self.encoder = SentenceTransformer('all-MiniLM-L6-v2')
        self.graph = TraceabilityGraph()
    
    def find_associations(self, requirement, code_candidates):
        """
        为需求找到最可能关联的代码
        """
        # 编码需求
        req_text = f"{requirement['title']} {requirement['description']}"
        req_embedding = self.encoder.encode(req_text)
        
        associations = []
        
        for code in code_candidates:
            # 编码代码
            code_text = f"{code['message']} {' '.join(code['files'])}"
            code_embedding = self.encoder.encode(code_text)
            
            # 计算语义相似度
            similarity = cosine_similarity([req_embedding], [code_embedding])[0][0]
            
            if similarity > 0.7:  # 阈值
                associations.append({
                    'code_id': code['id'],
                    'confidence': similarity,
                    'reason': 'semantic_similarity'
                })
        
        return sorted(associations, key=lambda x: x['confidence'], reverse=True)
    
    def find_test_coverage(self, requirement, test_candidates):
        """
        找到覆盖需求的测试
        """
        req_text = f"{requirement['title']} {' '.join(requirement.get('acceptance_criteria', []))}"
        req_embedding = self.encoder.encode(req_text)
        
        coverage = []
        
        for test in test_candidates:
            test_text = f"{test['title']} {' '.join(test.get('steps', []))}"
            test_embedding = self.encoder.encode(test_text)
            
            similarity = cosine_similarity([req_embedding], [test_embedding])[0][0]
            
            if similarity > 0.6:
                coverage.append({
                    'test_id': test['id'],
                    'confidence': similarity
                })
        
        return coverage

class TraceabilityAnalyzer:
    def __init__(self, graph):
        self.graph = graph
    
    def impact_analysis(self, requirement_id):
        """
        分析需求变更的影响范围
        """
        # 找到关联的代码
        related_code = self.graph.get_related(requirement_id, 'implemented_by')
        
        # 找到关联的测试
        related_tests = self.graph.get_related(requirement_id, 'tested_by')
        
        # 找到下游依赖（这个需求依赖的其他需求）
        downstream = self.graph.get_related(requirement_id, 'depends_on')
        
        return {
            'code_to_update': [c[0].id for c in related_code],
            'tests_to_update': [t[0].id for t in related_tests],
            'downstream_requirements': [d[0].id for d in downstream],
            'impact_score': len(related_code) + len(related_tests)
        }
    
    def coverage_analysis(self):
        """
        分析需求-测试覆盖率
        """
        requirements = [n for n in self.graph.nodes.values() if n.type == 'requirement']
        
        coverage = []
        for req in requirements:
            tests = self.graph.get_related(req.id, 'tested_by')
            coverage.append({
                'requirement_id': req.id,
                'requirement_title': req.content['title'],
                'test_count': len(tests),
                'is_covered': len(tests) > 0,
                'coverage_confidence': sum([t[2] for t in tests]) / len(tests) if tests else 0
            })
        
        return {
            'total_requirements': len(requirements),
            'covered_requirements': sum([1 for c in coverage if c['is_covered']]),
            'coverage_rate': sum([1 for c in coverage if c['is_covered']]) / len(requirements),
            'details': coverage
        }
    
    def generate_compliance_report(self):
        """
        生成合规报告
        """
        coverage = self.coverage_analysis()
        
        report = f"""
# 可追溯性合规报告
生成时间：{datetime.now()}

## 覆盖率统计
- 总需求数：{coverage['total_requirements']}
- 已覆盖需求：{coverage['covered_requirements']}
- 覆盖率：{coverage['coverage_rate']*100:.1f}%

## 未覆盖需求
{chr(10).join([f"- {c['requirement_id']}: {c['requirement_title']}" 
               for c in coverage['details'] if not c['is_covered']])}

## 合规状态
{'✅ 通过' if coverage['coverage_rate'] >= 0.9 else '❌ 未通过（覆盖率低于90%）'}
"""
        return report