app.py

"""
Intelligent Audit Report Chatbot UI
"""


import os
import sys
import time
import json
import uuid
import logging
from pathlib import Path

import argparse
import streamlit as st
from langchain_core.messages import HumanMessage, AIMessage

from multi_agent_chatbot import get_multi_agent_chatbot
from smart_chatbot import get_chatbot as get_smart_chatbot
from src.reporting.feedback_schema import create_feedback_from_dict

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

# Page config
st.set_page_config(
    layout="wide",
    page_icon="🤖",
    initial_sidebar_state="expanded",
    page_title="Intelligent Audit Report Chatbot"
)

# Custom CSS
st.markdown("""
<style>
    .main-header {
        font-size: 2.5rem;
        font-weight: bold;
        color: #1f77b4;
        text-align: center;
        margin-bottom: 1rem;
    }
    
    .subtitle {
        font-size: 1.2rem;
        color: #666;
        text-align: center;
        margin-bottom: 2rem;
    }
    
    .session-info {
        background-color: #f0f2f6;
        padding: 10px;
        border-radius: 5px;
        margin-bottom: 20px;
        font-size: 0.9rem;
    }
    
    .user-message {
        background-color: #007bff;
        color: white;
        padding: 12px 16px;
        border-radius: 18px 18px 4px 18px;
        margin: 8px 0;
        margin-left: 20%;
        word-wrap: break-word;
    }
    
    .bot-message {
        background-color: #f1f3f4;
        color: #333;
        padding: 12px 16px;
        border-radius: 18px 18px 18px 4px;
        margin: 8px 0;
        margin-right: 20%;
        word-wrap: break-word;
        border: 1px solid #e0e0e0;
    }
    
    .filter-section {
        margin-bottom: 20px;
        padding: 15px;
        background-color: #f8f9fa;
        border-radius: 8px;
        border: 1px solid #e9ecef;
    }
    
    .filter-title {
        font-weight: bold;
        margin-bottom: 10px;
        color: #495057;
    }
    
    .feedback-section {
        background-color: #f8f9fa;
        padding: 20px;
        border-radius: 10px;
        margin-top: 30px;
        border: 2px solid #dee2e6;
    }
    
    .retrieval-history {
        background-color: #ffffff;
        padding: 15px;
        border-radius: 5px;
        margin: 10px 0;
        border-left: 4px solid #007bff;
    }
</style>
""", unsafe_allow_html=True)

def get_system_type():
    """Get the current system type"""
    system = os.environ.get('CHATBOT_SYSTEM', 'multi-agent')
    if system == 'smart':
        return "Smart Chatbot System"
    else:
        return "Multi-Agent System"

def get_chatbot():
    """Initialize and return the chatbot based on system type"""
    # Check environment variable for system type
    system = os.environ.get('CHATBOT_SYSTEM', 'multi-agent')
    if system == 'smart':
        return get_smart_chatbot()
    else:
        return get_multi_agent_chatbot()

def serialize_messages(messages):
    """Serialize LangChain messages to dictionaries"""
    serialized = []
    for msg in messages:
        if hasattr(msg, 'content'):
            serialized.append({
                "type": type(msg).__name__,
                "content": str(msg.content)
            })
    return serialized

