app/api/v1/chat.py

# """
# Chat API Endpoints (WITH AUTHENTICATION)
# RESTful API for the Banking RAG Chatbot

# NOW REQUIRES JWT TOKEN FOR ALL ENDPOINTS!

# Endpoints:
# - POST /chat - Send a message and get response (PROTECTED)
# - GET /chat/history/{conversation_id} - Get conversation history (PROTECTED)
# - POST /chat/conversation - Create new conversation (PROTECTED)
# - GET /chat/conversations - List user's conversations (PROTECTED)
# - DELETE /chat/conversation/{conversation_id} - Delete conversation (PROTECTED)
# - GET /chat/health - Health check (PUBLIC)
# """

# from fastapi import APIRouter, HTTPException, status, Depends
# from pydantic import BaseModel, Field
# from typing import List, Dict, Optional
# from datetime import datetime

# from app.services.chat_service import chat_service
# from app.db.repositories.conversation_repository import ConversationRepository
# from app.utils.dependencies import get_current_user  # AUTH DEPENDENCY
# from app.models.user import TokenData  # USER DATA FROM TOKEN


# # ============================================================================
# # CREATE ROUTER
# # ============================================================================
# router = APIRouter()


# # ============================================================================
# # DEPENDENCY: Get ConversationRepository instance
# # ============================================================================
# def get_conversation_repo() -> ConversationRepository:
#     """
#     Dependency that provides ConversationRepository instance.
#     This ensures MongoDB is connected before repository is used.
#     """
#     return ConversationRepository()


# # ============================================================================
# # PYDANTIC MODELS (Request/Response schemas)
# # ============================================================================

# class ChatRequest(BaseModel):
#     """Request model for chat endpoint"""
#     query: str = Field(..., description="User query text", min_length=1, max_length=1000)
#     conversation_id: Optional[str] = Field(None, description="Optional conversation ID")
    
#     class Config:
#         json_schema_extra = {
#             "example": {
#                 "query": "What is my account balance?",
#                 "conversation_id": "conv-123"
#             }
#         }


# class ChatResponse(BaseModel):
#     """Response model for chat endpoint"""
#     response: str = Field(..., description="Generated response text")
#     conversation_id: str = Field(..., description="Conversation ID")
#     policy_action: str = Field(..., description="Policy decision: FETCH or NO_FETCH")
#     policy_confidence: float = Field(..., description="Policy confidence score (0-1)")
#     documents_retrieved: int = Field(..., description="Number of documents retrieved")
#     top_doc_score: Optional[float] = Field(None, description="Best document similarity score")
#     total_time_ms: float = Field(..., description="Total processing time in milliseconds")
#     timestamp: str = Field(..., description="Response timestamp (ISO format)")


# class ConversationCreateResponse(BaseModel):
#     """Response after creating a conversation"""
#     conversation_id: str = Field(..., description="Created conversation ID")
#     created_at: str = Field(..., description="Creation timestamp")


# class MessageModel(BaseModel):
#     """Single message in conversation history"""
#     role: str = Field(..., description="Message role: user or assistant")
#     content: str = Field(..., description="Message content")
#     timestamp: str = Field(..., description="Message timestamp")
#     metadata: Optional[Dict] = Field(None, description="Optional metadata")


# class ConversationHistoryResponse(BaseModel):
#     """Response containing conversation history"""
#     conversation_id: str
#     messages: List[MessageModel]
#     message_count: int


# # ============================================================================
# # ENDPOINTS (ALL PROTECTED WITH JWT)
# # ============================================================================

# @router.post("/", response_model=ChatResponse, status_code=status.HTTP_200_OK)
# async def chat(
#     request: ChatRequest,
#     current_user: TokenData = Depends(get_current_user),
#     repo: ConversationRepository = Depends(get_conversation_repo)  # ← INJECT REPO
# ):
#     """
#     Main chat endpoint - Send a query and get a response.
    
#     **REQUIRES AUTHENTICATION** - JWT token must be provided in Authorization header.
#     """
#     try:
#         # Get user_id from token
#         user_id = current_user.user_id
        
#         # If no conversation_id provided, create a new conversation
#         conversation_id = request.conversation_id
#         if not conversation_id:
#             conversation_id = await repo.create_conversation(user_id=user_id)
#         else:
#             # Verify user owns this conversation
#             conversation = await repo.get_conversation(conversation_id)
#             if not conversation:
#                 raise HTTPException(
#                     status_code=status.HTTP_404_NOT_FOUND,
#                     detail="Conversation not found"
#                 )
#             if conversation["user_id"] != user_id:
#                 raise HTTPException(
#                     status_code=status.HTTP_403_FORBIDDEN,
#                     detail="Access denied - you don't own this conversation"
#                 )
        
#         # Get conversation history
#         history = await repo.get_conversation_history(
#             conversation_id=conversation_id,
#             max_messages=10
#         )
        
#         # Save user message
#         await repo.add_message(
#             conversation_id=conversation_id,
#             message={
#                 'role': 'user',
#                 'content': request.query,
#                 'timestamp': datetime.now()
#             }
#         )
        
#         # Process query through RAG pipeline
#         result = await chat_service.process_query(
#             query=request.query,
#             conversation_history=history,
#             user_id=user_id
#         )
        
