import gradio as gr
import tempfile
import os
import requests
import json
import re
from bs4 import BeautifulSoup
from datetime import datetime
import urllib.parse


# Configuration
SPACE_NAME = 'Writing Aid'
SPACE_DESCRIPTION = 'A customizable AI assistant'

# Default configuration values (used only if config.json is missing)
DEFAULT_CONFIG = {
    'name': SPACE_NAME,
    'description': SPACE_DESCRIPTION,
    'system_prompt': 'You are a humanities scholar and pedagogue specializing in interdisciplinary approaches across literature, philosophy, history, religious studies, and cultural analysis. Your expertise lies in close reading, hermeneutical interpretation, contextual analysis, and cross-cultural comparison. Guide students through primary source analysis, encourage deep engagement with texts and artifacts, and foster critical interpretation skills. Emphasize the importance of historical context, cultural sensitivity, and multiple perspectives. Help students develop sophisticated arguments grounded in textual evidence while appreciating the complexity and ambiguity inherent in humanistic inquiry. Draw connections between historical and contemporary issues, encouraging students to see the ongoing relevance of humanistic knowledge. Model intellectual curiosity, empathy, and the art of asking meaningful questions about human experience, meaning, and values.',
    'temperature': 0.8,
    'max_tokens': 1000,
    'model': 'openai/gpt-4.1-nano',
    'api_key_var': 'API_KEY',
    'theme': Origin,
    'grounding_urls': ["https://en.wikipedia.org/wiki/Hermeneutics", "https://plato.stanford.edu/entries/hermeneutics/", "https://en.wikipedia.org/wiki/Close_reading", "https://en.wikipedia.org/wiki/Cultural_studies"],
    'enable_dynamic_urls': True,
    'examples': ['How do I analyze the symbolism in this medieval manuscript?', "What historical context should I consider when reading Dante's Inferno?", 'Can you help me compare philosophical approaches to justice across different cultures?', 'How do I interpret conflicting historical accounts of the same event?'],
    'locked': False
}

# Load configuration from file - this is the single source of truth
def load_config():
    """Load configuration from config.json with fallback to defaults"""
    try:
        with open('config.json', 'r') as f:
            config = json.load(f)
            print("✅ Loaded configuration from config.json")
            return config
    except FileNotFoundError:
        print("ℹ️ No config.json found, using default configuration")
        # Save default config for future use
        try:
            with open('config.json', 'w') as f:
                json.dump(DEFAULT_CONFIG, f, indent=2)
            print("✅ Created config.json with default values")
        except:
            pass
        return DEFAULT_CONFIG
    except Exception as e:
        print(f"⚠️ Error loading config.json: {e}, using defaults")
        return DEFAULT_CONFIG

# Load configuration
config = load_config()

# Initial load of configuration values
SPACE_NAME = config.get('name', DEFAULT_CONFIG['name'])
SPACE_DESCRIPTION = config.get('description', DEFAULT_CONFIG['description'])
SYSTEM_PROMPT = config.get('system_prompt', DEFAULT_CONFIG['system_prompt'])
temperature = config.get('temperature', DEFAULT_CONFIG['temperature'])
max_tokens = config.get('max_tokens', DEFAULT_CONFIG['max_tokens'])
MODEL = config.get('model', DEFAULT_CONFIG['model'])
THEME = config.get('theme', DEFAULT_CONFIG['theme'])
GROUNDING_URLS = config.get('grounding_urls', DEFAULT_CONFIG['grounding_urls'])
ENABLE_DYNAMIC_URLS = config.get('enable_dynamic_urls', DEFAULT_CONFIG['enable_dynamic_urls'])

# Get access code from environment variable for security
# If ACCESS_CODE is not set, no access control is applied
ACCESS_CODE = os.environ.get("ACCESS_CODE")

# Get API key from environment - customizable variable name with validation
API_KEY_VAR = config.get('api_key_var', DEFAULT_CONFIG['api_key_var'])
API_KEY = os.environ.get(API_KEY_VAR)
if API_KEY:
    API_KEY = API_KEY.strip()  # Remove any whitespace
    if not API_KEY:  # Check if empty after stripping
        API_KEY = None
        
