Update pages/tasks.py

pages/tasks.py

@@ -1,550 +1,450 @@
-import gradio as gr
-import datetime
-from typing import Dict, List, Any, Union, Optional
-import random
+import streamlit as st
+import pandas as pd
+from datetime import datetime, timedelta
+import plotly.express as px
+import plotly.graph_objects as go
+from typing import Dict, List, Any, Optional
 
 # Import utilities
 from utils.storage import load_data, save_data
-from utils.state import generate_id, get_timestamp, record_activity
-from utils.ai_models import break_down_task, estimate_task_time
-from utils.ui_components import create_kanban_board, create_priority_matrix
-from utils.config import FILE_PATHS
+from utils.error_handling import show_error, show_success, show_warning, handle_data_exceptions
 from utils.logging import get_logger
-from utils.error_handling import handle_exceptions, ValidationError, safe_get
+from utils.state import generate_id, get_timestamp, record_activity, get_session_state, set_session_state
 
-# Initialize logger
 logger = get_logger(__name__)
 
-@handle_exceptions
-def create_tasks_page(state: Dict[str, Any]) -> None:
+# Task status options
+TASK_STATUSES = ["Todo", "In Progress", "Review", "Done", "Cancelled"]
+TASK_PRIORITIES = ["Low", "Medium", "High", "Critical"]
+TASK_CATEGORIES = ["Development", "Testing", "Documentation", "Bug Fix", "Feature", "Maintenance"]
+
+def create_tasks_page():
     """
-    Create the tasks and projects page with multiple views
-    
-    Args:
-        state: Application state
+    Create the tasks management page
     """
-    logger.info("Creating tasks page")
+    st.title("📋 Task Management")
     
-    # Create the tasks page layout
-    with gr.Column(elem_id="tasks-page"):
-        gr.Markdown("# 📋 Tasks & Projects")
+    # Initialize session state
+    if 'tasks' not in st.session_state:
+        st.session_state.tasks = load_tasks_data()
+    
+    # Sidebar for task controls
+    with st.sidebar:
+        st.header("🔧 Task Controls")
         
-        # Task views and actions
-        with gr.Row():
-            # View selector
-            view_selector = gr.Radio(
-                choices=["Kanban", "List", "Calendar", "Timeline", "Priority Matrix"],
-                value="Kanban",
-                label="View",
-                elem_id="task-view-selector"
-            )
-            
-            # Add task button
-            add_task_btn = gr.Button("➕ Add Task", elem_classes=["action-button"])
+        # Add new task button
+        if st.button("➕ Add New Task", use_container_width=True):
+            set_session_state('show_add_task', True)
         
