class PerformanceTargets:
    def __init__(self):
        self.targets = {
            'response_time': {'p50': 500, 'p95': 2000, 'p99': 5000},
            'throughput': {'qps': 1000, 'concurrent_users': 500},
            'resource_efficiency': {'cpu_utilization': 0.8, 'cache_hit_rate': 0.85}
        }
    
    def evaluate_performance(self, metrics: Dict) -> Dict:
        """评估性能指标达成情况"""
        evaluation = {}
        for category, targets in self.targets.items():
            category_score = 0
            for metric, target in targets.items():
                actual = metrics.get(category, {}).get(metric, 0)
                score = max(0, 1 - (actual - target) / target) if category == 'response_time' else min(1, actual / target)
                category_score += score
            evaluation[category] = {'overall_score': category_score / len(targets)}
        return evaluation

class OptimizedHNSW:
    def __init__(self, space='cosine', max_connections=16, ef_construction=200):
        self.space = space
        self.max_connections = max_connections
        self.layers = []
        self.entry_point = None
        self.distance_cache = {}  # 距离计算缓存优化
    
    def _calculate_distance(self, vec1: np.ndarray, vec2: np.ndarray) -> float:
        """带缓存的距离计算"""
        cache_key = (id(vec1), id(vec2))
        if cache_key in self.distance_cache:
            return self.distance_cache[cache_key]
        distance = 1 - np.dot(vec1, vec2) / (np.linalg.norm(vec1) * np.linalg.norm(vec2))
        self.distance_cache[cache_key] = distance
        return distance

class HNSWIndexBuilder:
    def __init__(self, hnsw_index: OptimizedHNSW):
        self.index = hnsw_index
        self.build_statistics = {'total_time': 0, 'insertion_times': []}
    
    def build_index_optimized(self, vectors: np.ndarray, batch_size: int = 1000):
        """分批构建索引，避免内存压力"""
        start_time = time.time()
        for batch_start in range(0, len(vectors), batch_size):
            batch_end = min(batch_start + batch_size, len(vectors))
            self._batch_insert(vectors[batch_start:batch_end], batch_start)
            print(f"索引构建进度: {batch_end / len(vectors) * 100:.1f}%")
        self.build_statistics['total_time'] = time.time() - start_time
        return self.build_statistics

class MultiLevelCacheSystem:
    def __init__(self, config: Dict):
        # L1内存缓存 + L2Redis缓存 + L3持久化缓存
        self.l1_cache = {}
        self.l2_cache = redis.Redis(host=config.get('redis_host', 'localhost'))
        self.l3_cache = PersistentCache(config.get('l3_config', {}))
        self.cache_stats = {'l1_hits': 0, 'l2_hits': 0, 'l3_hits': 0}
    
    def get(self, key: str) -> Optional[Any]:
        """多级缓存获取：L1 -> L2 -> L3"""
        cache_key = hashlib.md5(key.encode()).hexdigest()
        
        # L1缓存检查
        if cache_key in self.l1_cache:
            self.cache_stats['l1_hits'] += 1
            return self.l1_cache[cache_key]
        
        # L2缓存检查并提升到L1
        l2_result = self.l2_cache.get(cache_key)
        if l2_result:
            self.cache_stats['l2_hits'] += 1
            return json.loads(l2_result)
        return None

class QueryResultCache:
    def __init__(self, cache_system: MultiLevelCacheSystem):
        self.cache_system = cache_system
        self.semantic_similarity_threshold = 0.95
        
    def get_cached_result(self, query: str, user_context: Dict = None) -> Optional[Dict]:
        """多层次缓存获取：精确匹配 -> 语义相似"""
        cache_key = self._generate_cache_key(query, user_context)
        exact_result = self.cache_system.get(cache_key)
        if exact_result:
            return {'result': exact_result, 'cache_type': 'exact_match', 'confidence': 1.0}
        return None
    
    def _analyze_query_pattern(self, query: str) -> Dict:
        """查询模式识别：问题类型、复杂度"""
        patterns = {'question_type': 'definition' if any(word in query for word in ['什么', '如何']) else 'explanation'}
        patterns['complexity'] = 'simple' if len(query) < 10 else 'complex' if len(query) > 50 else 'medium'
        return patterns

