from fastapi import FastAPI, UploadFile, File, Form, HTTPException
from fastapi.responses import JSONResponse
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel
from typing import Optional, List, Dict
from PIL import Image
import io
import numpy as np
import os
from datetime import datetime
from pymongo import MongoClient
from huggingface_hub import InferenceClient

from embedding_service import JinaClipEmbeddingService
from qdrant_service import QdrantVectorService
from advanced_rag import AdvancedRAG
from cag_service import CAGService
from pdf_parser import PDFIndexer
from multimodal_pdf_parser import MultimodalPDFIndexer
from conversation_service import ConversationService
from tools_service import ToolsService

# Initialize FastAPI app
app = FastAPI(
    title="Event Social Media Embeddings & ChatbotRAG API",
    description="API để embeddings, search và ChatbotRAG với Jina CLIP v2 + Qdrant + MongoDB + LLM",
    version="2.0.0"
)

# CORS middleware
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# Initialize services
print("Initializing services...")
embedding_service = JinaClipEmbeddingService(model_path="jinaai/jina-clip-v2")

collection_name = os.getenv("COLLECTION_NAME", "event_social_media")
qdrant_service = QdrantVectorService(
    collection_name=collection_name,
    vector_size=embedding_service.get_embedding_dimension()
)
print(f"✓ Qdrant collection: {collection_name}")

# MongoDB connection
mongodb_uri = os.getenv("MONGODB_URI", "mongodb+srv://truongtn7122003:7KaI9OT5KTUxWjVI@truongtn7122003.xogin4q.mongodb.net/")
mongo_client = MongoClient(mongodb_uri)
db = mongo_client[os.getenv("MONGODB_DB_NAME", "chatbot_rag")]
documents_collection = db["documents"]
chat_history_collection = db["chat_history"]
print("✓ MongoDB connected")

# Hugging Face token
hf_token = os.getenv("HUGGINGFACE_TOKEN")
if hf_token:
    print("✓ Hugging Face token configured")

# Initialize Advanced RAG (Best Case 2025)
advanced_rag = AdvancedRAG(
    embedding_service=embedding_service,
    qdrant_service=qdrant_service
)
print("✓ Advanced RAG pipeline initialized (with Cross-Encoder)")

# Initialize CAG Service (Semantic Cache)
try:
    cag_service = CAGService(
        embedding_service=embedding_service,
        cache_collection="semantic_cache",
        vector_size=embedding_service.get_embedding_dimension(),
        similarity_threshold=0.9,
        ttl_hours=24
    )
    print("✓ CAG Service initialized (Semantic Caching enabled)")
except Exception as e:
    print(f"Warning: CAG Service initialization failed: {e}")
    print("Continuing without semantic caching...")
    cag_service = None

# Initialize PDF Indexer
pdf_indexer = PDFIndexer(
    embedding_service=embedding_service,
    qdrant_service=qdrant_service,
    documents_collection=documents_collection
)
print("✓ PDF Indexer initialized")

# Initialize Multimodal PDF Indexer
multimodal_pdf_indexer = MultimodalPDFIndexer(
    embedding_service=embedding_service,
    qdrant_service=qdrant_service,
    documents_collection=documents_collection
)
print("✓ Multimodal PDF Indexer initialized")

# Initialize Conversation Service
conversations_collection = db["conversations"]
conversation_service = ConversationService(conversations_collection, max_history=10)
print("✓ Conversation Service initialized")

# Initialize Tools Service
tools_service = ToolsService(base_url="https://www.festavenue.site")
print("✓ Tools Service initialized (Function Calling enabled)")

print("✓ Services initialized successfully")


# Pydantic models for embeddings
class SearchRequest(BaseModel):
    text: Optional[str] = None
    limit: int = 10
    score_threshold: Optional[float] = None
    text_weight: float = 0.5
    image_weight: float = 0.5


class SearchResponse(BaseModel):
    id: str
    confidence: float
    metadata: dict


class IndexResponse(BaseModel):
    success: bool
    id: str
    message: str