# API Key validation and logging
def validate_api_key():
    """Validate API key configuration with detailed logging"""
    if not API_KEY:
        print(f"⚠️  API KEY CONFIGURATION ERROR:")
        print(f"   Variable name: {API_KEY_VAR}")
        print(f"   Status: Not set or empty")
        print(f"   Action needed: Set '{API_KEY_VAR}' in HuggingFace Space secrets")
        print(f"   Expected format: sk-or-xxxxxxxxxx")
        return False
    elif not API_KEY.startswith('sk-or-'):
        print(f"⚠️  API KEY FORMAT WARNING:")
        print(f"   Variable name: {API_KEY_VAR}")
        print(f"   Current value: {API_KEY[:10]}..." if len(API_KEY) > 10 else "{API_KEY}")
        print(f"   Expected format: sk-or-xxxxxxxxxx")
        print(f"   Note: OpenRouter keys should start with 'sk-or-'")
        return True  # Still try to use it
    else:
        print(f"✅ API Key configured successfully")
        print(f"   Variable: {API_KEY_VAR}")
        print(f"   Format: Valid OpenRouter key")
        return True

# Validate on startup
try:
    API_KEY_VALID = validate_api_key()
except NameError:
    # During template generation, API_KEY might not be defined yet
    API_KEY_VALID = False

def validate_url_domain(url):
    """Basic URL domain validation"""
    try:
        from urllib.parse import urlparse
        parsed = urlparse(url)
        # Check for valid domain structure
        if parsed.netloc and '.' in parsed.netloc:
            return True
    except:
        pass
    return False

def fetch_url_content(url):
    """Enhanced URL content fetching with improved compatibility and error handling"""
    if not validate_url_domain(url):
        return f"Invalid URL format: {url}"
    
    try:
        # Enhanced headers for better compatibility
        headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
            'Accept-Language': 'en-US,en;q=0.5',
            'Accept-Encoding': 'gzip, deflate',
            'Connection': 'keep-alive'
        }
        
        response = requests.get(url, timeout=15, headers=headers)
        response.raise_for_status()
        soup = BeautifulSoup(response.content, 'html.parser')
        
        # Enhanced content cleaning
        for element in soup(["script", "style", "nav", "header", "footer", "aside", "form", "button"]):
            element.decompose()
        
        # Extract main content preferentially
        main_content = soup.find('main') or soup.find('article') or soup.find('div', class_=lambda x: bool(x and 'content' in x.lower())) or soup
        text = main_content.get_text()
        
        # Enhanced text cleaning
        lines = (line.strip() for line in text.splitlines())
        chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
        text = ' '.join(chunk for chunk in chunks if chunk and len(chunk) > 2)
        
        # Smart truncation - try to end at sentence boundaries
        if len(text) > 4000:
            truncated_text = text[:4000]
            # Try to find the last complete sentence
            last_period = truncated_text.rfind('.')
            if last_period > 3500:  # Only if we have a reasonably long truncation
                text = truncated_text[:last_period + 1]
            else:
                text = truncated_text + "..."
        
        return text if text.strip() else "No readable content found at this URL"
        
    except requests.exceptions.Timeout:
        return f"Timeout error fetching {url} (15s limit exceeded)"
    except requests.exceptions.RequestException as e:
        return f"Error fetching {url}: {str(e)}"
    except Exception as e:
        return f"Error processing content from {url}: {str(e)}"

def extract_urls_from_text(text):
    """Extract URLs from text using regex with enhanced validation"""
    url_pattern = r'https?://[^\s<>"{}|\\^`\[\]"]+'
    urls = re.findall(url_pattern, text)
    
    # Basic URL validation and cleanup
    validated_urls = []
    for url in urls:
        # Remove trailing punctuation that might be captured
        url = url.rstrip('.,!?;:')
        # Basic domain validation
        if '.' in url and len(url) > 10:
            validated_urls.append(url)
    
    return validated_urls

# Global cache for URL content to avoid re-crawling in generated spaces
_url_content_cache = {}

def get_grounding_context():
    """Fetch context from grounding URLs with caching"""
    # Handle both string and list formats for grounding_urls
    urls = GROUNDING_URLS
    if isinstance(urls, str):
        try:
            urls = json.loads(urls)
        except:
            urls = []
    
    if not urls:
        return ""
    
    # Create cache key from URLs
    cache_key = tuple(sorted([url for url in urls if url and url.strip()]))
    
    # Check cache first
    if cache_key in _url_content_cache:
        return _url_content_cache[cache_key]
    
    context_parts = []
    for i, url in enumerate(urls, 1):
        if url.strip():
            content = fetch_url_content(url.strip())
            # Add priority indicators
            priority_label = "PRIMARY" if i <= 2 else "SECONDARY"
            context_parts.append(f"[{priority_label}] Context from URL {i} ({url}):\n{content}")
    
    if context_parts:
        result = "\n\n" + "\n\n".join(context_parts) + "\n\n"
    else:
        result = ""
    
    # Cache the result
    _url_content_cache[cache_key] = result
    return result