#         # Save assistant message
#         await repo.add_message(
#             conversation_id=conversation_id,
#             message={
#                 'role': 'assistant',
#                 'content': result['response'],
#                 'timestamp': datetime.now(),
#                 'metadata': {
#                     'policy_action': result['policy_action'],
#                     'policy_confidence': result['policy_confidence'],
#                     'documents_retrieved': result['documents_retrieved'],
#                     'top_doc_score': result['top_doc_score']
#                 }
#             }
#         )
        
#         # Log retrieval data for RL training
#         await repo.log_retrieval({
#             'conversation_id': conversation_id,
#             'user_id': user_id,
#             'query': request.query,
#             'policy_action': result['policy_action'],
#             'policy_confidence': result['policy_confidence'],
#             'should_retrieve': result['should_retrieve'],
#             'documents_retrieved': result['documents_retrieved'],
#             'top_doc_score': result['top_doc_score'],
#             'response': result['response'],
#             'retrieval_time_ms': result['retrieval_time_ms'],
#             'generation_time_ms': result['generation_time_ms'],
#             'total_time_ms': result['total_time_ms'],
#             'retrieved_docs_metadata': result.get('retrieved_docs_metadata', []),
#             'timestamp': datetime.now()
#         })
        
#         # Return response
#         return ChatResponse(
#             response=result['response'],
#             conversation_id=conversation_id,
#             policy_action=result['policy_action'],
#             policy_confidence=result['policy_confidence'],
#             documents_retrieved=result['documents_retrieved'],
#             top_doc_score=result['top_doc_score'],
#             total_time_ms=result['total_time_ms'],
#             timestamp=result['timestamp']
#         )
    
#     except HTTPException:
#         raise
#     except Exception as e:
#         print(f"❌ Chat endpoint error: {e}")
#         import traceback
#         traceback.print_exc()
#         raise HTTPException(
#             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
#             detail=f"Failed to process chat request: {str(e)}"
#         )


# @router.post("/conversation", response_model=ConversationCreateResponse, status_code=status.HTTP_201_CREATED)
# async def create_conversation(
#     current_user: TokenData = Depends(get_current_user),
#     repo: ConversationRepository = Depends(get_conversation_repo)
# ):
#     """Create a new conversation"""
#     try:
#         conversation_id = await repo.create_conversation(user_id=current_user.user_id)
#         return ConversationCreateResponse(
#             conversation_id=conversation_id,
#             created_at=datetime.now().isoformat()
#         )
#     except Exception as e:
#         raise HTTPException(
#             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
#             detail=f"Failed to create conversation: {str(e)}"
#         )


# @router.get("/history/{conversation_id}", response_model=ConversationHistoryResponse)
# async def get_conversation_history(
#     conversation_id: str,
#     current_user: TokenData = Depends(get_current_user),
#     repo: ConversationRepository = Depends(get_conversation_repo)
# ):
#     """Get conversation history by ID"""
#     try:
#         conversation = await repo.get_conversation(conversation_id)
        
#         if not conversation:
#             raise HTTPException(
#                 status_code=status.HTTP_404_NOT_FOUND,
#                 detail=f"Conversation {conversation_id} not found"
#             )
        
#         if conversation["user_id"] != current_user.user_id:
#             raise HTTPException(
#                 status_code=status.HTTP_403_FORBIDDEN,
#                 detail="Access denied - you don't own this conversation"
#             )
        
#         messages = []
#         for msg in conversation.get('messages', []):
#             messages.append(MessageModel(
#                 role=msg['role'],
#                 content=msg['content'],
#                 timestamp=msg['timestamp'].isoformat() if isinstance(msg['timestamp'], datetime) else msg['timestamp'],
#                 metadata=msg.get('metadata')
#             ))
        
#         return ConversationHistoryResponse(
#             conversation_id=conversation_id,
#             messages=messages,
#             message_count=len(messages)
#         )
    
#     except HTTPException:
#         raise
#     except Exception as e:
#         raise HTTPException(
#             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
#             detail=f"Failed to fetch conversation history: {str(e)}"
#         )


# @router.get("/conversations")
# async def list_user_conversations(
#     limit: int = 10,
#     skip: int = 0,
#     current_user: TokenData = Depends(get_current_user),
#     repo: ConversationRepository = Depends(get_conversation_repo)
# ):
#     """List all conversations for the authenticated user"""
#     try:
#         conversations = await repo.get_user_conversations(
#             user_id=current_user.user_id,
#             limit=limit,
#             skip=skip
#         )
        
#         return {
#             "user_id": current_user.user_id,
#             "user_email": current_user.email,
#             "conversations": [
#                 {
#                     "conversation_id": conv['conversation_id'],
#                     "created_at": conv['created_at'].isoformat() if isinstance(conv['created_at'], datetime) else conv['created_at'],
#                     "updated_at": conv['updated_at'].isoformat() if isinstance(conv['updated_at'], datetime) else conv['updated_at'],
#                     "message_count": len(conv.get('messages', []))
#                 }
#                 for conv in conversations
#             ],
#             "total": len(conversations)
#         }
    
#     except Exception as e:
#         raise HTTPException(
#             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
#             detail=f"Failed to fetch conversations: {str(e)}"
#         )


# @router.delete("/conversation/{conversation_id}")
# async def delete_conversation(
#     conversation_id: str,
#     current_user: TokenData = Depends(get_current_user),
#     repo: ConversationRepository = Depends(get_conversation_repo)
# ):
#     """Delete a conversation"""
#     try:
#         conversation = await repo.get_conversation(conversation_id)
        