-        # Task views container
-        with gr.Group(elem_id="task-views-container"):
-            # Kanban View
-            with gr.Group(elem_id="kanban-view", visible=True) as kanban_view:
-                create_kanban_board(safe_get(state, "tasks", []))
-            
-            # List View
-            with gr.Group(elem_id="list-view", visible=False) as list_view:
-                with gr.Column():
-                    # Filter and sort options
-                    with gr.Row():
-                        status_filter = gr.Dropdown(
-                            choices=["All", "To Do", "In Progress", "Done"],
-                            value="All",
-                            label="Status"
-                        )
-                        priority_filter = gr.Dropdown(
-                            choices=["All", "High", "Medium", "Low"],
-                            value="All",
-                            label="Priority"
-                        )
-                        sort_by = gr.Dropdown(
-                            choices=["Created (Newest)", "Created (Oldest)", "Due Date", "Priority"],
-                            value="Created (Newest)",
-                            label="Sort By"
-                        )
-                    
-                    # Task list
-                    task_list = gr.Dataframe(
-                        headers=["Title", "Status", "Priority", "Due Date", "Created"],
-                        datatype=["str", "str", "str", "str", "str"],
-                        col_count=(5, "fixed"),
-                        elem_id="task-list-table"
-                    )
-                    
-                    # Function to update task list based on filters
-                    @handle_exceptions
-                    def update_task_list(status, priority, sort):
-                        """Update the task list based on filters and sort options"""
-                        logger.debug(f"Updating task list with filters: status={status}, priority={priority}, sort={sort}")
-                        tasks = safe_get(state, "tasks", [])
-                        
-                        # Apply status filter
-                        if status != "All":
-                            status_map = {"To Do": "todo", "In Progress": "in_progress", "Done": "done"}
-                            tasks = [t for t in tasks if safe_get(t, "status", "") == status_map.get(status, "")]
-                        
-                        # Apply priority filter
-                        if priority != "All":
-                            tasks = [t for t in tasks if safe_get(t, "priority", "").lower() == priority.lower()]
-                        
-                        # Apply sorting
-                        if sort == "Created (Newest)":
-                            tasks.sort(key=lambda x: safe_get(x, "created_at", ""), reverse=True)
-                        elif sort == "Created (Oldest)":
-                            tasks.sort(key=lambda x: safe_get(x, "created_at", ""))
-                        elif sort == "Due Date":
-                            # Sort by due date, putting tasks without due dates at the end
-                            tasks.sort(
-                                key=lambda x: safe_get(x, "deadline", "9999-12-31T23:59:59")
-                            )
-                        elif sort == "Priority":
-                            # Sort by priority (high, medium, low)
-                            priority_order = {"high": 0, "medium": 1, "low": 2}
-                            tasks.sort(
-                                key=lambda x: priority_order.get(safe_get(x, "priority", "").lower(), 3)
-                            )
-                        
-                        # Format data for the table
-                        table_data = []
-                        for task in tasks:
-                            # Format status
-                            status_map = {"todo": "To Do", "in_progress": "In Progress", "done": "Done"}
-                            status_str = status_map.get(safe_get(task, "status", ""), "To Do")
-                            
-                            # Format priority
-                            priority_str = safe_get(task, "priority", "").capitalize()
-                            
-                            # Format due date
-                            due_date = "None"
-                            if "deadline" in task:
-                                try:
-                                    deadline = datetime.datetime.fromisoformat(task["deadline"])
-                                    due_date = deadline.strftime("%Y-%m-%d")
-                                except Exception as e:
-                                    logger.warning(f"Error formatting deadline: {str(e)}")
-                            
-                            # Format created date
-                            created = "Unknown"
-                            if "created_at" in task:
-                                try:
-                                    created_at = datetime.datetime.fromisoformat(task["created_at"])
-                                    created = created_at.strftime("%Y-%m-%d")
-                                except Exception as e:
-                                    logger.warning(f"Error formatting created_at: {str(e)}")
-                            
-                            table_data.append([
-                                safe_get(task, "title", "Untitled Task"),
-                                status_str,
-                                priority_str,
-                                due_date,
-                                created
-                            ])
-                        
-                        return table_data
-                    
-                    # Update task list when filters change
-                    status_filter.change(
-                        update_task_list,
-                        inputs=[status_filter, priority_filter, sort_by],
-                        outputs=[task_list]
-                    )
-                    priority_filter.change(
-                        update_task_list,
-                        inputs=[status_filter, priority_filter, sort_by],
-                        outputs=[task_list]
-                    )
-                    sort_by.change(
-                        update_task_list,
-                        inputs=[status_filter, priority_filter, sort_by],
-                        outputs=[task_list]
-                    )
-                    
-                    # Initialize task list
-                    task_list.value = update_task_list("All", "All", "Created (Newest)")
-            
-            # Calendar View
-            with gr.Group(elem_id="calendar-view", visible=False) as calendar_view:
-                gr.Markdown("### 📅 Calendar View")
-                gr.Markdown("*Calendar view will display tasks with due dates*")
-                
-                # Simple calendar implementation (placeholder)
-                current_month = datetime.datetime.now().strftime("%B %Y")
-                gr.Markdown(f"## {current_month}")
-                
-                # Create a simple calendar grid
-                days_of_week = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]
-                with gr.Row():
-                    for day in days_of_week:
-                        gr.Markdown(f"**{day}**")
-                
-                # Get the current month's calendar
-                now = datetime.datetime.now()
-                month_start = datetime.datetime(now.year, now.month, 1)
-                month_end = (month_start.replace(month=month_start.month+1, day=1) - 
-                            datetime.timedelta(days=1))
-                start_weekday = month_start.weekday()
-                days_in_month = month_end.day
-                
-                # Adjust for Sunday as first day of week
-                start_weekday = (start_weekday + 1) % 7
-                
-                # Create calendar grid
-                day_counter = 1
-                for week in range(6):  # Maximum 6 weeks in a month
-                    with gr.Row():
-                        for weekday in range(7):
-                            if (week == 0 and weekday < start_weekday) or day_counter > days_in_month:
-                                # Empty cell
-                                gr.Markdown("")
-                            else:
-                                # Get tasks for this day
-                                day_tasks = []
-                                for task in safe_get(state, "tasks", []):
-                                    if "deadline" in task:
-                                        try:
-                                            deadline = datetime.datetime.fromisoformat(task["deadline"])
-                                            if (deadline.year == now.year and 
-                                                deadline.month == now.month and 
-                                                deadline.day == day_counter):
-                                                day_tasks.append(task)
-                                        except Exception as e:
-                                            logger.warning(f"Error parsing deadline: {str(e)}")
-                                
-                                # Create day cell
-                                with gr.Group(elem_classes=["calendar-day"]):
-                                    gr.Markdown(f"**{day_counter}**")
-                                    
-                                    # Add tasks for this day
-                                    for task in day_tasks:
-                                        priority_colors = {"high": "red", "medium": "orange", "low": "green"}
-                                        priority = safe_get(task, "priority", "").lower()
-                                        color = priority_colors.get(priority, "gray")
-                                        
-                                        gr.Markdown(
-                                            f"<span style='color: {color};'>●</span> {safe_get(task, 'title', 'Untitled')}"
-                                        )
-                                
-                                day_counter += 1
-                            
-                            if day_counter > days_in_month:
-                                break
-                    
-                    if day_counter > days_in_month:
-                        break
-            
-            # Timeline View
-            with gr.Group(elem_id="timeline-view", visible=False) as timeline_view:
-                gr.Markdown("### ⏱️ Timeline View")
-                gr.Markdown("*Timeline view will display tasks in chronological order*")
-                
-                # Get tasks with dates
-                dated_tasks = []
-                for task in safe_get(state, "tasks", []):
-                    if "deadline" in task or "created_at" in task:
-                        dated_tasks.append(task)
-                
-                # Sort by date
-                dated_tasks.sort(key=lambda x: safe_get(x, "deadline", safe_get(x, "created_at", "")))
-                
-                # Group tasks by month
-                tasks_by_month = {}
-                for task in dated_tasks:
-                    date_str = safe_get(task, "deadline", safe_get(task, "created_at", ""))
-                    try:
-                        date = datetime.datetime.fromisoformat(date_str)
-                        month_key = date.strftime("%Y-%m")
-                        if month_key not in tasks_by_month:
-                            tasks_by_month[month_key] = []
-                        tasks_by_month[month_key].append((date, task))
-                    except Exception as e:
-                        logger.warning(f"Error parsing date: {str(e)}")
-                
-                # Display timeline
-                for month_key in sorted(tasks_by_month.keys()):
-                    try:
-                        month_date = datetime.datetime.strptime(month_key, "%Y-%m")
-                        month_name = month_date.strftime("%B %Y")
-                        gr.Markdown(f"## {month_name}")
-                        
-                        # Display tasks for this month
-                        for date, task in sorted(tasks_by_month[month_key]):
-                            day_str = date.strftime("%d %b")
-                            status_emoji = "🔴" if safe_get(task, "status") == "todo" else \
-                                        "🟡" if safe_get(task, "status") == "in_progress" else "🟢"
-                            
-                            with gr.Group(elem_classes=["timeline-item"]):
-                                with gr.Row():
-                                    gr.Markdown(f"**{day_str}**")
-                                    gr.Markdown(f"{status_emoji} {safe_get(task, 'title', 'Untitled Task')}")
-                                
-                                if safe_get(task, "description"):
-                                    gr.Markdown(task["description"])
-                    except Exception as e:
-                        logger.warning(f"Error displaying timeline month: {str(e)}")
-            
-            # Priority Matrix View
-            with gr.Group(elem_id="priority-matrix-view", visible=False) as priority_matrix_view:
-                create_priority_matrix(safe_get(state, "tasks", []))
+        # Filter options
+        st.subheader("🔍 Filters")
         