def serialize_documents(sources):
    """Serialize document objects to dictionaries with deduplication"""
    serialized = []
    seen_content = set()
    
    for doc in sources:
        content = getattr(doc, 'page_content', getattr(doc, 'content', ''))
        
        # Skip if we've seen this exact content before
        if content in seen_content:
            continue
            
        seen_content.add(content)
        
        doc_dict = {
            "content": content,
            "metadata": getattr(doc, 'metadata', {}),
            "score": getattr(doc, 'metadata', {}).get('reranked_score', getattr(doc, 'metadata', {}).get('original_score', 0.0)),
            "id": getattr(doc, 'metadata', {}).get('_id', 'unknown'),
            "source": getattr(doc, 'metadata', {}).get('source', 'unknown'),
            "year": getattr(doc, 'metadata', {}).get('year', 'unknown'),
            "district": getattr(doc, 'metadata', {}).get('district', 'unknown'),
            "page": getattr(doc, 'metadata', {}).get('page', 'unknown'),
            "chunk_id": getattr(doc, 'metadata', {}).get('chunk_id', 'unknown'),
            "page_label": getattr(doc, 'metadata', {}).get('page_label', 'unknown'),
            "original_score": getattr(doc, 'metadata', {}).get('original_score', 0.0),
            "reranked_score": getattr(doc, 'metadata', {}).get('reranked_score', None)
        }
        serialized.append(doc_dict)
    
    return serialized

@st.cache_data
def load_filter_options():
    try:
        with open("filter_options.json", "r") as f:
            return json.load(f)
    except FileNotFoundError:
        st.info([x for x in os.listdir() if x.endswith('.json')])
        st.error("filter_options.json not found. Please run the metadata analysis script.")
        return {"sources": [], "years": [], "districts": [], 'filenames': []}

