import streamlit as st
import pandas as pd
import plotly.express as px
from pandasai import Agent
from langchain_community.embeddings.openai import OpenAIEmbeddings
from langchain_community.vectorstores import FAISS
from langchain_openai import ChatOpenAI
from langchain.chains import RetrievalQA
from langchain.schema import Document
import os

# Set title
st.title("Data Analyzer")

# Add fields to input API keys via the sidebar
api_key = os.getenv("OPENAI_API_KEY")
pandasai_api_key = os.getenv("PANDASAI_API_KEY")

if not api_key or not pandasai_api_key:
    st.warning("API keys for OpenAI or PandasAI are missing. Ensure both keys are set in environment variables.")

# Function to load datasets into session
def load_dataset_into_session():
    input_option = st.radio(
        "Select Dataset Input:",
        ["Use Repo Directory Dataset", "Use Hugging Face Dataset", "Upload CSV File"],
    )

    # Option 1: Load dataset from the repo directory
    if input_option == "Use Repo Directory Dataset":
        file_path = "./source/test.csv"
        if st.button("Load Dataset"):
            try:
                st.session_state.df = pd.read_csv(file_path)
                st.success(f"File loaded successfully from '{file_path}'!")
                st.dataframe(st.session_state.df.head(10))
            except Exception as e:
                st.error(f"Error loading dataset from the repo directory: {e}")

    # Option 2: Load dataset from Hugging Face
    elif input_option == "Use Hugging Face Dataset":
        dataset_name = st.text_input(
            "Enter Hugging Face Dataset Name:", value="HUPD/hupd"
        )
        if st.button("Load Hugging Face Dataset"):
            try:
                from datasets import load_dataset
                dataset = load_dataset(dataset_name, split="train", trust_remote_code=True)
                if hasattr(dataset, "to_pandas"):
                    st.session_state.df = dataset.to_pandas()
                else:
                    st.session_state.df = pd.DataFrame(dataset)
                st.success(f"Hugging Face Dataset '{dataset_name}' loaded successfully!")
                st.dataframe(st.session_state.df.head(10))
            except Exception as e:
                st.error(f"Error loading Hugging Face dataset: {e}")

    # Option 3: Upload CSV File
    elif input_option == "Upload CSV File":
        uploaded_file = st.file_uploader("Upload a CSV File:", type=["csv"])
        if uploaded_file:
            try:
                st.session_state.df = pd.read_csv(uploaded_file)
                st.success("File uploaded successfully!")
                st.dataframe(st.session_state.df.head(10))
            except Exception as e:
                st.error(f"Error reading uploaded file: {e}")

load_dataset_into_session()

# Check if the dataset and API keys are loaded
if "df" in st.session_state and api_key and pandasai_api_key:
    # Set API keys
    os.environ["OPENAI_API_KEY"] = api_key
    os.environ["PANDASAI_API_KEY"] = pandasai_api_key

    df = st.session_state.df
    st.write("Dataset Preview:")
    st.write(df.head())

    # Set up PandasAI Agent
    agent = Agent(df)

    # Convert dataframe into documents
    documents = [
        Document(
            page_content=", ".join([f"{col}: {row[col]}" for col in df.columns]),
            metadata={"index": index}
        )
        for index, row in df.iterrows()
    ]

    # Set up RAG
    embeddings = OpenAIEmbeddings()
    vectorstore = FAISS.from_documents(documents, embeddings)
    retriever = vectorstore.as_retriever()
    qa_chain = RetrievalQA.from_chain_type(
        llm=ChatOpenAI(),
        chain_type="stuff",
        retriever=retriever
    )

    # Create tabs
    tab1, tab2, tab3 = st.tabs(["PandasAI Analysis", "RAG Q&A", "Data Visualization"])

    with tab1:
        st.header("Data Analysis with PandasAI")
        pandas_question = st.text_input("Ask a question about the dataset (PandasAI):")
        if pandas_question:
            result = agent.chat(pandas_question)
            st.write("PandasAI Answer:", result)

    with tab2:
        st.header("Q&A with RAG")
        rag_question = st.text_input("Ask a question about the dataset (RAG):")
        if rag_question:
            result = qa_chain.run(rag_question)
            st.write("RAG Answer:", result)

    with tab3:
        st.header("Data Visualization")
        viz_question = st.text_input("What kind of graph would you like? (e.g., 'Show a scatter plot of salary vs experience')")
        if viz_question:
            try:
                result = agent.chat(viz_question)
                
                # Extract Python code from PandasAI response
                import re
                code_pattern = r'```python\n(.*?)\n```'
                code_match = re.search(code_pattern, result, re.DOTALL)
                
                if code_match:
                    viz_code = code_match.group(1)
                    
                    # Replace matplotlib with plotly
                    viz_code = viz_code.replace('plt.', 'px.')
                    viz_code = viz_code.replace('plt.show()', 'fig = px.scatter(df, x=x, y=y)')
                    
                    # Execute the modified code
                    exec(viz_code)
                    st.plotly_chart(fig)
                else:
                    st.write("Unable to generate the graph. Please try a different query.")
            except Exception as e:
                st.write(f"An error occurred: {str(e)}")
                st.write("Please try asking in a different way.")
else:
    if not api_key:
        st.warning("Please set the OpenAI API key in environment variables.")
    if not pandasai_api_key:
        st.warning("Please set the PandasAI API key in environment variables.")