# Pydantic models for ChatbotRAG
class ChatRequest(BaseModel):
    message: str
    session_id: Optional[str] = None  # Multi-turn conversation
    use_rag: bool = True
    top_k: int = 3
    system_message: Optional[str] = """Bạn là trợ lý AI chuyên biệt cho hệ thống quản lý sự kiện và bán vé. 
Vai trò của bạn là trả lời các câu hỏi CHÍNH XÁC dựa trên dữ liệu được cung cấp từ hệ thống.

Quy tắc tuyệt đối:
- CHỈ trả lời câu hỏi liên quan đến: events, social media posts, PDFs đã upload, và dữ liệu trong knowledge base
- KHÔNG trả lời câu hỏi ngoài phạm vi (tin tức, thời tiết, toán học, lập trình, tư vấn cá nhân, v.v.)
- Nếu câu hỏi nằm ngoài phạm vi: BẮT BUỘC trả lời "Chúng tôi không thể trả lời câu hỏi này vì nó nằm ngoài vùng application xử lí."
- Luôn ưu tiên thông tin từ context được cung cấp"""
    max_tokens: int = 512
    temperature: float = 0.7
    top_p: float = 0.95
    hf_token: Optional[str] = None
    # Advanced RAG options
    use_advanced_rag: bool = True
    use_query_expansion: bool = True
    use_reranking: bool = False  # Disabled - Cross-Encoder not good for Vietnamese
    use_compression: bool = True
    score_threshold: float = 0.5
    # Function calling
    enable_tools: bool = True  # Enable API tool calling


class ChatResponse(BaseModel):
    response: str
    context_used: List[Dict]
    timestamp: str
    rag_stats: Optional[Dict] = None  # Stats from advanced RAG pipeline
    session_id: Optional[str] = None  # Session identifier for multi-turn (auto-generated if not provided)
    tool_calls: Optional[List[Dict]] = None  # Track API calls made


class AddDocumentRequest(BaseModel):
    text: str
    metadata: Optional[Dict] = None


class AddDocumentResponse(BaseModel):
    success: bool
    doc_id: str
    message: str


