import gradio as gr
import requests
import pandas as pd
from langchain.chat_models import ChatOpenAI
from langchain.document_loaders import CSVLoader
from langchain_together import TogetherEmbeddings
from langchain.prompts import ChatPromptTemplate
from langchain.vectorstores import Chroma
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnableLambda, RunnablePassthrough
from langchain.document_loaders import CSVLoader
from langchain.embeddings.sentence_transformer import SentenceTransformerEmbeddings
from langchain.vectorstores import Chroma
from langchain_core.vectorstores import InMemoryVectorStore
from langchain import PromptTemplate
from langchain import LLMChain
from langchain_together import Together
import os


os.environ['TOGETHER_API_KEY'] = "c2f52626b97118b71c0c36f66eda4f5957c8fc475e760c3d72f98ba07d3ed3b5"

# Initialize global variable for vectorstore
vectorstore = None
embeddings = TogetherEmbeddings(model="togethercomputer/m2-bert-80M-8k-retrieval")
llama3 = Together(model="meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo", max_tokens=1024)

def update_csv_files():
    # Define the login URL and credentials
    login_url = "https://livesystem.hisabkarlay.com/auth/login"
    payload = {
        "username": "user@123",
        "password": "user@123",
        "client_secret": "kNqJjlPkxyHdIKt3szCt4PYFWtFOdUheb8QVN8vQ",
        "client_id": "5",
        "grant_type": "password"
    }

    # Send a POST request to the login URL
    response = requests.post(login_url, data=payload)

    # Check the status and get the response data
    if response.status_code == 200:
        print("Login successful!")
        access_token = response.json()['access_token']
    else:
        return f"Failed to log in: {response.status_code}"

    # Profit loss Fetch report
    report_url = "https://livesystem.hisabkarlay.com/connector/api/profit-loss-report"
    headers = {
        "Authorization": f"Bearer {access_token}"
    }
    response = requests.get(report_url, headers=headers)
    profit_loss_data = response.json()['data']
    keys = list(profit_loss_data.keys())
    del keys[23]  # Adjust according to your needs
    del keys[20]
    del keys[19]
    data_dict = {}
    for key in keys:
        data_dict[key] = profit_loss_data.get(key)
    df = pd.DataFrame(data_dict, index=[0])
    df.to_csv('profit_loss.csv', index=False)

    # API call to get purchase-sell data
    report_url = "https://livesystem.hisabkarlay.com/connector/api/purchase-sell"
    response = requests.get(report_url, headers=headers)
    sell_purchase_data = response.json()
    sell_purchase_data = dict(list(sell_purchase_data.items())[2:])
    df = pd.json_normalize(sell_purchase_data)
    df.to_csv('purchase_sell_report.csv', index=False)

    # API call to get trending product data
    report_url = "https://livesystem.hisabkarlay.com/connector/api/trending-products"
    response = requests.get(report_url, headers=headers)
    trending_product_data = response.json()['data']
    df = pd.DataFrame(trending_product_data)
    df.columns = ['Product Units Sold', 'Product Name', 'Unit Type', 'SKU (Stock Keeping Unit)']
    df.to_csv('trending_product.csv', index=False)

    return "CSV files updated successfully!"

def initialize_embedding():
    global vectorstore
    # Initialize the embedding function
    

    # Load CSV files
    file_paths = [
        "profit_loss.csv",
        "purchase_sell_report.csv",
        "trending_product.csv"
    ]
    documents = []
    for path in file_paths:
        loader = CSVLoader(path, encoding="windows-1252")
        documents.extend(loader.load())  # Combine documents from all files

    # Create an InMemoryVectorStore from the combined documents
    vectorstore = InMemoryVectorStore.from_texts(
        [doc.page_content for doc in documents],  # Extract the page_content from Document objects
        embedding=embeddings,
    )
    return "Embeddings initialized successfully!"

def qa_chain(query):
    if vectorstore is None:
        return "Please initialize the embeddings first."
    
    retriever = vectorstore.as_retriever()
    retrieved_documents = retriever.invoke(query)
    return retrieved_documents  # Not shown directly in the UI

