# Tương tự nhúng cơ bản - những gì mọi người làm sai
def search(query: str):
    query_embedding = embed(query)
    results = vector_db.similarity_search(query_embedding, top_k=10)
    return results

class IntentAnalyzer:
    def __init__(self):
        self.intent_classifier = self.load_intent_model()
        self.entity_extractor = EntityExtractor()
        self.temporal_analyzer = TemporalAnalyzer()

    async def analyze_query(self, query: str) -> QueryIntent:
        # Trích xuất ý định có cấu trúc
        intent_type = await self.intent_classifier.classify(query)
        entities = await self.entity_extractor.extract(query)
        temporal_context = await self.temporal_analyzer.analyze(query)

        return QueryIntent(
            type=intent_type,  # phân tích, tin tức, so sánh, tóm tắt
            entities=entities,  # công ty, người, địa điểm
            temporal_context=temporal_context,  # gần đây, lịch sử, xu hướng
            specificity_score=self.calculate_specificity(query),
            domain_hints=self.extract_domain_hints(query)
        )

class ContextualEmbedding:
    def __init__(self):
        self.domain_models = {
            'finance': FinanceDomainModel(),
            'technology': TechDomainModel(),
            'politics': PoliticsDomainModel()
        }
        self.temporal_weights = TemporalWeighting()

    async def embed_with_context(self, text: str, context: QueryIntent) -> np.ndarray:
        # Chọn mô hình miền cụ thể
        domain_model = self.domain_models.get(
            context.primary_domain, 
            self.default_model
        )

        # Tạo nhúng cơ bản
        base_embedding = await domain_model.embed(text)

        # Áp dụng trọng số tạm thời
        if context.temporal_context.is_time_sensitive:
            temporal_weight = self.temporal_weights.calculate_weight(
                text_timestamp=self.extract_timestamp(text),
                query_time_preference=context.temporal_context.preference
            )
            base_embedding = base_embedding * temporal_weight

        # Tăng cường thực thể - tăng độ phù hợp cho các thực thể khớp
        entity_boost = self.calculate_entity_boost(text, context.entities)

        return base_embedding + entity_boost

class RelevanceScorer:
    def __init__(self):
        self.signals = [
            SemanticSimilaritySignal(),
            EntityMatchingSignal(), 
            TemporalRelevanceSignal(),
            PopularitySignal(),
            QualitySignal(),
            UserContextSignal()
        ]

    async def score_result(self, document: Document, query_intent: QueryIntent, user_context: UserContext) -> float:
        signal_scores = {}

        for signal in self.signals:
            try:
                score = await signal.calculate_score(document, query_intent, user_context)
                weight = self.get_signal_weight(signal.name, query_intent.type)
                signal_scores[signal.name] = score * weight
            except Exception as e:
                # Giảm thiểu sự cố - bỏ qua các tín hiệu thất bại
                signal_scores[signal.name] = 0.0

        # Kết hợp tín hiệu một cách thông minh
        final_score = self.combine_signals(signal_scores, query_intent)

        return final_score

    def combine_signals(self, scores: Dict[str, float], intent: QueryIntent) -> float:
        # Trọng số động dựa trên loại truy vấn
        if intent.type == "factual_lookup":
            return (scores['entity_matching'] * 0.4 + 
                   scores['semantic_similarity'] * 0.3 + 
                   scores['quality'] * 0.3)

        elif intent.type == "trend_analysis":
            return (scores['temporal_relevance'] * 0.4 + 
                   scores['popularity'] * 0.3 + 
                   scores['semantic_similarity'] * 0.3)

        else:
            # Phương pháp cân bằng cho các truy vấn chung
            return np.average(list(scores.values()))

class SemanticSearchEngine:
    def __init__(self):
        self.intent_analyzer = IntentAnalyzer()
        self.contextual_embedding = ContextualEmbedding()
        self.relevance_scorer = RelevanceScorer()
        self.result_diversifier = ResultDiversifier()

    async def search(self, query: str, user_context: UserContext) -> SearchResults:
        # Giai đoạn 1: Hiểu người dùng muốn gì
        query_intent = await self.intent_analyzer.analyze_query(query)

        # Giai đoạn 2: Lấy các ứng viên liên quan đến ngữ cảnh
        query_embedding = await self.contextual_embedding.embed_with_context(
            query, query_intent
        )

        # Đưa ra nhiều ứng viên hơn ban đầu
        candidates = await self.vector_db.similarity_search(
            query_embedding, 
            top_k=100  # Lấy nhiều ứng viên hơn cần thiết
        )

        # Giai đoạn 3: Chấm điểm từng ứng viên với nhiều tín hiệu
        scored_results = []
        for candidate in candidates:
            relevance_score = await self.relevance_scorer.score_result(
                candidate, query_intent, user_context
            )
            scored_results.append((candidate, relevance_score))

        # Giai đoạn 4: Xếp hạng lại và đa dạng hóa
        ranked_results = sorted(scored_results, key=lambda x: x[1], reverse=True)
        diversified_results = await self.result_diversifier.diversify(
            ranked_results, query_intent
        )

        return SearchResults(
            results=diversified_results[:10],
            total_found=len(candidates),
            query_understanding=query_intent,
            search_time_ms=self.timer.elapsed()
        )

class EntityRelationshipGraph:
    def __init__(self):
        self.graph = nx.DiGraph()
        self.relationship_types = [
            'works_for', 'competes_with', 'supplies_to', 
            'influences', 'reports_on', 'similar_to'
        ]

    async def expand_query_entities(self, entities: List[Entity]) -> List[Entity]:
        expanded_entities = entities.copy()

        for entity in entities:
            # Tìm các thực thể liên quan trong 2 cấp độ
            related = self.graph.neighbors(entity.id, depth=2)

            for related_entity in related:
                relationship_strength = self.calculate_relationship_strength(
                    entity, related_entity
                )

                if relationship_strength > 0.7:  # Mối quan hệ mạnh
                    expanded_entities.append(related_entity)

        return expanded_entities