@app.get("/")
async def root():
    """Health check endpoint with comprehensive API documentation"""
    return {
        "status": "running",
        "service": "ChatbotRAG API",
        "version": "2.0.0",
        "vector_db": "Qdrant",
        "document_db": "MongoDB",        
        "endpoints": {
            "chatbot_rag": {
                "API endpoint": "https://minhvtt-ChatbotRAG.hf.space/",
                "POST /chat": {
                    "description": "Chat với AI sử dụng RAG (Retrieval-Augmented Generation)",
                    "request": {
                        "method": "POST",
                        "content_type": "application/json",
                        "body": {
                            "message": "string (required) - User message/question",
                            "use_rag": "boolean (optional, default: true) - Enable RAG context retrieval",
                            "top_k": "integer (optional, default: 3) - Number of context documents to retrieve",
                            "system_message": "string (optional) - Custom system prompt",
                            "max_tokens": "integer (optional, default: 512) - Max response length",
                            "temperature": "float (optional, default: 0.7, range: 0-1) - Creativity level",
                            "top_p": "float (optional, default: 0.95) - Nucleus sampling",
                            "hf_token": "string (optional) - Hugging Face token (fallback to env)"
                        }
                    },
                    "response": {
                        "response": "string - AI generated response",
                        "context_used": [
                            {
                                "id": "string - Document ID",
                                "confidence": "float - Relevance score",
                                "metadata": {
                                    "text": "string - Retrieved context"
                                }
                            }
                        ],
                        "timestamp": "string - ISO 8601 timestamp"
                    },
                    "example_request": {
                        "message": "Dao có nguy hiểm không?",
                        "use_rag": True,
                        "top_k": 3,
                        "temperature": 0.7
                    },
                    "example_response": {
                        "response": "Dựa trên thông tin trong database, dao được phân loại là vũ khí nguy hiểm. Dao sắc có thể gây thương tích nghiêm trọng nếu không sử dụng đúng cách. Cần tuân thủ các quy định an toàn khi sử dụng.",
                        "context_used": [
                            {
                                "id": "68a3fc14c853d7621e8977b5",
                                "confidence": 0.92,
                                "metadata": {
                                    "text": "Vũ khí"
                                }
                            },
                            {
                                "id": "68a3fc4cc853d7621e8977b6",
                                "confidence": 0.85,
                                "metadata": {
                                    "text": "Con dao sắc"
                                }
                            }
                        ],
                        "timestamp": "2025-10-13T10:30:45.123456"
                    },
                    "notes": [
                        "RAG retrieves relevant context from vector DB before generating response",
                        "LLM uses context to provide accurate, grounded answers",
                        "Requires HUGGINGFACE_TOKEN environment variable or hf_token in request"
                    ]
                },
                "POST /documents": {
                    "description": "Add document to knowledge base for RAG",
                    "request": {
                        "method": "POST",
                        "content_type": "application/json",
                        "body": {
                            "text": "string (required) - Document text content",
                            "metadata": "object (optional) - Additional metadata (source, category, etc.)"
                        }
                    },
                    "response": {
                        "success": "boolean",
                        "doc_id": "string - MongoDB ObjectId",
                        "message": "string - Status message"
                    },
                    "example_request": {
                        "text": "Để tạo event mới: Click nút 'Tạo Event' ở góc trên bên phải màn hình. Điền thông tin sự kiện bao gồm tên, ngày giờ, địa điểm. Click Lưu để hoàn tất.",
                        "metadata": {
                            "source": "user_guide.pdf",
                            "section": "create_event",
                            "page": 5,
                            "category": "tutorial"
                        }
                    },
                    "example_response": {
                        "success": True,
                        "doc_id": "67a9876543210fedcba98765",
                        "message": "Document added successfully with ID: 67a9876543210fedcba98765"
                    }
                },
                "POST /rag/search": {
                    "description": "Search in knowledge base (similar to /search/text but for RAG documents)",
                    "request": {
                        "method": "POST",
                        "content_type": "multipart/form-data",
                        "body": {
                            "query": "string (required) - Search query",
                            "top_k": "integer (optional, default: 5) - Number of results",
                            "score_threshold": "float (optional, default: 0.5) - Minimum relevance score"
                        }
                    },
                    "response": [
                        {
                            "id": "string",
                            "confidence": "float",
                            "metadata": {
                                "text": "string",
                                "source": "string"
                            }
                        }
                    ],
                    "example_request": {
                        "query": "cách tạo sự kiện mới",
                        "top_k": 3,
                        "score_threshold": 0.6
                    }
                },
                "GET /history": {
                    "description": "Get chat conversation history",
                    "request": {
                        "method": "GET",
                        "query_params": {
                            "limit": "integer (optional, default: 10) - Number of messages",
                            "skip": "integer (optional, default: 0) - Pagination offset"
                        }
                    },
                    "response": {
                        "history": [
                            {
                                "user_message": "string",
                                "assistant_response": "string",
                                "context_used": "array",
                                "timestamp": "string - ISO 8601"
                            }
                        ],
                        "total": "integer - Total messages count"
                    },
                    "example_request": "GET /history?limit=5&skip=0",
                    "example_response": {
                        "history": [
                            {
                                "user_message": "Dao có nguy hiểm không?",
                                "assistant_response": "Dao được phân loại là vũ khí...",
                                "context_used": [],
                                "timestamp": "2025-10-13T10:30:45.123456"
                            }
                        ],
                        "total": 15
                    }
                },
                "DELETE /documents/{doc_id}": {
                    "description": "Delete document from knowledge base",
                    "request": {
                        "method": "DELETE",
                        "path_params": {
                            "doc_id": "string - MongoDB ObjectId"
                        }
                    },
                    "response": {
                        "success": "boolean",
                        "message": "string"
                    }
                }
            }
        },
        "usage_examples": {
            "curl_chat": "curl -X POST 'http://localhost:8000/chat' -H 'Content-Type: application/json' -d '{\"message\": \"Dao có nguy hiểm không?\", \"use_rag\": true}'",
            "python_chat": """
import requests

response = requests.post(
    'http://localhost:8000/chat',
    json={
        'message': 'Nút tạo event ở đâu?',
        'use_rag': True,
        'top_k': 3
    }
)
print(response.json()['response'])
            """
        },
        "authentication": {
            "embeddings_apis": "No authentication required",
            "chat_api": "Requires HUGGINGFACE_TOKEN (env variable or request body)"
        },
        "rate_limits": {
            "embeddings": "No limit",
            "chat_with_llm": "Limited by Hugging Face API (free tier: ~1000 requests/hour)"
        },
        "error_codes": {
            "400": "Bad Request - Missing required fields or invalid input",
            "401": "Unauthorized - Invalid Hugging Face token",
            "404": "Not Found - Document ID not found",
            "500": "Internal Server Error - Server or database error"
        },
        "links": {
            "docs": "http://localhost:8000/docs",
            "redoc": "http://localhost:8000/redoc",
            "openapi": "http://localhost:8000/openapi.json"
        }
    }

