# 响应时间分解分析
class ResponseTimeAnalyzer:
    def __init__(self, traces):
        self.traces = traces
    
    def analyze_response_time(self):
        """分析响应时间分布"""
        results = {
            'total_time_distribution': [],
            'service_time_breakdown': defaultdict(list),
            'operation_time_breakdown': defaultdict(list)
        }
        
        for trace in self.traces:
            root_span = self.get_root_span(trace)
            if not root_span:
                continue
            
            total_time = root_span['duration']
            results['total_time_distribution'].append(total_time)
            
            # 分解到各个服务
            service_times = self.decompose_by_service(trace)
            for service, time in service_times.items():
                results['service_time_breakdown'][service].append(time)
            
            # 分解到各个操作
            operation_times = self.decompose_by_operation(trace)
            for operation, time in operation_times.items():
                results['operation_time_breakdown'][operation].append(time)
        
        return self.calculate_statistics(results)
    
    def get_root_span(self, trace):
        """获取根Span"""
        spans = trace.get('spans', [])
        for span in spans:
            if 'parentSpanId' not in span:
                return span
        return None
    
    def decompose_by_service(self, trace):
        """按服务分解时间"""
        service_times = defaultdict(int)
        spans = trace.get('spans', [])
        
        for span in spans:
            service = span.get('tags', {}).get('service', 'unknown')
            service_times[service] += span.get('duration', 0)
        
        return service_times
    
    def decompose_by_operation(self, trace):
        """按操作分解时间"""
        operation_times = defaultdict(int)
        spans = trace.get('spans', [])
        
        for span in spans:
            operation = span.get('operationName', 'unknown')
            operation_times[operation] += span.get('duration', 0)
        
        return operation_times
    
    def calculate_statistics(self, results):
        """计算统计信息"""
        stats = {}
        
        # 总时间统计
        total_times = results['total_time_distribution']
        if total_times:
            stats['total_time'] = {
                'avg': sum(total_times) / len(total_times),
                'p50': self.percentile(total_times, 50),
                'p95': self.percentile(total_times, 95),
                'p99': self.percentile(total_times, 99),
                'max': max(total_times)
            }
        
        # 服务时间统计
        service_stats = {}
        for service, times in results['service_time_breakdown'].items():
            service_stats[service] = {
                'total_time': sum(times),
                'avg_time': sum(times) / len(times),
                'count': len(times),
                'percentage': (sum(times) / sum(total_times)) * 100 if total_times else 0
            }
        stats['service_breakdown'] = service_stats
        
        return stats
    
    def percentile(self, data, percentile):
        """计算百分位数"""
        if not data:
            return 0
        sorted_data = sorted(data)
        index = int(len(sorted_data) * percentile / 100)
        return sorted_data[min(index, len(sorted_data) - 1)]