def export_conversation_to_markdown(conversation_history):
    """Export conversation history to markdown format"""
    if not conversation_history:
        return "No conversation to export."
    
    markdown_content = f"""# Conversation Export
Generated on: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}

---

"""
    
    message_pair_count = 0
    for i, message in enumerate(conversation_history):
        if isinstance(message, dict):
            role = message.get('role', 'unknown')
            content = message.get('content', '')
            
            if role == 'user':
                message_pair_count += 1
                markdown_content += f"## User Message {message_pair_count}\n\n{content}\n\n"
            elif role == 'assistant':
                markdown_content += f"## Assistant Response {message_pair_count}\n\n{content}\n\n---\n\n"
        elif isinstance(message, (list, tuple)) and len(message) >= 2:
            # Handle legacy tuple format: ["user msg", "assistant msg"]
            message_pair_count += 1
            user_msg, assistant_msg = message[0], message[1]
            if user_msg:
                markdown_content += f"## User Message {message_pair_count}\n\n{user_msg}\n\n"
            if assistant_msg:
                markdown_content += f"## Assistant Response {message_pair_count}\n\n{assistant_msg}\n\n---\n\n"
    
    return markdown_content


def generate_response(message, history):
    """Generate response using OpenRouter API"""
    
    # Enhanced API key validation with helpful messages
    if not API_KEY:
        error_msg = f"🔑 **API Key Required**\n\n"
        error_msg += f"Please configure your OpenRouter API key:\n"
        error_msg += f"1. Go to Settings (⚙️) in your HuggingFace Space\n"
        error_msg += f"2. Click 'Variables and secrets'\n"
        error_msg += f"3. Add secret: **{API_KEY_VAR}**\n"
        error_msg += f"4. Value: Your OpenRouter API key (starts with `sk-or-`)\n\n"
        error_msg += f"Get your API key at: https://openrouter.ai/keys"
        print(f"❌ API request failed: No API key configured for {API_KEY_VAR}")
        return error_msg
    
    # Get grounding context
    grounding_context = get_grounding_context()
    
    # Process uploaded files if any
    file_context = ""
    if files:
        file_contents = []
        for file_obj in files:
            if file_obj is not None:
                try:
                    file_content = extract_file_content(file_obj.name)
                    file_contents.append(file_content)
                except Exception as e:
                    file_contents.append(f"Error processing file: {str(e)}")
        
        if file_contents:
            file_context = "\n\n[UPLOADED FILES]\n" + "\n\n".join(file_contents) + "\n"
    
    # If dynamic URLs are enabled, check message for URLs to fetch
    if ENABLE_DYNAMIC_URLS:
        urls_in_message = extract_urls_from_text(message)
        if urls_in_message:
            dynamic_context = ""
            for url in urls_in_message[:3]:  # Limit to 3 URLs per message
                content = fetch_url_content(url)
                dynamic_context += f"\n\n[DYNAMIC] Context from {url}:\n{content}"
            grounding_context += dynamic_context
    
    # Build enhanced system prompt with grounding context and file content
    enhanced_system_prompt = SYSTEM_PROMPT + grounding_context + file_context
    
    # Build messages array for the API
    messages = [{"role": "system", "content": enhanced_system_prompt}]
    
    # Add conversation history - handle both modern messages format and legacy tuples
    for chat in history:
        if isinstance(chat, dict):
            messages.append(chat)
        elif isinstance(chat, (list, tuple)) and len(chat) >= 2:
            messages.append({"role": "user", "content": chat[0]})
            messages.append({"role": "assistant", "content": chat[1]})
    
    # Add current message
    messages.append({"role": "user", "content": message})
    
    # Make API request with enhanced error handling
    try:
        print(f"🔄 Making API request to OpenRouter...")
        print(f"   Model: {MODEL}")
        print(f"   Messages: {len(messages)} in conversation")
        
        response = requests.post(
            url="https://openrouter.ai/api/v1/chat/completions",
            headers={
                "Authorization": f"Bearer {API_KEY}",
                "Content-Type": "application/json",
                "HTTP-Referer": "https://huggingface.co",
                "X-Title": "HuggingFace Space"
            },
            json={
                "model": MODEL,
                "messages": messages,
                "temperature": temperature,
                "max_tokens": max_tokens
            },
            timeout=30
        )
        
        print(f"📡 API Response: {response.status_code}")
        
        if response.status_code == 200:
            try:
                result = response.json()
                return result['choices'][0]['message']['content']
            except (KeyError, IndexError, json.JSONDecodeError) as e:
                error_msg = f"❌ **Response Parsing Error**\n\n"
                error_msg += f"Received response from API but couldn't parse it properly.\n"
                error_msg += f"Error: {str(e)}\n\n"
                error_msg += f"**Troubleshooting:**\n"
                error_msg += f"1. Check OpenRouter service status\n"
                error_msg += f"2. Try again in a few moments\n"
                error_msg += f"3. Try a different model if available"
                print(f"❌ Response parsing error: {str(e)}")
                return error_msg
        elif response.status_code == 401:
            error_msg = f"🔑 **Authentication Error**\n\n"
            error_msg += f"Your API key appears to be invalid or expired.\n\n"
            error_msg += f"**Troubleshooting:**\n"
            error_msg += f"1. Check that your **{API_KEY_VAR}** secret is set correctly\n"
            error_msg += f"2. Verify your OpenRouter API key at https://openrouter.ai/keys\n"
            error_msg += f"3. Make sure the key starts with `sk-or-`\n"
            error_msg += f"4. Check if you have sufficient credits"
            print(f"❌ Authentication failed: Invalid API key")
            return error_msg
        elif response.status_code == 429:
            error_msg = f"⏱️ **Rate Limit Exceeded**\n\n"
            error_msg += f"Too many requests. Please wait a moment and try again.\n\n"
            error_msg += f"**Troubleshooting:**\n"
            error_msg += f"1. Wait 30-60 seconds before trying again\n"
            error_msg += f"2. Check your OpenRouter usage limits\n"
            error_msg += f"3. Consider upgrading your OpenRouter plan"
            print(f"❌ Rate limit exceeded")
            return error_msg
        elif response.status_code == 400:
            error_msg = f"📝 **Request Error**\n\n"
            error_msg += f"There was a problem with the request format.\n"
            error_msg += f"Response: {response.text[:500]}\n\n"
            error_msg += f"**Troubleshooting:**\n"
            error_msg += f"1. Try a shorter message\n"
            error_msg += f"2. Check for special characters in your message\n"
            error_msg += f"3. Try a different model"
            print(f"❌ Bad request: {response.status_code} - {response.text[:200]}")
            return error_msg
        else:
            error_msg = f"🌐 **API Error {response.status_code}**\n\n"
            error_msg += f"An unexpected error occurred.\n"
            error_msg += f"Response: {response.text[:500]}\n\n"
            error_msg += f"**Troubleshooting:**\n"
            error_msg += f"1. Try again in a few moments\n"
            error_msg += f"2. Check OpenRouter service status\n"
            error_msg += f"3. Contact support if this persists"
            print(f"❌ API error: {response.status_code} - {response.text[:200]}")
            return error_msg
            
    except requests.exceptions.Timeout:
        error_msg = f"⏰ **Request Timeout**\n\n"
        error_msg += f"The API request took too long (30s limit).\n\n"
        error_msg += f"**Troubleshooting:**\n"
        error_msg += f"1. Try again with a shorter message\n"
        error_msg += f"2. Check your internet connection\n"
        error_msg += f"3. Try a different model"
        print(f"❌ Request timeout after 30 seconds")
        return error_msg
    except requests.exceptions.ConnectionError:
        error_msg = f"🌐 **Connection Error**\n\n"
        error_msg += f"Could not connect to OpenRouter API.\n\n"
        error_msg += f"**Troubleshooting:**\n"
        error_msg += f"1. Check your internet connection\n"
        error_msg += f"2. Check OpenRouter service status\n"
        error_msg += f"3. Try again in a few moments"
        print(f"❌ Connection error to OpenRouter API")
        return error_msg
    except Exception as e:
        error_msg = "❌ **Unexpected Error**\n\n"
        error_msg += "An unexpected error occurred:\n"
        error_msg += f"`{str(e)}`\n\n"
        error_msg += "Please try again or contact support if this persists."
        print(f"❌ Unexpected error: {str(e)}")
        return error_msg