def main():
    # Initialize session state
    if 'messages' not in st.session_state:
        st.session_state.messages = []
    if 'conversation_id' not in st.session_state:
        st.session_state.conversation_id = f"session_{uuid.uuid4().hex[:8]}"
    if 'session_start_time' not in st.session_state:
        st.session_state.session_start_time = time.time()
    if 'active_filters' not in st.session_state:
        st.session_state.active_filters = {'sources': [], 'years': [], 'districts': [], 'filenames': []}
    # Track RAG retrieval history for feedback
    if 'rag_retrieval_history' not in st.session_state:
        st.session_state.rag_retrieval_history = []
    # Initialize chatbot only once per app session (cached)
    if 'chatbot' not in st.session_state:
        with st.spinner("🔄 Loading AI models and connecting to database..."):
            st.session_state.chatbot = get_chatbot()
        st.success("✅ AI system ready!")
    
    # Reset conversation history if needed (but keep chatbot cached)
    if 'reset_conversation' in st.session_state and st.session_state.reset_conversation:
        st.session_state.messages = []
        st.session_state.conversation_id = f"session_{uuid.uuid4().hex[:8]}"
        st.session_state.session_start_time = time.time()
        st.session_state.rag_retrieval_history = []
        st.session_state.feedback_submitted = False
        st.session_state.reset_conversation = False
        st.rerun()

    # Header with system indicator
    col1, col2 = st.columns([3, 1])
    with col1:
        st.markdown('<h1 class="main-header">🤖 Intelligent Audit Report Chatbot</h1>', unsafe_allow_html=True)
    with col2:
        system_type = get_system_type()
        if "Multi-Agent" in system_type:
            st.success(f"🔧 {system_type}")
        else:
            st.info(f"🔧 {system_type}")
    st.markdown('<p class="subtitle">Ask questions about audit reports. Use the sidebar filters to narrow down your search!</p>', unsafe_allow_html=True)
    
    # Session info
    duration = int(time.time() - st.session_state.session_start_time)
    duration_str = f"{duration // 60}m {duration % 60}s"
    st.markdown(f'''
    <div class="session-info">
        <strong>Session Info:</strong> Messages: {len(st.session_state.messages)} | Duration: {duration_str} | Status: Active | ID: {st.session_state.conversation_id}
    </div>
    ''', unsafe_allow_html=True)

    # Load filter options
    filter_options = load_filter_options()

    # Sidebar for filters
    with st.sidebar:
        st.markdown("### 🔍 Search Filters")
        st.markdown("Select filters to narrow down your search. Leave empty to search all data.")
        
        st.markdown('<div class="filter-section">', unsafe_allow_html=True)
        st.markdown('<div class="filter-title">📄 Specific Reports (Filename Filter)</div>', unsafe_allow_html=True)
        st.markdown('<p style="font-size: 0.85em; color: #666;">⚠️ Selecting specific reports will ignore all other filters</p>', unsafe_allow_html=True)
        selected_filenames = st.multiselect(
                "Select specific reports:",
                options=filter_options.get('filenames', []),
                default=st.session_state.active_filters.get('filenames', []),
                key="filenames_filter",
                help="Choose specific reports to search. When enabled, all other filters are ignored."
            )
        st.markdown('</div>', unsafe_allow_html=True)
        
        # Determine if filename filter is active
        filename_mode = len(selected_filenames) > 0
        # Sources filter
        st.markdown('<div class="filter-section">', unsafe_allow_html=True)
        st.markdown('<div class="filter-title">📊 Sources</div>', unsafe_allow_html=True)
        selected_sources = st.multiselect(
            "Select sources:",
            options=filter_options['sources'],
            default=st.session_state.active_filters['sources'],
            disabled = filename_mode,
            key="sources_filter",
            help="Choose which types of reports to search"
        )
        st.markdown('</div>', unsafe_allow_html=True)
        
        # Years filter
        st.markdown('<div class="filter-section">', unsafe_allow_html=True)
        st.markdown('<div class="filter-title">📅 Years</div>', unsafe_allow_html=True)
        selected_years = st.multiselect(
            "Select years:",
            options=filter_options['years'],
            default=st.session_state.active_filters['years'],
            disabled = filename_mode,
            key="years_filter",
            help="Choose which years to search"
        )
        st.markdown('</div>', unsafe_allow_html=True)
        
        # Districts filter
        st.markdown('<div class="filter-section">', unsafe_allow_html=True)
        st.markdown('<div class="filter-title">🏘️ Districts</div>', unsafe_allow_html=True)
        selected_districts = st.multiselect(
            "Select districts:",
            options=filter_options['districts'],
            default=st.session_state.active_filters['districts'],
            disabled = filename_mode,
            key="districts_filter",
            help="Choose which districts to search"
        )
        st.markdown('</div>', unsafe_allow_html=True)
        
        # Update active filters
        st.session_state.active_filters = {
            'sources': selected_sources if not filename_mode else [],
            'years': selected_years if not filename_mode else [],
            'districts': selected_districts if not filename_mode else [],
            'filenames': selected_filenames
        }
        
        # Clear filters button
        if st.button("🗑️ Clear All Filters", key="clear_filters_button"):
            st.session_state.active_filters = {'sources': [], 'years': [], 'districts': [], 'filenames': []}
            st.rerun()

    # Main content area with tabs
    tab1, tab2 = st.tabs(["💬 Chat", "📄 Retrieved Documents"])
    
    with tab1:
        # Chat container
        chat_container = st.container()
        
        with chat_container:
            # Display conversation history
            for message in st.session_state.messages:
                if isinstance(message, HumanMessage):
                    st.markdown(f'<div class="user-message">{message.content}</div>', unsafe_allow_html=True)
                elif isinstance(message, AIMessage):
                    st.markdown(f'<div class="bot-message">{message.content}</div>', unsafe_allow_html=True)
        
        # Input area
        st.markdown("<br>", unsafe_allow_html=True)
        
        # Create two columns for input and button
        col1, col2 = st.columns([4, 1])
        
        with col1:
            # Use a counter to force input clearing
            if 'input_counter' not in st.session_state:
                st.session_state.input_counter = 0
            
            user_input = st.text_input(
                "Type your message here...",
                placeholder="Ask about budget allocations, expenditures, or audit findings...",
                key=f"user_input_{st.session_state.input_counter}",
                label_visibility="collapsed"
            )
        
        with col2:
            send_button = st.button("Send", key="send_button", use_container_width=True)
        
        # Clear chat button
        if st.button("🗑️ Clear Chat", key="clear_chat_button"):
            st.session_state.reset_conversation = True
            # Clear all conversation files
            import os
            conversations_dir = "conversations"
            if os.path.exists(conversations_dir):
                for file in os.listdir(conversations_dir):
                    if file.endswith('.json'):
                        os.remove(os.path.join(conversations_dir, file))
            st.rerun()
        
        # Handle user input
        if send_button and user_input:
            # Construct filter context string
            filter_context_str = ""
            if selected_filenames:
                filter_context_str += "FILTER CONTEXT:\n"
                filter_context_str += f"Filenames: {', '.join(selected_filenames)}\n"
                filter_context_str += "USER QUERY:\n"
            elif selected_sources or selected_years or selected_districts:
                filter_context_str += "FILTER CONTEXT:\n"
                if selected_sources:
                    filter_context_str += f"Sources: {', '.join(selected_sources)}\n"
                if selected_years:
                    filter_context_str += f"Years: {', '.join(selected_years)}\n"
                if selected_districts:
                    filter_context_str += f"Districts: {', '.join(selected_districts)}\n"
                filter_context_str += "USER QUERY:\n"
            
            full_query = filter_context_str + user_input
            
            # Add user message to history
            st.session_state.messages.append(HumanMessage(content=user_input))
            
            # Get chatbot response
            with st.spinner("🤔 Thinking..."):
                try:
                    # Pass the full query with filter context
                    chat_result = st.session_state.chatbot.chat(full_query, st.session_state.conversation_id)
                    
                    # Handle both old format (string) and new format (dict)
                    if isinstance(chat_result, dict):
                        response = chat_result['response']
                        rag_result = chat_result.get('rag_result')
                        st.session_state.last_rag_result = rag_result
                        
                        # Track RAG retrieval for feedback
                        if rag_result:
                            sources = rag_result.get('sources', []) if isinstance(rag_result, dict) else (rag_result.sources if hasattr(rag_result, 'sources') else [])
                            
                            # Get the actual RAG query
                            actual_rag_query = chat_result.get('actual_rag_query', '')
                            if actual_rag_query:
                                # Format it like the log message
                                timestamp = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
                                formatted_query = f"{timestamp} - INFO - 🔍 ACTUAL RAG QUERY: '{actual_rag_query}'"
                            else:
                                formatted_query = "No RAG query available"
                            
                            retrieval_entry = {
                                "conversation_up_to": serialize_messages(st.session_state.messages),
                                "rag_query_expansion": formatted_query,
                                "docs_retrieved": serialize_documents(sources)
                            }
                            st.session_state.rag_retrieval_history.append(retrieval_entry)
                    else:
                        response = chat_result
                        st.session_state.last_rag_result = None
                    
                    # Add bot response to history
                    st.session_state.messages.append(AIMessage(content=response))
                    
                except Exception as e:
                    error_msg = f"Sorry, I encountered an error: {str(e)}"
                    st.session_state.messages.append(AIMessage(content=error_msg))
            
            # Clear input and rerun
            st.session_state.input_counter += 1  # This will clear the input
            st.rerun()
    
    with tab2:
        # Document retrieval panel
        if hasattr(st.session_state, 'last_rag_result') and st.session_state.last_rag_result:
            rag_result = st.session_state.last_rag_result
            
            # Handle both PipelineResult object and dictionary formats
            sources = None
            if hasattr(rag_result, 'sources'):
                # PipelineResult object format
                sources = rag_result.sources
            elif isinstance(rag_result, dict) and 'sources' in rag_result:
                # Dictionary format from multi-agent system
                sources = rag_result['sources']
            
            if sources and len(sources) > 0:
                # Count unique filenames
                unique_filenames = set()
                for doc in sources:
                    filename = getattr(doc, 'metadata', {}).get('filename', 'Unknown')
                    unique_filenames.add(filename)
                
                st.markdown(f"**Found {len(sources)} document chunks from {len(unique_filenames)} unique documents (showing top 10):**")
                if len(unique_filenames) < len(sources):
                    st.info(f"💡 **Note**: Each document is split into multiple chunks. You're seeing {len(sources)} chunks from {len(unique_filenames)} documents.")
                
                for i, doc in enumerate(sources[:10]):  # Show top 10
                    # Get relevance score and ID if available
                    metadata = getattr(doc, 'metadata', {})
                    score = metadata.get('reranked_score', metadata.get('original_score', None))
                    chunk_id = metadata.get('_id', 'Unknown')
                    score_text = f" (Score: {score:.3f}, ID: {chunk_id[:8]}...)" if score is not None else f" (ID: {chunk_id[:8]}...)"
                    
                    with st.expander(f"📄 Document {i+1}: {getattr(doc, 'metadata', {}).get('filename', 'Unknown')[:50]}...{score_text}"):
                        # Display document metadata with emojis
                        metadata = getattr(doc, 'metadata', {})
                        col1, col2, col3, col4 = st.columns([2, 1.5, 1, 1])
                        
                        with col1:
                            st.write(f"📄 **File:** {metadata.get('filename', 'Unknown')}")
                        with col2:
                            st.write(f"🏛️ **Source:** {metadata.get('source', 'Unknown')}")
                        with col3:
                            st.write(f"📅 **Year:** {metadata.get('year', 'Unknown')}")
                        with col4:
                            # Display page number and chunk ID
                            page = metadata.get('page_label', metadata.get('page', 'Unknown'))
                            chunk_id = metadata.get('_id', 'Unknown')
                            st.write(f"📖 **Page:** {page}")
                            st.write(f"🆔 **ID:** {chunk_id}")
                        
                        # Display full content (no truncation)
                        content = getattr(doc, 'page_content', 'No content available')
                        st.write(f"**Full Content:**")
                        st.text_area("Full Content", value=content, height=300, disabled=True, label_visibility="collapsed", key=f"preview_{i}")
            else:
                st.info("No documents were retrieved for the last query.")
        else:
            st.info("No documents have been retrieved yet. Start a conversation to see retrieved documents here.")
    
    # Feedback Dashboard Section
    st.markdown("---")
    st.markdown("### 💬 Feedback Dashboard")
    
    # Check if there's any conversation to provide feedback on
    has_conversation = len(st.session_state.messages) > 0
    has_retrievals = len(st.session_state.rag_retrieval_history) > 0
    
    if not has_conversation:
        st.info("💡 Start a conversation to provide feedback!")
        st.markdown("The feedback dashboard will be enabled once you begin chatting.")
    else:
        st.markdown("Help us improve by providing feedback on this conversation.")
        
        # Initialize feedback state if not exists
        if 'feedback_submitted' not in st.session_state:
            st.session_state.feedback_submitted = False
        
        # Feedback form
        with st.form("feedback_form", clear_on_submit=False):
            col1, col2 = st.columns([1, 1])
            
            with col1:
                feedback_score = st.slider(
                    "Rate this conversation (1-5)",
                    min_value=1,
                    max_value=5,
                    help="How satisfied are you with the conversation?"
                )
            
            with col2:
                is_feedback_about_last_retrieval = st.checkbox(
                    "Feedback about last retrieval only",
                    value=True,
                    help="If checked, feedback applies to the most recent document retrieval"
                )
            
            open_ended_feedback = st.text_area(
                "Your feedback (optional)",
                placeholder="Tell us what went well or what could be improved...",
                height=100
            )
            
            # Disable submit if no score selected
            submit_disabled = feedback_score is None
            
            submitted = st.form_submit_button(
                "📤 Submit Feedback", 
                use_container_width=True,
                disabled=submit_disabled
            )
            
            if submitted and not st.session_state.feedback_submitted:
                # Log the feedback data being submitted
                print("=" * 80)
                print("🔄 FEEDBACK SUBMISSION: Starting...")
                print("=" * 80)
                st.write("🔍 **Debug: Feedback Data Being Submitted:**")
                
                # Create feedback data dictionary
                feedback_dict = {
                    "open_ended_feedback": open_ended_feedback,
                    "score": feedback_score,
                    "is_feedback_about_last_retrieval": is_feedback_about_last_retrieval,
                    "retrieved_data": st.session_state.rag_retrieval_history.copy() if st.session_state.rag_retrieval_history else [],
                    "conversation_id": st.session_state.conversation_id,
                    "timestamp": time.time(),
                    "message_count": len(st.session_state.messages),
                    "has_retrievals": has_retrievals,
                    "retrieval_count": len(st.session_state.rag_retrieval_history)
                }
                
                print(f"📝 FEEDBACK SUBMISSION: Score={feedback_score}, Retrievals={len(st.session_state.rag_retrieval_history) if st.session_state.rag_retrieval_history else 0}")
                
                # Create UserFeedback dataclass instance
                feedback_obj = None  # Initialize outside try block
                try:
                    feedback_obj = create_feedback_from_dict(feedback_dict)
                    print(f"✅ FEEDBACK SUBMISSION: Feedback object created - ID={feedback_obj.feedback_id}")
                    st.write(f"✅ **Feedback Object Created**")
                    st.write(f"- Feedback ID: {feedback_obj.feedback_id}")
                    st.write(f"- Score: {feedback_obj.score}/5")
                    st.write(f"- Has Retrievals: {feedback_obj.has_retrievals}")
                    
                    # Convert back to dict for JSON serialization
                    feedback_data = feedback_obj.to_dict()
                except Exception as e:
                    print(f"❌ FEEDBACK SUBMISSION: Failed to create feedback object: {e}")
                    st.error(f"Failed to create feedback object: {e}")
                    feedback_data = feedback_dict
                
                # Display the data being submitted
                st.json(feedback_data)
                
                # Save feedback to file
                feedback_dir = Path("feedback")
                feedback_dir.mkdir(exist_ok=True)
                
                feedback_file = feedback_dir / f"feedback_{st.session_state.conversation_id}_{int(time.time())}.json"
                
                try:
                    # Save to local file
                    print(f"💾 FEEDBACK SAVE: Saving to local file: {feedback_file}")
                    with open(feedback_file, 'w') as f:
                        json.dump(feedback_data, f, indent=2, default=str)
                    
                    print(f"✅ FEEDBACK SAVE: Local file saved successfully")
                    st.success("✅ Thank you for your feedback! It has been saved locally.")
                    st.balloons()
                    
                    # Save to Snowflake if enabled and credentials available
                    logger.info("🔄 FEEDBACK SAVE: Starting Snowflake save process...")
                    logger.info(f"📊 FEEDBACK SAVE: feedback_obj={'exists' if feedback_obj else 'None'}")
                    
                    try:
                        import os
                        snowflake_enabled = os.getenv("SNOWFLAKE_ENABLED", "false").lower() == "true"
                        logger.info(f"🔍 SNOWFLAKE CHECK: enabled={snowflake_enabled}")
                        
                        if snowflake_enabled:
                            if feedback_obj:
                                try:
                                    from auditqa.reporting.snowflake_connector import save_to_snowflake
                                    logger.info("📤 SNOWFLAKE UI: Attempting to save feedback to Snowflake...")
                                    print("📤 SNOWFLAKE UI: Attempting to save feedback to Snowflake...")  # Also print to terminal
                                    
                                    if save_to_snowflake(feedback_obj):
                                        logger.info("✅ SNOWFLAKE UI: Successfully saved to Snowflake")
                                        print("✅ SNOWFLAKE UI: Successfully saved to Snowflake")  # Also print to terminal
                                        st.success("✅ Feedback also saved to Snowflake!")
                                    else:
                                        logger.warning("⚠️ SNOWFLAKE UI: Save failed")
                                        print("⚠️ SNOWFLAKE UI: Save failed")  # Also print to terminal
                                        st.warning("⚠️ Snowflake save failed, but local save succeeded")
                                except Exception as e:
                                    logger.error(f"❌ SNOWFLAKE UI ERROR: {e}")
                                    print(f"❌ SNOWFLAKE UI ERROR: {e}")  # Also print to terminal
                                    import traceback
                                    traceback.print_exc()  # Print full traceback to terminal
                                    st.warning(f"⚠️ Could not save to Snowflake: {e}")
                            else:
                                logger.warning("⚠️ SNOWFLAKE UI: Skipping (feedback object not created)")
                                print("⚠️ SNOWFLAKE UI: Skipping (feedback object not created)")  # Also print to terminal
                                st.warning("⚠️ Skipping Snowflake save (feedback object not created)")
                        else:
                            logger.info("💡 SNOWFLAKE UI: Integration disabled")
                            print("💡 SNOWFLAKE UI: Integration disabled")  # Also print to terminal
                            st.info("💡 Snowflake integration disabled (set SNOWFLAKE_ENABLED=true to enable)")
                    except NameError as e:
                        import traceback
                        traceback.print_exc()
                        logger.error(f"❌ NameError in Snowflake save: {e}")
                        print(f"❌ NameError in Snowflake save: {e}")  # Also print to terminal
                        st.warning(f"⚠️ Snowflake save error: {e}")
                    except Exception as e:
                        logger.error(f"❌ Exception in Snowflake save: {type(e).__name__}: {e}")
                        print(f"❌ Exception in Snowflake save: {type(e).__name__}: {e}")  # Also print to terminal
                        st.warning(f"⚠️ Snowflake save error: {e}")
                    
                    # Mark feedback as submitted to prevent resubmission
                    st.session_state.feedback_submitted = True
                    
                    print("=" * 80)
                    print(f"✅ FEEDBACK SUBMISSION: Completed successfully")
                    print("=" * 80)
                    
                    # Log file location
                    st.info(f"📁 Feedback saved to: {feedback_file}")
                    
                except Exception as e:
                    print(f"❌ FEEDBACK SUBMISSION: Error saving feedback: {e}")
                    print(f"❌ FEEDBACK SUBMISSION: Error type: {type(e).__name__}")
                    import traceback
                    traceback.print_exc()
                    st.error(f"❌ Error saving feedback: {e}")
                    st.write(f"Debug error: {str(e)}")
            
            elif st.session_state.feedback_submitted:
                st.success("✅ Feedback already submitted for this conversation!")
                if st.button("🔄 Submit New Feedback", key="new_feedback_button"):
                    st.session_state.feedback_submitted = False
                    st.rerun()
    
    # Display retrieval history stats
    if st.session_state.rag_retrieval_history:
        st.markdown("---")
        st.markdown("#### 📊 Retrieval History")
        
        with st.expander(f"View {len(st.session_state.rag_retrieval_history)} retrieval entries", expanded=False):
            for idx, entry in enumerate(st.session_state.rag_retrieval_history, 1):
                st.markdown(f"**Retrieval #{idx}**")
                
                # Display the actual RAG query
                rag_query_expansion = entry.get("rag_query_expansion", "No query available")
                st.code(rag_query_expansion, language="text")
                
                # Display summary stats
                st.json({
                    "conversation_length": len(entry.get("conversation_up_to", [])),
                    "documents_retrieved": len(entry.get("docs_retrieved", []))
                })
                st.markdown("---")
    
    # Auto-scroll to bottom
    st.markdown("""
    <script>
        window.scrollTo(0, document.body.scrollHeight);
    </script>
    """, unsafe_allow_html=True)

if __name__ == "__main__":
    main()