#         if not conversation:
#             raise HTTPException(
#                 status_code=status.HTTP_404_NOT_FOUND,
#                 detail=f"Conversation {conversation_id} not found"
#             )
        
#         if conversation["user_id"] != current_user.user_id:
#             raise HTTPException(
#                 status_code=status.HTTP_403_FORBIDDEN,
#                 detail="Access denied - you don't own this conversation"
#             )
        
#         success = await repo.delete_conversation(conversation_id)
        
#         if success:
#             return {
#                 "message": "Conversation deleted successfully",
#                 "conversation_id": conversation_id
#             }
#         else:
#             raise HTTPException(
#                 status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
#                 detail="Failed to delete conversation"
#             )
    
#     except HTTPException:
#         raise
#     except Exception as e:
#         raise HTTPException(
#             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
#             detail=f"Failed to delete conversation: {str(e)}"
#         )


# @router.get("/health")
# async def chat_health():
#     """Health check for chat service (PUBLIC)"""
#     try:
#         health = await chat_service.health_check()
        
#         return {
#             "status": "healthy",
#             "service": "chat",
#             "components": health['components'],
#             "timestamp": datetime.now().isoformat()
#         }
    
#     except Exception as e:
#         return {
#             "status": "unhealthy",
#             "service": "chat",
#             "error": str(e),
#             "timestamp": datetime.now().isoformat()
#         }
# # ============================================================================









# # """
# # Chat API Endpoints (WITH AUTHENTICATION)
# # RESTful API for the Banking RAG Chatbot

# # NOW REQUIRES JWT TOKEN FOR ALL ENDPOINTS!

# # Endpoints:
# # - POST /chat - Send a message and get response (PROTECTED)
# # - GET /chat/history/{conversation_id} - Get conversation history (PROTECTED)
# # - POST /chat/conversation - Create new conversation (PROTECTED)
# # - GET /chat/conversations - List user's conversations (PROTECTED)
# # - DELETE /chat/conversation/{conversation_id} - Delete conversation (PROTECTED)
# # - GET /chat/health - Health check (PUBLIC)
# # """

# # from fastapi import APIRouter, HTTPException, status, Depends
# # from pydantic import BaseModel, Field
# # from typing import List, Dict, Optional
# # from datetime import datetime

# # from app.services.chat_service import chat_service
# # from app.db.repositories.conversation_repository import ConversationRepository
# # from app.utils.dependencies import get_current_user  # AUTH DEPENDENCY
# # from app.models.user import TokenData  # USER DATA FROM TOKEN


# # # ============================================================================
# # # CREATE ROUTER
# # # ============================================================================
# # router = APIRouter()

# # # Initialize repository
# # conversation_repo = ConversationRepository()


# # # ============================================================================
# # # PYDANTIC MODELS (Request/Response schemas)
# # # ============================================================================

# # class ChatRequest(BaseModel):
# #     """
# #     Request model for chat endpoint.
    
# #     NOTE: user_id is now extracted from JWT token, not from request body!
    
# #     Example:
# #         {
# #             "query": "What is my account balance?",
# #             "conversation_id": "abc-123"
# #         }
# #     """
# #     query: str = Field(..., description="User query text", min_length=1, max_length=1000)
# #     conversation_id: Optional[str] = Field(None, description="Optional conversation ID")
    
# #     class Config:
# #         json_schema_extra = {
# #             "example": {
# #                 "query": "What is my account balance?",
# #                 "conversation_id": "conv-123"
# #             }
# #         }


# # class ChatResponse(BaseModel):
# #     """
# #     Response model for chat endpoint.
    
# #     Contains the generated response plus metadata about the RAG pipeline.
# #     """
# #     response: str = Field(..., description="Generated response text")
# #     conversation_id: str = Field(..., description="Conversation ID")
# #     policy_action: str = Field(..., description="Policy decision: FETCH or NO_FETCH")
# #     policy_confidence: float = Field(..., description="Policy confidence score (0-1)")
# #     documents_retrieved: int = Field(..., description="Number of documents retrieved")
# #     top_doc_score: Optional[float] = Field(None, description="Best document similarity score")
# #     total_time_ms: float = Field(..., description="Total processing time in milliseconds")
# #     timestamp: str = Field(..., description="Response timestamp (ISO format)")


# # class ConversationCreateRequest(BaseModel):
# #     """Request to create a new conversation (no user_id needed - from token)"""
# #     pass  # Empty - user_id comes from JWT token


# # class ConversationCreateResponse(BaseModel):
# #     """Response after creating a conversation"""
# #     conversation_id: str = Field(..., description="Created conversation ID")
# #     created_at: str = Field(..., description="Creation timestamp")


# # class MessageModel(BaseModel):
# #     """Single message in conversation history"""
# #     role: str = Field(..., description="Message role: user or assistant")
# #     content: str = Field(..., description="Message content")
# #     timestamp: str = Field(..., description="Message timestamp")
# #     metadata: Optional[Dict] = Field(None, description="Optional metadata")


# # class ConversationHistoryResponse(BaseModel):
# #     """Response containing conversation history"""
# #     conversation_id: str
# #     messages: List[MessageModel]
# #     message_count: int


# # # ============================================================================
# # # ENDPOINTS (ALL PROTECTED WITH JWT)
# # # ============================================================================