# Access code verification
access_granted = gr.State(False)
_access_granted_global = False  # Global fallback

def verify_access_code(code):
    """Verify the access code"""
    global _access_granted_global
    if ACCESS_CODE is None:
        _access_granted_global = True
        return gr.update(value="No access code required.", style={"color": "green"}), gr.update(visible=True), True
    
    if code == ACCESS_CODE:
        _access_granted_global = True
        return gr.update(value="✅ Access granted!", style={"color": "green"}), gr.update(visible=True), True
    else:
        _access_granted_global = False
        return gr.update(value="❌ Invalid access code. Please try again.", style={"color": "red"}), gr.update(visible=False), False

def protected_generate_response(message, history, files=None):
    """Protected response function that checks access"""
    # Check if access is granted via the global variable
    if ACCESS_CODE is not None and not _access_granted_global:
        return "Please enter the access code to continue."
    return generate_response(message, history, files)

# Global variable to store chat history for export
chat_history_store = []

def store_and_generate_response(message, history, files=None):
    """Wrapper function that stores history and generates response"""
    global chat_history_store
    
    # Generate response using the protected function
    response = protected_generate_response(message, history, files)
    
    # Convert current history to the format we need for export
    # history comes in as [["user1", "bot1"], ["user2", "bot2"], ...]
    chat_history_store = []
    if history:
        for exchange in history:
            if isinstance(exchange, dict):
                chat_history_store.append(exchange)
            elif isinstance(exchange, (list, tuple)) and len(exchange) >= 2:
                chat_history_store.append({"role": "user", "content": exchange[0]})
                chat_history_store.append({"role": "assistant", "content": exchange[1]})
    
    # Add the current exchange
    chat_history_store.append({"role": "user", "content": message})
    chat_history_store.append({"role": "assistant", "content": response})
    
    return response