def generate_response(query, history):
    if vectorstore is None:
        return history, "Please initialize the embeddings first."
    
    retrieved_documents = qa_chain(query)  # Call qa_chain internally
    chat_template = """
You are a highly intelligent and professional AI assistant.
Generate the response according to the user's query:
- If the user enters a greeting (e.g., "Hi", "Hello", "Good day"), give the following response:
    "Welcome to HisabKarLay, your business partner! You may choose from the following services 👇:
    1. Reports
    2. Forecasts
    3. Best Selling Items
    4. Chat with AI Agent
    5. Chat with our Customer Care Team
    6. Share your Feedback
    7. Checkout Latest Offers
    🔆 Suggestion: To make a selection, send the relevant number like 1
    ⭕ Note: If at any stage you wish to go back to the previous menu, type back, and to go to the main menu, type main menu.
    ⭕ Note: If you want to change the language, type and send 'change language.'
    💁🏻♂️ Help: If you need any help, you can call us at +923269498569."
- If the user enters a specific number (1-7), give the following responses:
    - If the user enters only 1, give the following response:
        If you are interested in insights related to your business, please find the available reports below:
            -> Profit Loss Report: Detailed analysis of your financial performance.
            -> Stock Report: Overview of your current inventory status.
            -> Sales Report: Summary of sales activities.
            -> Purchase Report: Insights into procurement activities.
            -> Trending Item Report: Highlights of popular products in demand.
    - If the user enters only 2, give the following response:
        For strategic planning and inventory management, consider the following forecasts:
            -> Sales Forecast: Projected sales for upcoming periods.
            -> Product Sales Forecast: Expected sales performance of specific products.
    - If the user enters only 3, give the following response:
        -> You have expressed interest in identifying the best-selling item. Please allow me to provide you with detailed insights.
    - If the user enters only 4, give the following response:
        -> Feel free to ask any questions regarding the status of your business. I’m here to assist you.
    - If the user enters only 5, give the following response:
        For inquiries or further assistance, please send your query to:
            -> Contact Number: +923269498569
    - If the user enters only 6, give the following response:
        Your feedback is invaluable to us. Kindly share your thoughts and suggestions at:
            -> Contact Number: +923269498569
    - If the user enters only 7, give the following response:
        -> Check out our latest offers and promotions to maximize your business potential.
- **Fallback**: If the query doesn't match a greeting or a specific command (1-7), provide a professional and clean response based on the user's question.
    When answering based on retrieved documents, make sure to exclude unnecessary metadata (like document IDs) and display only the relevant content. For example, extract the actual report details such as sales, purchases, and other key information without showing raw document metadata.
    Example response for a "purchase report":
    "It seems like you're asking about the purchase report. Here's what I found:
    - Total Purchase (including tax): 3150.00
    - Total Purchase (excluding tax): 3150.00
    - Purchase Due: 3150.00
    - Shipping Charges: 0.00
    - Additional Expenses: 0.00
    - Sales Total (including tax): 1000000000000953067.33
    - Sales Total (excluding tax): 1000000000000945928.50"
    Ensure the information is formatted clearly and no irrelevant document information (such as IDs or metadata) is displayed.
Context: {retrieved_documents}
Question: {query}
"""
    prompt = PromptTemplate(
        input_variables=['retrieved_documents', 'query'],
        template=chat_template
    )
    
    Generated_chat = LLMChain(llm=llama3, prompt=prompt)
    result = Generated_chat.run({
        "retrieved_documents": retrieved_documents,
        "query": query
    })

    # Append the conversation history
    history.append((query, result))

    return history, result

# Define Gradio UI
with gr.Blocks() as demo:
    chatbot = gr.Chatbot(label="AI Chat")
    query = gr.Textbox(label="Ask anything!")
    initialize_button = gr.Button("Initialize Embeddings")
    update_csv_button = gr.Button("Update CSV Files")

    def on_query(query, history):
        return generate_response(query, history)
    
    query.submit(on_query, [query, chatbot], [chatbot, query])

    initialize_button.click(initialize_embedding, outputs=None)
    update_csv_button.click(update_csv_files, outputs=None)

# Launch Gradio App
demo.launch()