# # @router.post("/", response_model=ChatResponse, status_code=status.HTTP_200_OK)
# # async def chat(
# #     request: ChatRequest,
# #     current_user: TokenData = Depends(get_current_user)  # ← REQUIRES AUTH!
# # ):
# #     """
# #     Main chat endpoint - Send a query and get a response.
    
# #     **REQUIRES AUTHENTICATION** - JWT token must be provided in Authorization header.
    
# #     This endpoint:
# #     1. Extracts user_id from JWT token
# #     2. Processes the query through the RAG pipeline
# #     3. Saves messages to MongoDB
# #     4. Logs retrieval data for RL training
# #     5. Returns response with metadata
    
# #     Args:
# #         request: ChatRequest with query and optional conversation_id
# #         current_user: Authenticated user data from JWT token
    
# #     Returns:
# #         ChatResponse: Generated response with metadata
    
# #     Raises:
# #         HTTPException: If processing fails or user not authenticated
# #     """
# #     try:
# #         # Get user_id from token (NOT from request body!)
# #         user_id = current_user.user_id
        
# #         # If no conversation_id provided, create a new conversation
# #         conversation_id = request.conversation_id
# #         if not conversation_id:
# #             conversation_id = await conversation_repo.create_conversation(
# #                 user_id=user_id
# #             )
# #         else:
# #             # Verify user owns this conversation
# #             conversation = await conversation_repo.get_conversation(conversation_id)
# #             if not conversation:
# #                 raise HTTPException(
# #                     status_code=status.HTTP_404_NOT_FOUND,
# #                     detail="Conversation not found"
# #                 )
# #             if conversation["user_id"] != user_id:
# #                 raise HTTPException(
# #                     status_code=status.HTTP_403_FORBIDDEN,
# #                     detail="Access denied - you don't own this conversation"
# #                 )
        
# #         # Get conversation history
# #         history = await conversation_repo.get_conversation_history(
# #             conversation_id=conversation_id,
# #             max_messages=10  # Last 5 turns (10 messages)
# #         )
        
# #         # Save user message to database
# #         await conversation_repo.add_message(
# #             conversation_id=conversation_id,
# #             message={
# #                 'role': 'user',
# #                 'content': request.query,
# #                 'timestamp': datetime.now()
# #             }
# #         )
        
# #         # Process query through RAG pipeline
# #         result = await chat_service.process_query(
# #             query=request.query,
# #             conversation_history=history,
# #             user_id=user_id
# #         )
        
# #         # Save assistant message to database
# #         await conversation_repo.add_message(
# #             conversation_id=conversation_id,
# #             message={
# #                 'role': 'assistant',
# #                 'content': result['response'],
# #                 'timestamp': datetime.now(),
# #                 'metadata': {
# #                     'policy_action': result['policy_action'],
# #                     'policy_confidence': result['policy_confidence'],
# #                     'documents_retrieved': result['documents_retrieved'],
# #                     'top_doc_score': result['top_doc_score']
# #                 }
# #             }
# #         )
        
# #         # Log retrieval data for RL training
# #         await conversation_repo.log_retrieval({
# #             'conversation_id': conversation_id,
# #             'user_id': user_id,
# #             'query': request.query,
# #             'policy_action': result['policy_action'],
# #             'policy_confidence': result['policy_confidence'],
# #             'should_retrieve': result['should_retrieve'],
# #             'documents_retrieved': result['documents_retrieved'],
# #             'top_doc_score': result['top_doc_score'],
# #             'response': result['response'],
# #             'retrieval_time_ms': result['retrieval_time_ms'],
# #             'generation_time_ms': result['generation_time_ms'],
# #             'total_time_ms': result['total_time_ms'],
# #             'retrieved_docs_metadata': result.get('retrieved_docs_metadata', []),
# #             'timestamp': datetime.now()
# #         })
        
# #         # Return response
# #         return ChatResponse(
# #             response=result['response'],
# #             conversation_id=conversation_id,
# #             policy_action=result['policy_action'],
# #             policy_confidence=result['policy_confidence'],
# #             documents_retrieved=result['documents_retrieved'],
# #             top_doc_score=result['top_doc_score'],
# #             total_time_ms=result['total_time_ms'],
# #             timestamp=result['timestamp']
# #         )
    
# #     except HTTPException:
# #         raise  # Re-raise HTTP exceptions
# #     except Exception as e:
# #         print(f"❌ Chat endpoint error: {e}")
# #         raise HTTPException(
# #             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
# #             detail=f"Failed to process chat request: {str(e)}"
# #         )


# # @router.post("/conversation", response_model=ConversationCreateResponse, status_code=status.HTTP_201_CREATED)
# # async def create_conversation(
# #     current_user: TokenData = Depends(get_current_user)  # ← REQUIRES AUTH!
# # ):
# #     """
# #     Create a new conversation.
    
# #     **REQUIRES AUTHENTICATION** - User ID is extracted from JWT token.
    
# #     Args:
# #         current_user: Authenticated user data from JWT token
    
# #     Returns:
# #         ConversationCreateResponse: Created conversation ID
# #     """
# #     try:
# #         conversation_id = await conversation_repo.create_conversation(
# #             user_id=current_user.user_id
# #         )
        
# #         return ConversationCreateResponse(
# #             conversation_id=conversation_id,
# #             created_at=datetime.now().isoformat()
# #         )
    