-        # Task detail modal (shown when a task is selected)
-        with gr.Group(elem_id="task-detail-modal", visible=False) as task_detail_modal:
-            gr.Markdown("## Task Details")
-            
-            # Task information
-            task_title_display = gr.Textbox(label="Title", interactive=True)
-            task_description_display = gr.Textbox(label="Description", lines=3, interactive=True)
-            task_status_display = gr.Dropdown(
-                choices=["To Do", "In Progress", "Done"],
-                label="Status",
-                interactive=True
-            )
-            task_priority_display = gr.Dropdown(
-                choices=["High", "Medium", "Low"],
-                label="Priority",
-                interactive=True
-            )
-            task_deadline_display = gr.Textbox(
-                label="Deadline (YYYY-MM-DD)",
-                interactive=True
-            )
-            
-            # Task actions
-            with gr.Row():
-                save_task_btn = gr.Button("Save Changes")
-                delete_task_btn = gr.Button("Delete Task")
-                close_detail_btn = gr.Button("Close")
-            
-            # AI features
-            with gr.Accordion("AI Features", open=False):
-                # AI Task Breakdown
-                gr.Markdown("### 🤖 AI Task Breakdown")
-                generate_subtasks_btn = gr.Button("Generate Subtasks")
-                subtasks_display = gr.Markdown("*Click the button to generate subtasks*")
-                
-                # AI Time Estimation
-                gr.Markdown("### ⏱️ AI Time Estimation")
-                estimate_time_btn = gr.Button("Estimate Time")
-                time_estimate_display = gr.Markdown("*Click the button to estimate time*")
-            
-            # Subtasks
-            with gr.Group():
-                gr.Markdown("### Subtasks")
-                subtask_list = gr.Dataframe(
-                    headers=["Subtask", "Status"],
-                    datatype=["str", "str"],
-                    col_count=(2, "fixed"),
-                    row_count=(0, "dynamic"),
-                    elem_id="subtask-list"
-                )
-                add_subtask_btn = gr.Button("Add Subtask")
+        status_filter = st.multiselect(
+            "Filter by Status",
+            TASK_STATUSES,
+            default=TASK_STATUSES
+        )
         
