"""
Naive RAG Implementation
Standard retrieve-then-generate pattern.
ADAPTED: Uses Anthropic and FastEmbed.
"""

from typing import List, Dict
from config import config

class NaiveRAG:
    def __init__(self):
        self.qdrant = config.get_qdrant_client()
        self.anthropic = config.get_anthropic_client() # Changed from openai
        self.collection = config.qdrant.collection_name

    def embed_query(self, query: str) -> List[float]:
        """Generate embedding for the query using FastEmbed via config."""
        return config.get_embedding(query)

    def retrieve(self, query: str, limit: int = 5) -> List[Dict]:
        """Retrieve relevant documents from Qdrant."""
        vector = self.embed_query(query)
        
        search_result = self.qdrant.query_points(
            collection_name=self.collection,
            query=vector,
            limit=limit,
            with_payload=True
        ).points
        
        results = []
        for hit in search_result:
            results.append({
                "score": hit.score,
                "content": hit.payload.get("text") or hit.payload.get("content", str(hit.payload)),
                "metadata": hit.payload
            })
        return results

    def generate(self, query: str, context: List[Dict]) -> str:
        """Generate answer based on retrieved context."""
        context_str = "\n\n".join([f"[Source {i+1}]: {c['content']}" for i, c in enumerate(context)])
        
        prompt = f"""
        Answer the user's question using ONLY the context provided below.
        If the context doesn't contain the answer, say "I don't have enough information."
        
        Context:
        {context_str}
        
        Question: {query}
        """
        
        response = self.anthropic.messages.create(
            model=config.llm.model,
            max_tokens=1024,
            messages=[
                {"role": "user", "content": prompt}
            ],
            system="You are a helpful assistant serving as the knowledge interface for the Genesis System."
        )
        return response.content[0].text

    def query(self, query: str) -> Dict:
        """End-to-end RAG pipeline."""
        context = self.retrieve(query)
        answer = self.generate(query, context)
        return {
            "query": query,
            "answer": answer,
            "context": context
        }

if __name__ == "__main__":
    rag = NaiveRAG()