app.py

import logging
import os
import streamlit as st 
from dotenv import load_dotenv
import openai
from langchain_openai import ChatOpenAI
from langchain_community.vectorstores import FAISS
from langchain_openai import OpenAIEmbeddings
from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.agents import tool, AgentExecutor
from langchain.agents.output_parsers.openai_tools import OpenAIToolsAgentOutputParser
from langchain.agents.format_scratchpad.openai_tools import format_to_openai_tool_messages
from langchain_core.messages import AIMessage, HumanMessage
from langchain_community.document_loaders import TextLoader
from langchain_text_splitters import CharacterTextSplitter
from langchain.text_splitter import RecursiveCharacterTextSplitter
from urllib.parse import quote, urlparse

import serpapi
import requests 
import streamlit.components.v1 as components
import smtplib
from email.mime.multipart import MIMEMultipart
from datetime import datetime
import pandas as pd
import re
from io import BytesIO
import base64

import random
from bs4 import BeautifulSoup
import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from markdownify import markdownify
import chargebee
import pyrebase
import streamlit.components.v1 as components
import time
import warnings
from streamlit.components.v1 import html
from langchain.docstore.document import Document  
import firebase_admin
import uuid
import json
import io
from firebase_admin import credentials, firestore
import base64
from pdfminer.high_level import extract_text  # Import for PDF text extraction
from PIL import Image
from PyPDF2 import PdfReader
import docx

st.set_page_config(layout="wide")
import logging
import asyncio
import re 
from langchain_community.tools import TavilySearchResults

# Set up logging to suppress Streamlit warnings about experimental functions
logging.getLogger('streamlit').setLevel(logging.ERROR)
INITIAL_MESSAGE_LIMIT = 100


if "wix_user_id" not in st.session_state:
    st.session_state["wix_user_id"] = str(uuid.uuid4())  # Assign unique user ID for the session
if "email" not in st.session_state:
    st.session_state["email"] = f"user_{uuid.uuid4()}@example.com"
if "message_limit" not in st.session_state:
    st.session_state["message_limit"] = 1000
if "used_messages" not in st.session_state:
    st.session_state["used_messages"] = 0
if "chat_history" not in st.session_state:
    st.session_state["chat_history"] = []
if "documents" not in st.session_state:
    st.session_state["documents"] = {}

# Initialize logging and load environment variables
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
load_dotenv()

chargebee.configure(site="mextconsulting", api_key="live_dBLXn8yG5dFcuIgU5Szebj2KfTcdt4hjpf")

# Firebase Configuration
firebase_config = {
    "apiKey": "AIzaSyAWiaqrduoG7fzmJxBVnVg9nCC4EoEnwfY",
    "authDomain": "trustai-3e7a2.firebaseapp.com",
    "databaseURL": "https://trustai-3e7a2-default-rtdb.firebaseio.com",
    "projectId": "trustai-3e7a2",
    "storageBucket": "trustai-3e7a2.appspot.com",
    "messagingSenderId": "964339831031",
    "appId": "1:964339831031:web:66d21ceea68ab03f1043f2",
   "measurementId": "G-ZMLZQZMHK2"
}
# Initialize Firebase
firebase = pyrebase.initialize_app(firebase_config)
db = firebase.database()
storage = firebase.storage()

backend_url = "https://backend-web-05122eab4e09.herokuapp.com"

def convert_pdf_to_md(file):
    """
    Convert a PDF file to Markdown.
    """
    try:
        text = extract_text(file)
        return f"# PDF Document\n\n{text}"
    except Exception as e:
        logger.error(f"Error converting PDF to MD: {e}")
        return ""

def convert_docx_to_md(file):
    """
    Extract text from a .docx file and return as a single string.
    """
    try:
        # Read the file
        doc =  docx.Document(file)
        # Extract all text
        text = "\n".join([paragraph.text for paragraph in doc.paragraphs])
        if not text.strip():  # Handle empty content
            raise ValueError("The document has no content.")
        return text
    except Exception as e:
        raise ValueError(f"Error reading .docx file: {e}")

def convert_txt_to_md(file):
    """
    Convert a TXT file to Markdown.
    """
    try:
        text = file.read().decode("utf-8")
        return f"# Text Document\n\n{text}"
    except Exception as e:
        logger.error(f"Error converting TXT to MD: {e}")
        return ""
def display_save_confirmation(type_saved):
    """
    Display a confirmation message when content is saved.
    """
    st.info(f"Content successfully saved as **{type_saved}**!")

def convert_file_to_md(file):
    """
    Detect file type and convert to Markdown accordingly.
    """
    if file.type == "application/pdf":
        return convert_pdf_to_md(file)
    elif file.type == "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
        return convert_docx_to_md(file)
    elif file.type == "text/plain":
        return convert_txt_to_md(file)
    else:
        st.sidebar.warning(f"Unsupported file type: {file.type}")
        return ""

def merge_markdown_contents(contents):
    """
    Merge multiple Markdown contents into a single Markdown string.
    """
    merged_content = "\n\n---\n\n".join(contents)
    return 


def upload_to_firebase(user_id, file):
    """
    Upload document to Firebase, extract content, and add it to the knowledge base.
    """
    content = convert_file_to_md(file)  # Ensure this function extracts content correctly
    if not content:
        return None, "Failed to extract content from the file."
    
    existing_files = st.session_state.get("documents", {})
    for doc_id, doc_data in existing_files.items():
        if doc_data["name"] == file.name and doc_data["content"] == content:
            return None, f"File '{file.name}' already exists."

    doc_id = str(uuid.uuid4())
    document_data = {"content": content, "name": file.name}

    # Save document to Firebase
    db.child("users").child(user_id).child("KnowledgeBase").child(doc_id).set(document_data)
    fetch_documents() 
    # Add content to the knowledge base
    if "knowledge_base" not in st.session_state:
        st.session_state["knowledge_base"] = []
    st.session_state["knowledge_base"].append({"doc_id": doc_id, "content": content})

    # Index the document content for semantic search
    index_document_content(content, doc_id)

    st.sidebar.success(f"Document '{file.name}' uploaded successfully and added to the knowledge base!")
    return content, None


    
def index_document_content(doc_content, doc_id):
    """
    Indexes the document content by splitting it into chunks and creating embeddings.
    """
    text_splitter = RecursiveCharacterTextSplitter(chunk_size=2000, chunk_overlap=500)
    texts = text_splitter.split_text(doc_content)

    # Create embeddings for each chunk
    embeddings = OpenAIEmbeddings(model="text-embedding-ada-002", api_key=openai_api_key)
    doc_metadata = [{"doc_id": doc_id, "chunk_id": i} for i in range(len(texts))]
    vector_store = FAISS.from_texts(texts, embeddings, metadatas=doc_metadata)

    # Save the vector store in session state
    if "vector_store" not in st.session_state:
        st.session_state["vector_store"] = {}
    st.session_state["vector_store"][doc_id] = vector_store










def fetch_trustbuilders(user_id):
    """
    Retrieve TrustBuilders from Firebase for a specific user.
    """
    try:
        trustbuilders = db.child("users").child(user_id).child("TrustBuilders").get().val()
        
        if trustbuilders:
            # Extract content from TrustBuilders
            return [tb["content"] for tb in trustbuilders.values()]
        else:
            st.warning("No TrustBuilders found in Firebase.")
            return []
    except Exception as e:
        st.error(f"Error fetching TrustBuilders: {e}")
        return []

def delete_trustbuilder(user_id, trustbuilder_id):
    try:
        db.child("users").child(user_id).child("TrustBuilder").child(trustbuilder_id).remove()
        st.success("TrustBuilder deleted successfully.")
        st.rerun()
    except Exception as e:
        st.error(f"Error deleting TrustBuilder: {e}")

        

# Define and validate API keys
openai_api_key = os.getenv("OPENAI_API_KEY")
serper_api_key = os.getenv("SERPER_API_KEY")

if not openai_api_key or not serper_api_key:
    logger.error("API keys are not set properly.")
    raise ValueError("API keys for OpenAI and SERPER must be set in the .env file.")

openai.api_key = openai_api_key


st.markdown("""
    <style>
    .custom-image img {
        width: 100px;  /* Set the width to make the image smaller */
        height: auto;  /* Keep the aspect ratio */
    }
    </style>
    """, unsafe_allow_html=True)
if "chat_started" not in st.session_state:
    st.session_state["chat_started"] = False
if 'previous_trust_tip' not in st.session_state:
    st.session_state.previous_trust_tip = None
if 'previous_suggestion' not in st.session_state:
    st.session_state.previous_suggestion = None

if 'used_trust_tips' not in st.session_state:
    st.session_state.used_trust_tips = set()
if 'used_suggestions' not in st.session_state:
    st.session_state.used_suggestions = set()


# Suppress Streamlit deprecation and warning messages

def copy_to_clipboard(text):
    """Creates a button to copy text to clipboard."""
    escaped_text = text.replace('\n', '\\n').replace('"', '\\"')
    copy_icon_html = f"""
    <style>
    .copy-container {{
        position: relative;
        margin-top: 10px;
        padding-bottom: 30px; /* Space for the button */
        font-size: 0; /* Hide extra space */
    }}
    .copy-button {{
        background: none;
        border: none;
        color: #808080; /* Grey color */
        cursor: pointer;
        font-size: 18px; /* Adjust icon size */
        position: absolute;
        bottom: 0;
        right: 0;
    }}
    .copy-button:hover {{
        color: #606060; /* Darker grey on hover */
    }}
    .copy-message {{
        font-size: 12px;
        color: #4CAF50;
        margin-left: 10px;
        display: none;
    }}
    </style>
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0-beta3/css/all.min.css">
    <div class="copy-container">
        <button class="copy-button" onclick="copyToClipboard()">
            <i class="fas fa-copy"></i>
        </button>
        <span class="copy-message" id="copy_message">Copied!</span>
    </div>
    
    <script>
    function copyToClipboard() {{
        var textArea = document.createElement("textarea");
        textArea.value = "{escaped_text}";
        document.body.appendChild(textArea);
        textArea.select();
        document.execCommand("copy");
        document.body.removeChild(textArea);
        
        var copyMessage = document.getElementById("copy_message");
        copyMessage.style.display = "inline";
        setTimeout(function() {{
            copyMessage.style.display = "none";
        }}, 2000);
    }}
    </script>
    """
    components.html(copy_icon_html, height=60)
 