-        # Add task modal
-        with gr.Group(elem_id="add-task-modal", visible=False) as add_task_modal:
-            gr.Markdown("## Add New Task")
-            
-            # Task information inputs
-            new_task_title = gr.Textbox(label="Title", placeholder="Enter task title")
-            new_task_description = gr.Textbox(
-                label="Description", 
-                placeholder="Enter task description",
-                lines=3
-            )
-            new_task_status = gr.Dropdown(
-                choices=["To Do", "In Progress", "Done"],
-                label="Status",
-                value="To Do"
-            )
-            new_task_priority = gr.Dropdown(
-                choices=["High", "Medium", "Low"],
-                label="Priority",
-                value="Medium"
-            )
-            new_task_deadline = gr.Textbox(
-                label="Deadline (YYYY-MM-DD)",
-                placeholder="YYYY-MM-DD"
-            )
-            
-            # Task categorization
-            with gr.Accordion("Smart Categorization", open=False):
-                gr.Markdown("### 🏷️ Tags")
-                new_task_tags = gr.Textbox(
-                    label="Tags (comma separated)",
-                    placeholder="work, project, urgent"
-                )
-                
-                gr.Markdown("### 📂 Project")
-                new_task_project = gr.Dropdown(
-                    choices=["None", "Work", "Personal", "Study", "Health"],
-                    label="Project",
-                    value="None"
-                )
-            
-            # Task actions
-            with gr.Row():
-                create_task_btn = gr.Button("Create Task")
-                cancel_add_btn = gr.Button("Cancel")
+        priority_filter = st.multiselect(
+            "Filter by Priority",
+            TASK_PRIORITIES,
+            default=TASK_PRIORITIES
+        )
+        
+        category_filter = st.multiselect(
+            "Filter by Category",
+            TASK_CATEGORIES,
+            default=TASK_CATEGORIES
+        )
+        
+        # Date range filter
+        st.subheader("📅 Date Range")
+        date_range = st.date_input(
+            "Select Date Range",
+            value=(datetime.now() - timedelta(days=30), datetime.now()),
+            max_value=datetime.now()
+        )
+        
+        # Bulk actions
+        st.subheader("🔄 Bulk Actions")
+        if st.button("Save All Tasks"):
+            save_tasks_data(st.session_state.tasks)
+            show_success("Tasks saved successfully!")
+        
+        if st.button("Reset Filters"):
+            st.experimental_rerun()
+    
+    # Main content area
+    if get_session_state('show_add_task', False):
+        show_add_task_form()
+    
+    # Task statistics
+    show_task_statistics()
+    
+    # Tasks table
+    show_tasks_table(status_filter, priority_filter, category_filter, date_range)
+    
+    # Task analytics
+    show_task_analytics()
+
+def show_add_task_form():
+    """
+    Display the add task form
+    """
+    st.subheader("➕ Add New Task")
+    
+    with st.form("add_task_form"):
+        col1, col2 = st.columns(2)
         
