import logging

from namespaces.base import BaseNamespace
from services.docchat.chat import ConversationalRAG
from utils.mysql_db import mysql_db
from services.docchat.chat_history_mysql import MySQLChatMessageHistory
from configs.config import OPENAI_MODEL_MINI

XCM_logger = logging.getLogger()


class ChatNamespace(BaseNamespace):
    def __init__(self, namespace=None, redis_client=None):
        super().__init__(namespace, redis_client)

    async def on_chat_message(
        self,
        sid,
        query,
        user_id,
        project_id,
        file_names,
        session_id,
        ai_model=OPENAI_MODEL_MINI,
    ):

        try:
            chat_history = MySQLChatMessageHistory(
                db=mysql_db,
                session_id=session_id,
                socket_id=sid,
                created_by=user_id,
            )

            chat_instance = ConversationalRAG(
                selected_files=file_names,
                project_id=project_id,
                history_provider=chat_history,
                ai_model=ai_model,
            )

            combined_answer = ""

            async for chunk in chat_instance.conversational_rag_chain.astream(
                {"input": query},
                config={"configurable": {"session_id": session_id}},
            ):
                if "answer" in chunk:
                    combined_answer += chunk["answer"]
                    await self.emit(
                        "response_chat_message",
                        {"sid": sid, "message": chunk["answer"]},
                        room=sid,
                    )

            response = await chat_history.get_chat_session_name()
            if response and response.name is None:
                summary = chat_instance.get_summary_of_combined_answer(combined_answer)
                if summary:
                    await self.emit(
                        "session_name_updated",
                        {"sid": sid, "name": summary.content},
                        room=sid,
                    )
                    await chat_history.update_chat_session_name(
                        summary.content, user_id
                    )

            await chat_history.add_interaction(
                question=query,
                response=combined_answer,
                model=ai_model,
                tokens_used=0,
            )
            await self.emit(
                "message_complete",
                {"sid": sid},
                room=sid,
            )

        except Exception as e:
            XCM_logger.error(e)
            await self.emit(
                "response_chat_message",
                {"sid": sid, "message": "Unable to process your request"},
                room=sid,
            )
            await self.emit(
                "message_complete",
                {"sid": sid},
                room=sid,
            )