class CriticalPathAnalyzer:
    def __init__(self, system_architecture):
        self.architecture = system_architecture
        self.performance_model = self.build_performance_model()
    
    def identify_critical_paths(self):
        """识别系统关键路径"""
        critical_paths = []
        
        # 分析数据流路径
        for data_flow in self.architecture.data_flows:
            path_latency = self.calculate_path_latency(data_flow)
            path_throughput = self.calculate_path_throughput(data_flow)
            
            # 判断是否为关键路径
            if self.is_critical_path(path_latency, path_throughput):
                critical_paths.append({
                    'path': data_flow,
                    'latency': path_latency,
                    'throughput': path_throughput,
                    'bottleneck_components': self.find_bottleneck_components(data_flow)
                })
        
        return critical_paths
    
    def calculate_path_latency(self, data_flow):
        """计算路径延迟"""
        total_latency = 0
        for component in data_flow.components:
            component_latency = self.get_component_latency(component)
            total_latency += component_latency
        
        return total_latency
    
    def find_bottleneck_components(self, data_flow):
        """找出路径中的瓶颈组件"""
        bottleneck_components = []
        max_latency = 0
        
        for component in data_flow.components:
            component_latency = self.get_component_latency(component)
            if component_latency > max_latency:
                max_latency = component_latency
                bottleneck_components = [component]
            elif component_latency == max_latency:
                bottleneck_components.append(component)
        
        return bottleneck_components

class SmallFileMerger:
    def __init__(self, chunk_size=4*1024*1024):  # 4MB chunks
        self.chunk_size = chunk_size
        self.merged_files = {}
    
    def merge_small_files(self, small_files, target_container):
        """将小文件合并为大文件"""
        merged_data = bytearray()
        file_index = []
        current_offset = 0
        
        for file_info in small_files:
            # 读取小文件内容
            file_content = self.read_file(file_info.path)
            
            # 记录文件在合并文件中的位置信息
            file_entry = {
                'name': file_info.name,
                'offset': current_offset,
                'size': len(file_content),
                'metadata': file_info.metadata
            }
            file_index.append(file_entry)
            
            # 添加到合并数据中
            merged_data.extend(file_content)
            current_offset += len(file_content)
            
            # 如果合并数据达到chunk大小，写入存储
            if len(merged_data) >= self.chunk_size:
                self.write_merged_chunk(merged_data, file_index, target_container)
                merged_data = bytearray()
                file_index = []
                current_offset = 0
        
        # 处理剩余数据
        if len(merged_data) > 0:
            self.write_merged_chunk(merged_data, file_index, target_container)
    
    def write_merged_chunk(self, data, index, container):
        """写入合并后的数据块"""
        chunk_id = self.generate_chunk_id()
        chunk_metadata = {
            'id': chunk_id,
            'size': len(data),
            'files': index,
            'created_at': datetime.now()
        }
        
        # 写入数据
        self.storage_client.write_data(container, f"chunk_{chunk_id}", data)
        
        # 写入元数据
        self.metadata_store.save_chunk_metadata(chunk_metadata)

class ClusterTopologyView:
    def __init__(self, cluster_manager):
        self.cluster_manager = cluster_manager
        self.nodes = []
        self.connections = []
    
    def render_topology(self):
        """渲染集群拓扑图"""
        cluster_info = self.cluster_manager.get_cluster_info()
        
        # 构建节点信息
        for node in cluster_info['nodes']:
            node_info = {
                'id': node['id'],
                'name': node['name'],
                'status': node['status'],
                'role': node['role'],
                'ip': node['ip'],
                'capacity': node['capacity'],
                'used': node['used'],
                'health': node['health_score']
            }
            self.nodes.append(node_info)
        
        # 构建连接关系
        for connection in cluster_info['connections']:
            self.connections.append({
                'source': connection['source_node'],
                'target': connection['target_node'],
                'bandwidth': connection['bandwidth'],
                'latency': connection['latency'],
                'status': connection['status']
            })
        
        return self.generate_topology_html()
    
    def generate_topology_html(self):
        """生成拓扑图HTML"""
        html = """
        <div id="cluster-topology" style="width: 100%; height: 600px;">
            <svg width="100%" height="100%">
        """
        
        # 绘制节点
        for i, node in enumerate(self.nodes):
            x = 100 + (i % 5) * 200
            y = 100 + (i // 5) * 150
            
            color = self.get_node_color(node['status'])
            html += f"""
                <circle cx="{x}" cy="{y}" r="30" fill="{color}" stroke="#333" stroke-width="2"/>
                <text x="{x}" y="{y+5}" text-anchor="middle" font-size="12">{node['name']}</text>
                <text x="{x}" y="{y+20}" text-anchor="middle" font-size="10">{node['status']}</text>
            """
        
        # 绘制连接线
        for conn in self.connections:
            source_node = next(n for n in self.nodes if n['id'] == conn['source'])
            target_node = next(n for n in self.nodes if n['id'] == conn['target'])
            
            line_color = "#4caf50" if conn['status'] == 'healthy' else "#f44336"
            html += f"""
                <line x1="{source_node['x']}" y1="{source_node['y']}" 
                      x2="{target_node['x']}" y2="{target_node['y']}" 
                      stroke="{line_color}" stroke-width="2"/>
            """
        
        html += """
            </svg>
        </div>
        """
        return html
    
    def get_node_color(self, status):
        """根据节点状态返回颜色"""
        color_map = {
            'online': '#4caf50',    # 绿色
            'offline': '#f44336',   # 红色
            'maintenance': '#ff9800' # 橙色
        }
        return color_map.get(status, '#9e9e9e')  # 灰色默认