# #     except Exception as e:
# #         raise HTTPException(
# #             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
# #             detail=f"Failed to create conversation: {str(e)}"
# #         )


# # @router.get("/history/{conversation_id}", response_model=ConversationHistoryResponse)
# # async def get_conversation_history(
# #     conversation_id: str,
# #     current_user: TokenData = Depends(get_current_user)  # ← REQUIRES AUTH!
# # ):
# #     """
# #     Get conversation history by ID.
    
# #     **REQUIRES AUTHENTICATION** - User can only access their own conversations.
    
# #     Args:
# #         conversation_id: Conversation ID
# #         current_user: Authenticated user data from JWT token
    
# #     Returns:
# #         ConversationHistoryResponse: List of messages
        
# #     Raises:
# #         HTTPException: If conversation not found or user doesn't own it
# #     """
# #     try:
# #         # Get conversation
# #         conversation = await conversation_repo.get_conversation(conversation_id)
        
# #         if not conversation:
# #             raise HTTPException(
# #                 status_code=status.HTTP_404_NOT_FOUND,
# #                 detail=f"Conversation {conversation_id} not found"
# #             )
        
# #         # Verify user owns this conversation
# #         if conversation["user_id"] != current_user.user_id:
# #             raise HTTPException(
# #                 status_code=status.HTTP_403_FORBIDDEN,
# #                 detail="Access denied - you don't own this conversation"
# #             )
        
# #         # Format messages
# #         messages = []
# #         for msg in conversation.get('messages', []):
# #             messages.append(MessageModel(
# #                 role=msg['role'],
# #                 content=msg['content'],
# #                 timestamp=msg['timestamp'].isoformat() if isinstance(msg['timestamp'], datetime) else msg['timestamp'],
# #                 metadata=msg.get('metadata')
# #             ))
        
# #         return ConversationHistoryResponse(
# #             conversation_id=conversation_id,
# #             messages=messages,
# #             message_count=len(messages)
# #         )
    
# #     except HTTPException:
# #         raise
# #     except Exception as e:
# #         raise HTTPException(
# #             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
# #             detail=f"Failed to fetch conversation history: {str(e)}"
# #         )


# # @router.get("/conversations")
# # async def list_user_conversations(
# #     limit: int = 10,
# #     skip: int = 0,
# #     current_user: TokenData = Depends(get_current_user)  # ← REQUIRES AUTH!
# # ):
# #     """
# #     List all conversations for the authenticated user.
    
# #     **REQUIRES AUTHENTICATION** - User ID is extracted from JWT token.
    
# #     Args:
# #         limit: Maximum conversations to return (default: 10)
# #         skip: Number to skip for pagination (default: 0)
# #         current_user: Authenticated user data from JWT token
    
# #     Returns:
# #         dict: List of conversations for current user
# #     """
# #     try:
# #         conversations = await conversation_repo.get_user_conversations(
# #             user_id=current_user.user_id,  # From JWT token!
# #             limit=limit,
# #             skip=skip
# #         )
        
# #         # Format response
# #         return {
# #             "user_id": current_user.user_id,
# #             "user_email": current_user.email,
# #             "conversations": [
# #                 {
# #                     "conversation_id": conv['conversation_id'],
# #                     "created_at": conv['created_at'].isoformat() if isinstance(conv['created_at'], datetime) else conv['created_at'],
# #                     "updated_at": conv['updated_at'].isoformat() if isinstance(conv['updated_at'], datetime) else conv['updated_at'],
# #                     "message_count": len(conv.get('messages', []))
# #                 }
# #                 for conv in conversations
# #             ],
# #             "total": len(conversations)
# #         }
    
# #     except Exception as e:
# #         raise HTTPException(
# #             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
# #             detail=f"Failed to fetch conversations: {str(e)}"
# #         )


# # @router.delete("/conversation/{conversation_id}")
# # async def delete_conversation(
# #     conversation_id: str,
# #     current_user: TokenData = Depends(get_current_user)  # ← REQUIRES AUTH!
# # ):
# #     """
# #     Delete a conversation.
    
# #     **REQUIRES AUTHENTICATION** - User can only delete their own conversations.
    
# #     Args:
# #         conversation_id: Conversation ID to delete
# #         current_user: Authenticated user data from JWT token
    
# #     Returns:
# #         dict: Success message
        
# #     Raises:
# #         HTTPException: If conversation not found or user doesn't own it
# #     """
# #     try:
# #         # Get conversation
# #         conversation = await conversation_repo.get_conversation(conversation_id)
        
# #         if not conversation:
# #             raise HTTPException(
# #                 status_code=status.HTTP_404_NOT_FOUND,
# #                 detail=f"Conversation {conversation_id} not found"
# #             )
        
# #         # Verify user owns this conversation
# #         if conversation["user_id"] != current_user.user_id:
# #             raise HTTPException(
# #                 status_code=status.HTTP_403_FORBIDDEN,
# #                 detail="Access denied - you don't own this conversation"
# #             )
        
# #         # Delete conversation
# #         success = await conversation_repo.delete_conversation(conversation_id)
        
# #         if success:
# #             return {
# #                 "message": "Conversation deleted successfully",
# #                 "conversation_id": conversation_id
# #             }
# #         else:
# #             raise HTTPException(
# #                 status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
# #                 detail="Failed to delete conversation"
# #             )
    
# #     except HTTPException:
# #         raise
# #     except Exception as e:
# #         raise HTTPException(
# #             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
# #             detail=f"Failed to delete conversation: {str(e)}"
# #         )