class BatchRAGProcessor:
    def __init__(self, config: Dict):
        self.batch_size = config.get('batch_size', 8)
        self.batch_timeout = config.get('batch_timeout', 100)  # ms
        self.pending_requests = []
        self.performance_metrics = {'total_requests': 0, 'avg_response_time': 0}
    
    async def process_batch_queries(self, queries: List[str]) -> List[Dict]:
        """批量查询处理：减少模型调用次数，提升GPU利用率"""
        # 1. 批量向量检索
        batch_vectors = await self._batch_vector_retrieval(queries)
        
        # 2. 批量LLM推理（关键优化点）
        batch_contexts = [self._build_context(q, v) for q, v in zip(queries, batch_vectors)]
        batch_answers = await self._batch_llm_inference(batch_contexts)
        
        return [{'query': q, 'answer': a} for q, a in zip(queries, batch_answers)]
    
    def _build_context(self, query: str, vectors: List[Dict]) -> str:
        """构建单个查询的上下文"""
        context_docs = "\n".join([doc['content'] for doc in vectors[:3]])
        return f"文档内容：{context_docs}\n用户问题：{query}"

class LoadBalancer:
    def __init__(self, worker_configs: List[Dict]):
        self.workers = [RAGWorker(config) for config in worker_configs]
        self.worker_stats = {w.worker_id: {'active_connections': 0, 'health_status': 'healthy'} 
                            for w in self.workers}
    
    async def route_request(self, request: Dict) -> Dict:
        """智能路由：选择最优节点→处理请求→更新统计"""
        selected_worker = self._select_worker()
        if not selected_worker:
            return {'error': '无可用工作节点'}
        self.worker_stats[selected_worker.worker_id]['active_connections'] += 1
        return await selected_worker.process_request(request)

class ProductQuantizer:
    def __init__(self, dimension: int, num_subvectors: int = 8, num_centroids: int = 256):
        self.dimension = dimension
        self.num_subvectors = num_subvectors
        self.subvector_dimension = dimension // num_subvectors
        self.codebooks = None
        
    def train(self, training_vectors: np.ndarray):
        """PQ训练：分割子空间→K-means聚类→生成codebook"""
        self.codebooks = []
        for i in range(self.num_subvectors):
            start_dim = i * self.subvector_dimension
            subvectors = training_vectors[:, start_dim:start_dim + self.subvector_dimension]
            centroids = self._kmeans_clustering(subvectors, self.num_centroids)
            self.codebooks.append(centroids)
    
    def encode(self, vectors: np.ndarray) -> np.ndarray:
        """向量编码：分割→查找最近聚类中心→生成PQ码"""
        codes = np.zeros((vectors.shape[0], self.num_subvectors), dtype=np.uint8)
        for i in range(self.num_subvectors):
            distances = np.sqrt(((vectors[:, i*self.subvector_dimension:(i+1)*self.subvector_dimension][:, np.newaxis, :] - self.codebooks[i])**2).sum(axis=2))
            codes[:, i] = np.argmin(distances, axis=1)
        return codes

class StorageOptimizedVectorDB:
    def __init__(self, config: Dict):
        self.hot_storage = {}   # 内存：高成本高速度
        self.warm_storage = {}  # SSD：中成本中速度  
        self.cold_storage = {}  # 归档：低成本低速度
        self.hot_threshold = 1000   # 热数据阈值
        
    def optimize_storage_cost(self, vectors: np.ndarray, access_patterns: Dict):
        """智能分层存储：访问模式分析→成本计算→存储优化"""
        hot_vectors, warm_vectors, cold_vectors = self._classify_by_access(vectors, access_patterns)
        storage_plan = {
            'hot_storage': {'vectors': hot_vectors, 'compression': False, 'cost_per_gb': 100},
            'warm_storage': {'vectors': warm_vectors, 'compression': True, 'cost_per_gb': 10},
            'cold_storage': {'vectors': cold_vectors, 'compression': True, 'cost_per_gb': 1}
        }
        cost_analysis = self._calculate_storage_costs(storage_plan)
        return storage_plan, cost_analysis