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.text_splitter import RecursiveCharacterTextSplitter
from urllib.parse import quote, urlparse

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
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  # ✅ Correct
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
st.set_page_config(layout="wide")
import logging
import asyncio
import re 
import docx
from langchain_community.tools import TavilySearchResults
import docx
from docx import Document as DocxDocument
from typing import List, Optional
from openai import OpenAI
import numpy as np  # ✅ Import NumPy
import hashlib

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

if "documents" not in st.session_state:
    st.session_state["documents"] = {}
    
if "chat_history" not in st.session_state:
    st.session_state["chat_history"] = []

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


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

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

# Initialize Firebase
firebase = pyrebase.initialize_app(firebase_config)
db = firebase.database()
storage = firebase.storage()

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


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_txt(file):
    """
    Convert different file types to plain text.
    """
    if file.type == "application/pdf":
        return convert_pdf_to_txt(file)
    elif file.type == "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
        return convert_docx_to_txt(file)
    elif file.type == "text/plain":
        return convert_txt_to_txt(file)
    elif file.type == "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet":
        return convert_excel_to_txt(file)
    elif file.type == "text/csv":
        return convert_csv_to_txt(file)
    else:
        st.sidebar.warning(f"Unsupported file type: {file.type}")
        return None

def convert_pdf_to_txt(file):
    """
    Convert a PDF file to plain text.
    """
    try:
        text = extract_text(file)  # Use PyPDF2 or pdfplumber for better accuracy if needed
        return text.strip()
    except Exception as e:
        st.sidebar.error(f"Error converting PDF to TXT: {e}")
        return None

def convert_docx_to_txt(file):
    """
    Extract text from a .docx file.
    """
    try:
        doc = docx.Document(file)
        text = "\n".join([paragraph.text for paragraph in doc.paragraphs])
        return text.strip()
    except Exception as e:
        st.sidebar.error(f"Error converting DOCX to TXT: {e}")
        return None

def convert_txt_to_txt(file):
    """
    Handle plain text file as is.
    """
    try:
        text = file.read().decode("utf-8")
        return text.strip()
    except Exception as e:
        st.sidebar.error(f"Error reading TXT file: {e}")
        return None

def convert_excel_to_txt(file):
    """
    Convert an Excel file to plain text.
    """
    try:
        df = pd.read_excel(file)
        text = df.to_string(index=False)
        return text.strip()
    except Exception as e:
        st.sidebar.error(f"Error converting Excel to TXT: {e}")
        return None

def convert_csv_to_txt(file):
    """
    Convert a CSV file to plain text.
    """
    try:
        df = pd.read_csv(file)
        text = df.to_string(index=False)
        return text.strip()
    except Exception as e:
        st.sidebar.error(f"Error converting CSV to TXT: {e}")
        return None
     

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

def upload_to_firebase(user_id, file):
    """
    Upload document to Firebase, extract content, and add it to the knowledge base.
    """
    content = convert_file_to_txt(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
    user_data = db.child("users").child(user_id).get().val()
    business_data = db.child("business_accounts").child(user_id).get().val()
    if user_data:
        db.child("users").child(user_id).child("KnowledgeBase").child(doc_id).set(document_data)
    if business_data:
            db.child("business_accounts").child(user_id).child("KnowledgeBase").child(doc_id).set(document_data)

    fetch_documents(user_id) 
    # 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-3-large", api_key=client)
    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 extract_name(email):
    return email.split('@')[0].capitalize()
    



def clean_text(text):
    """
    Cleans and formats the LLM output for display in Streamlit.
    Returns the cleaned text for further use.
    """
    # Step 1: Replace newline characters
    text = text.replace('\\n', '\n')

    # Step 2: Remove all HTML tags and remaining `<` or `>` characters
    text = re.sub(r'<[^>]*>', '', text)
    text = text.replace('<', '').replace('>', '')
    text = re.sub(r'<[^>]+>', '', text)

    # Step 3: Fix broken numbers and words, remove unnecessary spans
    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)

    # Step 4: Split into paragraphs and clean each paragraph
    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()
            
            cleaned_lines.append(cleaned_line)
        
        cleaned_paragraph = '\n'.join(cleaned_lines)
        cleaned_paragraphs.append(cleaned_paragraph)
    
    # Join cleaned paragraphs
    cleaned_text = '\n\n'.join(para for para in cleaned_paragraphs if para)

    # Step 5: Return cleaned and formatted text
    if re.search(r"\$.*?\$", cleaned_text):  # Check for inline LaTeX
        return cleaned_text  # Return cleaned text for inline LaTeX
    elif re.search(r"\\\[.*?\\\]", cleaned_text) or re.search(r"\\\(.*?\\\)", cleaned_text):  # Check for block LaTeX
        return cleaned_text  # Return cleaned text for block LaTeX
    elif "$" in cleaned_text:  # Handle dollar signs in regular text
        return cleaned_text.replace("$", "\\$")  # Return escaped text
    else:  # Default case
        return cleaned_text


 
  

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



