app.py

import gradio as gr
import os
import json
import datetime
from pathlib import Path

# Import pages
from pages.dashboard import create_dashboard_page
from pages.tasks import create_tasks_page
from pages.notes import create_notes_page
from pages.goals import create_goals_page
from pages.ai_assistant import create_ai_assistant_page
from pages.search import create_search_page
from pages.analytics import create_analytics_page
from pages.focus import create_focus_page
from pages.integrations_new import create_integrations_page  # Using the new integrations page
from pages.settings import create_settings_page
from pages.multimedia import create_multimedia_page

# Import utilities
from utils.storage import load_data, save_data
from utils.state import initialize_state, record_activity
from utils.config import DATA_DIR, LOGGING_CONFIG
from utils.logging import get_logger
from utils.error_handling import handle_exceptions

# Initialize logger
logger = get_logger(__name__)

# Define sidebar items
sidebar_items = [
    "🏠 Dashboard",
    "📋 Tasks & Projects",
    "📝 Notes & Docs",
    "🎯 Goals & Planning",
    "🤖 AI Assistant Hub",
    "🔍 Smart Search",
    "📊 Analytics",
    "🧘 Focus & Wellness",
    "🖼️ Multimedia",
    "🔄 Integrations",
    "⚙️ Settings"
]

# Map sidebar items to page creation functions
page_creators = {
    "🏠 Dashboard": create_dashboard_page,
    "📋 Tasks & Projects": create_tasks_page,
    "📝 Notes & Docs": create_notes_page,
    "🎯 Goals & Planning": create_goals_page,
    "🤖 AI Assistant Hub": create_ai_assistant_page,
    "🔍 Smart Search": create_search_page,
    "📊 Analytics": create_analytics_page,
    "🧘 Focus & Wellness": create_focus_page,
    "🖼️ Multimedia": create_multimedia_page,
    "🔄 Integrations": create_integrations_page,
    "⚙️ Settings": create_settings_page
}

@handle_exceptions
def create_app():
    """Create and configure the Gradio application"""
    logger.info("Initializing Mona application")
    
    # Initialize application state
    state = initialize_state()
    
    # Create the Gradio Blocks app
    with gr.Blocks(title="Mona - AI Productivity Platform", theme=gr.themes.Soft()) as app:
        # Create header
        with gr.Row(elem_id="header"):
            gr.Markdown("# Mona - AI Productivity Platform")
            
        # Create main layout with sidebar and content area
        with gr.Row():
            # Sidebar navigation
            with gr.Column(scale=1, elem_id="sidebar"):
                # User profile section
                with gr.Group(elem_id="user-profile"):
                    gr.Markdown("### Welcome!")
                
                # Navigation menu
                selected_page = gr.Radio(
                    choices=sidebar_items,
                    value=sidebar_items[0],
                    label="Navigation",
                    elem_id="nav-menu"
                )
                
                # App info
                with gr.Group(elem_id="app-info"):
                    gr.Markdown("v0.1.0 | Using Free AI Models")
            
            # Main content area
            with gr.Column(scale=4, elem_id="content-area"):
                # Create a container for each page
                for page_name, create_page in page_creators.items():
                    with gr.Group(visible=(page_name == sidebar_items[0])) as page_container:
                        create_page(state)
                    # Store the container in state for navigation
                    state[f"{page_name}_container"] = page_container
        
        # Handle navigation changes
        @handle_exceptions
        def change_page(page_name):
            """Show the selected page and hide others"""
            logger.debug(f"Navigating to page: {page_name}")
            return [gr.update(visible=(name == page_name)) for name in sidebar_items]
        
        # Set up navigation event handler
        page_containers = [state[f"{name}_container"] for name in sidebar_items]
        selected_page.change(change_page, inputs=selected_page, outputs=page_containers)
        
        # Record app usage for analytics
        @handle_exceptions
        def record_app_usage():
            """Record app usage for analytics"""
            logger.info("Recording app usage")
            
            # Record activity using the centralized function
            # Commented out due to incorrect parameters
            # record_activity requires state, activity_type, and title
            # record_activity({
            #     "type": "app_opened",
            #     "timestamp": datetime.datetime.now().isoformat()
            # })
            
            # Correct implementation would be:
            # record_activity(state, "app_opened", "Application Started")
        
        # Record app usage on load
        app.load(record_app_usage)
    
    logger.info("Mona application initialized successfully")
    return app

if __name__ == "__main__":
    try:
        logger.info("Starting Mona application")
        app = create_app()
        app.launch()
    except Exception as e:
        logger.error(f"Failed to start application: {str(e)}")
        raise