import gradio as gr
from llama_index.core import (
    StorageContext,
    load_index_from_storage,
    VectorStoreIndex,
    SimpleDirectoryReader,
    ChatPromptTemplate,
)
from llama_index.llms.huggingface import HuggingFaceInferencePipeline
from llama_index.embeddings.huggingface import HuggingFaceEmbedding
from llama_index.core import Settings
import os
import tempfile
from pathlib import Path
import logging

# Set up logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Define the directory for persistent storage and data
PERSIST_DIR = "./db"
DATA_DIR = "data"

# Ensure data directory exists
os.makedirs(DATA_DIR, exist_ok=True)
os.makedirs(PERSIST_DIR, exist_ok=True)

# Configure the Llama index settings
Settings.embed_model = HuggingFaceEmbedding(
    model_name="BAAI/bge-small-en-v1.5"
)

def data_ingestion():
    try:
        documents = SimpleDirectoryReader(DATA_DIR).load_data()
        if not documents:
            logger.warning("No documents loaded from the data directory.")
            return False
        storage_context = StorageContext.from_defaults()
        index = VectorStoreIndex.from_documents(documents)
        index.storage_context.persist(persist_dir=PERSIST_DIR)
        return True
    except Exception as e:
        logger.error(f"Error during data ingestion: {str(e)}")
        return False

def handle_query(query):
    try:
        storage_context = StorageContext.from_defaults(persist_dir=PERSIST_DIR)
        index = load_index_from_storage(storage_context)
        chat_text_qa_msgs = [
            (
                "user",
                """You are a Q&A assistant named EazyPeazy. Your main goal is to provide answers as accurately as possible, based on the instructions and context you have been given. If a question does not match the provided context or is outside the scope of the document, kindly advise the user to ask questions within the context of the document.
                Context:
                {context_str}
                Question:
                {query_str}
                """
            )
        ]
        text_qa_template = ChatPromptTemplate.from_messages(chat_text_qa_msgs)
        
        query_engine = index.as_query_engine(text_qa_template=text_qa_template)
        answer = query_engine.query(query)
        
        if hasattr(answer, 'response'):
            return answer.response
        elif isinstance(answer, dict) and 'response' in answer:
            return answer['response']
        else:
            return "Sorry, I couldn't find an answer."
    except Exception as e:
        logger.error(f"Error handling query: {str(e)}")
        return "An error occurred while processing your query. Please try again."

def process_file(file):
    if file is None:
        return "Please upload a PDF file."
    
    try:
        temp_dir = tempfile.mkdtemp()
        temp_path = Path(temp_dir) / "uploaded.pdf"
        
        with open(temp_path, "wb") as f:
            f.write(file.read())
        
        # Copy the file to the DATA_DIR
        dest_path = Path(DATA_DIR) / "saved_pdf.pdf"
        dest_path.parent.mkdir(parents=True, exist_ok=True)
        temp_path.replace(dest_path)
        
        # Process the uploaded PDF
        if data_ingestion():
            return "PDF processed successfully. You can now ask questions about its content."
        else:
            return "Failed to process the PDF. Please try uploading again."
    except Exception as e:
        logger.error(f"Error processing file: {str(e)}")
        return f"An error occurred while processing the file: {str(e)}"

def chat_function(message, history):
    response = handle_query(message)
    history.append((message, response))
    return history

with gr.Blocks() as demo:
    gr.Markdown("# (PDF) Information and Inference🗞️")
    gr.Markdown("Retrieval-Augmented Generation")
    
    with gr.Row():
        with gr.Column(scale=1):
            file_output = gr.Textbox(label="Upload Status")
            upload_button = gr.UploadButton("Upload PDF", file_types=[".pdf"])
        
        with gr.Column(scale=2):
            chatbot = gr.Chatbot()
            msg = gr.Textbox(label="Ask me anything about the content of the PDF:")
            clear = gr.Button("Clear")
    
    upload_button.upload(process_file, upload_button, file_output)
    msg.submit(chat_function, [msg, chatbot], chatbot)
    clear.click(lambda: None, None, chatbot, queue=False)

if __name__ == "__main__":
    demo.launch()