from langchain.text_splitter import RecursiveCharacterTextSplitter


def extract_text_from_docx(file_path):
    """Extract and return structured text from a .docx file, including tables."""
    try:
        doc = DocxDocument(file_path)
        extracted_content = []

        # Extract paragraphs
        for para in doc.paragraphs:
            if para.text.strip():
                extracted_content.append(para.text.strip())

        # Extract tables
        for table in doc.tables:
            for row in table.rows:
                row_data = [cell.text.strip() for cell in row.cells if cell.text.strip()]
                if row_data:
                    extracted_content.append(" | ".join(row_data))  # Format as table row

        return "\n\n".join(extracted_content)  # Return structured text

    except Exception as e:
        print(f"Error extracting DOCX: {e}")
        return ""



            
            
def extract_text_from_md(md_file):
    """Extract text from a Markdown file."""
    try:
        with open(md_file, "r", encoding="utf-8") as file:
            return file.read()
    except Exception as e:
        print(f"Error reading Markdown file: {e}")
        return ""

def load_main_data_source():
    """
    Load the main data source from DOCX or Markdown, extract text, 
    structure it properly, and return Document objects.
    """
    try:
        file_path = "./data_source/time_to_rethink_trust_book.md"

        if not os.path.exists(file_path):
            print("❌ Error: File not found.")
            return []

        # Determine file type and extract text accordingly
        if file_path.endswith(".docx"):
            file_text = extract_text_from_docx(file_path)
        elif file_path.endswith(".md"):
            file_text = extract_text_from_md(file_path)
        else:
            print("❌ Unsupported file format.")
            return []

        if not file_text:
            print("⚠️ Warning: Extracted content is empty.")
            return []

        # Split text into chunks
        text_splitter = RecursiveCharacterTextSplitter(
            chunk_size=1500,  # Keep large sections intact
            chunk_overlap=200,  # Large overlap for context retention
        )
        main_texts = text_splitter.split_text(file_text)

        # Convert into Document objects
        main_documents = [Document(page_content=text) for text in main_texts]

        return main_documents

    except Exception as e:
        print(f"Unexpected error loading data: {e}")
        return []

def refresh_main_faiss_index():
    """Load the main data source and store it permanently in FAISS."""
    main_sources = load_main_data_source()

    if not main_sources:
        print("❌ No main data source found. FAISS index was NOT updated.")
        return

    embeddings = OpenAIEmbeddings()
    st.session_state["main_faiss_db"] = FAISS.from_documents(main_sources, embeddings)

    num_docs = len(st.session_state["main_faiss_db"].docstore._dict)