# # @router.get("/health")
# # async def chat_health():
# #     """
# #     Health check for chat service.
    
# #     **PUBLIC ENDPOINT** - No authentication required.
    
# #     Returns:
# #         dict: Health status of chat service components
# #     """
# #     try:
# #         health = await chat_service.health_check()
        
# #         return {
# #             "status": "healthy",
# #             "service": "chat",
# #             "components": health['components'],
# #             "timestamp": datetime.now().isoformat()
# #         }
    
# #     except Exception as e:
# #         return {
# #             "status": "unhealthy",
# #             "service": "chat",
# #             "error": str(e),
# #             "timestamp": datetime.now().isoformat()
# #         }


# # # ============================================================================
# # # USAGE DOCUMENTATION
# # # ============================================================================
# # """
# # === API USAGE EXAMPLES (WITH AUTHENTICATION) ===

# # ALL ENDPOINTS (except /health) NOW REQUIRE JWT TOKEN IN AUTHORIZATION HEADER!

# # 1. Register user:
# #    POST /api/v1/auth/register
# #    Body: {
# #        "email": "user@example.com",
# #        "password": "SecurePass123",
# #        "full_name": "John Doe"
# #    }
# #    Response: { "access_token": "eyJ...", "user": {...} }

# # 2. Login:
# #    POST /api/v1/auth/login
# #    Body: {
# #        "email": "user@example.com",
# #        "password": "SecurePass123"
# #    }
# #    Response: { "access_token": "eyJ...", "user": {...} }

# # 3. Send chat message (WITH TOKEN):
# #    POST /api/v1/chat/
# #    Headers: { "Authorization": "Bearer eyJ..." }
# #    Body: {
# #        "query": "What is my account balance?",
# #        "conversation_id": "conv_abc"  // optional
# #    }

# # 4. Get conversation history (WITH TOKEN):
# #    GET /api/v1/chat/history/conv_abc
# #    Headers: { "Authorization": "Bearer eyJ..." }

# # 5. List conversations (WITH TOKEN):
# #    GET /api/v1/chat/conversations?limit=10
# #    Headers: { "Authorization": "Bearer eyJ..." }

# # === TESTING WITH CURL ===

# # # 1. Register
# # TOKEN=$(curl -X POST "http://localhost:8000/api/v1/auth/register" \
# #   -H "Content-Type: application/json" \
# #   -d '{"email":"test@test.com","password":"test123","full_name":"Test User"}' \
# #   | jq -r '.access_token')

# # # 2. Send chat message with token
# # curl -X POST "http://localhost:8000/api/v1/chat/" \
# #   -H "Content-Type: application/json" \
# #   -H "Authorization: Bearer $TOKEN" \
# #   -d '{"query": "What is my balance?"}'
# # """
# # # ============================================================================

























# # # ======================================================================================================
# # # OLD CODE
# # # ======================================================================================================

# # # """
# # # Chat API Endpoints
# # # RESTful API for the Banking RAG Chatbot

# # # Endpoints:
# # # - POST /chat - Send a message and get response
# # # - GET /chat/history/{conversation_id} - Get conversation history
# # # - POST /chat/conversation - Create new conversation
# # # - GET /chat/conversations - List user's conversations
# # # - GET /chat/health - Health check for chat service
# # # """

# # # from fastapi import APIRouter, HTTPException, status
# # # from pydantic import BaseModel, Field
# # # from typing import List, Dict, Optional
# # # from datetime import datetime

# # # from app.services.chat_service import chat_service
# # # from app.db.repositories.conversation_repository import ConversationRepository


# # # # ============================================================================
# # # # CREATE ROUTER
# # # # ============================================================================
# # # router = APIRouter()

# # # # Initialize repository
# # # conversation_repo = ConversationRepository()


# # # # ============================================================================
# # # # PYDANTIC MODELS (Request/Response schemas)
# # # # ============================================================================

# # # class ChatRequest(BaseModel):
# # #     """
# # #     Request model for chat endpoint.
    
# # #     Example:
# # #         {
# # #             "query": "What is my account balance?",
# # #             "conversation_id": "abc-123",
# # #             "user_id": "user_456"
# # #         }
# # #     """
# # #     query: str = Field(..., description="User query text", min_length=1, max_length=1000)
# # #     conversation_id: Optional[str] = Field(None, description="Optional conversation ID")
# # #     user_id: str = Field(..., description="User ID")
    
# # #     class Config:
# # #         json_schema_extra = {
# # #             "example": {
# # #                 "query": "What is my account balance?",
# # #                 "conversation_id": "conv-123",
# # #                 "user_id": "user-456"
# # #             }
# # #         }


# # # class ChatResponse(BaseModel):
# # #     """
# # #     Response model for chat endpoint.
    
# # #     Contains the generated response plus metadata about the RAG pipeline.
# # #     """
# # #     response: str = Field(..., description="Generated response text")
# # #     conversation_id: str = Field(..., description="Conversation ID")
# # #     policy_action: str = Field(..., description="Policy decision: FETCH or NO_FETCH")
# # #     policy_confidence: float = Field(..., description="Policy confidence score (0-1)")
# # #     documents_retrieved: int = Field(..., description="Number of documents retrieved")
# # #     top_doc_score: Optional[float] = Field(None, description="Best document similarity score")
# # #     total_time_ms: float = Field(..., description="Total processing time in milliseconds")
# # #     timestamp: str = Field(..., description="Response timestamp (ISO format)")