def send_feedback_via_email(name, email, feedback):
    """Sends an email with feedback details."""
    smtp_server = 'smtp.office365.com'  
    smtp_port = 465  # Typically 587 for TLS, 465 for SSL
    smtp_user = os.getenv("EMAIL_ADDRESS") 
    smtp_password = os.getenv("Password")   

    msg = MIMEMultipart()
    msg['From'] = smtp_user
    msg['To'] = "wajahat698@gmail.com"
    msg['Subject'] = 'Feedback Received'
    
    body = f"Feedback received from {name}:\n\n{feedback}"
    msg.attach(MIMEText(body, 'plain'))

    try:
        with smtplib.SMTP(smtp_server, smtp_port, timeout=10) as server:
            server.set_debuglevel(1)  # Enable debug output for troubleshooting
            server.starttls()  
            server.login(smtp_user, smtp_password)
            server.sendmail(smtp_user, email, msg.as_string())
            st.success("Feedback sent via email successfully!")
    except smtplib.SMTPConnectError:
        st.error("Failed to connect to the SMTP server. Check server settings and network connectivity.")
    except smtplib.SMTPAuthenticationError:
        st.error("Authentication failed. Check email and password.")
    except Exception as e:
        st.error(f"Error sending email: {e}")



def clean_text(text):
    text = text.replace('\\n', '\n')

    # Remove all HTML tags, including nested structures
    text = re.sub(r'<[^>]*>', '', text)
    # Remove any remaining < or > characters
    text = text.replace('<', '').replace('>', '')
    text = re.sub(r'<[^>]+>', '', text)
    text = re.sub(r'(\d+)\s*(B|M|T|billion|million|trillion)', lambda m: f"{m.group(1)} {m.group(2)}", text)    
    text = re.sub(r'(\d)\s*([a-zA-Z])', r'\1 \2', text)  # Fix numbers next to letters
    text = re.sub(r'(\d+)\s+([a-zA-Z])', r'\1 \2', text)  # Fix broken numbers and words
    text = re.sub(r'<span class="(mathnormal|mord)">.*?</span>', '', text, flags=re.DOTALL)

    # Split the text into paragraphs
    paragraphs = text.split('\n\n')
    
    cleaned_paragraphs = []
    for paragraph in paragraphs:
        lines = paragraph.split('\n')
        cleaned_lines = []
        for line in lines:
            # Preserve bold formatting for headings
            if line.strip().startswith('**') and line.strip().endswith('**'):
                cleaned_line = line.strip()
            else:
                # Remove asterisks, special characters, and fix merged text
                cleaned_line = re.sub(r'\*|\−|\∗', '', line)
                cleaned_line = re.sub(r'([a-z])([A-Z])', r'\1 \2', cleaned_line)
            
            # Handle bullet points
            if cleaned_line.strip().startswith('-'):
                cleaned_line = '\n' + cleaned_line.strip()
            
            # Remove extra spaces
          
            cleaned_lines.append(cleaned_line)
        
        # Join the lines within each paragraph
        cleaned_paragraph = '\n'.join(cleaned_lines)
        cleaned_paragraphs.append(cleaned_paragraph)
    
    # Join the paragraphs back together
    cleaned_text = '\n\n'.join(para for para in cleaned_paragraphs if para)
    return cleaned_text
    

 
  

def get_trust_tip_and_suggestion():
    trust_tip = random.choice(trust_tips)
    suggestion = random.choice(suggestions)
    return trust_tip, suggestion



def load_main_data_source():
    try:
        with open("./data_source/time_to_rethink_trust_book.md", "r") as f:
            main_content = f.read()
        
        # Split main content into chunks
        text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
        main_texts = text_splitter.split_text(main_content)

        # Create Document objects for the main data source
        main_documents = [Document(page_content=text) for text in main_texts]
        return main_documents
    except Exception as e:
        st.error(f"Error loading main data source: {e}")
        return []



def refresh_faiss_index():
    combined_sources = load_main_data_source()
    if combined_sources:
        embeddings = OpenAIEmbeddings()
        db_faiss = FAISS.from_documents(combined_sources, embeddings)
        st.session_state["faiss_db"] = db_faiss


def update_message_counter():
    remaining_messages = st.session_state["message_limit"] - st.session_state["used_messages"]
    message_counter_placeholder = st.sidebar.empty()

    message_counter_placeholder.markdown(f" Message left : unlimited \n\n Unlimited chats for a limited time")




def store_brand_tonality(user_id, message):
    try:
        tonality_id = str(uuid.uuid4())
        # Save to Firebase
        db.child("users").child(user_id).child("BrandTonality").child(tonality_id).set({"message": message})

        # Update `st.session_state` for immediate sidebar display
        if "BrandTonality" not in st.session_state:
            st.session_state["BrandTonality"] = {}
        st.session_state["BrandTonality"][tonality_id] = {"message": message}

        # Confirmation
        display_save_confirmation("Brand Tonality")

    except Exception as e:
        st.error(f"Error saving Brand Tonality: {e}")


def store_trustbuilder(user_id, message):
    try:
        trustbuilder_id = str(uuid.uuid4())
        # Save to Firebase
        db.child("users").child(user_id).child("TrustBuilder").child(trustbuilder_id).set({"message": message})

        # Update `st.session_state` for immediate sidebar display
        if "TrustBuilder" not in st.session_state:
            st.session_state["TrustBuilder"] = {}
        st.session_state["TrustBuilder"][trustbuilder_id] = {"message": message}

        # Confirmation
        display_save_confirmation("TrustBuilder")

    except Exception as e:
        st.error(f"Error saving TrustBuilder: {e}")


def load_user_content(user_id):
    """
    Load all content for a user from Firebase, ensuring each user has a single root
    containing TrustBuilder, BrandTonality, and other data fields like email, message limits, etc.
    """
    try:
        user_data = db.child("users").child(user_id).get().val()
        if user_data:
            # Update session state with all user data
            st.session_state.update(user_data)
            
            # Load TrustBuilder and BrandTonality into session state for display
            st.session_state["TrustBuilder"] = user_data.get("TrustBuilder", {})
            st.session_state["BrandTonality"] = user_data.get("BrandTonality", {})
            
    except Exception as e:
         st.info("not loaded ")

def save_content(user_id, content):
    """
    Save a TrustBuilder as plain text under the user's TrustBuilders node in Firebase.
    """
    try:
        # Prepare the TrustBuilder data
        trustbuilder_data = {
            "content": content
        }
        
        # Push to TrustBuilders node under the user's ID
        db.child("users").child(user_id).child("TrustBuilders").push(trustbuilder_data)
        
        st.success("TrustBuilder saved successfully!")
    except Exception as e:
        st.error(f"Error saving TrustBuilder: {e}")

        
def ai_allocate_trust_bucket(trust_builder_text):
    # Implement your AI allocation logic here
    return "Stability"

        

def download_link(content, filename):
    """
    Create a download link for content.
    """
    b64 = base64.b64encode(content.encode()).decode()
    return f'<a href="data:text/plain;base64,{b64}" download="{filename}">Download</a>'




def fetch_documents():
    """
    Fetch all documents for the current user from Firebase and update session state.
    """
    user_id = st.session_state["wix_user_id"]
    try:
        documents = db.child("users").child(user_id).child("KnowledgeBase").get()
        st.session_state["documents"] = {
            doc.key(): doc.val() for doc in documents.each()
        } if documents.each() else {}
    except Exception as e:
        st.sidebar.error(f"Error fetching documents: {e}")


# Function to delete a document from Firebase
def delete_document(user_id, doc_id):
    """
    Deletes a document from Firebase.
    """
    try:
        db.child("users").child(user_id).child("KnowledgeBase").child(doc_id).remove()
        st.success("Document deleted successfully!")
        st.rerun()  # Refresh the list after deletion
    except Exception as e:
        st.error(f"Error deleting document: {e}")







