Update pages/settings.py

pages/settings.py

@@ -1,568 +1,327 @@
-import gradio as gr
-import datetime
-import random
-import time
-from typing import Dict, List, Any, Union, Optional
-import os
-import json
+import streamlit as st
+from datetime import datetime
 
-# Import utilities
-from utils.storage import load_data, save_data, safe_get
-from utils.state import generate_id, get_timestamp, record_activity
-from utils.config import FILE_PATHS
-from utils.logging import setup_logger
-from utils.error_handling import handle_exceptions
+from utils.config import load_config, save_config, reset_config, AppConfig
+from utils.storage import get_storage_info, clear_storage, list_keys
+from utils.error_handling import handle_ui_exceptions
+from utils.logging import get_logger
 
-# Initialize logger
-logger = setup_logger(__name__)
+logger = get_logger(__name__)
 
-@handle_exceptions
-def create_settings_page(state: Dict[str, Any]) -> None:
-    """
-    Create the Settings page with options to customize the application
+@handle_ui_exceptions
+def create_settings_page():
+    """Create the settings page"""
+    st.title("⚙️ Settings")
+    st.write("Configure your MONA dashboard preferences and system settings.")
     
-    Args:
-        state: Application state
-    """
-    logger.info("Creating settings page")
+    # Create tabs for different settings categories
+    tab1, tab2, tab3, tab4 = st.tabs(["General", "Display", "Data", "System"])
     
-    # Initialize settings if not present
-    if "settings" not in state:
-        state["settings"] = load_data(FILE_PATHS["settings"], {
-            "appearance": {
-                "theme": "light",
-                "accent_color": "#4CAF50",
-                "font_size": "medium",
-                "sidebar_position": "left"
-            },
-            "notifications": {
-                "enabled": True,
-                "task_reminders": True,
-                "goal_updates": True,
-                "daily_summary": True,
-                "sound_enabled": True
-            },
-            "ai_preferences": {
-                "suggestions_enabled": True,
-                "suggestion_frequency": "medium",
-                "preferred_models": {
-                    "text_generation": "microsoft/DialoGPT-medium",
-                    "question_answering": "distilbert-base-uncased-distilled-squad",
-                    "image_analysis": "Salesforce/blip-image-captioning-base",
-                    "speech_to_text": "openai/whisper-small",
-                    "translation": "Helsinki-NLP/opus-mt-en-de",
-                    "sentiment": "cardiffnlp/twitter-roberta-base-sentiment-latest",
-                    "summarization": "facebook/bart-large-cnn",
-                    "code_generation": "microsoft/CodeBERT-base"
-                }
-            },
-            "data_management": {
-                "auto_backup": True,
-                "backup_frequency": "weekly",
-                "data_retention": "1 year"
-            },
-            "user_profile": {
-                "name": "",
-                "email": "",
-                "timezone": "UTC",
-                "language": "English"
-            }
-        })
+    with tab1:
+        create_general_settings()
     
-    # Create the settings page layout
-    with gr.Column(elem_id="settings-page"):
-        gr.Markdown("# ⚙️ Settings")
-        gr.Markdown("*Customize your Mona experience*")
+    with tab2:
+        create_display_settings()
+    
+    with tab3:
+        create_data_settings()
+    
+    with tab4:
+        create_system_settings()
+
+@handle_ui_exceptions
+def create_general_settings():
+    """Create general settings section"""
+    st.header("🔧 General Settings")
+    
+    config = load_config()
+    
+    # Application settings
+    with st.form("general_settings_form"):
+        st.subheader("Application Configuration")
+        
+        app_name = st.text_input("Application Name", value=config.app_name)
+        version = st.text_input("Version", value=config.version, disabled=True)
+        debug_mode = st.checkbox("Debug Mode", value=config.debug_mode)
+        
+        st.subheader("Performance Settings")
+        max_data_points = st.number_input(
+            "Maximum Data Points", 
+            min_value=100, 
+            max_value=10000, 
+            value=config.max_data_points,
+            step=100
+        )
         