@app.post("/index", response_model=IndexResponse)
async def index_data(
    id: str = Form(...),
    text: str = Form(...),
    image: Optional[UploadFile] = File(None)
):
    """
    Index data vào vector database

    Body:
    - id: Document ID (event ID, post ID, etc.)
    - text: Text content (tiếng Việt supported)
    - image: Image file (optional)

    Returns:
    - success: True/False
    - id: Document ID
    - message: Status message
    """
    try:
        # Prepare embeddings
        text_embedding = None
        image_embedding = None

        # Encode text (tiếng Việt)
        if text and text.strip():
            text_embedding = embedding_service.encode_text(text)

        # Encode image nếu có
        if image:
            image_bytes = await image.read()
            pil_image = Image.open(io.BytesIO(image_bytes)).convert('RGB')
            image_embedding = embedding_service.encode_image(pil_image)

        # Combine embeddings
        if text_embedding is not None and image_embedding is not None:
            # Average của text và image embeddings
            combined_embedding = np.mean([text_embedding, image_embedding], axis=0)
        elif text_embedding is not None:
            combined_embedding = text_embedding
        elif image_embedding is not None:
            combined_embedding = image_embedding
        else:
            raise HTTPException(status_code=400, detail="Phải cung cấp ít nhất text hoặc image")

        # Normalize
        combined_embedding = combined_embedding / np.linalg.norm(combined_embedding, axis=1, keepdims=True)

        # Index vào Qdrant
        metadata = {
            "text": text,
            "has_image": image is not None,
            "image_filename": image.filename if image else None
        }

        result = qdrant_service.index_data(
            doc_id=id,
            embedding=combined_embedding,
            metadata=metadata
        )

        return IndexResponse(
            success=True,
            id=result["original_id"],  # Trả về MongoDB ObjectId
            message=f"Đã index thành công document {result['original_id']} (Qdrant UUID: {result['qdrant_id']})"
        )

    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Lỗi khi index: {str(e)}")


