class RetrieverConfigurator:
    """
    A class for configuring a retriever object based on uploaded files.

    This class encapsulates the process of reading documents from uploaded files,
    splitting them into smaller chunks, creating embeddings for each chunk, and defining
    a retriever object that uses the FAISS vector database to search for similar documents.
    """

    def __init__(self, uploaded_files):
        """
        Initialize the RetrieverConfigurator object.

        Args:
            uploaded_files (list): A list of Streamlit uploaded file objects.
        """
        self.uploaded_files = uploaded_files
        self.docs = []
        self.chunks = []
        self.vectordb = None
        self.retriever = None

    def read_documents(self):
        """
        Reads the documents from the uploaded files.

        This method iterates over the uploaded files, writes them to temporary files,
        and loads the documents using the UnstructuredFileLoader.
        """
        temp_dir = tempfile.TemporaryDirectory()
        for file in self.uploaded_files:
            temp_filepath = os.path.join(temp_dir.name, file.name)
            with open(temp_filepath, "wb") as f:
                f.write(file.getvalue())
            loader = UnstructuredFileLoader(temp_filepath)
            self.docs.extend(loader.load())
            logger.info("Loaded document: %s", file.name)

    def split_documents(self):
        """
        Splits the loaded documents into smaller chunks.

        This method uses the RecursiveCharacterTextSplitter to split the documents
        into chunks based on the specified chunk size and overlap.
        """
        text_splitter = RecursiveCharacterTextSplitter(chunk_size=800, chunk_overlap=75)
        self.chunks = text_splitter.split_documents(self.docs)

    def create_embeddings(self):
        """
        Creates embeddings for each chunk using the HuggingFace's MiniLM model.

        This method initializes the HuggingFaceEmbeddings with the specified model
        and generates embeddings for the chunks. The embeddings are then stored
        in a FAISS vector database.
        """
        model_kwargs = {"device": "cuda" if torch.cuda.is_available() else "cpu"}
        embeddings = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2", model_kwargs=model_kwargs)
        self.vectordb = FAISS.from_documents(self.chunks, embeddings)

    def define_retriever(self):
        """
        Defines a retriever object that uses the FAISS vector database.

        This method creates a retriever object from the FAISS vector database,
        configuring it with the specified search type and parameters.
        """
        self.retriever = self.vectordb.as_retriever(search_type="mmr", search_kwargs={"k": 3, "fetch_k": 7})

    def configure_retriever(self):
        """
        Configures and returns a retriever object for a given list of uploaded files.

        This method orchestrates the process of reading documents, splitting them into chunks,
        creating embeddings, and defining a retriever object. The configured retriever
        object is then returned.

        Returns:
            retriever (Retriever): A retriever object that can be used to search for similar documents.
        """
        self.read_documents()
        self.split_documents()
        self.create_embeddings()
        self.define_retriever()
        return self.retriever

configurator = RetrieverConfigurator(uploaded_files)
retriever = configurator.configure_retriever()

# Create a history-aware retriever
history_aware_retriever = create_history_aware_retriever(
    retriever, combine_docs_chain
)

# Create a RAG chain
qa_chain = create_retrieval_chain(history_aware_retriever, llm)

# if the length of messages is 0, or when the user \
# clicks the clear button
if len(msgs.messages) == 0 or st.sidebar.button("Clear message history"):
    msgs.clear()
    # show a default message from the AI
    msgs.add_ai_message("How can I help you?")

# Display coversation history window
avatars = {"human": "user", "ai": "assistant"}
for msg in msgs.messages:
    st.chat_message(avatars[msg.type]).write(msg.content)

# Display user input field and enter button
if user_query := st.chat_input(placeholder="Ask me anything!"):
    st.chat_message("user").write(user_query)

    # Display assistant response
    with st.chat_message("assistant"):
        # Check for the presence of the "messages" key in session state
        if "messages" not in st.session_state:
            st.session_state.messages = []

        retrieval_handler = PrintRetrievalHandler(st.container())
        stream_handler = StreamHandler(st.empty())
        response = qa_chain.invoke(
            {"input": user_query}, callbacks=[retrieval_handler, stream_handler]
        )

    chat_agent = ConversationalChatAgent.from_llm_and_tools(llm=llm, tools=tools)
    executor = AgentExecutor.from_agent_and_tools(
        agent=chat_agent,
        tools=tools,
        memory=memory,
        return_intermediate_steps=True,
        handle_parsing_errors=True,
    )

# Create a chain that ties everything together
qa_chain = ConversationalRetrievalChain.from_llm(
    # switch to 
    # create_history_aware_retriever
    llm, retriever=retriever, memory=memory, verbose=True
)

        response = qa_chain.run(
            user_query, callbacks=[retrieval_handler, stream_handler] # when switching to `qa_chain.invoke` you 
            # will use cfg = RunnableConfig()
            # cfg["callbacks"] = [retrieval_handler, stream_handler]
        )

# Init different built-in tools
search = DuckDuckGoSearchAPIWrapper()
llm_math_chain = LLMMathChain.from_llm(llm)

# create a toolset list
tools = [
    Tool(
        name="Search",
        func=search.run,
        description="useful for when you need to answer questions about current events. You should ask targeted questions",
    ),
    Tool(
        name="Calculator",
        func=llm_math_chain.run,
        description="useful for when you need to answer questions about math",
    ),
]