def side():
    with st.sidebar:

        with st.sidebar.expander("**TrustLogic®**", expanded=False):
                st.image("Trust Logic_Wheel_RGB_Standard.png")
            
                st.markdown(
                    """
                    **TrustLogic®** is a proven, scientific method for building trust, showing how our minds process trust.  
                    Remember:
            
                    You can’t trust in general – only for specific reasons.
            
                    Our mind organizes these reasons into six types of trust:  
                    **Stability**, **Development**, **Relationship**, **Benefit**, **Vision**, and **Competence**.  
                    Together, they form your **trust score**. Every bit more trust counts and can be nudged up in each interaction.
            
                    Think of these as the **Six Buckets of Trust®** – the fuller each bucket, the greater the trust.
            
                    To build trust, understand what makes you more trustworthy in each **Trust Bucket®** and convey these **Trust Builders®** – because what I don’t know about you, I can’t trust.
            
                    **Stability + Development + Relationship + Benefit + Vision + Competence Trust = Your Trust.**
                    """
                )
                st.markdown("For detailed descriptions, visit [Academy](https://www.trustifier.ai/account/academy)")

            
        st.image("Trust Logic_Wheel_RGB_Standard.png")
        
        st.sidebar.markdown('<hr style="border: 2px solid rgb(255, 153, 0); width: 80%; margin: 20px auto;">', unsafe_allow_html=True)
                
        with st.sidebar.expander("**Trust Buckets® and Trust Builders®**", expanded=False):
                        
                        st.image("s (3).png")  # Adjust width as needed

                        
                        st.markdown(
                            "Our minds assess trust through Six Buckets of Trust® and determine their importance and order in a given situation. We then evaluate why we can or can’t trust someone in these Buckets. Trustifier.ai®, trained on 20 years of TrustLogic® application, helps you identify reasons why your audience can trust you in each Bucket and create trust-optimised solutions. It’s copy AI with substance."
                        )
                        st.markdown(
                            """
                            <style>
                                .stability { color: rgb(7, 55, 99); font-size: 24px; font-weight: bold; }
                                .development { color: rgb(241, 194, 50); font-size: 24px; font-weight: bold; }
                                .relationship { color: rgb(204, 0, 0); font-size: 24px; font-weight: bold; }
                                .benefit { color: rgb(56, 118, 29); font-size: 24px; font-weight: bold; }
                                .vision { color: rgb(255, 153, 0); font-size: 24px; font-weight: bold; }
                                .competence { color: rgb(111, 168, 220); font-size: 24px; font-weight: bold; }
                            </style>
                
                            <h3 class="stability">Stability Trust:</h3>
                            <p>Why can I trust you to have built a strong and stable foundation?</p>
                            <h5>Examples</h5>
                            <ul>
                                <li>
                                    Volkswagen Auto Lease Trust 2023-A's note issuance is an ABS transaction backed by prime automobile lease receivables. This ensures financial reliability for investors.
                                </li>
                                <li>
                                    The Group aims to reduce the life-cycle carbon emissions of its vehicles by <strong>30%</strong> compared to 2018, promoting environmental responsibility for customers.
                                </li>
                            </ul>

                            <h3 class="development">Development Trust:</h3>
                            <p>Why can I trust you to develop well in the future?</p>
                            <h5>Examples</h5>
                             <ul>
                                <li>
                                    In 2023, Volkswagen announced a <strong>€1 billion</strong> investment in a new development and procurement center for electric vehicles in Hefei, China, enhancing the company's commitment to e-mobility. This supports technological advancement for eco-conscious consumers.
                                </li>
                                <li>
                                    Volkswagen Group of America launched its first autonomous vehicle test program in Austin, Texas, in July 2023, spearheaded by a dedicated team of engineers. This supports innovation for tech enthusiasts.
                                </li>
                            </ul>
                            
                            <h3 class="relationship">Relationship Trust:</h3>
                            <p>What appealing relationship qualities can I trust you for?</p>
                            <h5>Examples</h5>
                            <ul>
                                <li>
                                    In March 2023, Volkswagen joined forces with <strong>20 universities</strong> worldwide to advance automotive research, impacting over <strong>5,000 students</strong>. This promotes educational partnerships for academic institutions.
                                </li>
                                <li>
                                    Dr. Herbert Diess, CEO of Volkswagen, led initiatives in 2023 to engage <strong>3,000 employees</strong> in community volunteering projects, enhancing corporate social responsibility. This supports community engagement for employees.
                                </li>
                            </ul>


                
                            <h3 class="benefit">Benefit Trust:</h3>
                            <p>What benefits can I trust you for?</p>
                            <h5>Examples</h5>

                            <ul>
                                <li>
                                    Volkswagen's commitment to becoming a <strong>net-carbon-neutral</strong> company by 2050 includes using recycled materials to reduce primary raw material needs, supporting sustainability. This promotes environmental responsibility for future generations.
                                </li>
                                <li>
                                    The company has reduced water consumption by <strong>24%</strong>, waste by <strong>75%</strong>, and VOC emissions by <strong>68%</strong> per vehicle as of 2023, highlighting its dedication to minimizing environmental impact. This supports eco-friendly manufacturing for industry stakeholders.
                                </li>
                            </ul>

                            
                            
                                                        
                
                            <h3 class="vision">Vision Trust:</h3>
                            <p>What Vision and Values can I trust you for?</p>
                            <h5>Examples</h5>


                            <ul>
                                <li>
                                    The company has committed to investing <strong>€180 billion</strong> between 2023 and 2027 in areas like battery technology, digitalization, and e-mobility, driving forward its vision of sustainable transport. This supports technological advancement for stakeholders.
                                </li>
                                <li>
                                    Volkswagen's <strong>"NEW AUTO"</strong> strategy, unveiled in 2023, aims to transform the company into a leading provider of sustainable and software-driven mobility solutions by 2030. This supports future mobility innovation for the automotive industry.
                                </li>
                            </ul>

    
                            <h3 class="competence">Competence Trust:</h3>
                            <p>What competencies can I trust you for?</p>
                            <h5>Examples</h5>

                            
                            <ul>
                                <li>
                                    Volkswagen's manufacturing plants in Wolfsburg, Germany, are known for their advanced automation and production techniques, producing over <strong>800,000 vehicles annually</strong>. This supports manufacturing excellence for industry professionals.
                                </li>
                                <li>
                                    Volkswagen's design team, led by <strong>Klaus Bischoff</strong>, has received accolades for innovative vehicle designs, enhancing aesthetic appeal and functionality. For instance, the Volkswagen Touareg received the top gold award in the "Passenger Vehicles" category at the German Design Awards. This supports creativity for automotive designers.
                                </li>
                            </ul>

                                                      
                            
                            
                            
                            """, unsafe_allow_html=True
                        )
                        st.markdown("For detailed descriptions, visit [Academy](https://www.trustifier.ai/account/academy)")

        st.image("s (3).png")  # Adjust width as needed


                
        st.sidebar.markdown('<hr style="border: 2px solid rgb(255, 153, 0); width: 80%; margin: 20px auto;">', unsafe_allow_html=True)

        st.header("TrustVault®")
        st.markdown("In the TrustVault you can save your preferred trust equity Trust Builders®, great outputs, brand and segment info for easy use.")
        st.sidebar.markdown("""
            <style>
            .scrollable-container {
                max-height: 200px;
                overflow-y: auto;
                border: 1px solid gray;
                padding: 10px;
                border-radius: 5px;
                background-color: #f9f9f9;
                margin-bottom: 10px;
            }
            .button-container {
                display: flex;
                justify-content: space-between;
                gap: 10px;
            }
            .stTextArea [data-baseweb="textarea"] {
                    resize: none; /* Disable resizing */
                    overflow: hidden; /* Hide scrollbars */
                }
            </style>
        """, unsafe_allow_html=True)
            
        # Fetch documents from Firebase
        
        if "documents" not in st.session_state:
            try:
                docs = db.child("users").child(st.session_state["wix_user_id"]).child("KnowledgeBase").get().val()
                st.session_state["documents"] = docs if docs else {}
            except Exception as e:
                st.sidebar.error(f"Error fetching documents: {e}")
                st.session_state["documents"] = {}
        
        def update_saved_docs_content():
            return "\n\n---\n\n".join(
                [
                    f"**{doc_data.get('name', f'Document {doc_id[:8]}')}**\n{doc_data.get('content', 'No content available')}"
                    for doc_id, doc_data in st.session_state["documents"].items()
                ]
            ) if st.session_state["documents"] else "Save documents like your brand tonality, key phrases, or segments here and they will show here."
        saved_docs_content = update_saved_docs_content()

        st.text_area(
            label="",
            value=saved_docs_content,
            height=150,
            key="saved_documents_text_area",
            disabled=True
        )
        
        # File uploader
        uploaded_files = st.file_uploader(
            "",
            type=["pdf", "docx", "txt"],
            accept_multiple_files=True,
            key="file_uploader"
        )        
        
        if uploaded_files:
            for uploaded_file in uploaded_files:
                try:
                    upload_to_firebase(st.session_state["wix_user_id"], uploaded_file)
                except Exception as e:
                    st.sidebar.error(f"Error processing file '{uploaded_file.name}': {e}")
        
        
        # Display and delete functionality for documents
        if st.session_state.get("documents"):
            doc_ids = list(st.session_state["documents"].keys())
            doc_options = ["None (use only main knowledge base)"] + doc_ids
            selected_options = st.multiselect(
                "",
                options=doc_options,
                default="None (use only main knowledge base)",
                format_func=lambda x: st.session_state["documents"][x].get("name", f"Document {x}") if x != "None (use only main knowledge base)" else x,
                key="select_docs"
            )
            selected_doc_ids = [doc_id for doc_id in selected_options if doc_id != "None (use only main knowledge base)"]
            st.session_state['selected_doc_ids'] = selected_doc_ids

            if selected_doc_ids:
                selected_doc_names = [st.session_state['documents'][doc_id]['name'] for doc_id in selected_doc_ids]
                st.info(f"Selected Documents: {', '.join(selected_doc_names)}")
            else:
                st.sidebar.info("Using only the main knowledge base.")
        else:
          
            selected_doc_ids = []
        
        # Button to delete the selected documents
        if selected_doc_ids:
            if st.button("Delete", key="delete_button"):
                try:
                    for doc_id in selected_doc_ids:
                        # Remove the document from Firebase
                        db.child("users").child(st.session_state["wix_user_id"]).child("KnowledgeBase").child(doc_id).remove()
        
                        # Remove from session state
                        st.session_state["vector_store"].pop(doc_id, None)
                        st.session_state["documents"].pop(doc_id, None)
        
                    st.success("Selected documents deleted successfully!")
                    st.rerun()
                except Exception as e:
                    st.sidebar.error(f"Error deleting document: {e}")
    
        st.sidebar.markdown("</div>", unsafe_allow_html=True)
        trust_buckets = ["Any","Stability", "Development", "Relationship", "Benefit", "Vision", "Competence"]

      
        


        st.markdown("""
            <style>
            .info-icon {
                display: inline-block;
                margin-left: 8px;
                color: #007BFF;
                cursor: pointer;
                position: relative;
            }
            .tooltip {
                visibility: hidden;
                width: 250px;
                background-color: #555;
                color: #fff;
                text-align: center;
                border-radius: 5px;
                padding: 5px;
                position: absolute;
                z-index: 1;
                bottom: 125%; /* Position above the icon */
                left: 50%;
                margin-left: -125px; /* Center the tooltip */
                opacity: 0;
                transition: opacity 0.3s;
            }
            .info-icon:hover .tooltip {
                visibility: visible;
                opacity: 1;
            }
            </style>
        """, unsafe_allow_html=True)
        
        # Add the header with the info icon and hover effect
        st.markdown("""
            <div style="display: flex; align-items: center;">
                <h3>Show My TrustBuilders®</h3>
                <div class="info-icon">
                    ⓘ
                    <span class="tooltip">You can ask AI to find your TrustBuilders® also by prompting "show my saved trustbuilders".</span>
                </div>
            </div>
        """, unsafe_allow_html=True)

        
        search_query = st.text_input("Search by keyword", key="search_query")
        st.write("or")
        search_query1 = st.text_input("Search by Brand/Product/Person", key="search_query1")
        
        # Dropdown for selecting a trust bucket
        selected_bucket = st.selectbox("Select Trust Bucket", trust_buckets, key="selected_bucket")
        
        # Button to show results
        if st.button("Show TrustBuilders", key="show_trustbuilders"):
            # Fetch trustbuilders
            trustbuilders = fetch_trustbuilders(st.session_state.get("wix_user_id"))
        
            # Initialize variable for a match
            matching_trustbuilders = []
        
            # Filter trustbuilders based on the criteria
            for tb in trustbuilders:
                # Split bucket and text
                bucket, text = tb.split(": ", 1) if ": " in tb else ("", tb)
        
                # Check if bucket matches or "Any" is selected
                bucket_matches = selected_bucket == "Any" or bucket == selected_bucket
        
                # Match keyword or brand/product/person search
                keyword_match = search_query.lower() in text.lower() if search_query else False
                additional_match = search_query1.lower() in text.lower() if search_query1 else False
        
                # Append if all conditions are met
                if bucket_matches and (keyword_match or additional_match):
                    matching_trustbuilders.append(tb)
        
            # Display the first matching trustbuilder
            if matching_trustbuilders:
                st.write("### Result:")
                # Join the matching trustbuilders into a bullet list
                st.markdown("\n".join([f"- {tb}" for tb in matching_trustbuilders]))
            else:
                st.write("No TrustBuilders found matching the criteria.")


            
                # UI for saving TrustBuilders
        st.subheader("Save TrustBuilders®")
        brand_save = st.text_input("Brand/Product/Person", key="brand_input_save")
        trust_builder_text = st.text_area("Type/paste Trust Builder®", key="trust_builder_text")
        trust_buckets = ["Stability", "Development", "Relationship", "Benefit", "Vision", "Competence"]
        selected_save_bucket = st.selectbox("Allocate to®", trust_buckets, key="save_bucket")
        
        col1, col2 = st.columns([1, 1])  # Adjust column widths as needed
        with col1:

            if st.button("Allocate", key="save_trustbuilder"):
                        if trust_builder_text.strip() and selected_save_bucket:
                            content_to_save = f"{selected_save_bucket}: Brand: {brand_save.strip()} | {trust_builder_text.strip()}"
                            save_content(st.session_state.get("wix_user_id"), content_to_save)
                        else:
                            st.warning("Please fill all fields")
    
        with col2:
            
            tooltip_css = """
                <style>
                    /* Tooltip container styling */
                    .tooltip-container {
                        position: relative; 
                        display: inline-block; 
                        vertical-align: top; 
                        width: 100%;
                        margin-top: -15px; /* Aligns with st.button */
                    }
        
                    /* Tooltip text styling */
                    .tooltip-container .tooltiptext {
                        visibility: hidden;
                        width: 300px; /* Fixed width for better readability */
                        max-width: 90%; /* Ensure tooltip fits within sidebar */
                        background-color: #f9f9f9;
                        color: #333;
                        text-align: left;
                        border-radius: 8px;
                        padding: 10px;
                        box-shadow: 0px 4px 8px rgba(0, 0, 0, 0.1);
                        position: absolute;
                        z-index: 1000; /* Ensure tooltip is above other elements */
                        top: calc(100% + 10px); /* Position tooltip below the button with spacing */
                        left: 50%; /* Center horizontally */
                        transform: translateX(-50%);
                        opacity: 0;
                        transition: opacity 0.3s ease-in-out;
                    }
        
                    /* Show tooltip on hover */
                    .tooltip-container:hover .tooltiptext {
                        visibility: visible;
                        opacity: 1;
                    }
        
                    /* Button styling */
                    .tooltip-container button {
                        background-color: rgb(82, 129, 134);
                        color: white;
                        border: none;
                        padding: 8px 16px;
                        font-size: 14px;
                        border-radius: 5px;
                        cursor: pointer;
                        box-shadow: 0px 4px 8px rgba(0,0,0,0.2);
                        font-family: Arial, sans-serif;
                    }
        
                    /* Hover effect for button */
                    .tooltip-container button:hover {
                        background-color: rgb(70, 115, 119);
                    }
                </style>
            """
        
            # Inject CSS
            st.markdown(tooltip_css, unsafe_allow_html=True)
        
            # Tooltip Button
            st.markdown("""
                <div class="tooltip-container">
                    <button>LetAI Allocate</button>
                    <span class="tooltiptext">
                        <b>Here’s how you can save your TrustBuilder®:</b><br><br>
                        1. Type your TrustBuilder® in the chat.<br>
                        2. If unsure of the TrustBucket®, ask the AI:<br>
                           <i>"Hey, which TrustBucket does this TrustBuilder® belong to?"</i><br><br>
                        3. Save it using the following format:<br>
                           <code>Save this as a TrustBuilder. [BucketName]. [TrustBuilder Text]</code><br><br>
                        Example:<br>
                           <code>Save this as a TrustBuilder. Stability. We focus on keeping and nurturing our team.</code>
                    </span>
                </div>
            """, unsafe_allow_html=True)
        
        
        
        