@app.post("/search", response_model=List[SearchResponse])
async def search(
    text: Optional[str] = Form(None),
    image: Optional[UploadFile] = File(None),
    limit: int = Form(10),
    score_threshold: Optional[float] = Form(None),
    text_weight: float = Form(0.5),
    image_weight: float = Form(0.5)
):
    """
    Search similar documents bằng text và/hoặc image

    Body:
    - text: Query text (tiếng Việt supported)
    - image: Query image (optional)
    - limit: Số lượng kết quả (default: 10)
    - score_threshold: Minimum confidence score (0-1)
    - text_weight: Weight cho text search (default: 0.5)
    - image_weight: Weight cho image search (default: 0.5)

    Returns:
    - List of results với id, confidence, và metadata
    """
    try:
        # Prepare query embeddings
        text_embedding = None
        image_embedding = None

        # Encode text query
        if text and text.strip():
            text_embedding = embedding_service.encode_text(text)

        # Encode image query
        if image:
            image_bytes = await image.read()
            pil_image = Image.open(io.BytesIO(image_bytes)).convert('RGB')
            image_embedding = embedding_service.encode_image(pil_image)

        # Validate input
        if text_embedding is None and image_embedding is None:
            raise HTTPException(status_code=400, detail="Phải cung cấp ít nhất text hoặc image để search")

        # Hybrid search với Qdrant
        results = qdrant_service.hybrid_search(
            text_embedding=text_embedding,
            image_embedding=image_embedding,
            text_weight=text_weight,
            image_weight=image_weight,
            limit=limit,
            score_threshold=score_threshold,
            ef=256  # High accuracy search
        )

        # Format response
        return [
            SearchResponse(
                id=result["id"],
                confidence=result["confidence"],
                metadata=result["metadata"]
            )
            for result in results
        ]

    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Lỗi khi search: {str(e)}")


@app.post("/search/text", response_model=List[SearchResponse])
async def search_by_text(
    text: str = Form(...),
    limit: int = Form(10),
    score_threshold: Optional[float] = Form(None)
):
    """
    Search chỉ bằng text (tiếng Việt)

    Body:
    - text: Query text (tiếng Việt)
    - limit: Số lượng kết quả
    - score_threshold: Minimum confidence score

    Returns:
    - List of results
    """
    try:
        # Encode text
        text_embedding = embedding_service.encode_text(text)

        # Search
        results = qdrant_service.search(
            query_embedding=text_embedding,
            limit=limit,
            score_threshold=score_threshold,
            ef=256
        )

        return [
            SearchResponse(
                id=result["id"],
                confidence=result["confidence"],
                metadata=result["metadata"]
            )
            for result in results
        ]

    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Lỗi khi search: {str(e)}")


@app.post("/search/image", response_model=List[SearchResponse])
async def search_by_image(
    image: UploadFile = File(...),
    limit: int = Form(10),
    score_threshold: Optional[float] = Form(None)
):
    """
    Search chỉ bằng image

    Body:
    - image: Query image
    - limit: Số lượng kết quả
    - score_threshold: Minimum confidence score

    Returns:
    - List of results
    """
    try:
        # Encode image
        image_bytes = await image.read()
        pil_image = Image.open(io.BytesIO(image_bytes)).convert('RGB')
        image_embedding = embedding_service.encode_image(pil_image)

        # Search
        results = qdrant_service.search(
            query_embedding=image_embedding,
            limit=limit,
            score_threshold=score_threshold,
            ef=256
        )

        return [
            SearchResponse(
                id=result["id"],
                confidence=result["confidence"],
                metadata=result["metadata"]
            )
            for result in results
        ]

    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Lỗi khi search: {str(e)}")


@app.delete("/delete/{doc_id}")
async def delete_document(doc_id: str):
    """
    Delete document by ID (MongoDB ObjectId hoặc UUID)

    Args:
    - doc_id: Document ID to delete

    Returns:
    - Success message
    """
    try:
        qdrant_service.delete_by_id(doc_id)
        return {"success": True, "message": f"Đã xóa document {doc_id}"}
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Lỗi khi xóa: {str(e)}")


@app.get("/document/{doc_id}")
async def get_document(doc_id: str):
    """
    Get document by ID (MongoDB ObjectId hoặc UUID)

    Args:
    - doc_id: Document ID (MongoDB ObjectId)

    Returns:
    - Document data
    """
    try:
        doc = qdrant_service.get_by_id(doc_id)
        if doc:
            return {
                "success": True,
                "data": doc
            }
        raise HTTPException(status_code=404, detail=f"Không tìm thấy document {doc_id}")
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Lỗi khi get document: {str(e)}")