-        # Function to switch between views
-        @handle_exceptions
-        def switch_view(view):
-            """Switch between different task views"""
-            logger.info(f"Switching to {view} view")
-            views = {
-                "Kanban": kanban_view,
-                "List": list_view,
-                "Calendar": calendar_view,
-                "Timeline": timeline_view,
-                "Priority Matrix": priority_matrix_view
-            }
-            
-            return [gr.update(visible=(view_name == view)) for view_name, view_component in views.items()]
+        with col1:
+            title = st.text_input("Task Title*", placeholder="Enter task title")
+            status = st.selectbox("Status", TASK_STATUSES, index=0)
+            priority = st.selectbox("Priority", TASK_PRIORITIES, index=1)
         
-        # Set up view switching
-        view_outputs = [kanban_view, list_view, calendar_view, timeline_view, priority_matrix_view]
-        view_selector.change(switch_view, inputs=[view_selector], outputs=view_outputs)
+        with col2:
+            category = st.selectbox("Category", TASK_CATEGORIES, index=0)
+            assignee = st.text_input("Assignee", placeholder="Assign to...")
+            due_date = st.date_input("Due Date", value=datetime.now() + timedelta(days=7))
         
-        # Function to show add task modal
-        @handle_exceptions
-        def show_add_task_modal():
-            """Show the add task modal"""
-            logger.debug("Showing add task modal")
-            return gr.update(visible=True)
+        description = st.text_area("Description", placeholder="Task description...")
+        tags = st.text_input("Tags", placeholder="Enter tags separated by commas")
         
-        # Function to hide add task modal
-        @handle_exceptions
-        def hide_add_task_modal():
-            """Hide the add task modal"""
-            logger.debug("Hiding add task modal")
-            return gr.update(visible=False)
+        col1, col2, col3 = st.columns(3)
         
-        # Set up add task modal
-        add_task_btn.click(show_add_task_modal, inputs=[], outputs=[add_task_modal])
-        cancel_add_btn.click(hide_add_task_modal, inputs=[], outputs=[add_task_modal])
+        with col1:
+            submitted = st.form_submit_button("Create Task", type="primary")
         
-        # Function to create a new task
-        @handle_exceptions
-        def create_task(title, description, status, priority, deadline, tags, project):
-            """Create a new task"""
-            if not title.strip():
-                logger.warning("Attempted to create task with empty title")
-                return "Please enter a task title", gr.update(visible=True)
-            
-            logger.info(f"Creating new task: {title}")
-            
-            # Validate deadline format if provided
-            deadline_iso = None
-            if deadline.strip():
-                try:
-                    deadline_date = datetime.datetime.strptime(deadline.strip(), "%Y-%m-%d")
-                    deadline_iso = deadline_date.isoformat()
-                except ValueError as e:
-                    logger.warning(f"Invalid date format: {deadline}, error: {str(e)}")
-                    return "Invalid date format. Use YYYY-MM-DD", gr.update(visible=True)
-            
-            # Map status to internal representation
-            status_map = {"To Do": "todo", "In Progress": "in_progress", "Done": "done"}
-            
-            # Create new task
-            new_task = {
-                "id": generate_id(),
-                "title": title.strip(),
-                "description": description.strip(),
-                "status": status_map.get(status, "todo"),
-                "priority": priority.lower(),
-                "completed": status == "Done",
-                "created_at": get_timestamp()
-            }
-            
-            if deadline_iso:
-                new_task["deadline"] = deadline_iso
-            
-            # Add tags if provided
-            if tags.strip():
-                new_task["tags"] = [tag.strip() for tag in tags.split(",") if tag.strip()]
-            
-            # Add project if selected
-            if project != "None":
-                new_task["project"] = project
-            
-            # Add to state
-            state["tasks"].append(new_task)
-            state["stats"]["tasks_total"] += 1
-            if status == "Done":
-                state["stats"]["tasks_completed"] += 1
-                new_task["completed_at"] = get_timestamp()
-            
-            # Record activity
-            record_activity({
-                "type": "task_created",
-                "title": title,
-                "timestamp": datetime.datetime.now().isoformat()
-            })
-            
-            # Save to file
-            save_data(FILE_PATHS["tasks"], state["tasks"])
-            
-            # Reset form and hide modal
-            return "Task created successfully!", gr.update(visible=False)
+        with col2:
+            if st.form_submit_button("Cancel"):
+                set_session_state('show_add_task', False)
+                st.experimental_rerun()
         