side()
update_message_counter()
if st.session_state.get("wix_user_id") and "faiss_db" not in st.session_state:
    refresh_faiss_index()










 

# Define search functions
def search_knowledge_base(query):
    """
    Searches the FAISS index using the provided query.
    Returns the most relevant documents based on the query.
    """
    if "faiss_db" not in st.session_state:
        st.error("FAISS database is not initialized.")
        return []

    # Retrieve the top 5 most relevant documents
    retrieved_docs = st.session_state["faiss_db"].similarity_search(query, k=7)
    return retrieved_docs


def google_search(query):
    """
    Performs a Google search using the SerpApi service and retrieves search result snippets.

    This function uses the SerpApi client to perform a Google search based on the provided query.
    It extracts and returns the snippets from the organic search results.

    Args:
        query (str): The search query to be used for the Google search.

    Returns:
        list: A list of snippets from the organic search results. If an error occurs, returns a list with an error message.

    Raises:
        requests.exceptions.HTTPError: If an HTTP error occurs during the search, it is logged and an error message is returned.
        Exception: For any other general errors, they are logged and an error message is returned.
    """
    try:
        # Set up connection to google.serper.dev API
        conn = http.client.HTTPSConnection("google.serper.dev")
        payload = json.dumps({"q": query})
        headers = {
            "X-API-KEY": "07b4113c2730711b568623b13f7c88078bab9c78",
            "Content-Type": "application/json",
        }

        # Send POST request to the API
        conn.request("POST", "/search", payload, headers)

        # Get response and decode the data
        res = conn.getresponse()
        data = res.read()
        results = json.loads(data.decode("utf-8"))

        # Extract snippets from organic search results
        snippets = [result["snippet"] for result in results.get("organic", [])]

        # Return the list of snippets
        return snippets
    except http.client.HTTPException as http_err:
        # Log HTTP errors and return a specific error message
        print(f"HTTP error occurred: {http_err}")
        return ["HTTP error occurred during Google search"]
    except Exception as e:
        # Log any other general errors and return a generic error message
        print(f"General Error: {e}")
        return ["Error occurred during Google search"]



def rag_response(query, selected_doc_ids=None):
    """
    Handle queries by searching both the main knowledge base and the selected documents.
    """
    try:
        results = []

        # Search FAISS database (main knowledge base)
        if "faiss_db" in st.session_state:
            retrieved_docs = search_knowledge_base(query)
            results.extend(retrieved_docs)

        # If selected_doc_ids is None, try to get it from session state
        if selected_doc_ids is None:
            selected_doc_ids = st.session_state.get('selected_doc_ids', [])

        # Search vector stores of the selected documents
        if selected_doc_ids:
            for doc_id in selected_doc_ids:
                vector_store = st.session_state.get("vector_store", {}).get(doc_id)
                if vector_store:
                    vector_store_results = vector_store.similarity_search(query, k=5)
                    results.extend(vector_store_results)
                else:
                    st.warning(f"Vector store for document '{st.session_state['documents'][doc_id]['name']}' not found.")

        # Combine results into a single context
        context = "\n".join([doc.page_content for doc in results])

        if not context.strip():
            return "No relevant information found in the knowledge bases."

        # Generate AI response with the retrieved context
        prompt = f"Context:\n{context}\n\nQuestion: {query}\nAnswer:"
        llm = ChatOpenAI(model="gpt-4", temperature=0.3, api_key=openai_api_key)
        response = llm.invoke(prompt)

        return response.content.strip()
    except Exception as e:
        logger.error(f"Error generating RAG response: {e}")
        return "An error occurred during the RAG response generation process."


# Define tools
@tool
def knowledge_base_tool(query: str):
    """Query the knowledge base and retrieve a response."""
    return rag_response(query)

@tool
def google_search_tool(query: str):
    """Perform a Google search using the SERPER API."""
    return google_search(query)