# # # class ConversationCreateRequest(BaseModel):
# # #     """Request to create a new conversation"""
# # #     user_id: str = Field(..., description="User ID")


# # # class ConversationCreateResponse(BaseModel):
# # #     """Response after creating a conversation"""
# # #     conversation_id: str = Field(..., description="Created conversation ID")
# # #     created_at: str = Field(..., description="Creation timestamp")


# # # class MessageModel(BaseModel):
# # #     """Single message in conversation history"""
# # #     role: str = Field(..., description="Message role: user or assistant")
# # #     content: str = Field(..., description="Message content")
# # #     timestamp: str = Field(..., description="Message timestamp")
# # #     metadata: Optional[Dict] = Field(None, description="Optional metadata")


# # # class ConversationHistoryResponse(BaseModel):
# # #     """Response containing conversation history"""
# # #     conversation_id: str
# # #     messages: List[MessageModel]
# # #     message_count: int


# # # # ============================================================================
# # # # ENDPOINTS
# # # # ============================================================================

# # # @router.post("/", response_model=ChatResponse, status_code=status.HTTP_200_OK)
# # # async def chat(request: ChatRequest):
# # #     """
# # #     Main chat endpoint - Send a query and get a response.
    
# # #     This endpoint:
# # #     1. Processes the query through the RAG pipeline
# # #     2. Saves messages to MongoDB
# # #     3. Logs retrieval data for RL training
# # #     4. Returns response with metadata
    
# # #     Args:
# # #         request: ChatRequest with query, conversation_id, user_id
    
# # #     Returns:
# # #         ChatResponse: Generated response with metadata
    
# # #     Raises:
# # #         HTTPException: If processing fails
# # #     """
# # #     try:
# # #         # If no conversation_id provided, create a new conversation
# # #         conversation_id = request.conversation_id
# # #         if not conversation_id:
# # #             conversation_id = await conversation_repo.create_conversation(
# # #                 user_id=request.user_id
# # #             )
        
# # #         # Get conversation history
# # #         history = await conversation_repo.get_conversation_history(
# # #             conversation_id=conversation_id,
# # #             max_messages=10  # Last 5 turns (10 messages)
# # #         )
        
# # #         # Save user message to database
# # #         await conversation_repo.add_message(
# # #             conversation_id=conversation_id,
# # #             message={
# # #                 'role': 'user',
# # #                 'content': request.query,
# # #                 'timestamp': datetime.now()
# # #             }
# # #         )
        
# # #         # Process query through RAG pipeline
# # #         result = await chat_service.process_query(
# # #             query=request.query,
# # #             conversation_history=history,
# # #             user_id=request.user_id
# # #         )
        
# # #         # Save assistant message to database
# # #         await conversation_repo.add_message(
# # #             conversation_id=conversation_id,
# # #             message={
# # #                 'role': 'assistant',
# # #                 'content': result['response'],
# # #                 'timestamp': datetime.now(),
# # #                 'metadata': {
# # #                     'policy_action': result['policy_action'],
# # #                     'policy_confidence': result['policy_confidence'],
# # #                     'documents_retrieved': result['documents_retrieved'],
# # #                     'top_doc_score': result['top_doc_score']
# # #                 }
# # #             }
# # #         )
        
# # #         # Log retrieval data for RL training
# # #         await conversation_repo.log_retrieval({
# # #             'conversation_id': conversation_id,
# # #             'user_id': request.user_id,
# # #             'query': request.query,
# # #             'policy_action': result['policy_action'],
# # #             'policy_confidence': result['policy_confidence'],
# # #             'should_retrieve': result['should_retrieve'],
# # #             'documents_retrieved': result['documents_retrieved'],
# # #             'top_doc_score': result['top_doc_score'],
# # #             'response': result['response'],
# # #             'retrieval_time_ms': result['retrieval_time_ms'],
# # #             'generation_time_ms': result['generation_time_ms'],
# # #             'total_time_ms': result['total_time_ms'],
# # #             'retrieved_docs_metadata': result.get('retrieved_docs_metadata', []),
# # #             'timestamp': datetime.now()
# # #         })
        
# # #         # Return response
# # #         return ChatResponse(
# # #             response=result['response'],
# # #             conversation_id=conversation_id,
# # #             policy_action=result['policy_action'],
# # #             policy_confidence=result['policy_confidence'],
# # #             documents_retrieved=result['documents_retrieved'],
# # #             top_doc_score=result['top_doc_score'],
# # #             total_time_ms=result['total_time_ms'],
# # #             timestamp=result['timestamp']
# # #         )
    
# # #     except Exception as e:
# # #         print(f"❌ Chat endpoint error: {e}")
# # #         raise HTTPException(
# # #             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
# # #             detail=f"Failed to process chat request: {str(e)}"
# # #         )


# # # @router.post("/conversation", response_model=ConversationCreateResponse, status_code=status.HTTP_201_CREATED)
# # # async def create_conversation(request: ConversationCreateRequest):
# # #     """
# # #     Create a new conversation.
    
# # #     Args:
# # #         request: ConversationCreateRequest with user_id
    
# # #     Returns:
# # #         ConversationCreateResponse: Created conversation ID
# # #     """
# # #     try:
# # #         conversation_id = await conversation_repo.create_conversation(
# # #             user_id=request.user_id
# # #         )
        