def refresh_faiss_index(selected_doc_id=None):
    """Refresh FAISS index while keeping the main knowledge base intact."""
    if selected_doc_id is None:
        return

    if "documents" not in st.session_state or selected_doc_id not in st.session_state["documents"]:
        return

    doc_content = st.session_state["documents"][selected_doc_id]["content"]
    if not doc_content.strip():
        print(f"⚠️ Warning: Selected document {selected_doc_id} is empty.")
        return

    # Create embeddings and index only the selected document
    embeddings = OpenAIEmbeddings(model="text-embedding-3-large", api_key=client)
    text_splitter = RecursiveCharacterTextSplitter(chunk_size=2000, chunk_overlap=500)
    texts = text_splitter.split_text(doc_content)

    doc_metadata = [{"doc_id": selected_doc_id, "chunk_id": i} for i in range(len(texts))]
    new_vector_store = FAISS.from_texts(texts, embeddings, metadatas=doc_metadata)

    # Merge into session state FAISS index (separate from main knowledge base)
    if "faiss_db" in st.session_state and st.session_state["faiss_db"] is not None:
        old_db = st.session_state["faiss_db"]
        old_db.merge_from(new_vector_store)  # ✅ Merge only the selected document
        st.session_state["faiss_db"] = old_db
    else:
        st.session_state["faiss_db"] = new_vector_store  # ✅ Store only the selected doc

    num_docs = len(st.session_state["faiss_db"].docstore._dict)





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;
            }
            </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.error(f"Error deleting documents: {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()
            
if st.session_state.get("wix_user_id") and "faiss_db" not in st.session_state:
    refresh_faiss_index()



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")




update_message_counter()






 

# Define search functions
def search_knowledge_base(query, k=3):
    """Optimized FAISS search for main knowledge base and user-specific knowledge base."""
    results = []

    # Search in the main FAISS index
    if "main_faiss_db" in st.session_state and st.session_state["main_faiss_db"] is not None:
        main_results = st.session_state["main_faiss_db"].similarity_search_with_score(query, k=5)  # Fetch extra results for better ranking
        results.extend(main_results)

    # Search in the selected document's FAISS index
    if "faiss_db" in st.session_state and st.session_state["faiss_db"] is not None:
        user_results = st.session_state["faiss_db"].similarity_search_with_score(query, k=5)  # Fetch extra results for better ranking
        results.extend(user_results)

    # Sort results by similarity score (higher score = more relevant)
    sorted_results = sorted(results, key=lambda x: x[1], reverse=True)

    # Return only the top `k` most relevant results
    return [result[0] for result in sorted_results[:k]]

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

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

    Returns:
        list: A list of valid snippets from the search results. Returns an error message if an error occurs.
    """
    # API Configuration
    url = "https://google.serper.dev/search"
    api_key = "07b4113c2730711b568623b13f7c88078bab9c78"
    headers = {
        "X-API-KEY": api_key,
        "Content-Type": "application/json",
    }

    # Payload for the query
    payload = json.dumps({"q": query})

    try:
        # Perform the API request
        response = requests.post(url, headers=headers, data=payload, timeout=10)  # 10-second timeout
        response.raise_for_status()  # Raise HTTPError for bad responses (4xx, 5xx)

        # Parse the response JSON
        results = response.json()

        # Extract and validate snippets
        snippets = [
            result["snippet"] for result in results.get("organic", [])
            if result.get("snippet")  # Ensure snippet exists
        ]

        # Return valid snippets or a fallback message
        return snippets if snippets else ["No valid data found in results"]

    except requests.exceptions.HTTPError as http_err:
        print(f"HTTP error occurred: {http_err}")
        return ["HTTP error occurred during Google search"]
    except requests.exceptions.Timeout:
        print("Request timed out")
        return ["Request timed out"]
    except requests.exceptions.RequestException as req_err:
        print(f"Request error occurred: {req_err}")
        return ["Request error occurred during Google search"]
    except Exception as e:
        print(f"General Error: {e}")
        return ["Error occurred during Google search"]


# RAG response function
def rag_response(query, selected_doc_ids=None, selected_analyser_ids=None):
    """
    Handle queries by searching the main knowledge base, selected documents, and analyzer files.
    """
    try:
        results = []

        # Search FAISS database (main knowledge base)
        if "faiss_db" in st.session_state:
            retrieved_docs = search_knowledge_base(query,k=3)
            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", [])

        # If selected_analyser_ids is None, try to get it from session state
        if selected_analyser_ids is None:
            selected_analyser_ids = st.session_state.get("selected_analyser_file_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 is None:
                    st.warning(f"Vector store for document '{doc_id}' not found.")
                    continue  # Skip this iteration if vector store is missing

                vector_store_results = vector_store.similarity_search(query, k=5)
                results.extend(vector_store_results)

        # Search content of analyzer files (e.g., XLSX content)
        for analyser_id in selected_analyser_ids:
            analyser_data = st.session_state.get("analyser_files", {}).get(analyser_id, {})

            if "content" in analyser_data:
                # Perform search on analyzer file content
                analyser_results = search_excel_content(analyser_data["content"], query)
                results.extend(analyser_results)
            else:
                st.warning(f"No content found in Analyzer file '{analyser_id}'.")

        # Combine results into a single context
        context = "\n".join([doc.page_content if isinstance(doc, Document) else str(doc) for doc in results])

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

        # Generate AI response with the retrieved context
        prompt = f"""
        Context:
        {context}
        Rules:
        1. Use only the provided context to generate your answer.
        2. Match headings and content exactly as they appear in the knowledge base. Do not add, modify, or generalize content.
        3. Maintain clarity and accuracy.
        4. Follow instructions strictly.
        Question:
        {query}
        Answer:
        """
        llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.4, 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=12,
    search_depth="advanced",
    days=1,
    include_answer=True,
    include_raw_content=False,
    query_context=(
        "Extract details  from the internet related to the Brand. Give me multiple different source links and latest please 2024 onwards"
    ),
    include_domains=[
    ],
    exclude_domains=[
        'example.com',
        'https://www.trustlogic.us',
        'https://huggingface.co',
        'https://huggingface.co/spaces/trustlogic/FH-AI/commit/ef6fd56353ff4d7308bf7ed4e9c27d9aec43126b'
    ],
)
# 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 an expert multilingual  Only Active language copywriter specializing in creating highly fluid, compelling, and interconnected marketing copy that seamlessly integrates Trust Builders into various content formats for any organization. Your goal is to craft concise , engaging material  based on the knowledgebase, adhering to the following guidelines:**

- Write in **active voice** using **first-person perspective (“we”)**, avoiding third-person.
- Ensure **seamless flow** with logical transitions between paragraphs, maintaining relevance and consistency.
- Contextually integrate trust-building elements creatively. Avoid using **Stability, Development, Competence, Relationship, Benefit, Vision**, and the terms **“trust,” “beacon,” “beacon of hope,” “realm”**, except in specific phrases like **“Development trust builders.”**
- Focus on clarity, avoiding jargon or repetition while emphasizing impact on the audience.

### Key Requirements
**Adhere to Uploaded Document's Style**:
   - Match the uploaded document's tone, structure, and style exactly.
   - Use the same level of language complexity and formality.
   - If the uploaded document includes headings, subheadings, or specific formatting, replicate them. If none exist, avoid including headings.

### MANDATORY Elements
- **Avoid Prohibited Terms**:
  - Do **not** mention "trust," "trust buckets," or any category names like "Development," "Stability," "Competence," "Relationship," "Vision" in the copy.
  - Use these terms for searching and headings but **not in the content or any copy**.
- **Consistency**: Maintain a uniform format across all content types.
- Do not generate unverified or placeholder claims.


- **Formatting**: Ensure formatting is clean and professional, with **no HTML tags**.
- **List of TrustBuilders Used**:
     - Include relevant TrustBuilders® in every response.
     - Provide embedded, clickable source links for each TrustBuilder®.
- **Heuristics and Creative Techniques**:
     - Always include heuristics and creative techniques at the end of the response.
     - Use the following format under separate headings:
       - **Heuristics**: List relevant examples (e.g., social proof, authority, commitment).
       - **Creative Techniques**: List relevant marketing techniques (e.g., storytelling, visual metaphors).

*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]
          
### MANDATORY VERIFICATION CHECKLIST:
Before submitting **any content**, ensure that each piece includes:
1. **Specific Details**:
   - **At least 3 specific dollar amounts** with exact figures (e.g., "$127.5 million").
   - **Minimum 2 full dates** with day/month/year (e.g., "March 15, 2023").
   - **At least 3 specific quantities** of people/items (e.g., "12,457 beneficiaries").
   - **Minimum 2 full names with titles** 
   - **At least 2 complete program names with years** (e.g., "Operation Healthy Future 2024-2025").
   - **At least 1 specific award**with year and organization (e.g., "2023 UN Global Health Excellence Award"). 
   - **Minimum 2 measurable outcomes with percentages** (e.g., "47% reduction in malnutrition").
2. **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."


*SOURCE LINK*
1. **Each source link must**:
    -Be Latest, factual and verifiable not page not found links  please.

2. Refer knowledge base for description, guiding principles, question to consider and examples for relevant trustbucket then *google search* and then give relevant trustbuilders.

##SPECIFICITY ENFORCEMENT
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".



### CONTENT TYPES AND FORMATS

#### 1. Report/Article/writeup/blog
- **Introduction**: Start with "Here is a draft of your [Annual Report/Article/writeup]. Feel free to suggest further refinements."
- **Structure**:
  - **Headlines **: .Headline should be like this in active language *without mentioning prohibited terms and -ing **.
  - **Content**:
    -  **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."
     
#### 2. Social Media Posts
- **Introduction Line**: Start with "Here is a draft of your social media post. Feel free to suggest further refinements."
- **Content**:
  - Ensure the post is **concise, impactful**, and designed to engage the audience.
  - **Avoid prohibited terms or flowery language**.
  - **Include specific names, numbers, programs, strategies, places, awards, and actions** to enhance credibility.
  - Focus on **clear messaging**.
- **Additional Requirements**:
  - Do **not** mention prohibited terms in hashtags or post copy.
  - Ensure **source links are not included** in the post text.
- **Sub-Headings (After Summary) **:
  1. **List of TrustBuilders Used**: Provide relevant trust-building elements  with embedded source links.
  2. **Heuristics and Creative Techniques**:
     - List them in footnote-style tiny small heading.
     - Select and name only **3-5 relevant heuristics** with tight bullet points.
     - Name only the relevant marketing creative techniques, with no additional details.
- **Word Count**: Follow any specified word count.
 - **Important Notes**:
  - **Strictly search and provide accurate source links always**.
  
#### 3. Sales Conversations or Ad Copy
- **Introduction Line**: Start with "Here is a draft of your [Sales Conversation/Ad Copy]. Feel free to suggest further refinements."
- **Content**:
  - Include **persuasive elements** with integrated trust-building elements, interconnecting them fluidly **without mentioning prohibited terms**.
  - **Avoid flowery language** and focus on factual, specific information such as names, numbers, and actions.
    - **Sub-Headings(After Summary)  **:
      1. **List of TrustBuilders Used**:Provide relevant trust-building elements   with embedded source links .
      2. **Heuristics and Creative Techniques**:
         - List them in footnote-style tiny small heading.
         - Select and name only **3-5 relevant heuristics** with tight bullet points.
         - Name only the relevant marketing creative techniques, with no additional details.
- **Important Notes**:
  - Strictly search and provide accurate source links always.
  
#### 4. Emails, 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**: WRITE  CREATIVE ACTIVE LANGUAGE HEADLINE THAT SUMMARISES THE POINTS YOU MAKE.Headline should be like this in activae language eg.we empower instead **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.
Note: When including heuristics and creative techniques, use the structure “Heuristics: examples” and “Creative Techniques: examples” with no extra details.
- **Word Count**: Follow any specified word count for the main body. Do not count sub-heading sections in the word count limit.

### 5.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 with each point.
  - **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 **20XX**, 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](#)

### 6. LinkedIn Profile
- If requested, generate a LinkedIn profile in a professional manner.
- **Avoid prohibited terms** and **flowery language**.

### 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. Trustlogic means Trustlogic.info
-mext means mext consulting(https://www.mextconsulting.com/) by stefan grafe and also trustlogic.info.

"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."

"""



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.5,  # Balanced creativity and adherence
    #top_p=0.85,  # Focused outputs
   
# 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 World Vision
        </div>
        <div class="section">
            <h2>Create</h2>
            <p>Generate trust-optimised solutions : <br>Example: Find World Vision 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}**!")




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.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 
    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

    

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"].lower() == content.lower():
        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 map(str.lower, 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 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 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"] = {}




def clean_and_format_markdown(raw_text):
    """
    Dynamically cleans and formats Markdown text to ensure URLs are properly encoded 
    and handles issues with line breaks or improperly formatted Markdown.
    """
    # Regular expression to find Markdown links [text](url)
    pattern = r'\[([^\]]+)\]\(([^)]+)\)'

    def encode_url(match):
        text = match.group(1)
        url = match.group(2).strip()  # Remove leading/trailing spaces
        encoded_url = quote(url, safe=':/')  # Encode the URL while keeping : and /
        return f"[{text}]({encoded_url})"

    # Fix Markdown links dynamically
    formatted_text = re.sub(pattern, encode_url, raw_text)

    # Replace single newlines with spaces to avoid breaking Markdown rendering
    formatted_text = re.sub(r"(?<!\n)\n(?!\n)", " ", formatted_text)

    return formatted_text
        

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



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 "main_faiss_db" not in st.session_state:
                    refresh_main_faiss_index()  


                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})
                
                    
                    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")
                            handle_save_trustbuilder(content_to_save, bucket)
                        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
        
                    # Handle fetching saved TrustBuilders when user asks
                    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."
                    
                        # Append assistant's response to chat history
                        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
        
                    # 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 in the same prompt
                            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:
                                handle_save_trustbuilder(content_to_save, specified_bucket)
                            else:
                                # If content is not provided after the command, extract from prompt
                                content_to_save = re.sub(r"\b(save|add|keep|store)\s+(this)?\s*(as)?\s*(\w+\s*trustbuilder|trustbuilder)\b", "", prompt, flags=re.IGNORECASE).strip()
                                if content_to_save:
                                    handle_save_trustbuilder(content_to_save, specified_bucket)
                                else:
                                    with st.chat_message("assistant"):
                                        st.markdown("Please provide the content to save as a TrustBuilder.")
                            
                            # Mark as handled and exit to prevent further processing
                            st.session_state["handled"] = True
                            return  # Exit here to avoid triggering normal AI response
        
                    # Handle other memory queries if any
                    if not st.session_state["handled"]:
                        memory_response = handle_memory_queries(prompt)
                        if memory_response == "find_my_saved_trustbuilders":
                            # This case is already handled above, so we can set handled to True
                            st.session_state["handled"] = True
                        elif memory_response:
                            with st.chat_message("assistant"):
                                st.markdown(memory_response)
                            st.session_state["handled"] = True
        
                    # If not handled yet, proceed to the existing AI response generation
                    if not st.session_state["handled"]:
                        # Generate a response with AI for other types of queries
                        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 = """
                        # Avoid Flowery language and ai words.Be over specific with numbers,names,dollars, programs ,awards and action*
               
                        # 1. **Adhere to Uploaded Document's Style**:
                        #    - When asked uploaded files or document means knowledgebase.
                        #    - Use the uploaded document as a primary guide for writing style, tone, and structure. Just directly give response.
                        #    - Match formatting such as headings, subheadings, and paragraph styles. If the uploaded document lacks headings, Strictly do not include them in the response.
                        
                        # 2. **Prioritize Knowledge Base and Internet Sources**:
                        #    - Use uploaded documents or knowledge base files as the primary source.
                        #    - Perform a Google search to retrieve valid and correct internet links for references, ensuring only accurate and verified source links are used.
                        
                        # 3. **Avoid Flowery Language and AI Jargon**:
                        #    - Use clear, professional language without exaggerated or vague expressions. Avoid jargon like "beacon," "realm," "exemplifies," etc.
                        
                        # 4. **Ensure Accuracy**:
                        #    - Provide only verifiable and accurate information. Do not include placeholders, fabricated URLs, or vague references.
                        
        
                        # """
                        base_instructions="""
                         **General Guidelines**:
                        - Use **clear, professional language** without exaggerated expressions or AI words, jargon (e.g., "beacon," "realm," "exemplifies").
                        - Always include **specific numbers, names, dollar amounts, programs, awards, and actions** when identifying TrustBuilders®.
                
                        **Formatting and Accuracy**:
                        - Ensure responses are properly formatted and free of errors.
                        - Respond in the same language as the query.
                        - Provide **accurate source links** for all TrustBuilders® mentioned in a separate section.
                        
                        **Avoid**:
                        - Flowery language , AI JARGONS AND WORDS.
                        - Isolated facts—ensure logical connections between ideas to maintain flow and thematic consistency.
                        - Repetition or mechanical structures.
                        Detect user language and respond in same language user.
                        """
                        
                        # Check if user request includes blog, article, or newsletter
                        if any(keyword in prompt.lower() for keyword in [
                                    "blog", "article", "annual report", "report", "newsletter", "news letter",
                                    "website introduction", "intro", "website copy", "day-to-day email",
                                    "sales email", "proposal", "case study", "social media post", "press release",
                                    "executive profile", "fundraising email", "speech writing", "brand story",
                                    "product description", "advertising copy", "landing page copy",
                                    "seo blog article", "tagline", "slogan", "customer value proposition",
                                    "employee value proposition", "negotiation", "sales conversation",
                                    "customer testimonial", "sales deck content", "webinar",
                                    "event invitation", "white paper", "thought leadership article",
                                    "corporate announcement", "company newsletter", "investor article",
                                    "crisis communication", "panel discussion prep", "linkedin profile",
                                    "website team profile", "speaker bio", "board member profile",
                                    "customer onboarding email", "apology & service recovery email",
                                    "job ad", "job description", "employee newsletter",
                                    "company culture & values page", "internal memo", "performance review",
                                    "partner profile","profiles","Proposal","Proposal introductions"
                                ]):
                                                                     
                                appended_instructions = (
                                  
                          
                        
                        """
                        **Craft flawless, engaging content using clear, direct, non-flowery language that actively captivates readers. Avoid AI jargon, vague phrases, or overly formal wording. Follow industry-standard formats strictly. Write headlines and sentences exclusively in active voice—avoid passive constructions entirely.**                
                        ---
                        DONOT MENTION TRUSTBUCKET NAME IN THE OUTPUT. AVOID IT.
        
                        ## **Mandatory Guidelines for Partner Profiles**
                        
                                - Format Partner Profiles as a continuous, cohesive narrative without sub-lines, mini-headings, or sectioned headings.
                                - Include **one compelling quote** in bold with spacing , formatted similarly to partner profiles on BCLP Law’s website ([example](https://www.bclplaw.com/en-US/people/tom-bacon.html)):
                                  - Place the quote in quotation marks, and ensure it succinctly captures the individual's expertise, values, or professional philosophy.
                                  - Attribute clearly if necessary.
                                - Highlight specific achievements, areas of expertise, leadership roles, and notable contributions.
                                - Ensure seamless narrative flow without any sectioned headings or bullet points.
        
                        ## **General Guidelines for All Formats**
                         Strictly give headings and sub-headings . and Subject where necessary
                         DONOT MENTION TRUSTBUCKET NAMES LITERALLY
                        1. **Seamless Flow (Critical for All Formats)**  
                           - Every paragraph must connect logically to the previous one and transition naturally into the next.  
                           - Use linking phrases like "Building on this..." or "This aligns with..." to reinforce the narrative's interconnectedness.  
                           - Ensure no standalone or disjointed sections; the content should flow as one cohesive story.
                        
                        2. **Tailored Formats**  
                          - **Blogs/Articles/Reports/Annual Reports**:
                          - In-depth narrative paragraphs, creative subheadings, real-world examples.
                          
                          - **Newsletters**:
                            - Short paragraphs/bullet points, direct "you/your" engagement, strong CTAs.
                            - Donot include source link within content only in list of trustbuilders
                          - **Partner Profiles** *(Important addition you have now)*:
                            - Continuous narrative without sub-lines or headings.
                            - Include a compelling professional quote.
                            - Follow the structure of BCLP profiles precisely.
                        
                          - **Social Media Posts, Sales Emails, Proposals, Case Studies, etc.**:
                            - Concise, specific, action-oriented text with concrete examples, statistics, awards, and impactful details.
        
                        
                        3. **Dynamic Headlines and Subheadings**  
                           - Create active, action-oriented headlines summarizing the content below (e.g., "Transform Lives Today" rather than "Transforming Lives").  
                           - Avoid generic titles or "-ing" endings. Headlines should inspire curiosity and guide the reader through the content.  
                        
                        4. **Relatable, Audience-Centric Tone**  
                           - Address the audience directly ("you") to make the content feel personal, especially in newsletters.  
                           - Tailor the content to the audience's needs, challenges, and aspirations.  
                           - Use vivid imagery, relatable examples, and emotional appeals to create engagement.  
                        
                        5. **Purpose-Driven Impact**  
                           - Define and achieve the content’s purpose—whether to inform, persuade, or inspire action.  
                           - Ensure each paragraph contributes to the overall objective while reinforcing the key message.  
                        
                        6. **Polished and Professional Presentation**  
                           - Deliver error-free, well-structured content with visually appealing layouts.  
                           - Ensure concise paragraphs and bullet points highlight key statistics or achievements.
                        
                        ---
                        
                        ## **Mandatory Guidelines **
                        
                        1. ** Formatting**  
                           - Use short, impactful paragraphs or bullet points to improve readability.  
                           - Ensure content is visually digestible, with clear section breaks and prominent CTAs.  
                           - Example CTA: "Be the hope they need—donate today."  
                        
                        2. **TrustBuilder Integration**  
                           - Weave TrustBuilders® naturally into the narrative without isolating them.  
                           - Highlight relevance subtly while maintaining readability.  
                        
                        3. **Mandatory Sections**  
                           - **Engaging Opening**: Start with a compelling hook to draw the reader in.  
                             - Example: "Imagine transforming the life of a child in need—your support can make this possible."  
                           - **Highlight Initiatives**: Summarize key programs, achievements, and their impacts.  
                             - Example Headline: "Empower Communities Through Early Education"  
                           - **Leadership and Success Stories**: Highlight leadership contributions or personal stories that inspire confidence.  
                             - Example Headline: "DrivE Change with Strategic Leadership"  
                           - **Bolder Call-to-Action (CTA) **: End with a powerful CTA that encourages immediate reader engagement.  
                        4. **Headlines**:
                           - *Always Give active language  main headline and sub headlines with  paragraphs, should be creative.
                        ---
                        
                        ## **Mandatory Guidelines **
                        
                        1. **Blog/Article-Specific Formatting**  
                           - Stronger Emotional Hook at the Start
                           - Use in-depth, narrative-style paragraphs to explore topics comprehensively.  
                           - Ensure each section begins with a creative subheading summarizing its content.  
                           - Focus on storytelling techniques to maintain reader interest.
                           - Bring More Engaging Transitions Between Sections.
        
        
                        2. **Detailed Content Elements**  
                           - Include real-world examples and data to support claims.  
                           - Use actionable insights to provide value to the reader.  
                        
                        3. **Interconnected Narrative**  
                           - Ensure every paragraph connects logically to the previous one, building a seamless flow throughout.  
                           - Use phrases to maintain cohesiveness.
                        4. **Headlines**:
                           - Give active language  main headline and sub-headlines with each paragraphs, should be creative.
                        ---
                        
                        ## **Key Components for All Formats**
                        
                        1. **TrustBuilders and Techniques**  
                           - **List of TrustBuilders Used**: List TrustBuilders used along with source links.  
                             Add in footnote style:  
                             - **Heuristics**: Mention names only (e.g., Social Proof, Authority, Commitment).  
                             - **Creative Techniques**: Mention names only (e.g., Storytelling, Emotional Appeal).  
                        
                        2. **Creative Headlines and Subheadings**  
                           - Use dynamic, action-driven only acive voice strictly headlines to engage the reader.  
                           - Example: "Empower Strategic Growth and Development" or "Create Lasting Impact Together"
                        
                        3. **Actionable CTAs**  
                           - Include Bolder Call-to-Action  that inspire action at the end of relevant sections.                  
                        ---
                        
                        ## **Critical Reminders**
                        
                        - Strengthen connections between paragraphs to create a seamless flow.  
                        - Balance brevity and detail to suit the format (blogs/articles for depth, newsletters for quick summaries).  
                        - Maintain a cohesive tone and structure across all formats.  
                        """)
        
                        else:
                            appended_instructions = ""
                        final_prompt = f"{prompt} {base_instructions} {appended_instructions}"
                        global formatted_text

                        # Specialized responses if keywords detected
                        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("$", "\$")

                            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)
        
                            st.session_state.chat_history.append({"role": "assistant", "content": escaped_text})
                            copy_to_clipboard(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["handled"] = True  # Mark as handled
        
       
  
handle_prompt(prompt)