tavily_tool = TavilySearchResults(
    max_results=10,
    search_depth="advanced",
    topic="news",
    days=1,
    include_answer=True,
    include_raw_content=True,
    # include_domains=[...],
    exclude_domains=['example.com'],
    # name="...",            # overwrite default tool name
    # description="...",     # overwrite default tool description
    # args_schema=...,       # overwrite default args_schema: BaseModel
)
# Comp
# Compile all tool functions into a list
tools = [
    knowledge_base_tool,  # Tool for querying the knowledge base and retrieving responses
    tavily_tool,
    # google_search_tool,  # Tool for performing a Google search and retrieving search result snippets
]
prompt_message = f"""
** You are a Professional multilingual copywriter tasked with creating non-flowery fluid, interconnected marketing content that integrates Trust Builders into various formats . Your content should be compelling, factual, well-structured, concise, and based on the knowledgebase. Write in an active voice using the first-person perspective ("we"), and avoid the third-person perspective. Creatively interconnect trust-building elements to enhance flow and impact. Avoid using terms like Stability, Development, Competence, Relationship, Benefit, Vision, trust, beacon, beacon of hope, and realm, except where specified.
-Respond in the same language as in the query.

-When 'our,','VW,' ,'prospects','customers ' or 'Volkswagen' is mentioned, give  Volkswagen  information from the knowledge base.*


###Mandatory Verification Checklist
Before submitting any content, ensure it includes:
- **Specific Details**:
  - At least **three specific dollar amounts** with exact figures (e.g., "$127.5 million").
  - A minimum of **two full dates** with day/month/year (e.g., "March 15, 2023").
  - At least **three specific quantities** of people/items (e.g., "12,457 beneficiaries").
  - Minimum **two full names with titles**.
  - At least **two complete program names with years** (e.g., "Operation Healthy Future 2024-2025").
  - At least **one specific award** with year and organization (e.g., "2023 UN Global Health Excellence Award").
  - Minimum **two measurable outcomes with percentages** (e.g., "47% reduction in malnutrition").
**Audience Relevance**:
   - **Each point must be followed by**:
     - "This [specific benefit] for [specific audience]"
     - **Example**: "This reduces wait times by 47% for patients seeking emergency care."
-When query is specific to prospects or customers follow this:
    *Top Trustbuckets and Builders: 
        - Use the following format to display all buckets and display statements for prospects and customers from knowledgebase:
          Top-scoring statements
          -Give in bullet points under each bucket-name with percentage.
          **Bucket Name**
          1- TrustBuilder® Statement 1 [Percentage]
          2- TrustBuilder® Statement 2 [Percentage] 
          3- TrustBuilder® Statement 3 [Percentage]
          
      
### Sources and Specificity

- Include **valid source links** next to each trust building point.
- Replace vague phrases with specific details:
  - "many" → exact number.
  - "millions" → "$127.5 million".
  - "recently" → "March 15, 2023".
  - "global presence" → "offices in 127 cities across 45 countries".
  - "industry leader" → "ranked #1 in customer satisfaction by J.D. Power in 2023".
  - "significant impact" → "47% reduction in processing time".

### Critical Mandatory Instructions
- **Avoid Prohibited Terms**: Do not mention "trust," "trust buckets," or category names like Development, Stability, Competence, Relationship, Vision in the copy, except for headings and searches.
- **Consistency**: Maintain uniform format across all content types.
- **Tone**: Use an active, engaging, and direct tone.
- **Accuracy**: Ensure all details are current and correct.
- **Formatting**: Ensure clean and professional formatting, with no HTML tags.

### Content Types and Formats

#### Report/Article/Write-up/ Blog
- **Introduction**: "Here is a draft of your [Annual Report/Article/Write-up]. Feel free to suggest further refinements."
- **Headlines **: WRITE ONE CREATIVE ACTIVE LANGUAGE HEADLINE THAT SUMMARISES THE POINTS.Headline should be like this in activae language eg.we empower instead of empowering.**without mentioning prohibited terms**.
- **Content**:
        -**Donot give any source link in contents**
        - Write from the perspective of being part of the organization, using "we".
        - Maintain an active, engaging, and direct tone. Dont use flowery words
 
#### Social Media Posts
- **Introduction Line**: "Here is a draft of your social media post. Feel free to suggest further refinements."
- **Content**:
  - Ensure posts are concise, impactful, and designed to engage the audience.
  - Avoid prohibited terms or flowery language.
  - Focus on clear messaging with specific names, numbers, programs, strategies, places, awards, and actions.
- **Sub-Headings(After Summary) **:
  1. **List of TrustBuilders Used**: Provide relevant trust-building elements  followed  with embedded source links.
  2. **Heuristics and Creative Techniques**:
     -List them in a footnote-style small heading.
     -Use the following structure:
        -Heuristics: examples (e.g., social proof, authority, commitment).
        -Creative Techniques: examples (list only relevant marketing techniques without additional details).
     -Limit to 3-5 items in each category.
- **Additional Requirements**:
  - Do not include prohibited terms in hashtags or copy.
  - Ensure source links are not included in the post text.



### **Sales Conversations (between two persons)**

- **Introduction Line**:  
  Start with:  
  *"Here is a draft of your [Sales Conversation/Ad Copy]. Feel free to suggest further refinements."*

### **Content Guidelines**:
1. **Objective**:  
   Generate a **longer, detailed sales conversation** using **6+ TrustBuilders®**, with **4 from top-scoring Trust Buckets from knowledgebase **, based on both the **source data** and the **specific request**.
2. **Conversation Content**: - Avoid mentioning **source ** in the conversation.
   - Include **persuasive elements** integrated with **TrustBuilders®**.  
   - Use **TrustBuilders®** relevant to the **audience type (prospect or customer)** and **context**.  
   - Ensure TrustBuilders® are **fluidly interconnected** and fact-based.  
   - Avoid **flowery language**; focus on **specific, actionable details** (names, numbers, actions).  
   - Address **objections** with additional **high-scoring TrustBuilders®**.  
- **Sub-Headings(After Summary) **:
   1. **List of TrustBuilders Used**:- Include all TrustBuilders used with embedded source links.
   2. **Heuristics and Creative Techniques**:  
      - Use a **footnote-style small heading**.  
      - Structure as follows:  
        - **Heuristics**: (e.g., authority, social proof, commitment).  
        - **Creative Techniques**: (e.g., product demonstration, testimonial highlighting).  
      - Limit to **3-5 items** in each category.
  - Give correct sources even for trustbuilders from knowledgebase

### Emails, Newsletter, Direct Marketing Letters**
- **Introduction Line**: Start with "Here is a draft of your [Email/Newsletter/Letter,Blog]. Feel free to suggest further refinements."
- **Structure**:
  - **Headlines**: Create a compelling headline in active language that reflects the content, **without mentioning prohibited terms**.
  - **Content**:
    -  Use **headings** with all content paragraphs to structure the article.** Donot give any source link in contents**
    - **Perspective**: Write as if you are part of the organization (using "we"), emphasizing togetherness and collective effort.
    - **Integration**: Interweave various trust-builder  fluidly, focusing on specifics like names, numbers (dollar amounts and years), programs, strategies, places, awards, and actions, **without mentioning prohibited terms**.
    - **Avoid Flowery Language**: Ensure content is clear and factual.
    - Use an **active, engaging, and direct tone**. Eg:"World Vision partners with [organizations] to drive progress."
- **Sub-Headings(After Summary) **:
  1. **List of TrustBuilders Used**: Provide relevant trust-building elements  followed  with embedded source links.
  2. **Heuristics and Creative Techniques**:
     -List them in a footnote-style small heading.
     -Use the following structure:
        -Heuristics: examples (e.g., social proof, authority, commitment).
        -Creative Techniques: examples (list only relevant marketing techniques without additional details).
     -Limit to 3-5 items in each category.
     
### Trust-Based Queries:** 
Be over specific with numbers,names,dollars, programs ,awards and action. 
- When a query seeks a specific number of trust builders (e.g., "5 trust builders"), the AI should:
         - Randomly pick the requested number of trust buckets from the six available: Development Trust, Competence Trust, Stability Trust, Relationship Trust, Benefit Trust, and Vision Trust.
         - For each selected bucket, find 15  TrustBuilders® points be over specific with numbers,names,dollars, programs ,awards and action. 
         - Categorize these points into Organization, People, and Offers/Services (with 5 points for each category).
         - **Each point must be followed by**:
         - "This [specific benefit] for [specific audience]"
         - **Example**: "This reduces wait times by 47% for patients seeking emergency care."
       -For each selected bucket, find 15 TrustBuilders® points.
       
       -**Categorization:** Categorize these points into three sections with **specific details**:
        - **[Category Name]**
          - **Organization** (5 points)
          - **People** (5 points)
          - **Offers/Services** (5 points)
        - **[Next Category Name]**
          - **Organization** (5 points)
          - **People** (5 points)
          - **Offers/Services** (5 points)
      - **Important Specificity:** Always include **names**, **numbers** (e.g., $ amounts and years), **programs**, **strategies**, **places**, **awards**, and **actions** by searching on google to add credibility and depth to the content. Ensure that trust-building points are detailed and specific.
- **For Specific Categories:**
  - When a query asks for a specific category (e.g., "Development trust builders"), find 15 trust-building points that are specific with relevant names, numbers like $ amounts and years, programs, strategies, places, awards, and actions specifically for that category.
  - Categorize these points into Organization, People, and Offers/Services (with 5 points for each category).

-**Format:**
  - **Introduction Line:** Start with "Here are TrustBuilders® for [Selected Categories] at [Organization Name]. Let me know if you want to refine the results or find more."
  - **Categories:**
    - **Organization:**
      - [Trust-Building Point 1] - [Source](#)
      - [Trust-Building Point 2] - [Source](#)
      - [Trust-Building Point 3] - [Source](#)
      - [Trust-Building Point 4] - [Source](#)
      - [Trust-Building Point 5] - [Source](#)
    - **People:**
      - [Trust-Building Point 6] - [Source](#)
      - [Trust-Building Point 7] - [Source](#)
      - [Trust-Building Point 8] - [Source](#)
      - [Trust-Building Point 9] - [Source](#)
      - [Trust-Building Point 10] - [Source](#)
    - **Offers/Services:**
      - [Trust-Building Point 11] - [Source](#)
      - [Trust-Building Point 12] - [Source](#)
      - [Trust-Building Point 13] - [Source](#)
      - [Trust-Building Point 14] - [Source](#)
      - [Trust-Building Point 15] - [Source](#)
  - Ensure each selected category contains 15 trust-building points, categorized as specified.
  - Provide bullet points under each section with relevant accurate source link.
**Important Notes:**
  - Strictly search and provide accurate source links always.
  - **No Subheadings or Labels:** Under each main category, list the trust-building points directly as bullet points or numbered lists **without any additional subheadings, labels, descriptors, phrases, or words before the points**.
  - **Avoid Flowery Language:** Do not use any flowery or exaggerated language.
  - **Do Not Include:**
    - Heuristics and Creative Techniques** in Trust-Based Queries.
    - Subheadings or mini-titles before each point.
    - Labels or descriptors like "Strategic Partnerships:", "Global Reach:", etc.
    - Colons, dashes, or any formatting that separates a label from the point.
  - **Do Include:**
    - The full sentence of the trust-building point starting directly after the bullet, with specific details.
  - **Do Not Include the Prohibited Terms:** Do not mention the prohibited terms anywhere, **even when asked**.
-*Donot provide list of trustbuilders used and heuristics here. That is for copy applications not here.
- **Example of Correct Format**:
  **Organization**
  - In **2023**, World Vision invested **$150 million** in sustainable agriculture programs across **35 countries**, impacting over **2 million** farmers.This improves food security for vulnerable communities.- [Source](#)der each main category, list the trust-building points directly as bullet points or numbered lists **without any additional subheadings, labels, descriptors, phrases, or words before the points**.
**Audience Relevance**:
   - **Each point must be followed by**:
     - "This [specific benefit] for [specific audience]"
     - **Example**: "This reduces wait times by 47% for patients seeking emergency care."

### General Queries
- Do not use the knowledge base for non-trust content.
- Always clarify the audience impact and ensure all information is based on verified sources.
-Refer knowledgebase when asked about trustifier or TrustLogic.



"""