def export_current_conversation():
    """Export the current conversation"""
    if not chat_history_store:
        return gr.update(visible=False)
    
    markdown_content = export_conversation_to_markdown(chat_history_store)
    
    # Save to temporary file
    with tempfile.NamedTemporaryFile(mode='w', suffix='.md', delete=False, encoding='utf-8') as f:
        f.write(markdown_content)
        temp_file = f.name
    
    return gr.update(value=temp_file, visible=True)

def export_conversation(history):
    """Export conversation to markdown file"""
    if not history:
        return gr.update(visible=False)
    
    markdown_content = export_conversation_to_markdown(history)
    
    # Save to temporary file
    with tempfile.NamedTemporaryFile(mode='w', suffix='.md', delete=False, encoding='utf-8') as f:
        f.write(markdown_content)
        temp_file = f.name
    
    return gr.update(value=temp_file, visible=True)

# Configuration status display
def get_configuration_status():
    """Generate a clean configuration status message for display"""
    status_parts = []
    
    # Basic configuration info (without redundant "Configuration:" header)
    status_parts.append(f"**Name:** {SPACE_NAME}")
    status_parts.append(f"**Model:** {MODEL}")
    status_parts.append(f"**Theme:** {THEME}")
    status_parts.append(f"**Temperature:** {temperature}")
    status_parts.append(f"**Max Response Tokens:** {max_tokens}")
    status_parts.append("")
    
    # Example prompts
    status_parts.append("")
    examples_list = config.get('examples', [])
    if isinstance(examples_list, str):
        try:
            import ast
            examples_list = ast.literal_eval(examples_list)
        except:
            examples_list = []
    
    if examples_list and len(examples_list) > 0:
        status_parts.append("**Example Prompts:**")
        for example in examples_list[:5]:  # Show first 5 examples
            status_parts.append(f"• {example}")
        if len(examples_list) > 5:
            status_parts.append(f"• ... and {len(examples_list) - 5} more")
    else:
        status_parts.append("**Example Prompts:** No example prompts configured")
    
    # URL Context if configured
    urls = GROUNDING_URLS
    if isinstance(urls, str):
        try:
            import ast
            urls = ast.literal_eval(urls)
        except:
            urls = []
    
    if urls and len(urls) > 0:
        status_parts.append("")
        status_parts.append("**Grounding URLs:**")
        for i, url in enumerate(urls[:5], 1):  # Show first 5 URLs
            status_parts.append(f"{i}. {url}")
        if len(urls) > 5:
            status_parts.append(f"... and {len(urls) - 5} more URLs")
    
    # System prompt at the end
    status_parts.append("")
    status_parts.append(f"**System Prompt:** {SYSTEM_PROMPT}")
    
    # API Key status (minimal, at the end)
    status_parts.append("")
    if not API_KEY_VALID:
        status_parts.append(f"**Note:** API key ({API_KEY_VAR}) not configured in Space secrets")
    
    return "\n".join(status_parts)

# HuggingFace Authentication Utility
def verify_hf_token_access():
    """Verify HF_TOKEN has write access to the space"""
    hf_token = os.environ.get("HF_TOKEN")
    space_id = os.environ.get("SPACE_ID")
    
    if not hf_token or not space_id:
        return False, "Missing HF_TOKEN or SPACE_ID environment variables"
    
    try:
        from huggingface_hub import HfApi
        api = HfApi(token=hf_token)
        # Test access by getting space info
        api.space_info(space_id)
        return True, "Authenticated successfully"
    except Exception as e:
        return False, f"Authentication failed: {str(e)}"