-        # Settings saved notification
-        settings_notification = gr.Markdown(
-            "",
-            elem_id="settings-notification",
-            visible=False
+        refresh_interval = st.number_input(
+            "Refresh Interval (seconds)", 
+            min_value=1, 
+            max_value=300, 
+            value=config.refresh_interval,
+            step=1
         )
         
-        # Main tabs for different settings categories
-        with gr.Tabs():
-            # Appearance Tab
-            with gr.TabItem("Appearance"):
-                with gr.Group():
-                    gr.Markdown("### Theme & Colors")
-                    
-                    theme = gr.Radio(
-                        choices=["light", "dark", "system"],
-                        value=safe_get(state, ["settings", "appearance", "theme"], "light"),
-                        label="Theme"
-                    )
-                    
-                    accent_color = gr.ColorPicker(
-                        value=safe_get(state, ["settings", "appearance", "accent_color"], "#4CAF50"),
-                        label="Accent Color"
-                    )
-                    
-                    font_size = gr.Dropdown(
-                        choices=["small", "medium", "large"],
-                        value=safe_get(state, ["settings", "appearance", "font_size"], "medium"),
-                        label="Font Size"
-                    )
-                    
-                    sidebar_position = gr.Radio(
-                        choices=["left", "right"],
-                        value=safe_get(state, ["settings", "appearance", "sidebar_position"], "left"),
-                        label="Sidebar Position"
-                    )
-                    
-                    # Function to update appearance settings
-                    @handle_exceptions
-                    def update_appearance(
-                        theme_value: str,
-                        color_value: str,
-                        size_value: str,
-                        position_value: str
-                    ) -> str:
-                        """Update appearance settings"""
-                        logger.info("Updating appearance settings")
-                        
-                        state["settings"]["appearance"].update({
-                            "theme": theme_value,
-                            "accent_color": color_value,
-                            "font_size": size_value,
-                            "sidebar_position": position_value
-                        })
-                        
-                        save_data(FILE_PATHS["settings"], state["settings"])
-                        record_activity(state, "Updated Appearance Settings", {
-                            "theme": theme_value,
-                            "accent_color": color_value,
-                            "font_size": size_value,
-                            "sidebar_position": position_value
-                        })
-                        
-                        return "✅ Appearance settings saved!"
-                    
-                    # Connect appearance settings to update function
-                    gr.Button("Save Appearance").click(
-                        update_appearance,
-                        inputs=[theme, accent_color, font_size, sidebar_position],
-                        outputs=[settings_notification]
-                    )
+        if st.form_submit_button("Save General Settings"):
+            config.app_name = app_name
+            config.debug_mode = debug_mode
+            config.max_data_points = max_data_points
+            config.refresh_interval = refresh_interval
             
-            # Notifications Tab
-            with gr.TabItem("Notifications"):
-                with gr.Group():
-                    gr.Markdown("### Notification Settings")
-                    
-                    notifications_enabled = gr.Checkbox(
-                        value=safe_get(state, ["settings", "notifications", "enabled"], True),
-                        label="Enable Notifications"
-                    )
-                    
-                    task_reminders = gr.Checkbox(
-                        value=safe_get(state, ["settings", "notifications", "task_reminders"], True),
-                        label="Task Reminders"
-                    )
-                    
-                    goal_updates = gr.Checkbox(
-                        value=safe_get(state, ["settings", "notifications", "goal_updates"], True),
-                        label="Goal Updates"
-                    )
-                    
-                    daily_summary = gr.Checkbox(
-                        value=safe_get(state, ["settings", "notifications", "daily_summary"], True),
-                        label="Daily Summary"
-                    )
-                    
-                    sound_enabled = gr.Checkbox(
-                        value=safe_get(state, ["settings", "notifications", "sound_enabled"], True),
-                        label="Enable Sound"
-                    )
-                    
-                    # Function to update notification settings
-                    @handle_exceptions
-                    def update_notifications(
-                        enabled: bool,
-                        reminders: bool,
-                        updates: bool,
-                        summary: bool,
-                        sound: bool
-                    ) -> str:
-                        """Update notification settings"""
-                        logger.info("Updating notification settings")
-                        
-                        state["settings"]["notifications"].update({
-                            "enabled": enabled,
-                            "task_reminders": reminders,
-                            "goal_updates": updates,
-                            "daily_summary": summary,
-                            "sound_enabled": sound
-                        })
-                        
-                        save_data(FILE_PATHS["settings"], state["settings"])
-                        record_activity(state, "Updated Notification Settings", {
-                            "enabled": enabled,
-                            "task_reminders": reminders,
-                            "goal_updates": updates,
-                            "daily_summary": summary,
-                            "sound_enabled": sound
-                        })
-                        
-                        return "✅ Notification settings saved!"
-                    
-                    # Connect notification settings to update function
-                    gr.Button("Save Notifications").click(
-                        update_notifications,
-                        inputs=[
-                            notifications_enabled,
-                            task_reminders,
-                            goal_updates,
-                            daily_summary,
-                            sound_enabled
-                        ],
-                        outputs=[settings_notification]
-                    )
+            if save_config(config):
+                st.success("General settings saved successfully!")
+                st.rerun()
+            else:
+                st.error("Failed to save general settings.")
+
+@handle_ui_exceptions
+def create_display_settings():
+    """Create display settings section"""
+    st.header("🎨 Display Settings")
+    
+    config = load_config()
+    
+    with st.form("display_settings_form"):
+        st.subheader("Theme & Appearance")
+        
+        theme = st.selectbox(
+            "Theme", 
+            options=["light", "dark"], 
+            index=0 if config.theme == "light" else 1
+        )
+        
+        default_chart_type = st.selectbox(
+            "Default Chart Type",
+            options=["line", "bar", "scatter", "area"],
+            index=["line", "bar", "scatter", "area"].index(config.default_chart_type)
+        )
+        
+        st.subheader("Layout Settings")
+        
+        sidebar_width = st.slider(
+            "Sidebar Width (px)", 
+            min_value=200, 
+            max_value=500, 
+            value=config.sidebar_width,
+            step=10
+        )
+        
+        chart_height = st.slider(
+            "Default Chart Height (px)", 
+            min_value=300, 
+            max_value=800, 
+            value=config.chart_height,
+            step=50
+        )
+        
+        table_page_size = st.number_input(
+            "Table Page Size", 
+            min_value=10, 
+            max_value=200, 
+            value=config.table_page_size,
+            step=10
+        )
+        
+        if st.form_submit_button("Save Display Settings"):
+            config.theme = theme
+            config.default_chart_type = default_chart_type
+            config.sidebar_width = sidebar_width
+            config.chart_height = chart_height
+            config.table_page_size = table_page_size
             
-            # AI Preferences Tab
-            with gr.TabItem("AI Preferences"):
-                with gr.Group():
-                    gr.Markdown("### AI Assistant Settings")
-                    
-                    suggestions_enabled = gr.Checkbox(
-                        value=safe_get(state, ["settings", "ai_preferences", "suggestions_enabled"], True),
-                        label="Enable AI Suggestions"
-                    )
-                    
-                    suggestion_frequency = gr.Radio(
-                        choices=["low", "medium", "high"],
-                        value=safe_get(state, ["settings", "ai_preferences", "suggestion_frequency"], "medium"),
-                        label="Suggestion Frequency"
-                    )
-                    
-                    # Model selection dropdowns
-                    text_model = gr.Dropdown(
-                        choices=["microsoft/DialoGPT-small", "microsoft/DialoGPT-medium", "microsoft/DialoGPT-large"],
-                        value=safe_get(state, ["settings", "ai_preferences", "preferred_models", "text_generation"], "microsoft/DialoGPT-medium"),
-                        label="Text Generation Model"
-                    )
-                    
-                    qa_model = gr.Dropdown(
-                        choices=["distilbert-base-uncased-distilled-squad", "bert-large-uncased-whole-word-masking-finetuned-squad"],
-                        value=safe_get(state, ["settings", "ai_preferences", "preferred_models", "question_answering"], "distilbert-base-uncased-distilled-squad"),
-                        label="Question Answering Model"
-                    )
-                    
-                    # Function to update AI preferences
-                    @handle_exceptions
-                    def update_ai_preferences(
-                        enabled: bool,
-                        frequency: str,
-                        text_model_value: str,
-                        qa_model_value: str
-                    ) -> str:
-                        """Update AI preferences"""
-                        logger.info("Updating AI preferences")
-                        
-                        state["settings"]["ai_preferences"].update({
-                            "suggestions_enabled": enabled,
-                            "suggestion_frequency": frequency,
-                            "preferred_models": {
-                                **state["settings"]["ai_preferences"]["preferred_models"],
-                                "text_generation": text_model_value,
-                                "question_answering": qa_model_value
-                            }
-                        })
-                        
-                        save_data(FILE_PATHS["settings"], state["settings"])
-                        record_activity(state, "Updated AI Preferences", {
-                            "suggestions_enabled": enabled,
-                            "suggestion_frequency": frequency,
-                            "text_model": text_model_value,
-                            "qa_model": qa_model_value
-                        })
-                        
-                        return "✅ AI preferences saved!"
-                    
-                    # Connect AI preferences to update function
-                    gr.Button("Save AI Preferences").click(
-                        update_ai_preferences,
-                        inputs=[suggestions_enabled, suggestion_frequency, text_model, qa_model],
-                        outputs=[settings_notification]
-                    )
+            if save_config(config):
+                st.success("Display settings saved successfully!")
+                st.rerun()
+            else:
+                st.error("Failed to save display settings.")
+
+@handle_ui_exceptions
+def create_data_settings():
+    """Create data settings section"""
+    st.header("📊 Data Settings")
+    
+    config = load_config()
+    
+    with st.form("data_settings_form"):
+        st.subheader("Data Processing")
+        
+        data_cache_timeout = st.number_input(
+            "Data Cache Timeout (seconds)", 
+            min_value=60, 
+            max_value=3600, 
+            value=config.data_cache_timeout,
+            step=60
+        )
+        
+        max_file_size_mb = st.number_input(
+            "Maximum File Size (MB)", 
+            min_value=1, 
+            max_value=100, 
+            value=config.max_file_size_mb,
+            step=1
+        )
+        
+        st.subheader("Supported File Types")
+        current_types = config.supported_file_types or ['.csv', '.xlsx', '.json', '.parquet']
+        
+        col1, col2 = st.columns(2)
+        with col1:
+            csv_support = st.checkbox("CSV Files (.csv)", value='.csv' in current_types)
+            xlsx_support = st.checkbox("Excel Files (.xlsx)", value='.xlsx' in current_types)
+        
+        with col2:
+            json_support = st.checkbox("JSON Files (.json)", value='.json' in current_types)
+            parquet_support = st.checkbox("Parquet Files (.parquet)", value='.parquet' in current_types)
+        
+        if st.form_submit_button("Save Data Settings"):
+            supported_types = []
+            if csv_support:
+                supported_types.append('.csv')
+            if xlsx_support:
+                supported_types.append('.xlsx')
+            if json_support:
+                supported_types.append('.json')
+            if parquet_support:
+                supported_types.append('.parquet')
             
-            # Data Management Tab
-            with gr.TabItem("Data Management"):
-                with gr.Group():
-                    gr.Markdown("### Data Management Settings")
-                    
-                    auto_backup = gr.Checkbox(
-                        value=safe_get(state, ["settings", "data_management", "auto_backup"], True),
-                        label="Enable Auto-Backup"
-                    )
-                    
-                    backup_frequency = gr.Radio(
-                        choices=["daily", "weekly", "monthly"],
-                        value=safe_get(state, ["settings", "data_management", "backup_frequency"], "weekly"),
-                        label="Backup Frequency"
-                    )
-                    
-                    data_retention = gr.Dropdown(
-                        choices=["1 month", "3 months", "6 months", "1 year", "forever"],
-                        value=safe_get(state, ["settings", "data_management", "data_retention"], "1 year"),
-                        label="Data Retention Period"
-                    )
-                    
-                    # Function to update data management settings
-                    @handle_exceptions
-                    def update_data_management(
-                        backup_enabled: bool,
-                        frequency: str,
-                        retention: str
-                    ) -> str:
-                        """Update data management settings"""
-                        logger.info("Updating data management settings")
-                        
-                        state["settings"]["data_management"].update({
-                            "auto_backup": backup_enabled,
-                            "backup_frequency": frequency,
-                            "data_retention": retention
-                        })
-                        
-                        save_data(FILE_PATHS["settings"], state["settings"])
-                        record_activity(state, "Updated Data Management Settings", {
-                            "auto_backup": backup_enabled,
-                            "backup_frequency": frequency,
-                            "data_retention": retention
-                        })
-                        
-                        return "✅ Data management settings saved!"
-                    
-                    # Connect data management settings to update function
-                    gr.Button("Save Data Management").click(
-                        update_data_management,
-                        inputs=[auto_backup, backup_frequency, data_retention],
-                        outputs=[settings_notification]
-                    )
+            config.data_cache_timeout = data_cache_timeout
+            config.max_file_size_mb = max_file_size_mb
+            config.supported_file_types = supported_types
             
-            # User Profile Tab
-            with gr.TabItem("User Profile"):
-                with gr.Group():
-                    gr.Markdown("### User Profile Settings")
-                    
-                    name = gr.Textbox(
-                        value=safe_get(state, ["settings", "user_profile", "name"], ""),
-                        label="Name"
-                    )
-                    
-                    email = gr.Textbox(
-                        value=safe_get(state, ["settings", "user_profile", "email"], ""),
-                        label="Email"
-                    )
-                    
-                    timezone = gr.Dropdown(
-                        choices=["UTC", "US/Eastern", "US/Central", "US/Mountain", "US/Pacific"],
-                        value=safe_get(state, ["settings", "user_profile", "timezone"], "UTC"),
-                        label="Timezone"
-                    )
-                    
-                    language = gr.Dropdown(
-                        choices=["English", "Spanish", "French", "German", "Chinese", "Japanese"],
-                        value=safe_get(state, ["settings", "user_profile", "language"], "English"),
-                        label="Language"
-                    )
-                    
-                    # Function to update user profile
-                    @handle_exceptions
-                    def update_user_profile(
-                        name_value: str,
-                        email_value: str,
-                        timezone_value: str,
-                        language_value: str
-                    ) -> str:
-                        """Update user profile settings"""
-                        logger.info("Updating user profile")
-                        
-                        state["settings"]["user_profile"].update({
-                            "name": name_value,
-                            "email": email_value,
-                            "timezone": timezone_value,
-                            "language": language_value
-                        })
-                        
-                        save_data(FILE_PATHS["settings"], state["settings"])
-                        record_activity(state, "Updated User Profile", {
-                            "name": name_value,
-                            "email": email_value,
-                            "timezone": timezone_value,
-                            "language": language_value
-                        })
-                        
-                        return "✅ User profile saved!"
-                    
-                    # Connect user profile to update function
-                    gr.Button("Save Profile").click(
-                        update_user_profile,
-                        inputs=[name, email, timezone, language],
-                        outputs=[settings_notification]
-                    )
+            if save_config(config):
+                st.success("Data settings saved successfully!")
+                st.rerun()
+            else:
+                st.error("Failed to save data settings.")
+    
+    # Data management section
+    st.subheader("📁 Data Management")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.write("**Memory Storage**")
+        memory_info = get_storage_info("memory")
+        st.write(f"Keys stored: {memory_info['total_keys']}")
         
-            # API Keys Tab
-            with gr.TabItem("API Keys"):
-                with gr.Group():
-                    gr.Markdown("### API Keys Management")
-                    gr.Markdown("Enter your API keys for various services. These keys will be securely stored and used for integrations.")
-                    
-                    # Create a dropdown to select the service
-                    service_selector = gr.Dropdown(
-                        choices=[
-                            "OpenWeatherMap", 
-                            "GitHub", 
-                            "Google Calendar", 
-                            "Telegram", 
-                            "News API", 
-                            "Crypto API"
-                        ],
-                        label="Select Service",
-                        value="OpenWeatherMap"
-                    )
-                    
-                    # API key input
-                    api_key_input = gr.Textbox(
-                        value=safe_get(state, ["settings", "api_keys", "OpenWeatherMap"], ""),
-                        label="API Key",
-                        placeholder="Enter your API key here",
-                        type="password"
-                    )
-                    
-                    # Function to update the API key input when service is changed
-                    def update_api_key_input(service):
-                        """Update API key input when service is changed"""
-                        return gr.update(
-                            value=safe_get(state, ["settings", "api_keys", service], ""),
-                            label=f"{service} API Key"
-                        )
-                    
-                    # Connect service selector to update function
-                    service_selector.change(
-                        update_api_key_input,
-                        inputs=[service_selector],
-                        outputs=[api_key_input]
-                    )
-                    
-                    # Function to save API key
-                    @handle_exceptions
-                    def save_api_key(service, api_key):
-                        """Save API key for selected service"""
-                        logger.info(f"Saving API key for {service}")
-                        
-                        # Initialize api_keys dict if it doesn't exist
-                        if "api_keys" not in state["settings"]:
-                            state["settings"]["api_keys"] = {}
-                        
-                        # Save the API key
-                        state["settings"]["api_keys"][service] = api_key
-                        
-                        # Save settings
-                        save_data(FILE_PATHS["settings"], state["settings"])
-                        
-                        # Record activity
-                        record_activity(state, f"Updated API key for {service}")
-                        
-                        return f"✅ API key for {service} saved!"
-                    
-                    # Connect save button to save function
-                    gr.Button("Save API Key").click(
-                        save_api_key,
-                        inputs=[service_selector, api_key_input],
-                        outputs=[settings_notification]
-                    )
-                    
-                    # Function to test API key
-                    @handle_exceptions
-                    def test_api_key(service, api_key):
-                        """Test API key for selected service"""
-                        logger.info(f"Testing API key for {service}")
-                        
-                        if not api_key:
-                            return "❌ Please enter an API key first"
-                        
-                        # Test the API key based on the service
-                        try:
-                            if service == "OpenWeatherMap":
-                                from utils.integrations.weather import WeatherIntegration
-                                weather = WeatherIntegration(api_key=api_key)
-                                if weather.test_connection():
-                                    return "✅ API key is valid!"
-                                else:
-                                    return "❌ API key is invalid or connection failed"
-                            
-                            # Add more services as needed
-                            else:
-                                return "⚠️ Testing not implemented for this service yet"
-                        
-                        except Exception as e:
-                            logger.error(f"Error testing API key: {str(e)}")
-                            return f"❌ Error: {str(e)}"
-                    
-                    # Connect test button to test function
-                    gr.Button("Test API Key").click(
-                        test_api_key,
-                        inputs=[service_selector, api_key_input],
-                        outputs=[settings_notification]
-                    )
-                    
-                    # Display current API keys
-                    gr.Markdown("### Current API Keys")
-                    
-                    # Function to render current API keys
-                    def render_api_keys():
-                        """Render current API keys as HTML"""
-                        api_keys = safe_get(state, ["settings", "api_keys"], {})
-                        
-                        if not api_keys:
-                            return "<p>No API keys configured yet.</p>"
-                        
-                        html = "<div class='api-keys-list'>"
-                        for service, key in api_keys.items():
-                            # Mask the API key for display
-                            masked_key = "*" * (len(key) - 4) + key[-4:] if key else ""
-                            
-                            html += f"""
-                            <div class='api-key-item'>
-                                <div class='api-key-service'>{service}</div>
-                                <div class='api-key-value'>{masked_key}</div>
-                                <div class='api-key-actions'>
-                                    <button class='delete-api-key' data-service='{service}'>Delete</button>
-                                </div>
-                            </div>
-                            """
-                        
-                        html += "</div>"
-                        return html
-                    
-                    api_keys_display = gr.HTML(render_api_keys())
-                    
-                    # Function to delete API key
-                    @handle_exceptions
-                    def delete_api_key(service):
-                        """Delete API key for selected service"""
-                        logger.info(f"Deleting API key for {service}")
-                        
-                        if "api_keys" in state["settings"] and service in state["settings"]["api_keys"]:
-                            del state["settings"]["api_keys"][service]
-                            
-                            # Save settings
-                            save_data(FILE_PATHS["settings"], state["settings"])
-                            
-                            # Record activity
-                            record_activity(state, f"Deleted API key for {service}")
-                            
-                            return render_api_keys(), f"✅ API key for {service} deleted!"
-                        
-                        return render_api_keys(), f"⚠️ No API key found for {service}"
-                    
-                    # Refresh button to update the API keys display
-                    gr.Button("Refresh API Keys").click(
-                        lambda: render_api_keys(),
-                        outputs=[api_keys_display]
-                    )
+        if st.button("Clear Memory Storage", type="secondary"):
+            if clear_storage("memory"):
+                st.success("Memory storage cleared!")
+                st.rerun()
+            else:
+                st.error("Failed to clear memory storage.")
+    
+    with col2:
+        st.write("**Session Storage**")
+        session_info = get_storage_info("session")
+        st.write(f"Keys stored: {session_info['total_keys']}")
         
-        # Record page visit in activity
-        record_activity(state, "Viewed Settings Page")
+        if st.button("Clear Session Storage", type="secondary"):
+            if clear_storage("session"):
+                st.success("Session storage cleared!")
+                st.rerun()
+            else:
+                st.error("Failed to clear session storage.")
+    
+    # Show stored data keys
+    with st.expander("View Stored Data Keys"):
+        memory_keys = list_keys("memory")
+        session_keys = list_keys("session")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.write("**Memory Keys:**")
+            for key in memory_keys:
+                st.write(f"- {key}")
+        
+        with col2:
+            st.write("**Session Keys:**")
+            for key in session_keys:
+                st.write(f"- {key}")
+
+@handle_ui_exceptions
+def create_system_settings():
+    """Create system settings section"""
+    st.header("🔧 System Settings")
+    
+    # System information
+    st.subheader("📋 System Information")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.write("**Application Info:**")
+        config = load_config()
+        st.write(f"- Name: {config.app_name}")
+        st.write(f"- Version: {config.version}")
+        st.write(f"- Debug Mode: {'Enabled' if config.debug_mode else 'Disabled'}")
+        
+    with col2:
+        st.write("**Runtime Info:**")
+        st.write(f"- Current Time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+        st.write(f"- Streamlit Version: {st.__version__}")
+        st.write("- Python Version: 3.8+")
+    
+    # Configuration management
+    st.subheader("⚙️ Configuration Management")
+    
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        if st.button("Export Configuration", type="secondary"):
+            config_dict = config.__dict__
+            st.download_button(
+                label="Download Config",
+                data=str(config_dict),
+                file_name=f"mona_config_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt",
+                mime="text/plain"
+            )
+    
+    with col2:
+        if st.button("Reset to Defaults", type="secondary"):
+            if st.session_state.get('confirm_reset', False):
+                reset_config()
+                st.success("Configuration reset to defaults!")
+                st.session_state['confirm_reset'] = False
+                st.rerun()
+            else:
+                st.session_state['confirm_reset'] = True
+                st.warning("Click again to confirm reset.")
+    
+    with col3:
+        if st.button("Reload Configuration", type="secondary"):
+            # Force reload by clearing the global config
+            from utils.config import _config
+            if '_config' in globals():
+                globals()['_config'] = None
+            st.success("Configuration reloaded!")
+            st.rerun()
+    
+    # Advanced settings
+    with st.expander("🔧 Advanced Settings"):
+        st.subheader("Developer Options")
+        
+        if config.debug_mode:
+            st.write("**Debug Information:**")
+            st.json(config.__dict__)
+            
+            if st.button("View Session State"):
+                st.write("**Session State:**")
+                st.json(dict(st.session_state))
+        else:
+            st.info("Enable Debug Mode in General Settings to access developer options.")
+    
+    # System actions
+    st.subheader("🔄 System Actions")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        if st.button("Clear All Cache", type="secondary"):
+            st.cache_data.clear()
+            st.success("All cache cleared!")
+    
+    with col2:
+        if st.button("Restart Application", type="primary"):
+            st.info("Application will restart...")
+            st.rerun()