@app.get("/stats")
async def get_stats():
    """
    Lấy thông tin thống kê collection

    Returns:
    - Collection statistics
    """
    try:
        info = qdrant_service.get_collection_info()
        return info
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Lỗi khi lấy stats: {str(e)}")


# ============================================
# ChatbotRAG Endpoints
# ============================================

@app.post("/chat", response_model=ChatResponse)
async def chat(request: ChatRequest):
    """
    Multi-turn conversational chatbot với RAG + Function Calling
    
    Features:
    - ✅ Server-side session management (tự động tạo session_id)
    - ✅ Conversation history tracking
    - ✅ RAG context retrieval
    - ✅ Function calling (gọi API khi cần thông tin chi tiết)
    
    Flow:
    1. Request đầu tiên: Không cần session_id → BE tạo mới
    2. Request tiếp theo: Gửi session_id từ response trước → BE nhớ context
    
    Example:
    ```
    # Lần 1
    POST /chat { "message": "Tìm sự kiện hòa nhạc" }
    Response: { "session_id": "abc-123", "response": "..." }
    
    # Lần 2 (follow-up)
    POST /chat { "message": "Ngày tổ chức chính xác?", "session_id": "abc-123" }
    Response: { "session_id": "abc-123", "response": "..." }  # Bot hiểu context
    ```
    
    Body Parameters:
    - message: User message (required)
    - session_id: Session ID cho multi-turn (optional, tự tạo nếu không có)
    - use_rag: Enable RAG retrieval (default: true)
    - enable_tools: Enable function calling (default: true) 
    - top_k: Number of documents (default: 3)
    - temperature: LLM temperature (default: 0.7)
    
    Returns:
    - response: AI generated response
    - session_id: Session identifier (TRẢ VỀ trong mọi trường hợp)
    - context_used: Retrieved context documents
    - tool_calls: API calls made (if any)
    - timestamp: Response timestamp
    """
    # Import chat endpoint logic
    from chat_endpoint import chat_endpoint
    
    return await chat_endpoint(
        request=request,
        conversation_service=conversation_service,
        tools_service=tools_service,
        advanced_rag=advanced_rag,
        embedding_service=embedding_service,
        qdrant_service=qdrant_service,
        chat_history_collection=chat_history_collection,
        hf_token=hf_token
    )


@app.get("/chat/history/{session_id}")
async def get_conversation_history(session_id: str, include_metadata: bool = False):
    """
    Get conversation history for a session
    
    Args:
        session_id: Session identifier
        include_metadata: Include metadata (rag_stats, tool_calls) in response
    
    Returns:
        List of messages with role and content
        
    Example:
    ```
    GET /chat/history/abc-123?include_metadata=true
    ```
    """
    if not conversation_service.session_exists(session_id):
        raise HTTPException(
            status_code=404,
            detail=f"Session {session_id} not found or has expired"
        )
    
    history = conversation_service.get_conversation_history(
        session_id,
        include_metadata=include_metadata
    )
    
    session_info = conversation_service.get_session_info(session_id)
    
    return {
        "session_id": session_id,
        "message_count": len(history),
        "messages": history,
        "created_at": session_info.get("created_at") if session_info else None,
        "updated_at": session_info.get("updated_at") if session_info else None
    }


@app.post("/chat/clear-session")
async def clear_chat_session(session_id: str):
    """
    Clear conversation history for a session
    
    Args:
        session_id: Session identifier to clear
    
    Returns:
        Success message
        
    Example:
    ```
    POST /chat/clear-session?session_id=abc-123
    ```
    """
    success = conversation_service.clear_session(session_id)
    
    if success:
        return {
            "success": True,
            "message": f"Session {session_id} cleared successfully"
        }
    else:
        raise HTTPException(
            status_code=404,
            detail=f"Session {session_id} not found or already cleared"
        )