-        # Set up create task action
-        create_task_btn.click(
-            create_task,
-            inputs=[
-                new_task_title, new_task_description, new_task_status,
-                new_task_priority, new_task_deadline, new_task_tags, new_task_project
-            ],
-            outputs=[gr.Markdown(visible=False), add_task_modal]
+        if submitted:
+            if title.strip():
+                new_task = create_new_task(
+                    title=title.strip(),
+                    description=description.strip(),
+                    status=status,
+                    priority=priority,
+                    category=category,
+                    assignee=assignee.strip(),
+                    due_date=due_date,
+                    tags=tags.strip()
+                )
+                
+                st.session_state.tasks.append(new_task)
+                save_tasks_data(st.session_state.tasks)
+                record_activity("task_created", {"task_id": new_task["id"], "title": title})
+                
+                show_success(f"Task '{title}' created successfully!")
+                set_session_state('show_add_task', False)
+                st.experimental_rerun()
+            else:
+                show_error("Task title is required!")
+
+def create_new_task(title: str, description: str, status: str, priority: str, 
+                   category: str, assignee: str, due_date, tags: str) -> Dict[str, Any]:
+    """
+    Create a new task dictionary
+    """
+    return {
+        "id": generate_id("task"),
+        "title": title,
+        "description": description,
+        "status": status,
+        "priority": priority,
+        "category": category,
+        "assignee": assignee,
+        "due_date": due_date.isoformat() if due_date else None,
+        "created_at": get_timestamp(),
+        "updated_at": get_timestamp(),
+        "tags": [tag.strip() for tag in tags.split(",") if tag.strip()],
+        "completed": status == "Done"
+    }
+
+def show_task_statistics():
+    """
+    Display task statistics
+    """
+    st.subheader("📊 Task Statistics")
+    
+    tasks = st.session_state.tasks
+    
+    if not tasks:
+        st.info("No tasks available. Create your first task!")
+        return
+    
+    # Calculate statistics
+    total_tasks = len(tasks)
+    completed_tasks = len([t for t in tasks if t["status"] == "Done"])
+    in_progress_tasks = len([t for t in tasks if t["status"] == "In Progress"])
+    overdue_tasks = len(get_overdue_tasks(tasks))
+    
+    # Display metrics
+    col1, col2, col3, col4 = st.columns(4)
+    
+    with col1:
+        st.metric(
+            "Total Tasks",
+            total_tasks,
+            delta=None
+        )
+    
+    with col2:
+        completion_rate = (completed_tasks / total_tasks * 100) if total_tasks > 0 else 0
+        st.metric(
+            "Completed",
+            completed_tasks,
+            delta=f"{completion_rate:.1f}%"
+        )
+    
+    with col3:
+        st.metric(
+            "In Progress",
+            in_progress_tasks,
+            delta=None
         )
+    
+    with col4:
+        st.metric(
+            "Overdue",
+            overdue_tasks,
+            delta="⚠️" if overdue_tasks > 0 else "✅"
+        )
+
+def show_tasks_table(status_filter: List[str], priority_filter: List[str], 
+                    category_filter: List[str], date_range):
+    """
+    Display the tasks table with filtering
+    """
+    st.subheader("📋 Tasks List")
+    
+    tasks = st.session_state.tasks
+    
+    if not tasks:
+        st.info("No tasks to display.")
+        return
+    
+    # Apply filters
+    filtered_tasks = filter_tasks(tasks, status_filter, priority_filter, category_filter, date_range)
+    
+    if not filtered_tasks:
+        st.warning("No tasks match the current filters.")
+        return
+    
+    # Convert to DataFrame for display
+    df = pd.DataFrame(filtered_tasks)
+    
+    # Select columns to display
+    display_columns = ["title", "status", "priority", "category", "assignee", "due_date", "created_at"]
+    available_columns = [col for col in display_columns if col in df.columns]
+    
+    # Display the table
+    edited_df = st.data_editor(
+        df[available_columns],
+        use_container_width=True,
+        hide_index=True,
+        column_config={
+            "title": st.column_config.TextColumn("Title", max_chars=50),
+            "status": st.column_config.SelectboxColumn(
+                "Status",
+                options=TASK_STATUSES,
+                required=True
+            ),
+            "priority": st.column_config.SelectboxColumn(
+                "Priority",
+                options=TASK_PRIORITIES,
+                required=True
+            ),
+            "category": st.column_config.SelectboxColumn(
+                "Category",
+                options=TASK_CATEGORIES,
+                required=True
+            ),
+            "due_date": st.column_config.DateColumn("Due Date"),
+            "created_at": st.column_config.DatetimeColumn("Created")
+        },
+        num_rows="dynamic"
+    )
+    
+    # Handle updates
+    if not edited_df.equals(df[available_columns]):
+        # Update the original tasks
+        for idx, row in edited_df.iterrows():
+            if idx < len(filtered_tasks):
+                task_id = filtered_tasks[idx]["id"]
+                update_task_from_row(task_id, row)
         
-        # Function to generate subtasks using AI
-        @handle_exceptions
-        def generate_subtasks(title, description):
-            """Generate subtasks using AI"""
-            logger.info(f"Generating subtasks for task: {title}")
-            subtasks = break_down_task(title, description)
-            
-            # Format subtasks as markdown list
-            subtasks_md = "**Suggested Subtasks:**\n\n"
-            for subtask in subtasks:
-                subtasks_md += f"- {subtask}\n"
-            
-            return subtasks_md
+        save_tasks_data(st.session_state.tasks)
+        show_success("Tasks updated successfully!")
+
+def show_task_analytics():
+    """
+    Display task analytics charts
+    """
+    st.subheader("📈 Task Analytics")
+    
+    tasks = st.session_state.tasks
+    
+    if not tasks:
+        return
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        # Status distribution
+        status_counts = pd.Series([t["status"] for t in tasks]).value_counts()
+        fig_status = px.pie(
+            values=status_counts.values,
+            names=status_counts.index,
+            title="Tasks by Status"
+        )
+        st.plotly_chart(fig_status, use_container_width=True)
+    
+    with col2:
+        # Priority distribution
+        priority_counts = pd.Series([t["priority"] for t in tasks]).value_counts()
+        fig_priority = px.bar(
+            x=priority_counts.index,
+            y=priority_counts.values,
+            title="Tasks by Priority"
+        )
+        st.plotly_chart(fig_priority, use_container_width=True)
+    
+    # Tasks over time
+    tasks_df = pd.DataFrame(tasks)
+    if "created_at" in tasks_df.columns:
+        tasks_df["created_date"] = pd.to_datetime(tasks_df["created_at"]).dt.date
+        daily_counts = tasks_df.groupby("created_date").size().reset_index(name="count")
         
-        # Set up generate subtasks action
-        generate_subtasks_btn.click(
-            generate_subtasks,
-            inputs=[task_title_display, task_description_display],
-            outputs=[subtasks_display]
+        fig_timeline = px.line(
+            daily_counts,
+            x="created_date",
+            y="count",
+            title="Tasks Created Over Time"
         )
+        st.plotly_chart(fig_timeline, use_container_width=True)
+
+@handle_data_exceptions
+def load_tasks_data() -> List[Dict[str, Any]]:
+    """
+    Load tasks from storage
+    """
+    tasks = load_data("tasks.json", "json")
+    if tasks is None:
+        # Create sample tasks
+        sample_tasks = create_sample_tasks()
+        save_data(sample_tasks, "tasks.json", "json")
+        return sample_tasks
+    return tasks
+
+@handle_data_exceptions
+def save_tasks_data(tasks: List[Dict[str, Any]]) -> bool:
+    """
+    Save tasks to storage
+    """
+    return save_data(tasks, "tasks.json", "json")
+
+def create_sample_tasks() -> List[Dict[str, Any]]:
+    """
+    Create sample tasks for demonstration
+    """
+    sample_tasks = [
+        create_new_task(
+            "Setup project structure",
+            "Initialize the project with proper folder structure and configuration files",
+            "Done",
+            "High",
+            "Development",
+            "Developer 1",
+            datetime.now() - timedelta(days=2),
+            "setup, initialization"
+        ),
+        create_new_task(
+            "Implement user authentication",
+            "Add login/logout functionality with session management",
+            "In Progress",
+            "High",
+            "Development",
+            "Developer 2",
+            datetime.now() + timedelta(days=5),
+            "auth, security"
+        ),
+        create_new_task(
+            "Write unit tests",
+            "Create comprehensive unit tests for core functionality",
+            "Todo",
+            "Medium",
+            "Testing",
+            "QA Team",
+            datetime.now() + timedelta(days=10),
+            "testing, quality"
+        )
+    ]
+    
+    return sample_tasks
+
+def filter_tasks(tasks: List[Dict], status_filter: List[str], priority_filter: List[str], 
+                category_filter: List[str], date_range) -> List[Dict]:
+    """
+    Filter tasks based on criteria
+    """
+    filtered = []
+    
+    for task in tasks:
+        # Status filter
+        if task["status"] not in status_filter:
+            continue
         
-        # Function to estimate task time using AI
-        @handle_exceptions
-        def estimate_task_time_ai(title, description):
-            """Estimate task time using AI"""
-            logger.info(f"Estimating time for task: {title}")
-            minutes = estimate_task_time(title, description)
-            
-            # Format time estimate
-            if minutes < 60:
-                time_str = f"{minutes} minutes"
-            else:
-                hours = minutes // 60
-                remaining_minutes = minutes % 60
-                time_str = f"{hours} hour{'s' if hours > 1 else ''}"
-                if remaining_minutes > 0:
-                    time_str += f" {remaining_minutes} minute{'s' if remaining_minutes > 1 else ''}"
-            
-            return f"**Estimated Time:** {time_str}"
+        # Priority filter
+        if task["priority"] not in priority_filter:
+            continue
+        
+        # Category filter
+        if task["category"] not in category_filter:
+            continue
+        
+        # Date filter
+        if "created_at" in task and task["created_at"]:
+            try:
+                task_date = datetime.fromisoformat(task["created_at"]).date()
+                if len(date_range) == 2:
+                    start_date, end_date = date_range
+                    if not (start_date <= task_date <= end_date):
+                        continue
+            except (ValueError, TypeError):
+                continue
         
-        # Set up estimate time action
-        estimate_time_btn.click(
-            estimate_task_time_ai,
-            inputs=[task_title_display, task_description_display],
-            outputs=[time_estimate_display]
-        )
+        filtered.append(task)
+    
+    return filtered
+
+def get_overdue_tasks(tasks: List[Dict]) -> List[Dict]:
+    """
+    Get overdue tasks
+    """
+    overdue = []
+    today = datetime.now().date()
+    
+    for task in tasks:
+        if task["status"] != "Done" and task.get("due_date"):
+            try:
+                due_date = datetime.fromisoformat(task["due_date"]).date()
+                if due_date < today:
+                    overdue.append(task)
+            except (ValueError, TypeError):
+                continue
+    
+    return overdue
+
+def update_task_from_row(task_id: str, row: pd.Series):
+    """
+    Update task from DataFrame row
+    """
+    for task in st.session_state.tasks:
+        if task["id"] == task_id:
+            for key, value in row.items():
+                if key in task and pd.notna(value):
+                    task[key] = value
+            task["updated_at"] = get_timestamp()
+            break