from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.schema import Document
from typing import List


def chunk_documents(
    documents: List[Document],
    chunk_size: int = 1000,
    chunk_overlap: int = 200
) -> List[Document]:
    """
    Divide documentos en chunks optimizados para RAG retrieval.

    Args:
        documents: Lista de Document objects
        chunk_size: Tamaño máximo chunk en characters (default 1000)
        chunk_overlap: Overlap entre chunks para preservar contexto (default 200)

    Returns:
        Lista de Document chunks con metadata original preservada
    """
    # RecursiveCharacterTextSplitter respeta estructura natural del texto
    # Prioridad split: \n\n (párrafos) > \n (líneas) > " " (palabras) > "" (caracteres)
    splitter = RecursiveCharacterTextSplitter(
        chunk_size=chunk_size,
        chunk_overlap=chunk_overlap,
        separators=["\n\n", "\n", " ", ""],
        length_function=len
    )

    chunks = splitter.split_documents(documents)

    # Añadir metadata adicional a cada chunk
    for i, chunk in enumerate(chunks):
        chunk.metadata["chunk_id"] = i
        chunk.metadata["chunk_size"] = len(chunk.page_content)

    print(f"✓ Created {len(chunks)} chunks from {len(documents)} documents")
    print(f"  Avg chunk size: {sum([c.metadata['chunk_size'] for c in chunks]) / len(chunks):.0f} chars")

    return chunks


if __name__ == "__main__":
    from app.utils.loaders import load_documents_from_directory

    # Test chunking
    docs = load_documents_from_directory("data/")
    chunks = chunk_documents(docs)

    print(f"\nSample chunk:")
    print(f"Content: {chunks[0].page_content[:300]}...")
    print(f"Metadata: {chunks[0].metadata}")
  

from langchain.embeddings import OpenAIEmbeddings
import RecursiveCharacterTextSplitter
from langchain.vectorstores import Qdrant
from qdrant_client import QdrantClient
from typing import List
from langchain.schema import Document
import os


def create_vectorstore(
    chunks: List[Document],
    collection_name: str = "knowledge_base"
) -> Qdrant:
    """
    Genera embeddings y almacena en Qdrant vector database.

    Args:
        chunks: Lista de Document chunks
        collection_name: Nombre colección Qdrant

    Returns:
        Qdrant vectorstore instance ready para retrieval
    """
    # text-embedding-3-small: best ROI (85% cheaper que large, accuracy similar)
    embeddings = OpenAIEmbeddings(
        model="text-embedding-3-small",
        openai_api_key=os.getenv("OPENAI_API_KEY")
    )

    # Qdrant client (cloud o local)
    qdrant_url = os.getenv("QDRANT_URL", "http://localhost:6333")
    qdrant_api_key = os.getenv("QDRANT_API_KEY", None)

    client = QdrantClient(
        url=qdrant_url,
        api_key=qdrant_api_key
    )

    print(f"Creating embeddings for {len(chunks)} chunks...")
    print(f"Estimated cost: ~${len(chunks) * 500 / 1_000_000 * 0.02:.2f}")

    # Qdrant.from_documents crea collection automáticamente si no existe
    vectorstore = Qdrant.from_documents(
        documents=chunks,
        embedding=embeddings,
        url=qdrant_url,
        api_key=qdrant_api_key,
        collection_name=collection_name,
        force_recreate=True  # Recreate collection si existe (dev only)
    )

    print(f"✓ Vectorstore created with {len(chunks)} vectors")
    print(f"  Collection: {collection_name}")
    print(f"  Dimensions: 1536 (text-embedding-3-small)")

    return vectorstore


if __name__ == "__main__":
    from app.utils.loaders import load_documents_from_directory
    from app.utils.splitters import chunk_documents

    # Pipeline completo
    docs = load_documents_from_directory("data/")
    chunks = chunk_documents(docs)
    vectorstore = create_vectorstore(chunks)

    # Test retrieval
    query = "¿Cómo resetear contraseña?"
    results = vectorstore.similarity_search(query, k=3)

    print(f"\nTest query: '{query}'")
    print(f"Top result: {results[0].page_content[:200]}...")