# # #         return ConversationCreateResponse(
# # #             conversation_id=conversation_id,
# # #             created_at=datetime.now().isoformat()
# # #         )
    
# # #     except Exception as e:
# # #         raise HTTPException(
# # #             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
# # #             detail=f"Failed to create conversation: {str(e)}"
# # #         )


# # # @router.get("/history/{conversation_id}", response_model=ConversationHistoryResponse)
# # # async def get_conversation_history(conversation_id: str):
# # #     """
# # #     Get conversation history by ID.
    
# # #     Args:
# # #         conversation_id: Conversation ID
    
# # #     Returns:
# # #         ConversationHistoryResponse: List of messages
# # #     """
# # #     try:
# # #         # Get conversation
# # #         conversation = await conversation_repo.get_conversation(conversation_id)
        
# # #         if not conversation:
# # #             raise HTTPException(
# # #                 status_code=status.HTTP_404_NOT_FOUND,
# # #                 detail=f"Conversation {conversation_id} not found"
# # #             )
        
# # #         # Format messages
# # #         messages = []
# # #         for msg in conversation.get('messages', []):
# # #             messages.append(MessageModel(
# # #                 role=msg['role'],
# # #                 content=msg['content'],
# # #                 timestamp=msg['timestamp'].isoformat() if isinstance(msg['timestamp'], datetime) else msg['timestamp'],
# # #                 metadata=msg.get('metadata')
# # #             ))
        
# # #         return ConversationHistoryResponse(
# # #             conversation_id=conversation_id,
# # #             messages=messages,
# # #             message_count=len(messages)
# # #         )
    
# # #     except HTTPException:
# # #         raise
# # #     except Exception as e:
# # #         raise HTTPException(
# # #             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
# # #             detail=f"Failed to fetch conversation history: {str(e)}"
# # #         )


# # # @router.get("/conversations")
# # # async def list_user_conversations(user_id: str, limit: int = 10, skip: int = 0):
# # #     """
# # #     List all conversations for a user.
    
# # #     Args:
# # #         user_id: User ID
# # #         limit: Maximum conversations to return (default: 10)
# # #         skip: Number to skip for pagination (default: 0)
    
# # #     Returns:
# # #         dict: List of conversations
# # #     """
# # #     try:
# # #         conversations = await conversation_repo.get_user_conversations(
# # #             user_id=user_id,
# # #             limit=limit,
# # #             skip=skip
# # #         )
        
# # #         # Format response
# # #         return {
# # #             "user_id": user_id,
# # #             "conversations": [
# # #                 {
# # #                     "conversation_id": conv['conversation_id'],
# # #                     "created_at": conv['created_at'].isoformat() if isinstance(conv['created_at'], datetime) else conv['created_at'],
# # #                     "updated_at": conv['updated_at'].isoformat() if isinstance(conv['updated_at'], datetime) else conv['updated_at'],
# # #                     "message_count": len(conv.get('messages', []))
# # #                 }
# # #                 for conv in conversations
# # #             ],
# # #             "total": len(conversations)
# # #         }
    
# # #     except Exception as e:
# # #         raise HTTPException(
# # #             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
# # #             detail=f"Failed to fetch conversations: {str(e)}"
# # #         )


# # # @router.get("/health")
# # # async def chat_health():
# # #     """
# # #     Health check for chat service.
    
# # #     Returns:
# # #         dict: Health status of chat service components
# # #     """
# # #     try:
# # #         health = await chat_service.health_check()
        
# # #         return {
# # #             "status": "healthy",
# # #             "service": "chat",
# # #             "components": health['components'],
# # #             "timestamp": datetime.now().isoformat()
# # #         }
    
# # #     except Exception as e:
# # #         return {
# # #             "status": "unhealthy",
# # #             "service": "chat",
# # #             "error": str(e),
# # #             "timestamp": datetime.now().isoformat()
# # #         }


# # # # ============================================================================
# # # # USAGE DOCUMENTATION
# # # # ============================================================================
# # # """
# # # === API USAGE EXAMPLES ===

# # # 1. Send a chat message:
# # #    POST /api/v1/chat/
# # #    Body: {
# # #        "query": "What is my account balance?",
# # #        "user_id": "user_123",
# # #        "conversation_id": "conv_abc"  // optional
# # #    }

# # # 2. Create new conversation:
# # #    POST /api/v1/chat/conversation
# # #    Body: {
# # #        "user_id": "user_123"
# # #    }

# # # 3. Get conversation history:
# # #    GET /api/v1/chat/history/conv_abc

# # # 4. List user's conversations:
# # #    GET /api/v1/chat/conversations?user_id=user_123&limit=10&skip=0

# # # 5. Check health:
# # #    GET /api/v1/chat/health

# # # === TESTING WITH CURL ===

# # # # Send chat message
# # # curl -X POST "http://localhost:8000/api/v1/chat/" \
# # #   -H "Content-Type: application/json" \
# # #   -d '{
# # #     "query": "What is my balance?",
# # #     "user_id": "user_123"
# # #   }'

# # # # Get history
# # # curl "http://localhost:8000/api/v1/chat/history/conv_123"

# # # === TESTING WITH SWAGGER UI ===

# # # After starting the server, visit:
# # # http://localhost:8000/docs

# # # Interactive API documentation with "Try it out" buttons!
# # # """