prompt_template = ChatPromptTemplate.from_messages([
    ("system", prompt_message),
    MessagesPlaceholder(variable_name="chat_history"),
    ("user", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad"),
])

# Create Langchain Agent
llm = ChatOpenAI(
    model="gpt-4o",
    temperature=0.6,  # Balanced creativity and adherence
    max_tokens=3000,  # Ensure sufficient output length
    top_p=0.85,  # Focused outputs
    frequency_penalty=0.1,  # Minimize repetition
    presence_penalty=0.7  # Moderate novelty to maintain adherence
)


llm_with_tools = llm.bind_tools(tools)

# Define the agent pipeline
agent = (
    {
        "input": lambda x: x["input"],
        "agent_scratchpad": lambda x: format_to_openai_tool_messages(x["intermediate_steps"]),
        "chat_history": lambda x: x["chat_history"],
    }
    | prompt_template
    | llm_with_tools
    | OpenAIToolsAgentOutputParser()
)

# Instantiate an AgentExecutor
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# Streamlit app

# Display chat history
for message in st.session_state.chat_history:
    with st.chat_message(message["role"]):
        st.markdown(message["content"])

# Chat input
if not st.session_state.get("chat_started", False):


    st.markdown("""
    <script>
    document.addEventListener('DOMContentLoaded', (event) => {
        const svgs = document.querySelectorAll('svg');
        svgs.forEach(svg => {
            if (svg.getAttribute('xmlns') === 'http://www.w3.org/2000/svg' && svg.getAttribute('width') === '18' && svg.getAttribute('height') === '18') {
                svg.style.display = 'none';
            }
        });
    });
    </script>
    <style>
    /* Hide all <a> elements inside elements with block-container and st-emotion-cache-1eo1tir ea3mdgi5 classes */
    .block-container.st-emotion-cache-1eo1tir.ea3mdgi5 a {
        display: none !important;
    }
    /* Ensure links in the sidebar are visible and underlined */
    .stSidebar a {
        display: inline !important;
        text-decoration: underline !important;
        color: inherit !important;
    }
    /* Additional styles */
    .section-container {
        display: flex;
        justify-content: center;
        align-items: stretch;
        flex-wrap: wrap;
        gap: 4px;
    }
    
    .section {
        flex: 1;
        min-width: 150px;
        max-width: 90px;
        min-height: 150px;
        border: 1px solid #afafaf;
        border-radius: 10px;
        padding: 5px;
        background-color: transparent;
        margin: 3px;
        text-align: center;
        box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
        box-sizing: border-box;
        font-size: 12px;
        transition: background-color 0.3s ease;
    }
    .section h2 {
        color: #afafaf;
        font-size: 14px;
        margin-bottom: 8px;
        border-bottom: 1px solid #afafaf;
        padding-bottom: 4px;
        text-align: center; /* Center headings */
    }
    .section p {
        color: #afafaf;
        font-size: 11px;
        margin: 5px 0;
        line-height: 1.4;
    }
    @media (max-width: 100px) {
        .section {
            min-width: 90%;
            max-width: 90%;
        }
    }
    </style>
    
    <h1 style="text-align: center; background: #528186; -webkit-background-clip: text; color: transparent;">How can I help you today?</h1>
    <div class="section-container">
        <div class="section">
            <h2>Find</h2>
            <p>Discover all your great TrustBuilders®. <br> Example: Find Development Trust Builders® for Volkswagen
        </div>
        <div class="section">
            <h2>Create</h2>
            <p>Generate trust-optimised solutions : <br>Example: Find Volkswagen development TrustBuilders®. Then use them to write a 200-word annual report article. Enthusiastic tone.</p>
        </div>
        <div class="section">
            <h2>Trust-optimise</h2>
            <p>Paste your LinkedIn profile, EDM or blog and ask Trustifier.ai® to improve it using specific Trust Buckets® and add your specific TrustBuilders® as examples.</p>
        </div>
    </div>
    <div style="height: 50px;"></div> <!-- Adds a gap of 50px after the section containers -->
    """, unsafe_allow_html=True)
    
hide_specific_warning = """
<script>
document.addEventListener('DOMContentLoaded', function() {
    const alerts = window.parent.document.querySelectorAll('div[data-testid="stAlert"]');
    alerts.forEach(function(alert) {
        if (alert.innerText.includes('Please replace st.experimental_get_query_params with st.query_params')) {
            alert.style.display = 'none';          // Hide the warning
            alert.style.visibility = 'hidden';     // Make it invisible
            alert.style.height = '0px';            // Set height to zero to remove space
            alert.style.margin = '0px';            // Set margin to zero
            alert.style.padding = '0px';           // Set padding to zero
        }
    });
});
</script>
"""


# Embed the JavaScript in your Streamlit app
components.html(hide_specific_warning, height=0, scrolling=False)

query_params = st.experimental_get_query_params()
wix_user_id = query_params.get('wix_user_id', [None])[0]
email = query_params.get('email', [None])[0]

# Session state to track user login and message usage
if "wix_user_id" not in st.session_state:
    st.session_state["wix_user_id"] = wix_user_id
if "email" not in st.session_state:
    st.session_state["email"] = email
if "message_limit" not in st.session_state:
    st.session_state["message_limit"] = 0
if "used_messages" not in st.session_state:
    st.session_state["used_messages"] = 0


def receive_wix_message():
    components.html(
        """
        <script>
        window.addEventListener('message', function(event) {
            const data = event.data;
            if (data.wixUserId && data.email) {
                window.parent.postMessage({
                    'wix_user_id': data.wixUserId,
                    'email': data.email
                }, "*");

                // Send message back to Streamlit
                window.parent.postMessage({
                    wix_user_id: data.wixUserId,
                    email: data.email
                }, "*");
            }
        });
        </script>
        """,
        height=0
    )

# Calling  this function to initialize listening for Wix messages
receive_wix_message()

trust_tips = [
    "What I don’t know I can’t trust you for. Make sure you know all your great TrustBuilders® and use them over time.",
    "The more specific, the more trustworthy each TrustBuilder® is.",
    "For TrustBuilders®, think about each Trust Bucket® and in each one organization, product, and key individuals.",
    "You are infinitely trustworthy. Organization, products, and your people. In each Trust Bucket® and past, present, and future.",
    "Some TrustBuilders® are enduring (we have over 3 million clients), others changing (we are ranked No. 1 for 8 years/9 years), and yet others short-lived (we will present at XYZ conference next month).",
    "Not all Trust Buckets® are equally important all the time. Think about which ones are most important right now and how to fill them (with TrustAnalyser® you know).",
    "In social media, structure posts over time to focus on different Trust Buckets® and themes within them.",
    "Try focusing your idea on specific Trust Buckets® or a mix of them.",
    "Within each Trust Bucket®, ask for examples across different themes like employee programs, IT, R&D.",
    "To create more and different trust, ask trustifier.ai to combine seemingly unconnected aspects like 'I played in bands all my youth. What does this add to my competence as a lawyer?'",
    "With every little bit more trust, your opportunity doubles. It's about using trustifier.ai to help you nudge trust up ever so slightly in everything you do.",
    "Being honest is not enough. You can be honest with one aspect and destroy trust and build a lot of trust with another. Define what that is.",
    "The more I trust you, the more likely I am to recommend you. And that's much easier with specifics.",
    "What others don’t say they are not trusted for - but you can claim that trust.",
    "Building more trust is a service to your audience. It's so valuable to us, as humans, that we reflect that value right away in our behaviors.",
    "In your audience journey, you can use TrustAnalyser® to know precisely which Trust Buckets® and TrustBuilders® are most effective at each stage of the journey.",
    "Try structuring a document. Like % use of each Trust Bucket® and different orders in the document.",
    "In longer documents like proposals, think about the chapter structure and which Trust Buckets® and TrustBuilders® you want to focus on when.",
    "Building Trust doesn’t take a long time. Trust is built and destroyed every second, with every word, action, and impression. That's why it's so important to build more trust all the time.",
    "There is no prize for the second most trusted. To get the most business, support, and recognition, you have to be the most trusted.",
    "With most clients, we know they don’t know 90% of their available TrustBuilders®. Knowing them increases internal trust - and that can be carried to the outside.",
    "Our client data always shows that, after price, trust is the key decision factor (and price is a part of benefit and relationship trust).",
    "Our client data shows that customer value increases 9x times from Trust Neutral to High Trust. A good reason for internal discussions.",
    "Our client's data shows that high trust customers are consistently far more valuable than just trusting ones.",
    "Trust determines up to 85% of your NPS. No wonder, because the more I trust you, the more likely I am to recommend you.",
    "Trust determines up to 75% of your loyalty. Think about it yourself. It's intuitive.",
    "Trust determines up to 87% of your reputation. Effectively, they are one and the same.",
    "Trust determines up to 85% of your employee engagement. But what is it that they want to trust you for?",
    "Don't just ask 'what your audience needs to trust for'. That just keeps you at low, hygiene trust levels. Ask what they 'would love to trust for'. That's what gets you to High Trust."
]

suggestions = [
    "Try digging deeper into a specific TrustBuilder®.",
    "Ask just for organization, product, or a person's TrustBuilders® for a specific Trust Bucket®.",
    "Some TrustBuilders® can fill more than one Trust Bucket®. We call these PowerBuilders. TrustAnalyser® reveals them for you.",
    "Building trust is storytelling. trustifier.ai connects Trust Buckets® and TrustBuilders® for you. But you can push it more to connect specific Trust Buckets® and TrustBuilders®.",
    "Describe your audience and ask trustifier.ai to choose the most relevant Trust Buckets®, TrustBuilders®, and tonality (TrustAnalyser® can do this precisely for you).",
    "Ask trustifier.ai to find TrustBuilders® for yourself. Then correct and add a few for your focus Trust Buckets® - and generate a profile or CV.",
    "LinkedIn Profiles are at their most powerful if they are regularly updated and focused on your objectives. Rewrite it every 2-3 months using different Trust Buckets®.",
    "Share more of your TrustBuilders® with others and get them to help you build your trust.",
    "Build a trust strategy. Ask trustifier.ai to find all your TrustBuilders® in the Trust Buckets® and then create a trust-building program for a specific person/audience over 8 weeks focusing on different Trust Buckets® that build on one another over time. Then refine and develop by channel ideas.",
    "Brief your own TrustBuilders® and ask trustifier.ai to tell you which Trust Buckets® they're likely to fill (some can fill more than one).",
    "Have some fun. Ask trustifier.ai to write a 200-word speech to investors using all Trust Buckets®, but leading and ending with Development Trust. Use [BRAND], product, and personal CEO [NAME] TrustBuilders®.",
    "Ask why TrustLogic® can be trusted in each Trust Bucket®.",
    "Ask what's behind TrustLogic®."
]

def add_dot_typing_animation():
    st.markdown(
        """
        <style>
        .dots-container {
            display: flex;
            align-items: center;
        }

        .dot {
            height: 10px;
            width: 10px;
            margin: 0 5px;
            background-color: #bbb;
            border-radius: 50%;
            display: inline-block;
            animation: dot-blink 1.5s infinite ease-in-out;
        }

        .dot:nth-child(2) {
            animation-delay: 0.2s;
        }

        .dot:nth-child(3) {
            animation-delay: 0.4s;
        }

        @keyframes dot-blink {
            0% {
                opacity: 0.3;
            }
            20% {
                opacity: 1;
            }
            100% {
                opacity: 0.3;
            }
        }
        </style>
        """,
        unsafe_allow_html=True,
    )

# Function to display the assistant typing dots
def display_typing_indicator():
    dot_typing_html = """
    <div class="dots-container">
        <span class="dot"></span>
        <span class="dot"></span>
        <span class="dot"></span>
    </div>
    """
 
    st.markdown(dot_typing_html, unsafe_allow_html=True)
def display_save_confirmation(type_saved):
    st.info(f"Content successfully saved as **{type_saved}**!")


def extract_name(email):
    return email.split('@')[0].capitalize()

if "trustbuilders" not in st.session_state:
    st.session_state["trustbuilders"] = {}
if "brand_tonality" not in st.session_state:
    st.session_state["brand_tonality"] = {}

# Load saved entries upon user login
def retrieve_user_data(user_id):
    """
    Load all content for a user from Firebase, ensuring each user has a single root
    containing TrustBuilder, BrandTonality, and other data fields like email, message limits, etc.
    """
    try:
        user_data = db.child("users").child(user_id).get().val()
        if user_data:
            # Update session state with all user data
            st.session_state.update(user_data)
            
            # Load TrustBuilder and BrandTonality into session state for display
            st.session_state["TrustBuilder"] = user_data.get("TrustBuilder", {})
            st.session_state["BrandTonality"] = user_data.get("BrandTonality", {})
            
    except Exception as e:
        st.error(f"Error loading saved content: {e}")

def handle_memory_queries(prompt):
    """
    Main function to handle user commands and allocate Trust Buckets.
    """
    prompt = prompt.lower().strip()

    valid_buckets = ["Stability", "Development", "Relationship", "Benefit", "Vision", "Competence"]

    # Case 1: Save this as [bucket] trust builder: [content]
    match_save_this_specific = re.search(r"\bsave\s+(this\s+)?as\s+(\w+)\s+trust\s+builders?\s*:\s*(.+)", prompt, re.IGNORECASE)
    if match_save_this_specific:
        specified_bucket = match_save_this_specific.group(2).capitalize()
        content_to_save = match_save_this_specific.group(3).strip()

        if specified_bucket in valid_buckets:
            if content_to_save:
                assistant_response = handle_save_trustbuilder(content_to_save, specified_bucket)
            else:
                assistant_response = "No content provided. Please include content after 'save this as [bucket] trust builder:'."
        else:
            assistant_response = f"Invalid Trust Bucket '{specified_bucket}'. Valid buckets are: {', '.join(valid_buckets)}."

        # Save response to chat history and display it
        st.session_state.chat_history.append({"role": "assistant", "content": assistant_response})
        with st.chat_message("assistant"):
            st.markdown(assistant_response)
        return None

    # Case 2: Save this under [bucket]: [content]
    match_save_under_specific = re.search(r"\bsave\s+(this\s+)?under\s+(\w+)\s*:\s*(.+)", prompt, re.IGNORECASE)
    if match_save_under_specific:
        specified_bucket = match_save_under_specific.group(2).capitalize()
        content_to_save = match_save_under_specific.group(3).strip()

        if specified_bucket in valid_buckets:
            if content_to_save:
                assistant_response = handle_save_trustbuilder(content_to_save, specified_bucket)
            else:
                assistant_response = "No content provided. Please include content after 'save this under [bucket]:'."
        else:
            assistant_response = f"Invalid Trust Bucket '{specified_bucket}'. Valid buckets are: {', '.join(valid_buckets)}."

        # Save response to chat history and display it
        st.session_state.chat_history.append({"role": "assistant", "content": assistant_response})
        with st.chat_message("assistant"):
            st.markdown(assistant_response)
        return None

    # Case 3: Save and allocate: [content] (automatic allocation)
    match_save_allocate_auto = re.search(r"\bsave\s+(this\s+)?and\s+allocate\s*:\s*(.+)", prompt, re.IGNORECASE)
    if match_save_allocate_auto:
        content_to_save = match_save_allocate_auto.group(2).strip()
        if content_to_save:
            assistant_response = handle_save_trustbuilder(content_to_save)  # Automatically allocate bucket
        else:
            assistant_response = "No content provided. Please include content after 'save and allocate:'."

        # Save response to chat history and display it
        st.session_state.chat_history.append({"role": "assistant", "content": assistant_response})
        with st.chat_message("assistant"):
            st.markdown(assistant_response)
        return 

    # Show saved TrustBuilders
    elif "find my saved trustbuilders" in prompt or "show my saved trustbuilders" in prompt:
        trustbuilders = fetch_trustbuilders(st.session_state.get("wix_user_id", "default_user"))
        if trustbuilders:
            saved_content = "\n".join([f"- {entry['message']}" for entry in trustbuilders.values()])
            assistant_response = f"Here are your saved TrustBuilders:\n{saved_content}"
        else:
            assistant_response = "You haven't saved any TrustBuilders yet."

        # Save response to chat history and display it
        st.session_state.chat_history.append({"role": "assistant", "content": assistant_response})
        with st.chat_message("assistant"):
            st.markdown(assistant_response)
        return None

    return None
def delete_entry(category, entry_id):
    try:
        user_id = st.session_state["wix_user_id"]
        db.child("users").child(user_id).child(category).child(entry_id).remove()
        st.session_state[category].pop(entry_id, None)
        st.success(f"{category} entry deleted successfully!")
    except Exception as e:
        st.error(f"Error deleting entry: {e}")

        
# Function to download TrustBuilder as a .md file
def download_trustbuilder_as_md(content, trustbuilder_id):
    b64_content = base64.b64encode(content.encode()).decode()
    download_link = f'<a href="data:text/markdown;base64,{b64_content}" download="TrustBuilder_{trustbuilder_id}.md">Download</a>'
    st.sidebar.markdown(download_link, unsafe_allow_html=True)

def handle_save_trustbuilder(content, specified_bucket=None):
    """
    Handles saving TrustBuilders by detecting or automatically allocating the Trust Bucket.
    """
    # Avoid reprocessing the same content
    if "last_processed_content" in st.session_state and st.session_state["last_processed_content"] == content:
        return None  # Exit if the content was already processed

    trust_buckets = {
        "Stability": [
            "track record", "longevity", "size", "stability", "experience", "established", "heritage",
            "continuity", "reliable", "secure", "trustworthy", "dependable", "durable", "assurance",
            "foundation", "longstanding", "rooted", "strong", "solid", "proven", "milestones",
            "geographic footprint", "history", "recognizable", "retention", "consistent", "employees",
            "families", "recognition", "awards"
        ],
        "Development": [
            "innovation", "investment", "future-focused", "cutting-edge", "leadership", "growth",
            "ambition", "strategy", "adaptation", "forward-thinking", "evolve", "progress",
            "pilot programs", "technology", "training", "pioneering", "future-proof", "patents",
            "pipeline", "biotechnology", "adapt", "change", "radical", "sustainable"
        ],
        "Relationship": [
            "collaboration", "support", "empathy", "engagement", "customer-focused", "community",
            "partnership", "bond", "interaction", "sensitivity", "diversity", "social responsibility",
            "inclusive", "well-being", "investment", "communication", "feedback", "employee benefits",
            "customer councils", "loyalty", "wellness", "stakeholder", "inclusive initiatives",
            "social awareness", "active engagement", "connected"
        ],
        "Benefit": [
            "value", "benefit", "growth", "success", "advantage", "efficiency", "satisfaction",
            "reward", "functional value", "emotional value", "unique", "output", "results", "superior",
            "return", "proposition", "cost savings", "improvements", "enjoyment", "peace of mind",
            "confidence", "methodologies", "results", "growth strategy", "improvement", "continuous"
        ],
        "Vision": [
            "goal", "mission", "aspire", "dream", "visionary", "great", "future", "ideal", "ambition",
            "long-term", "objective", "focus", "drive", "purpose", "values", "integrity",
            "philanthropy", "social impact", "ethical", "society", "inspire", "sustainability",
            "impact", "initiatives", "greater good", "common good", "compelling", "volunteering"
        ],
        "Competence": [
            "expertise", "skills", "innovation", "excellence", "knowledge", "capability",
            "proficiency", "technical", "problem-solving", "methodologies", "effectiveness",
            "specialization", "certifications", "creativity", "collaboration", "leadership",
            "capabilities", "accreditations", "teamwork", "publications", "training", "patents",
            "high-profile", "results-oriented", "proven ability", "credentials", "creative excellence"
        ]
    }

    bucket = specified_bucket

    # Automatically allocate bucket if not provided
    if not bucket:
        for tb, keywords in trust_buckets.items():
            if any(keyword in content.lower() for keyword in keywords):
                bucket = tb
                break

    # If no bucket can be allocated, prompt the user
    if not bucket:
        st.session_state["missing_trustbucket_content"] = content
        return (
            "No Trust Bucket could be allocated automatically. "
            "Please indicate the Trust Bucket (e.g., Stability, Development, Relationship, Benefit, Vision, Competence)."
        )

    # Save TrustBuilder with detected/provided bucket
    brand = st.session_state.get("brand_input_save", "Unknown")
    content_to_save = f"{bucket}: Brand: {brand.strip()} | {content.strip()}"
    save_content(st.session_state["wix_user_id"], content_to_save)

    # Update last processed content
    st.session_state["last_processed_content"] = content
 # Confirm saving to the user
    return f"TrustBuilder allocated to **{bucket}** and saved successfully!"




                        
def load_user_memory(user_id):
    """
    Load saved TrustBuilders and uploaded documents from Firebase into session state.
    """
    try:
        # Load TrustBuilders
        trustbuilders = db.child("users").child(user_id).child("TrustBuilders").get().val()
        st.session_state["trustbuilders"] = trustbuilders if trustbuilders else []

        # Load Uploaded Documents from 'KnowledgeBase'
        documents = db.child("users").child(user_id).child("KnowledgeBase").get().val()
        st.session_state["documents"] = documents if documents else {}

        # Reconstruct vector stores for each document
        st.session_state["vector_store"] = {}
        for doc_id, doc_data in st.session_state["documents"].items():
            content = doc_data.get("content", "")
            if content:
                index_document_content(content, doc_id)

    except Exception as e:
        st.error(f"Error loading user memory: {e}")
        st.session_state["trustbuilders"] = []
        st.session_state["documents"] = {}
        st.session_state["vector_store"] = {}



if "missing_trustbucket_content" not in st.session_state:
    st.session_state["missing_trustbucket_content"] = None

if "handled" not in st.session_state:
    st.session_state["handled"] = False



if "email" not in st.session_state:
    st.session_state["email"] = f"demo_user_{st.session_state['wix_user_id']}@example.com"
if "user_name" not in st.session_state:
    st.session_state["user_name"] = "Demo"
if "message_limit" not in st.session_state:
    st.session_state["message_limit"] = 1000
if "used_messages" not in st.session_state:
    st.session_state["used_messages"] = 0

if "missing_trustbucket_content" not in st.session_state:
    st.session_state["missing_trustbucket_content"] = None

def initialize_user_session():
    """
    Initialize user session and ensure user data exists in Firebase.
    """
    try:
        user_id = st.session_state["wix_user_id"]
        email = st.session_state["email"]

        # Check if user already exists in Firebase
        user_data = db.child("users").child(user_id).get().val()
        
        if not user_data:
            # Create user data in Firebase if it doesn't exist
            user_data = {
                "user_name": user_id,
                "email": email,
                "message_limit": 1000,
                "used_messages": 0
            }
            db.child("users").child(user_id).set(user_data)
        
        
        # Update session state with user data
        st.session_state.update(user_data)
    except Exception as e:
        st.error(f"Error initializing user session: {e}")
   





initialize_user_session()

retrieve_user_data(st.session_state["wix_user_id"])  # Fetch and display saved data for the user

user_name = extract_name(st.session_state["email"])






def clean_and_format_markdown(text: str) -> str:
    # Normalize Unicode
    text = unicodedata.normalize('NFKC', text)

    # Remove zero-width and other invisible chars
    text = re.sub(r'[\u200B\uFEFF\u200C\u200D]', '', text)

    # Remove control characters
    text = re.sub(r'[\x00-\x1F\x7F-\x9F]', '', text)

    # Replace escaped and actual newlines with a single space
    text = text.replace('\\n', ' ').replace('\n', ' ')

    # Remove HTML tags if any
    text = re.sub(r'<[^>]*>', '', text)

    # Ensure space after punctuation if missing
    text = re.sub(r'([.,!?])(\S)', r'\1 \2', text)

    # Ensure spacing between numbers and letters
    text = re.sub(r'(\d)([A-Za-z])', r'\1 \2', text)
    text = re.sub(r'([A-Za-z])(\d)', r'\1 \2', text)

    # Normalize multiple spaces
    text = re.sub(r'\s+', ' ', text).strip()

    return text


prompt = st.chat_input("")
global combined_text
def handle_prompt(prompt):
    if st.session_state["used_messages"] < st.session_state["message_limit"]:
        if prompt:
            st.session_state.chat_started = True

            # Prevent duplicate messages in chat history
            if not any(msg["content"] == prompt for msg in st.session_state["chat_history"]):
                st.session_state.chat_history.append({"role": "user", "content": prompt})

            # Introduce a flag to track if a specific flow is handled
            st.session_state["handled"] = False

            # Handle missing Trust Bucket if needed
            if st.session_state.get("missing_trustbucket_content") and not st.session_state["handled"]:
                bucket = prompt.strip().capitalize()
                valid_buckets = ["Stability", "Development", "Relationship", "Benefit", "Vision", "Competence"]

                if bucket in valid_buckets:
                    content_to_save = st.session_state.pop("missing_trustbucket_content")
                    response = handle_save_trustbuilder(content_to_save, bucket)
                    if response:
                        st.session_state.chat_history.append({"role": "assistant", "content": response})
                        with st.chat_message("assistant"):
                            st.markdown(response)
                else:
                    with st.chat_message("assistant"):
                        st.markdown("Invalid Trust Bucket. Please choose from Stability, Development, Relationship, Benefit, Vision, or Competence.")
                st.session_state["handled"] = True
                return  # Exit to prevent further processing

            # Handle fetching saved TrustBuilders
            if ("find my saved trustbuilders" in prompt.lower() or "show my saved trustbuilders" in prompt.lower()) and not st.session_state["handled"]:
                trustbuilders = fetch_trustbuilders(st.session_state.get("wix_user_id", "default_user"))
                if trustbuilders:
                    saved_content = "\n".join([f"- {entry}" for entry in trustbuilders])
                    assistant_response = f"Here are your saved TrustBuilders:\n{saved_content}"
                else:
                    assistant_response = "You haven't saved any TrustBuilders yet."

                st.session_state.chat_history.append({"role": "assistant", "content": assistant_response})
                with st.chat_message("assistant"):
                    st.markdown(assistant_response)
                st.session_state["handled"] = True
                return  # Exit to prevent further processing

            # Handle save TrustBuilder command
            if not st.session_state["handled"]:
                save_match = re.search(r"\b(save|add|keep|store)\s+(this)?\s*(as)?\s*(\w+\s*trustbuilder|trustbuilder)\s*:?(.+)?", prompt, re.IGNORECASE)
                if save_match:
                    content_to_save = save_match.group(5).strip() if save_match.group(5) else None
                    specified_bucket = None

                    # Check for explicit bucket mention
                    bucket_match = re.search(r"\b(stability|development|relationship|benefit|vision|competence)\b", prompt, re.IGNORECASE)
                    if bucket_match:
                        specified_bucket = bucket_match.group(1).capitalize()

                    if content_to_save:
                        response = handle_save_trustbuilder(content_to_save, specified_bucket)
                        if response:
                            st.session_state.chat_history.append({"role": "assistant", "content": response})

                    else:
                        with st.chat_message("assistant"):
                            st.markdown("Please provide the content to save as a TrustBuilder.")

                    st.session_state["handled"] = True
                    return  # Exit to prevent further processing

            # Handle other memory queries
            if not st.session_state["handled"]:
                memory_response = handle_memory_queries(prompt)
                if memory_response:
                    st.session_state.chat_history.append({"role": "assistant", "content": memory_response})
                    with st.chat_message("assistant"):
                        st.markdown(memory_response)
                    st.session_state["handled"] = True
                    return  # Exit to prevent further processing

            # If no specific handling, generate a general AI response
            if not st.session_state["handled"]:
                with st.chat_message("user"):
                    st.markdown(prompt)

                response_placeholder = st.empty()
                with response_placeholder:
                    with st.chat_message("assistant"):
                        add_dot_typing_animation()
                        display_typing_indicator()  
                cleaned_text = ""
                base_instructions = (
                    "Strictly Avoid flowery language, typical AI phrases and jargons."
                    "When asked for top trustdrivers,buckets,builders,statements search in  knowledgebase when asked for prospects or customers give exact result with percentage.  Search google Give correct sources links always.For sales conversation donot give source in conversation give in list of trustbuilders  . *Be specific with $ amounts awards, people and programs*."
                    "Strictly dont use trustbucket names in copy headings and content avoid it"
                    "Response in same  language in which asked." 
                    "Use google to provide correct sources links containing the trustbuilder text information."
                )
                
                # Check if user request includes blog, article, or newsletter
                if any(keyword in prompt.lower() for keyword in ["blog", "write","article","annual report","report", "newsletter"]):
                    appended_instructions = (
                                "Craft a flawless, engaging, and fluid compelling copy using *non-flowery language* that reads as though written by a professional copywriter having 25 years of experience. "
                                "Do not use AI jargon, vague phrases, or  formal language. Follow these enhanced guidelines to ensure a polished, publication-ready copy with a 10/10 quality: "
                                "1. **Interconnected Structure**: Ensure all sections and ideas flow seamlessly with logical transitions between paragraphs. Build a cohesive narrative where every part supports the overall theme, reinforcing the message at every step. "                            
                                "3. **Seamless Integration of TrustBuilders®**: Naturally incorporate TrustBuilders® into the narrative without isolating or explicitly listing them in the main body. Instead, weave them fluidly into sentences to build credibility and trust while maintaining the content’s readability and engagement. "
                                "4. **Human Tone**: Write in a relatable, conversational tone that engages the reader and feels natural. Avoid repetitive phrasing, overly technical explanations, or mechanical structures. Use active voice consistently, ensuring the tone is both approachable and professional."
                                "5. **Audience-Centric Engagement**: Tailor the content to meet the audience's needs, goals, and challenges. Create emotional connections by using relatable examples, vivid imagery, and direct appeals. Emphasize actionable insights and practical relevance to ensure the audience feels seen and understood."
                                "6. **Enhanced Audience Engagement**: Use storytelling techniques and mix the trustbuilders into a content. Begin with a compelling hook, maintain momentum through transitions, and conclude with a strong call-to-action that inspires the reader to act or reflect. "
                                "7. **Purpose-Driven Impact**: Clearly define and achieve the content’s purpose—whether to inform, persuade, or inspire action. Ensure every paragraph serves the overall objective while reinforcing the key message. "
                                "8. **Polished Presentation**: Ensure the final output is refined, professional, and suitable for publication. The copy should demonstrate mastery of language and content design, leaving no room for ambiguity or errors. "
                                "dont give source link in content"
                                 "Dont mention trust bucket names literally"
                                 "1. ##List of TrustBuilders Used: Provide trustbuilders used followed by *Source links always*"
                                 " 2. ##Heuristics and Creative Techniques :"
                                 "   -List them in a footnote-style small heading."
                                  "    Use the following structure:"
                                  "      -Heuristics: Mention names only like examples (e.g., social proof, authority, commitment)."
                                  "    -Creative Techniques: Mention names onlyexamples (list only relevant marketing techniques without additional details)."
                                 "The final output must not include AI jargons. *With every paragraph give a creative headline that summarises the content give sub-headlines with each paragraph like example headline: We Empower or Similar Phrases*. Avoid mentioning trustbucket names."
                                 "MOST IMPORTANT RULE. IN EVERY PARAGRAPH Strengthen the connections between sections to ensure smoother flow and SHOULD  BE DEEPLY INTERCONNECTED WITH EACH OTHER TO CREATE A SEAMLESS FLOW, MAKING THE CONTENT READ LIKE A SINGLE CONTENT RATHER THAN DISJOINTED PARAGRAPHS OR INDEPENDENT BLOG SECTIONS. EACH SECTION MUST LOGICALLY TRANSITION INTO THE NEXT, ENSURING THAT THE TOPIC REMAINS CONSISTENT AND RELEVANT THROUGHOUT. BY MAINTAINING A COHESIVE STRUCTURE, THE ARTICLE WILL ENGAGE READERS MORE EFFECTIVELY, HOLDING THEIR ATTENTION AND CONVEYING THE INTENDED MESSAGE WITH CLARITY AND IMPACT."
                    )
                else:
                    appended_instructions = ""
                final_prompt = f"{prompt} {base_instructions} {appended_instructions}"
                      
                try:
                    output = agent_executor.invoke({
                        "input": final_prompt,
                        "chat_history": st.session_state.chat_history
                    })
                    full_response = output["output"]
                    import html
                    escaped_text = full_response.replace("$", "\$")

                    #cleaned_text = clean_text(full_response)
                    
                    trust_tip, suggestion = get_trust_tip_and_suggestion()
                    combined_text = f"{escaped_text}\n\n---\n\n**Trust Tip**: {trust_tip}\n\n**Suggestion**: {suggestion}"
                    #formatted_text = clean_and_format_markdown(combined_text)

                    with response_placeholder:
                        with st.chat_message("assistant"):
                            st.markdown(combined_text)


                except Exception as e:
                    logging.error(f"Error generating response: {e}")
                    st.error("An error occurred while generating the response. Please try again.")

                st.session_state.chat_history.append({"role": "assistant", "content": escaped_text})
                copy_to_clipboard(combined_text)
                st.session_state["handled"] = True  # Mark as handled

# Call the function to handle the prompt
handle_prompt(prompt)