# Create interface with access code protection
# Dynamically set theme based on configuration
theme_class = getattr(gr.themes, THEME, gr.themes.Default)
with gr.Blocks(title=SPACE_NAME, theme=theme_class()) as demo:
    # Check if HF_TOKEN is configured to determine configuration panel availability
    HF_TOKEN = os.environ.get("HF_TOKEN", "").strip()
    SPACE_ID = os.environ.get("SPACE_ID", "").strip()
    
    # Verify actual HuggingFace API access
    HF_ACCESS_VALID, HF_ACCESS_MESSAGE = verify_hf_token_access()
    
    # Always use tabs structure, Configuration tab visible only with HF_TOKEN
    with gr.Tabs() as main_tabs:
        with gr.Tab("Chat U/I"):
                gr.Markdown(f"# {SPACE_NAME}")
                gr.Markdown(SPACE_DESCRIPTION)
                
                # Access code section (shown only if ACCESS_CODE is set)
                with gr.Column(visible=(ACCESS_CODE is not None)) as access_section:
                    gr.Markdown("### 🔐 Access Required")
                    gr.Markdown("Please enter the access code provided by your instructor:")
                    
                    access_input = gr.Textbox(
                        label="Access Code",
                        placeholder="Enter access code...",
                        type="password"
                    )
                    access_btn = gr.Button("Submit", variant="primary")
                    access_error = gr.Markdown(visible=False)
                
                # Main chat interface (hidden until access granted)
                with gr.Column(visible=(ACCESS_CODE is None)) as chat_section:
                    # Get examples from config
                    examples = config.get('examples', [])
                    if isinstance(examples, str):
                        try:
                            import ast
                            examples = ast.literal_eval(examples)
                        except:
                            examples = []
                    
                    # Format examples for ChatInterface with additional_inputs
                    # When additional_inputs are present, examples must be list of lists
                    # where each inner list contains [message, *additional_input_values]
                    formatted_examples = None
                    if examples:
                        # Check if examples are already formatted correctly (list of lists)
                        if examples and isinstance(examples[0], list):
                            # Already formatted, use as-is
                            formatted_examples = examples
                        else:
                            # Format as [message, file_input] where file_input=None for examples
                            formatted_examples = [[example, None] for example in examples]
                    
                    chat_interface = gr.ChatInterface(
                        fn=store_and_generate_response,  # Use wrapper function to store history
                        title="",  # Title already shown above
                        description="",  # Description already shown above
                        examples=formatted_examples,
                        type="messages",  # Use modern message format for better compatibility
                        additional_inputs=[
                            gr.File(
                                label="📎",
                                file_types=None,  # Accept all file types
                                file_count="multiple",
                                visible=True
                            )
                        ]
                    )
                    
                    # Export functionality
                    with gr.Row():
                        export_btn = gr.Button("📥 Export Conversation", variant="secondary", size="sm")
                    export_file = gr.File(label="Download", visible=False)
                    
                    # Connect export functionality
                    export_btn.click(
                        export_current_conversation,
                        outputs=[export_file]
                    )
                    
                    # Configuration status
                    with gr.Accordion("Configuration", open=False):
                        gr.Markdown(get_configuration_status())
                
                # Connect access verification within tab context
                if ACCESS_CODE is not None:
                    access_btn.click(
                        verify_access_code,
                        inputs=[access_input],
                        outputs=[access_error, chat_section, access_granted]
                    )
                    access_input.submit(
                        verify_access_code,
                        inputs=[access_input],
                        outputs=[access_error, chat_section, access_granted]
                    )
            
        # Add Configuration tab (only visible with valid HF_TOKEN)
        with gr.Tab("Configuration", visible=HF_ACCESS_VALID) as config_tab:
            gr.Markdown("## Configuration Management")
            
            # Show authentication status
            if HF_ACCESS_VALID:
                gr.Markdown(f"✅ **Authenticated** - {HF_ACCESS_MESSAGE}")
                gr.Markdown("Configuration changes will be saved to the HuggingFace repository and the Space will restart automatically.")
                faculty_auth_state = gr.State(True)
            else:
                gr.Markdown(f"❌ **Not Available** - {HF_ACCESS_MESSAGE}")
                gr.Markdown("Set HF_TOKEN and SPACE_ID in Space secrets to enable configuration management.")
                faculty_auth_state = gr.State(False)
            
            # Configuration editor (visible if HF authentication is valid)
            with gr.Column(visible=HF_ACCESS_VALID) as faculty_config_section:
                gr.Markdown("### Edit Assistant Configuration")
                gr.Markdown("⚠️ **Warning:** Changes will affect all users immediately.")
                
                # Load current configuration
                try:
                    with open('config.json', 'r') as f:
                        current_config = json.load(f)
                except:
                    # Use DEFAULT_CONFIG as fallback
                    current_config = DEFAULT_CONFIG.copy()
                
                # Editable fields
                # System Prompt
                edit_system_prompt = gr.Textbox(
                    label="System Prompt",
                    value=current_config.get('system_prompt', SYSTEM_PROMPT),
                    lines=5
                )
                
                # 3. Model Selection
                edit_model = gr.Dropdown(
                    label="Model",
                    choices=[
                        "google/gemini-2.0-flash-001",
                        "google/gemma-3-27b-it",
                        "anthropic/claude-3.5-sonnet",
                        "anthropic/claude-3.5-haiku",
                        "openai/gpt-4o-mini-search-preview",
                        "openai/gpt-4.1-nano",
                        "nvidia/llama-3.1-nemotron-70b-instruct",
                        "mistralai/devstral-small"
                    ],
                    value=current_config.get('model', MODEL)
                )
            
                # 4. Example prompts field
                examples_value = current_config.get('examples', [])
                if isinstance(examples_value, list):
                    examples_text_value = "\n".join(examples_value)
                else:
                    examples_text_value = ""
                
                edit_examples = gr.Textbox(
                    label="Example Prompts (one per line)",
                    value=examples_text_value,
                    lines=3,
                    placeholder="What can you help me with?\nExplain this concept\nHelp me understand..."
                )
                
                # 5. Model Parameters
                with gr.Row():
                    edit_temperature = gr.Slider(
                        label="Temperature",
                        minimum=0,
                        maximum=2,
                        value=current_config.get('temperature', 0.7),
                        step=0.1
                    )
                    edit_max_tokens = gr.Slider(
                        label="Max Tokens",
                        minimum=50,
                        maximum=4096,
                        value=current_config.get('max_tokens', 750),
                        step=50
                    )
                
                # URL Grounding fields
                gr.Markdown("### URL Grounding")
                grounding_urls_value = current_config.get('grounding_urls', [])
                if isinstance(grounding_urls_value, str):
                    try:
                        import ast
                        grounding_urls_value = ast.literal_eval(grounding_urls_value)
                    except:
                        grounding_urls_value = []
                
                # Create 10 URL input fields
                url_fields = []
                for i in range(10):
                    url_value = grounding_urls_value[i] if i < len(grounding_urls_value) else ""
                    url_field = gr.Textbox(
                        label=f"URL {i+1}" + (" (Primary)" if i < 2 else " (Secondary)"),
                        value=url_value,
                        placeholder="https://..."
                    )
                    url_fields.append(url_field)
                
                config_locked = gr.Checkbox(
                    label="Lock Configuration (Prevent further edits)",
                    value=current_config.get('locked', False)
                )
                
                with gr.Row():
                    save_config_btn = gr.Button("Save Configuration", variant="primary")
                    reset_config_btn = gr.Button("Reset to Defaults", variant="secondary")
                
                config_status = gr.Markdown("")
            
            
            # Save configuration function
            def save_configuration(is_authenticated, new_prompt, new_model, new_examples, new_temp, new_tokens, *url_values):
                if not is_authenticated:
                    return "Not authenticated"
                
                # Check if configuration is already locked
                try:
                    with open('config.json', 'r') as f:
                        existing_config = json.load(f)
                        if existing_config.get('locked', False):
                            return "Configuration is locked and cannot be modified"
                except:
                    pass
                
                # Load current config to preserve all values
                try:
                    with open('config.json', 'r') as f:
                        current_full_config = json.load(f)
                except:
                    # If config.json doesn't exist, use default configuration
                    current_full_config = DEFAULT_CONFIG.copy()
                
                # Process example prompts
                examples_list = [ex.strip() for ex in new_examples.split('\n') if ex.strip()]
                
                # Process URL values - lock_config is the last parameter
                urls = list(url_values[:-1])  # All but last are URLs
                lock_config_from_args = url_values[-1]  # Last is lock_config
                # Filter out empty URLs
                grounding_urls = [url.strip() for url in urls if url.strip()]
                
                # Create backup before making changes
                try:
                    # Create backups directory if it doesn't exist
                    os.makedirs('config_backups', exist_ok=True)
                    
                    # Create timestamped backup
                    backup_filename = f"config_backups/config_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
                    with open(backup_filename, 'w') as backup_file:
                        json.dump(current_full_config, backup_file, indent=2)
                    
                    # Keep only last 10 backups
                    backups = sorted([f for f in os.listdir('config_backups') if f.endswith('.json')])
                    if len(backups) > 10:
                        for old_backup in backups[:-10]:
                            os.remove(os.path.join('config_backups', old_backup))
                except Exception as backup_error:
                    print(f"Warning: Could not create backup: {backup_error}")
                    # Continue with save even if backup fails
                
                # Update all editable fields while preserving everything else
                current_full_config.update({
                    'system_prompt': new_prompt,
                    'model': new_model,
                    'examples': examples_list,
                    'temperature': new_temp,
                    'max_tokens': int(new_tokens),
                    'grounding_urls': grounding_urls,
                    'locked': lock_config_from_args,
                    'last_modified': datetime.now().isoformat(),
                    'last_modified_by': 'faculty'
                })
                
                try:
                    with open('config.json', 'w') as f:
                        json.dump(current_full_config, f, indent=2)
                    
                    # Optional: Auto-commit to HuggingFace if token is available
                    hf_token = os.environ.get("HF_TOKEN")
                    space_id = os.environ.get("SPACE_ID") 
                    
                    if hf_token and space_id:
                        try:
                            from huggingface_hub import HfApi, CommitOperationAdd, restart_space
                            api = HfApi(token=hf_token)
                            
                            # Create commit operation to upload config.json
                            operations = [
                                CommitOperationAdd(
                                    path_or_fileobj="config.json",
                                    path_in_repo="config.json"
                                )
                            ]
                            
                            # Create commit with updated configuration
                            api.create_commit(
                                repo_id=space_id,
                                operations=operations,
                                commit_message=f"Update configuration by faculty at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
                                commit_description="Faculty configuration update through web interface",
                                repo_type="space",
                                token=hf_token
                            )
                            
                            # Automatic restart
                            try:
                                restart_space(space_id, token=hf_token)
                                return f"✅ Configuration saved and committed at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n🔄 **Space is restarting automatically!**\n\nThe page will refresh in about 30 seconds. Your changes will be applied."
                            except Exception as restart_error:
                                print(f"Could not auto-restart: {restart_error}")
                                return f"✅ Configuration saved and committed at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n🔄 **Please restart manually** (auto-restart failed)\n\n1. Go to Settings (⚙️)\n2. Click 'Factory reboot'\n3. Wait ~30 seconds"
                        except Exception as commit_error:
                            print(f"Note: Could not auto-commit to repository: {commit_error}")
                            return f"✅ Configuration saved locally at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n🔄 **Manual Restart Required**\nFor changes to take effect:\n1. Go to Settings (⚙️)\n2. Click 'Factory reboot'\n3. Wait ~30 seconds for restart"
                    else:
                        return f"✅ Configuration saved at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n🔄 **Manual Restart Required**\nFor changes to take effect:\n1. Go to Settings (⚙️)\n2. Click 'Factory reboot'\n3. Wait ~30 seconds for restart"
                except Exception as e:
                    return f"❌ Error saving configuration: {str(e)}"
            
            # Reset configuration function
            def reset_configuration(is_authenticated):
                if not is_authenticated:
                    updates = ["Not authenticated"] + [gr.update() for _ in range(14)]  # 1 status + 14 fields (prompt, model, examples, temp, tokens + 10 urls)
                    return tuple(updates)
                
                # Check if locked
                try:
                    with open('config.json', 'r') as f:
                        existing_config = json.load(f)
                        if existing_config.get('locked', False):
                            updates = ["Configuration is locked"] + [gr.update() for _ in range(14)]
                            return tuple(updates)
                except:
                    pass
                
                # Get default examples as text
                default_examples = DEFAULT_CONFIG.get('examples', [])
                if isinstance(default_examples, list):
                    examples_text = "\n".join(default_examples)
                else:
                    examples_text = ""
                
                # Get default URLs - parse from JSON string if needed
                default_urls = DEFAULT_CONFIG.get('grounding_urls', [])
                if isinstance(default_urls, str):
                    try:
                        import json
                        default_urls = json.loads(default_urls)
                    except:
                        default_urls = []
                elif not isinstance(default_urls, list):
                    default_urls = []
                
                # Reset to original default values
                updates = [
                    "Reset to default values",
                    gr.update(value=DEFAULT_CONFIG.get('system_prompt', SYSTEM_PROMPT)),
                    gr.update(value=DEFAULT_CONFIG.get('model', MODEL)),
                    gr.update(value=examples_text),
                    gr.update(value=DEFAULT_CONFIG.get('temperature', temperature)),
                    gr.update(value=DEFAULT_CONFIG.get('max_tokens', max_tokens))
                ]
                
                # Add URL updates
                for i in range(10):
                    url_value = default_urls[i] if i < len(default_urls) else ""
                    updates.append(gr.update(value=url_value))
                
                return tuple(updates)
            
            
            # Connect configuration buttons
            save_config_btn.click(
                save_configuration,
                inputs=[faculty_auth_state, edit_system_prompt, edit_model, edit_examples, edit_temperature, edit_max_tokens] + url_fields + [config_locked],
                outputs=[config_status]
            )
            
            reset_config_btn.click(
                reset_configuration,
                inputs=[faculty_auth_state],
                outputs=[config_status, edit_system_prompt, edit_model, edit_examples, edit_temperature, edit_max_tokens] + url_fields
            )

if __name__ == "__main__":
    demo.launch()