@app.get("/chat/session/{session_id}")
async def get_session_info(session_id: str):
    """
    Get metadata about a conversation session
    
    Args:
        session_id: Session identifier
    
    Returns:
        Session info including creation time and message count
        
    Example:
    ```
    GET /chat/session/abc-123
    ```
    """
    session = conversation_service.get_session_info(session_id)
    
    if not session:
        raise HTTPException(
            status_code=404,
            detail=f"Session {session_id} not found"
        )
    
    # Get message count
    history = conversation_service.get_conversation_history(
        session_id,
        include_metadata=True
    )
    
    return {
        "session_id": session["session_id"],
        "created_at": session["created_at"],
        "updated_at": session["updated_at"],
        "message_count": len(history),
        "metadata": session.get("metadata", {})
    }


@app.post("/documents", response_model=AddDocumentResponse)
async def add_document(request: AddDocumentRequest):
    """
    Add document to knowledge base

    Body:
    - text: Document text
    - metadata: Additional metadata (optional)

    Returns:
    - success: True/False
    - doc_id: MongoDB document ID
    - message: Status message
    """
    try:
        # Save to MongoDB
        doc_data = {
            "text": request.text,
            "metadata": request.metadata or {},
            "created_at": datetime.utcnow()
        }
        result = documents_collection.insert_one(doc_data)
        doc_id = str(result.inserted_id)

        # Generate embedding
        embedding = embedding_service.encode_text(request.text)

        # Index to Qdrant
        qdrant_service.index_data(
            doc_id=doc_id,
            embedding=embedding,
            metadata={
                "text": request.text,
                "source": "api",
                **(request.metadata or {})
            }
        )

        return AddDocumentResponse(
            success=True,
            doc_id=doc_id,
            message=f"Document added successfully with ID: {doc_id}"
        )

    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Error: {str(e)}")


@app.post("/rag/search", response_model=List[SearchResponse])
async def rag_search(
    query: str = Form(...),
    top_k: int = Form(5),
    score_threshold: Optional[float] = Form(0.5)
):
    """
    Search in knowledge base

    Body:
    - query: Search query
    - top_k: Number of results (default: 5)
    - score_threshold: Minimum score (default: 0.5)

    Returns:
    - results: List of matching documents
    """
    try:
        # Generate query embedding
        query_embedding = embedding_service.encode_text(query)

        # Search in Qdrant
        results = qdrant_service.search(
            query_embedding=query_embedding,
            limit=top_k,
            score_threshold=score_threshold
        )

        return [
            SearchResponse(
                id=result["id"],
                confidence=result["confidence"],
                metadata=result["metadata"]
            )
            for result in results
        ]

    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Error: {str(e)}")


@app.get("/history")
async def get_history(limit: int = 10, skip: int = 0):
    """
    Get chat history

    Query params:
    - limit: Number of messages to return (default: 10)
    - skip: Number of messages to skip (default: 0)

    Returns:
    - history: List of chat messages
    """
    try:
        history = list(
            chat_history_collection
            .find({}, {"_id": 0})
            .sort("timestamp", -1)
            .skip(skip)
            .limit(limit)
        )

        # Convert datetime to string
        for msg in history:
            if "timestamp" in msg:
                msg["timestamp"] = msg["timestamp"].isoformat()

        return {
            "history": history,
            "total": chat_history_collection.count_documents({})
        }

    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Error: {str(e)}")


@app.delete("/documents/{doc_id}")
async def delete_document_from_kb(doc_id: str):
    """
    Delete document from knowledge base

    Args:
    - doc_id: Document ID (MongoDB ObjectId)

    Returns:
    - success: True/False
    - message: Status message
    """
    try:
        # Delete from MongoDB
        result = documents_collection.delete_one({"_id": doc_id})

        # Delete from Qdrant
        if result.deleted_count > 0:
            qdrant_service.delete_by_id(doc_id)
            return {"success": True, "message": f"Document {doc_id} deleted from knowledge base"}
        else:
            raise HTTPException(status_code=404, detail=f"Document {doc_id} not found")

    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Error: {str(e)}")


if __name__ == "__main__":
    import uvicorn
    uvicorn.run(
        app,
        host="0.0.0.0",
        port=8000,
        log_level="info"
    )