Upload 10 files

Dockerfile

@@ -0,0 +1,36 @@
+# Use Python 3.11 slim image as base
+FROM python:3.11-slim
+
+# Set working directory
+WORKDIR /app
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1
+ENV PYTHONDONTWRITEBYTECODE=1
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    gcc \
+    g++ \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Create necessary directories
+RUN mkdir -p /tmp/wedding_data /tmp/demo_data
+
+# Expose port (Streamlit default)
+EXPOSE 8501
+
+# Health check
+HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+
+# Run the Streamlit app
+CMD ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0", "--server.headless=true", "--server.enableCORS=false", "--server.enableXsrfProtection=false"]

app.py

@@ -0,0 +1,904 @@
+import streamlit as st
+import json
+import os
+from datetime import datetime, date, timedelta
+import pandas as pd
+from config_manager import ConfigManager
+from dashboard import Dashboard
+from tasks import TasksManager
+from guests import GuestManager
+from wedding_party import WeddingPartyManager
+from vendors import VendorManager
+
+# Page configuration
+st.set_page_config(
+    page_title="Wedding Planner",
+    page_icon="💒",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS for green/Adirondack theme
+st.markdown("""
+<style>
+    .main-header {
+        background: linear-gradient(90deg, #2d5016, #4a7c59);
+        color: white;
+        padding: 1rem;
+        border-radius: 10px;
+        text-align: center;
+        margin-bottom: 2rem;
+    }
+    
+    .metric-card {
+        background: linear-gradient(135deg, #4a7c59, #6b8e6b);
+        color: white;
+        padding: 1rem;
+        border-radius: 10px;
+        text-align: center;
+        margin: 0.5rem;
+        height: 150px;
+        display: flex;
+        flex-direction: column;
+        justify-content: center;
+        align-items: center;
+    }
+    
+    .sidebar .sidebar-content {
+        background: linear-gradient(180deg, #2d5016, #4a7c59);
+    }
+    
+    .stButton > button {
+        background: linear-gradient(90deg, #4a7c59, #6b8e6b);
+        color: white;
+        border: none;
+        border-radius: 5px;
+        padding: 0.5rem 1rem;
+    }
+    
+    .stButton > button:hover {
+        background: linear-gradient(90deg, #2d5016, #4a7c59);
+        color: white;
+    }
+    
+    .task-card {
+        background: #f8f9fa;
+        border-left: 4px solid #4a7c59;
+        padding: 1rem;
+        margin: 0.5rem 0;
+        border-radius: 5px;
+    }
+    
+    .guest-card {
+        background: #f8f9fa;
+        border: 1px solid #4a7c59;
+        padding: 1rem;
+        margin: 0.5rem 0;
+        border-radius: 5px;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+def main():
+    # Initialize session state
+    if 'config_manager' not in st.session_state:
+        st.session_state.config_manager = ConfigManager()
+    
+    # Check if config exists, if not show setup
+    if not st.session_state.config_manager.config_exists():
+        show_setup_page()
+    else:
+        show_main_app()
+
+def show_setup_page():
+    st.markdown('<div class="main-header"><h1>💒 Wedding Planner Setup</h1></div>', unsafe_allow_html=True)
+    
+    st.markdown("### Welcome! Let's set up your wedding planning app.")
+    
+    # Demo mode option
+    st.markdown("#### Choose Your Experience")
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.markdown("**🎭 Try Demo Mode**")
+        st.markdown("Experience the app with sample data including:")
+        st.markdown("• Sample wedding (Emma & James)")
+        st.markdown("• Demo guests with RSVPs")
+        st.markdown("• Vendors with complex payment schedules")
+        st.markdown("• Tasks in various stages")
+        st.markdown("• Wedding party information")
+        
+        if st.button("Start with Demo Data", type="primary"):
+            if st.session_state.config_manager.set_demo_mode(True):
+                st.success("Demo mode enabled! Loading sample data...")
+                st.rerun()
+            else:
+                st.error("Failed to enable demo mode.")
+    
+    with col2:
+        st.markdown("**📝 Start Fresh**")
+        st.markdown("Create your own wedding from scratch:")
+        st.markdown("• Enter your wedding details")
+        st.markdown("• Add your own events")
+        st.markdown("• Build your guest list")
+        st.markdown("• Manage your vendors")
+        st.markdown("• Track your tasks")
+        
+        if st.button("Create My Wedding", type="secondary"):
+            if st.session_state.config_manager.set_demo_mode(False):
+                st.success("Demo mode disabled. Ready to create your wedding!")
+                st.rerun()
+            else:
+                st.error("Failed to disable demo mode.")
+    
+    st.markdown("---")
+    
+    # Initialize session state for events and form data if not exists
+    if 'setup_events' not in st.session_state:
+        st.session_state.setup_events = []
+    if 'setup_form_data' not in st.session_state:
+        st.session_state.setup_form_data = {
+            'partner1_name': '',
+            'partner2_name': '',
+            'venue_city': '',
+            'wedding_start_date': date.today(),
+            'wedding_end_date': date.today(),
+            'custom_tags': '',
+            'task_assignees': ''
+        }
+    
+    # Basic wedding information form
+    with st.form("wedding_setup"):
+        st.markdown("#### Basic Wedding Information")
+        
+        col1, col2 = st.columns(2)
+        with col1:
+            partner1_name = st.text_input("Partner 1 Name", value=st.session_state.setup_form_data['partner1_name'], placeholder="Enter first partner's name")
+            partner2_name = st.text_input("Partner 2 Name", value=st.session_state.setup_form_data['partner2_name'], placeholder="Enter second partner's name")
+            venue_city = st.text_input("City", value=st.session_state.setup_form_data['venue_city'], placeholder="Enter city")
+        
+        with col2:
+            st.markdown("**Wedding Date Range**")
+            wedding_start_date = st.date_input("Start Date", value=st.session_state.setup_form_data['wedding_start_date'])
+            wedding_end_date = st.date_input("End Date", value=st.session_state.setup_form_data['wedding_end_date'])
+            
+            if wedding_end_date < wedding_start_date:
+                st.error("End date must be after start date")
+                wedding_end_date = wedding_start_date
+        
+        st.markdown("#### Task Organization")
+        st.info("Tasks will be automatically grouped by your wedding events.")
+        
+        st.markdown("#### Custom Tags")
+        st.markdown("Enter custom tags (one per line):")
+        custom_tags = st.text_area("Custom Tags", value=st.session_state.setup_form_data['custom_tags'], placeholder="e.g.,\nUrgent\nHigh Priority\nDeposit Required\nResearch Needed")
+        
+        st.markdown("#### Task Assignees")
+        st.markdown("Enter people who will regularly be assigned tasks (one per line):")
+        task_assignees = st.text_area("Task Assignees", value=st.session_state.setup_form_data['task_assignees'], placeholder="e.g.,\nMom\nDad\nWedding Planner\nBest Friend\nCoordinator")
+        
+        form_submitted = st.form_submit_button("Update Wedding Information")
+        
+        if form_submitted:
+            # Update session state with form data
+            st.session_state.setup_form_data = {
+                'partner1_name': partner1_name,
+                'partner2_name': partner2_name,
+                'venue_city': venue_city,
+                'wedding_start_date': wedding_start_date,
+                'wedding_end_date': wedding_end_date,
+                'custom_tags': custom_tags,
+                'task_assignees': task_assignees
+            }
+            st.success("Wedding information updated!")
+            st.rerun()
+    
+    # Event management section (outside form)
+    st.markdown("#### Wedding Events")
+    st.markdown("Define all your wedding events with their details:")
+    
+    # Add/Remove event buttons
+    col1, col2 = st.columns(2)
+    with col1:
+        if st.button("➕ Add Event"):
+            # Set default date to wedding start date
+            wedding_start = st.session_state.setup_form_data['wedding_start_date']
+            st.session_state.setup_events.append({
+                "name": "New Event",
+                "description": "",
+                "date_offset": 0,
+                "requires_meal_choice": False,
+                "meal_options": [],
+                "location": "",
+                "address": ""
+            })
+            st.rerun()
+    
+    with col2:
+        if len(st.session_state.setup_events) > 0 and st.button("➖ Remove Last Event"):
+            st.session_state.setup_events.pop()
+            st.rerun()
+    
+    # Display events
+    if st.session_state.setup_events:
+        for i, event in enumerate(st.session_state.setup_events):
+            with st.expander(f"Event {i+1}: {event['name']}", expanded=True):
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    event_name = st.text_input("Event Name", value=event['name'], key=f"event_name_{i}")
+                    event_description = st.text_input("Time", value=event['description'], placeholder="e.g., 2:00 PM, 6:30 PM", key=f"event_desc_{i}")
+                    event_location = st.text_input("Location Name", value=event.get('location', ''), placeholder="e.g., Central Park, Grand Ballroom", key=f"event_location_{i}")
+                
+                with col2:
+                    # Get wedding date range
+                    wedding_start = st.session_state.setup_form_data['wedding_start_date']
+                    wedding_end = st.session_state.setup_form_data['wedding_end_date']
+                    
+                    # Calculate current event date from date_offset
+                    current_event_date = wedding_start + timedelta(days=event['date_offset'])
+                    
+                    # Use date input without constraints - allow any date
+                    event_date = st.date_input(
+                        "Event Date", 
+                        value=current_event_date, 
+                        key=f"event_date_{i}",
+                        help="Select any date for this event"
+                    )
+                    
+                    # Show warning if date is outside wedding range
+                    if event_date < wedding_start or event_date > wedding_end:
+                        st.warning(f"⚠️ Selected date is outside your wedding date range ({wedding_start.strftime('%B %d, %Y')} - {wedding_end.strftime('%B %d, %Y')})")
+                    
+                    requires_meal_choice = st.checkbox("Requires Meal Choice", value=event['requires_meal_choice'], key=f"event_meal_{i}")
+                    
+                    # Meal options section (only show if meal choice is required)
+                    if requires_meal_choice:
+                        st.markdown("**Meal Options**")
+                        st.markdown("Enter meal options (one per line):")
+                        current_meal_options = event.get('meal_options', [])
+                        meal_options_text = '\n'.join(current_meal_options) if current_meal_options else ''
+                        meal_options = st.text_area("Meal Options", value=meal_options_text, placeholder="e.g.,\nDuck\nSurf & Turf\nRisotto (vegetarian)\nStuffed Squash (vegetarian)", key=f"event_meal_options_{i}", height=100)
+                    else:
+                        meal_options = ""
+                    
+                    event_address = st.text_area("Address", value=event.get('address', ''), placeholder="Enter full address (street, city, state, zip code)", key=f"event_address_{i}", height=80)
+                
+                # Calculate date_offset from the selected date
+                date_offset = (event_date - wedding_start).days
+                
+                # Parse meal options
+                meal_options_list = []
+                if requires_meal_choice and meal_options:
+                    meal_options_list = [option.strip() for option in meal_options.split('\n') if option.strip()]
+                
+                # Update session state
+                st.session_state.setup_events[i] = {
+                    "name": event_name,
+                    "description": event_description,
+                    "date_offset": date_offset,
+                    "requires_meal_choice": requires_meal_choice,
+                    "meal_options": meal_options_list,
+                    "location": event_location,
+                    "address": event_address
+                }
+    else:
+        st.info("No events added yet. Click 'Add Event' to get started!")
+    
+    # Save configuration button (after event management)
+    st.markdown("---")
+    if st.button("Save Configuration", type="primary"):
+        # Get form values from session state
+        form_data = st.session_state.setup_form_data
+        
+        if form_data['partner1_name'] and form_data['partner2_name'] and form_data['wedding_start_date'] and form_data['wedding_end_date']:
+            # Parse tags (task groups will be auto-generated from events)
+            custom_tags_list = [tag.strip() for tag in form_data['custom_tags'].split('\n') if tag.strip()]
+            task_assignees_list = [assignee.strip() for assignee in form_data['task_assignees'].split('\n') if assignee.strip()]
+            
+            # Create configuration
+            config = {
+                'wedding_info': {
+                    'partner1_name': form_data['partner1_name'],
+                    'partner2_name': form_data['partner2_name'],
+                    'wedding_start_date': form_data['wedding_start_date'].isoformat(),
+                    'wedding_end_date': form_data['wedding_end_date'].isoformat(),
+                    'venue_city': form_data['venue_city']
+                },
+                'custom_settings': {
+                    'custom_tags': custom_tags_list,
+                    'task_assignees': task_assignees_list
+                },
+                'wedding_events': st.session_state.setup_events
+            }
+            
+            # Save configuration
+            st.session_state.config_manager.save_config(config)
+            # Clear setup session state
+            if 'setup_events' in st.session_state:
+                del st.session_state.setup_events
+            if 'setup_form_data' in st.session_state:
+                del st.session_state.setup_form_data
+            st.success("Configuration saved successfully!")
+            st.rerun()
+        else:
+            st.error("Please fill in at least the partner names and wedding date range in the form above.")
+
+def show_main_app():
+    config = st.session_state.config_manager.load_config()
+    wedding_info = config.get('wedding_info', {})
+    
+    # Check demo mode status
+    is_demo_mode = st.session_state.config_manager.is_demo_mode()
+    
+    # Header
+    partner1 = wedding_info.get('partner1_name', 'Partner 1')
+    partner2 = wedding_info.get('partner2_name', 'Partner 2')
+    venue_city = wedding_info.get('venue_city', '')
+    wedding_start_str = wedding_info.get('wedding_start_date', '')
+    wedding_end_str = wedding_info.get('wedding_end_date', '')
+    
+    # Build base header text with location
+    if venue_city:
+        header_text = f"{partner1} & {partner2}'s Wedding Planner - {venue_city} \n"
+    else:
+        header_text = f"{partner1} & {partner2}'s Wedding Planner \n"
+    
+    # Add demo mode indicator
+    if is_demo_mode:
+        header_text += "🎭 DEMO MODE - Sample Data"
+    
+    if wedding_start_str and wedding_end_str:
+        try:
+            wedding_start = datetime.fromisoformat(wedding_start_str).date()
+            wedding_end = datetime.fromisoformat(wedding_end_str).date()
+            today = date.today()
+            
+            if today < wedding_start:
+                days_until = (wedding_start - today).days
+                header_text += f"\n{days_until} days until wedding festivities begin!"
+            elif wedding_start <= today <= wedding_end:
+                header_text += " - Wedding festivities are happening now! 🎉"
+            else:
+                days_since = (today - wedding_end).days
+                header_text += f" - {days_since} days since the wedding celebration ended!"
+        except:
+            pass  # Keep the base header text if date parsing fails
+    
+    st.markdown(f'<div class="main-header"><h1>{header_text}</h1></div>', unsafe_allow_html=True)
+    
+    # Sidebar navigation
+    with st.sidebar:
+        st.markdown("### Navigation")
+        page = st.radio(
+            "Choose a page:",
+            ["Dashboard", "Tasks", "Guest Management", "Wedding Party", "Wedding Overview", "Vendors & Purchases", "Settings"]
+        )
+    
+    # Route to appropriate page
+    if page == "Dashboard":
+        Dashboard().render(config)
+    elif page == "Tasks":
+        TasksManager().render(config)
+    elif page == "Guest Management":
+        GuestManager().render(config)
+    elif page == "Wedding Party":
+        WeddingPartyManager().render(config)
+    elif page == "Wedding Overview":
+        show_wedding_timeline_page(config)
+    elif page == "Vendors & Purchases":
+        VendorManager().render(config)
+    elif page == "Settings":
+        show_settings_page(config)
+
+def show_wedding_timeline_page(config):
+    st.markdown("## 📅 Wedding Overview")
+    
+    # Show wedding events directly without tabs
+    show_wedding_events_section(config)
+
+def get_vendors_for_event(event_name, vendors_data):
+    """Get vendors associated with a specific event, handling multiple categories per vendor"""
+    event_vendors = []
+    for vendor in vendors_data:
+        vendor_events = vendor.get('events', [])
+        if event_name in vendor_events:
+            # Get all categories for this vendor
+            categories = vendor.get('categories', [])
+            primary_category = vendor.get('category', '')
+            
+            # If no categories array, use the primary category
+            if not categories and primary_category:
+                categories = [primary_category]
+            
+            # If still no categories, use a default
+            if not categories:
+                categories = ['Vendor/Service']
+            
+            # Create an entry for each category this vendor serves
+            for category in categories:
+                event_vendors.append({
+                    'name': vendor.get('name', ''),
+                    'category': category,
+                    'status': vendor.get('status', ''),
+                    'vendor_id': vendor.get('id', '')  # Add ID to help identify duplicates
+                })
+    
+    return event_vendors
+
+def get_meal_choices_for_event(event_name, rsvp_data, meal_options):
+    """Get meal choice counts for a specific event from RSVP data"""
+    meal_counts = {}
+    
+    # Initialize counts for all meal options
+    for option in meal_options:
+        meal_counts[option] = 0
+    
+    # Count meal choices from RSVP data
+    for group_code, group_data in rsvp_data.items():
+        event_responses = group_data.get('event_responses', {})
+        if event_name in event_responses:
+            event_data = event_responses[event_name]
+            meal_choices = event_data.get('meal_choice', {})
+            
+            for attendee, choice in meal_choices.items():
+                if choice in meal_counts:
+                    meal_counts[choice] += 1
+    
+    return meal_counts
+
+def show_wedding_events_section(config):
+    st.markdown("## 📅 Wedding Events")
+    
+    wedding_events = config.get('wedding_events', [])
+    wedding_info = config.get('wedding_info', {})
+    
+    if not wedding_events:
+        st.info("No events configured yet. Please complete the setup to define your wedding events.")
+        return
+    
+    # Get wedding dates
+    wedding_start_str = wedding_info.get('wedding_start_date', '')
+    wedding_end_str = wedding_info.get('wedding_end_date', '')
+    
+    if wedding_start_str and wedding_end_str:
+        try:
+            wedding_start = datetime.fromisoformat(wedding_start_str).date()
+            wedding_end = datetime.fromisoformat(wedding_end_str).date()
+        except:
+            st.error("Invalid wedding date format. Please check your settings.")
+            return
+    else:
+        st.warning("Wedding dates not set. Please complete the setup.")
+        return
+    
+    # Load vendors and RSVP data
+    config_manager = ConfigManager()
+    vendors_data = config_manager.load_json_data('vendors.json')
+    rsvp_data = config_manager.load_json_data('rsvp_data.json')
+    
+    # Display events
+    st.markdown(f"### Your Wedding Events ({len(wedding_events)} total)")
+    
+    # Group events by day
+    events_by_day = {}
+    for event in wedding_events:
+        event_date = wedding_start + timedelta(days=event.get('date_offset', 0))
+        day_key = event_date.strftime('%Y-%m-%d')
+        if day_key not in events_by_day:
+            events_by_day[day_key] = []
+        events_by_day[day_key].append(event)
+    
+    # Sort days
+    sorted_days = sorted(events_by_day.keys())
+    
+    for day in sorted_days:
+        day_date = datetime.fromisoformat(day).date()
+        day_events = events_by_day[day]
+        
+        # Determine day label
+        if day_date == wedding_start:
+            day_label = "Day 1 - Wedding Start"
+        elif day_date == wedding_end:
+            day_label = "Final Day - Wedding End"
+        else:
+            days_from_start = (day_date - wedding_start).days
+            day_label = f"Day {days_from_start + 1}"
+        
+        st.markdown(f"#### {day_label} - {day_date.strftime('%B %d, %Y')}")
+        
+        for event in day_events:
+            # Simple event display
+            time_info = event.get('description', '') or 'Time TBD'
+            location = event.get('location', '') or 'Location TBD'
+            address = event.get('address', '')
+            meal_required = event.get('requires_meal_choice', False)
+            event_name = event.get('name', 'Untitled Event')
+            
+            st.markdown(f"**{event_name}**")
+            st.markdown(f"🕐 **Time:** {time_info}")
+            st.markdown(f"📍 **Location:** {location}")
+            if address:
+                st.markdown(f"🏠 **Address:** {address}")
+            st.markdown(f"🍽️ **Meal Choice:** {'Required' if meal_required else 'Not Required'}")
+            
+            # Display meal choices and counts if meal choice is required
+            if meal_required:
+                meal_options = event.get('meal_options', [])
+                if meal_options:
+                    meal_counts = get_meal_choices_for_event(event_name, rsvp_data, meal_options)
+                    st.markdown("🍽️ **Meal Choices:**")
+                    for option in meal_options:
+                        count = meal_counts.get(option, 0)
+                        st.markdown(f"   • **{option}:** {count} orders")
+                else:
+                    st.markdown("🍽️ **Meal Choices:** No options configured")
+            
+            # Display vendors for this event
+            event_vendors = get_vendors_for_event(event_name, vendors_data)
+            if event_vendors:
+                st.markdown("🏢 **Vendors:**")
+                
+                # Group vendors by name to handle multiple categories
+                vendors_by_name = {}
+                for vendor in event_vendors:
+                    vendor_name = vendor['name']
+                    if vendor_name not in vendors_by_name:
+                        vendors_by_name[vendor_name] = {
+                            'categories': [],
+                            'status': vendor['status']
+                        }
+                    vendors_by_name[vendor_name]['categories'].append(vendor['category'])
+                
+                # Display grouped vendors
+                for vendor_name, vendor_info in vendors_by_name.items():
+                    status_emoji = "✅" if vendor_info['status'] == "Booked" else "⏳" if vendor_info['status'] == "Researching" else "📋"
+                    categories_text = ", ".join(vendor_info['categories'])
+                    st.markdown(f"   • {status_emoji} **{categories_text}:** {vendor_name}")
+            else:
+                st.markdown("🏢 **Vendors:** None assigned")
+            
+            st.markdown("---")
+    
+    # Event summary
+    st.markdown("### Event Summary")
+    
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        total_events = len(wedding_events)
+        st.metric("Total Events", total_events)
+    
+    with col2:
+        meal_events = len([e for e in wedding_events if e.get('requires_meal_choice', False)])
+        st.metric("Events with Meals", meal_events)
+    
+    with col3:
+        days_span = (wedding_end - wedding_start).days + 1
+        st.metric("Celebration Days", days_span)
+
+def show_settings_page(config):
+    st.markdown("### Settings")
+    
+    # Check demo mode status
+    is_demo_mode = st.session_state.config_manager.is_demo_mode()
+    
+    # Demo mode toggle at the top
+    st.markdown("#### Demo Mode")
+    col1, col2 = st.columns([3, 1])
+    with col1:
+        if is_demo_mode:
+            st.info("🎭 **Demo Mode is ON** - You are currently viewing sample data. This includes demo guests, vendors with complex payment schedules, tasks, and wedding party information.")
+        else:
+            st.info("📝 **Demo Mode is OFF** - You are viewing your actual wedding data.")
+    
+    with col2:
+        if st.button("Toggle Demo Mode", type="secondary"):
+            if st.session_state.config_manager.toggle_demo_mode():
+                st.success("Demo mode toggled! Please refresh the page.")
+                st.rerun()
+            else:
+                st.error("Failed to toggle demo mode.")
+    
+    # Create tabs for different settings
+    tab1, tab2, tab3, tab4, tab5 = st.tabs(["Edit Configuration", "Manage Events", "Google Drive", "Current Configuration", "Reset"])
+    
+    with tab1:
+        st.markdown("#### Edit Wedding Configuration")
+        
+        # Initialize session state for editing if not exists
+        if 'edit_config' not in st.session_state:
+            st.session_state.edit_config = config.copy()
+        
+        with st.form("edit_wedding_config"):
+            st.markdown("##### Basic Wedding Information")
+            
+            col1, col2 = st.columns(2)
+            with col1:
+                partner1_name = st.text_input("Partner 1 Name", value=st.session_state.edit_config.get('wedding_info', {}).get('partner1_name', ''))
+                partner2_name = st.text_input("Partner 2 Name", value=st.session_state.edit_config.get('wedding_info', {}).get('partner2_name', ''))
+                venue_city = st.text_input("City", value=st.session_state.edit_config.get('wedding_info', {}).get('venue_city', ''))
+            
+            with col2:
+                # Get current dates
+                wedding_start_str = st.session_state.edit_config.get('wedding_info', {}).get('wedding_start_date', '')
+                wedding_end_str = st.session_state.edit_config.get('wedding_info', {}).get('wedding_end_date', '')
+                
+                try:
+                    if wedding_start_str:
+                        wedding_start = datetime.fromisoformat(wedding_start_str).date()
+                    else:
+                        wedding_start = date.today()
+                    
+                    if wedding_end_str:
+                        wedding_end = datetime.fromisoformat(wedding_end_str).date()
+                    else:
+                        wedding_end = date.today()
+                except:
+                    wedding_start = date.today()
+                    wedding_end = date.today()
+                
+                wedding_start_date = st.date_input("Wedding Start Date", value=wedding_start)
+                wedding_end_date = st.date_input("Wedding End Date", value=wedding_end)
+                
+                if wedding_end_date < wedding_start_date:
+                    st.error("End date must be after start date")
+                    wedding_end_date = wedding_start_date
+            
+            st.markdown("##### Custom Tags")
+            current_tags = st.session_state.edit_config.get('custom_settings', {}).get('custom_tags', [])
+            custom_tags_text = '\n'.join(current_tags) if current_tags else ''
+            custom_tags = st.text_area("Custom Tags (one per line)", value=custom_tags_text, placeholder="e.g.,\nUrgent\nHigh Priority\nDeposit Required")
+            
+            st.markdown("##### Task Assignees")
+            current_assignees = st.session_state.edit_config.get('custom_settings', {}).get('task_assignees', [])
+            task_assignees_text = '\n'.join(current_assignees) if current_assignees else ''
+            task_assignees = st.text_area("Task Assignees (one per line)", value=task_assignees_text, placeholder="e.g.,\nMom\nDad\nWedding Planner\nBest Friend\nCoordinator")
+            
+            submitted = st.form_submit_button("Save Changes", type="primary")
+            
+            if submitted:
+                # Update the configuration
+                updated_config = st.session_state.edit_config.copy()
+                updated_config['wedding_info'] = {
+                    'partner1_name': partner1_name,
+                    'partner2_name': partner2_name,
+                    'venue_city': venue_city,
+                    'wedding_start_date': wedding_start_date.isoformat(),
+                    'wedding_end_date': wedding_end_date.isoformat()
+                }
+                
+                # Parse custom tags and task assignees
+                custom_tags_list = [tag.strip() for tag in custom_tags.split('\n') if tag.strip()]
+                task_assignees_list = [assignee.strip() for assignee in task_assignees.split('\n') if assignee.strip()]
+                updated_config['custom_settings'] = {
+                    'custom_tags': custom_tags_list,
+                    'task_assignees': task_assignees_list
+                }
+                
+                # Save the updated configuration
+                st.session_state.config_manager.save_config(updated_config)
+                st.success("Configuration updated successfully!")
+                st.rerun()
+    
+    with tab2:
+        show_event_management_section(config)
+    
+    with tab3:
+        show_google_drive_section()
+    
+    with tab4:
+        st.markdown("#### Current Configuration")
+        st.json(config)
+    
+    with tab5:
+        st.markdown("#### Reset Configuration")
+        st.warning("⚠️ This will permanently delete all your wedding configuration data. This action cannot be undone.")
+        
+        if st.button("Reset Configuration", type="secondary"):
+            if st.session_state.config_manager.reset_config():
+                st.success("Configuration reset! Please refresh the page.")
+                st.rerun()
+
+def show_google_drive_section():
+    st.markdown("#### Google Drive Integration")
+    
+    config_manager = st.session_state.config_manager
+    drive_status = config_manager.get_google_drive_status()
+    
+    # Status display
+    if drive_status['enabled']:
+        if drive_status['status'] == 'Online':
+            st.success(f"✅ {drive_status['message']}")
+        elif drive_status['status'] == 'Offline':
+            st.warning(f"⚠️ {drive_status['message']}")
+        else:
+            st.error(f"❌ {drive_status['message']}")
+    else:
+        st.info(f"ℹ️ {drive_status['message']}")
+    
+    # Show files if available
+    if drive_status['enabled'] and 'files' in drive_status:
+        st.markdown("**Files in Google Drive:**")
+        for file_name in drive_status['files']:
+            st.markdown(f"• {file_name}")
+    
+    # Manual sync buttons
+    if drive_status['enabled']:
+        st.markdown("#### Manual Sync")
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            if st.button("📥 Sync from Google Drive", help="Download latest data from Google Drive"):
+                with st.spinner("Syncing from Google Drive..."):
+                    if config_manager.manual_sync_from_drive():
+                        st.success("Successfully synced from Google Drive!")
+                        st.rerun()
+                    else:
+                        st.error("Failed to sync from Google Drive")
+        
+        with col2:
+            if st.button("📤 Sync to Google Drive", help="Upload current data to Google Drive"):
+                with st.spinner("Syncing to Google Drive..."):
+                    if config_manager.manual_sync_to_drive():
+                        st.success("Successfully synced to Google Drive!")
+                    else:
+                        st.error("Failed to sync to Google Drive")
+    
+    # Configuration info
+    st.markdown("#### Configuration")
+    st.markdown("To enable Google Drive integration, set the following environment variables:")
+    st.code("""
+GOOGLE_DRIVE_FOLDER_ID=your_folder_id
+GOOGLE_PROJECT_ID=your_project_id
+GOOGLE_PRIVATE_KEY_ID=your_private_key_id
+GOOGLE_PRIVATE_KEY=your_private_key
+GOOGLE_CLIENT_EMAIL=your_client_email
+GOOGLE_CLIENT_ID=your_client_id
+    """)
+    
+    st.markdown("**Note:** Google Drive integration is automatically enabled when running on Hugging Face Spaces with proper credentials configured.")
+
+def show_event_management_section(config):
+    st.markdown("#### Manage Wedding Events")
+    
+    # Initialize session state for event editing if not exists
+    if 'edit_events' not in st.session_state:
+        st.session_state.edit_events = config.get('wedding_events', []).copy()
+    
+    wedding_events = st.session_state.edit_events
+    wedding_info = config.get('wedding_info', {})
+    
+    # Get wedding dates for date calculations
+    wedding_start_str = wedding_info.get('wedding_start_date', '')
+    wedding_end_str = wedding_info.get('wedding_end_date', '')
+    
+    if not wedding_start_str or not wedding_end_str:
+        st.warning("Please set your wedding date range in the 'Edit Configuration' tab first.")
+        return
+    
+    try:
+        wedding_start = datetime.fromisoformat(wedding_start_str).date()
+        wedding_end = datetime.fromisoformat(wedding_end_str).date()
+    except:
+        st.error("Invalid wedding date format. Please check your configuration.")
+        return
+    
+    # Add event button
+    if st.button("➕ Add New Event"):
+        st.session_state.edit_events.append({
+            "name": "New Event",
+            "description": "",
+            "date_offset": 0,
+            "requires_meal_choice": False,
+            "meal_options": [],
+            "location": "",
+            "address": ""
+        })
+        st.rerun()
+    
+    # Display events for editing
+    if st.session_state.edit_events:
+        st.markdown("##### Edit Events")
+        
+        for i, event in enumerate(st.session_state.edit_events):
+            with st.expander(f"Event {i+1}: {event['name']}", expanded=True):
+                # Add delete button at the top right of each event
+                col_header1, col_header2 = st.columns([4, 1])
+                with col_header2:
+                    if st.button("🗑️ Delete", key=f"delete_event_{i}", help="Delete this event"):
+                        st.session_state.edit_events.pop(i)
+                        st.rerun()
+                
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    event_name = st.text_input("Event Name", value=event['name'], key=f"settings_event_name_{i}")
+                    event_description = st.text_input("Time", value=event['description'], placeholder="e.g., 2:00 PM, 6:30 PM", key=f"settings_event_desc_{i}")
+                    event_location = st.text_input("Location Name", value=event.get('location', ''), placeholder="e.g., Central Park, Grand Ballroom", key=f"settings_event_location_{i}")
+                
+                with col2:
+                    # Calculate current event date from date_offset
+                    current_event_date = wedding_start + timedelta(days=event['date_offset'])
+                    
+                    # Use date input without constraints - allow any date
+                    event_date = st.date_input(
+                        "Event Date", 
+                        value=current_event_date, 
+                        key=f"settings_event_date_{i}",
+                        help="Select any date for this event"
+                    )
+                    
+                    # Show warning if date is outside wedding range
+                    if event_date < wedding_start or event_date > wedding_end:
+                        st.warning(f"⚠️ Selected date is outside your wedding date range ({wedding_start.strftime('%B %d, %Y')} - {wedding_end.strftime('%B %d, %Y')})")
+                    
+                    requires_meal_choice = st.checkbox("Requires Meal Choice", value=event['requires_meal_choice'], key=f"settings_event_meal_{i}")
+                    
+                    # Meal options section (only show if meal choice is required)
+                    if requires_meal_choice:
+                        st.markdown("**Meal Options**")
+                        st.markdown("Enter meal options (one per line):")
+                        current_meal_options = event.get('meal_options', [])
+                        meal_options_text = '\n'.join(current_meal_options) if current_meal_options else ''
+                        meal_options = st.text_area("Meal Options", value=meal_options_text, placeholder="e.g.,\nDuck\nSurf & Turf\nRisotto (vegetarian)\nStuffed Squash (vegetarian)", key=f"settings_event_meal_options_{i}", height=100)
+                    else:
+                        meal_options = ""
+                    
+                    event_address = st.text_area("Address", value=event.get('address', ''), placeholder="Enter full address (street, city, state, zip code)", key=f"settings_event_address_{i}", height=80)
+                
+                # Calculate date_offset from the selected date
+                date_offset = (event_date - wedding_start).days
+                
+                # Parse meal options
+                meal_options_list = []
+                if requires_meal_choice and meal_options:
+                    meal_options_list = [option.strip() for option in meal_options.split('\n') if option.strip()]
+                
+                # Update session state
+                st.session_state.edit_events[i] = {
+                    "name": event_name,
+                    "description": event_description,
+                    "date_offset": date_offset,
+                    "requires_meal_choice": requires_meal_choice,
+                    "meal_options": meal_options_list,
+                    "location": event_location,
+                    "address": event_address
+                }
+        
+        # Save events button
+        st.markdown("---")
+        col1, col2, col3 = st.columns([1, 1, 1])
+        with col2:
+            if st.button("💾 Save Event Changes", type="primary"):
+                # Update the configuration with edited events
+                updated_config = config.copy()
+                updated_config['wedding_events'] = st.session_state.edit_events
+                
+                # Save the updated configuration
+                st.session_state.config_manager.save_config(updated_config)
+                st.success("Event changes saved successfully!")
+                st.rerun()
+    else:
+        st.info("No events added yet. Click 'Add New Event' to get started!")
+    
+    # Event summary
+    if st.session_state.edit_events:
+        st.markdown("##### Event Summary")
+        
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            total_events = len(st.session_state.edit_events)
+            st.metric("Total Events", total_events)
+        
+        with col2:
+            meal_events = len([e for e in st.session_state.edit_events if e.get('requires_meal_choice', False)])
+            st.metric("Events with Meals", meal_events)
+        
+        with col3:
+            days_span = (wedding_end - wedding_start).days + 1
+            st.metric("Celebration Days", days_span)
+
+if __name__ == "__main__":
+    main()

app_config.json

@@ -0,0 +1,9 @@
+{
+  "demo_mode": false,
+  "demo_data_path": "demo_data",
+  "app_settings": {
+    "theme": "green_adirondack",
+    "auto_save": true,
+    "backup_enabled": true
+  }
+}

config_manager.py

@@ -0,0 +1,334 @@
+import json
+import os
+from datetime import datetime
+from google_drive_manager import GoogleDriveManager
+
+class ConfigManager:
+    def __init__(self):
+        self.config_file = "wedding_config.json"
+        self.data_dir = "data"
+        self.app_config_file = "app_config.json"
+        self.demo_data_dir = "demo_data"
+        
+        # Check if running on Hugging Face Spaces
+        self.is_huggingface = os.getenv('SPACE_ID') is not None
+        
+        # Initialize Google Drive manager
+        self.drive_manager = GoogleDriveManager()
+        self.google_drive_enabled = False
+        
+        # Set up data directory
+        if self.is_huggingface:
+            self.data_dir = "/tmp/wedding_data"
+            self.demo_data_dir = "/tmp/demo_data"
+        
+        # Create data directory if it doesn't exist
+        if not os.path.exists(self.data_dir):
+            os.makedirs(self.data_dir)
+        if not os.path.exists(self.demo_data_dir):
+            os.makedirs(self.demo_data_dir)
+        
+        # Load app configuration
+        self.app_config = self.load_app_config()
+        
+        # Initialize Google Drive if enabled
+        self._initialize_google_drive()
+    
+    def _initialize_google_drive(self):
+        """Initialize Google Drive connection"""
+        try:
+            folder_id = os.getenv('GOOGLE_DRIVE_FOLDER_ID')
+            if folder_id:
+                if self.drive_manager.initialize(folder_id):
+                    self.google_drive_enabled = True
+                    # Sync data from Google Drive on startup
+                    self._sync_from_google_drive()
+        except Exception as e:
+            print(f"Google Drive initialization failed: {e}")
+            self.google_drive_enabled = False
+    
+    def _sync_from_google_drive(self):
+        """Sync data files from Google Drive to local storage"""
+        if not self.google_drive_enabled:
+            return
+        
+        # List of data files to sync
+        data_files = [
+            'guest_list_data.json',
+            'rsvp_data.json', 
+            'tasks.json',
+            'vendors.json',
+            'wedding_party.json'
+        ]
+        
+        # Sync config file
+        config_content = self.drive_manager.download_file('wedding_config.json')
+        if config_content:
+            config_path = self.get_config_file_path()
+            with open(config_path, 'w') as f:
+                json.dump(config_content, f, indent=2)
+        
+        # Sync data files
+        for file_name in data_files:
+            content = self.drive_manager.download_file(file_name)
+            if content:
+                file_path = self.get_data_file_path(file_name)
+                with open(file_path, 'w') as f:
+                    json.dump(content, f, indent=2)
+    
+    def _sync_to_google_drive(self):
+        """Sync local data files to Google Drive"""
+        if not self.google_drive_enabled:
+            return
+        
+        # Sync config file
+        config_path = self.get_config_file_path()
+        if os.path.exists(config_path):
+            with open(config_path, 'r') as f:
+                config_content = json.load(f)
+            self.drive_manager.upload_file('wedding_config.json', config_content)
+        
+        # Sync data files
+        data_files = [
+            'guest_list_data.json',
+            'rsvp_data.json',
+            'tasks.json', 
+            'vendors.json',
+            'wedding_party.json'
+        ]
+        
+        for file_name in data_files:
+            file_path = self.get_data_file_path(file_name)
+            if os.path.exists(file_path):
+                with open(file_path, 'r') as f:
+                    content = json.load(f)
+                self.drive_manager.upload_file(file_name, content)
+    
+    def load_app_config(self):
+        """Load app configuration from file"""
+        if os.path.exists(self.app_config_file):
+            try:
+                with open(self.app_config_file, 'r') as f:
+                    return json.load(f)
+            except (json.JSONDecodeError, FileNotFoundError):
+                return self.get_default_app_config()
+        return self.get_default_app_config()
+    
+    def get_default_app_config(self):
+        """Get default app configuration"""
+        return {
+            "demo_mode": False,
+            "demo_data_path": "demo_data",
+            "app_settings": {
+                "theme": "green_adirondack",
+                "auto_save": True,
+                "backup_enabled": True
+            }
+        }
+    
+    def is_demo_mode(self):
+        """Check if demo mode is enabled"""
+        return self.app_config.get("demo_mode", False)
+    
+    def get_data_directory(self):
+        """Get the appropriate data directory based on demo mode"""
+        if self.is_demo_mode():
+            return self.demo_data_dir
+        return self.data_dir
+    
+    def get_config_file_path(self):
+        """Get the appropriate config file path based on demo mode"""
+        if self.is_demo_mode():
+            return os.path.join(self.demo_data_dir, "wedding_config.json")
+        return self.config_file
+    
+    def config_exists(self):
+        """Check if configuration file exists"""
+        config_path = self.get_config_file_path()
+        return os.path.exists(config_path)
+    
+    def load_config(self):
+        """Load configuration from file"""
+        if self.config_exists():
+            try:
+                config_path = self.get_config_file_path()
+                with open(config_path, 'r') as f:
+                    return json.load(f)
+            except (json.JSONDecodeError, FileNotFoundError):
+                return self.get_default_config()
+        return self.get_default_config()
+    
+    def save_config(self, config):
+        """Save configuration to file"""
+        try:
+            config_path = self.get_config_file_path()
+            with open(config_path, 'w') as f:
+                json.dump(config, f, indent=2)
+            
+            # Sync to Google Drive if enabled
+            if self.google_drive_enabled:
+                self.drive_manager.upload_file('wedding_config.json', config)
+            
+            return True
+        except Exception as e:
+            print(f"Error saving config: {e}")
+            return False
+    
+    def reset_config(self):
+        """Reset configuration by deleting the config file"""
+        try:
+            config_path = self.get_config_file_path()
+            if os.path.exists(config_path):
+                os.remove(config_path)
+            return True
+        except Exception as e:
+            print(f"Error resetting config: {e}")
+            return False
+    
+    def get_default_config(self):
+        """Get default configuration"""
+        return {
+            'wedding_info': {
+                'partner1_name': '',
+                'partner2_name': '',
+                'wedding_start_date': '',
+                'wedding_end_date': '',
+                'venue_city': ''
+            },
+            'custom_settings': {
+                'custom_tags': [
+                    "Wedding Party", "Urgent", "Rehearsal", "Timeline",
+                    "Maid of Honor", "Best Man", "Bridesmaid", "Groomsman",
+                    "Flower Girl", "Ring Bearer", "Usher", "Reader",
+                    "Venue", "Catering", "Photography", "Videography", "Music/DJ", 
+                    "Flowers", "Decor", "Attire", "Hair & Makeup", "Transportation",
+                    "Invitations", "Cake", "Officiant", "Other",
+                    "Decorations", "Centerpieces", "Favors", "Signage", "Linens", 
+                    "Tableware", "Lighting", "Accessories", "Stationery", "Gifts",
+                    "Vendor", "Item", "Deposit Required", "Final Payment", "Installment",
+                    "Food & Beverage", "Music", "Entertainment", "Lodging"
+                ],
+                'task_assignees': []
+            },
+            'wedding_events': [
+                {"name": "Welcome Dinner", "date_offset": -1, "description": "Welcome dinner for out-of-town guests", "requires_meal_choice": True, "meal_options": ["Duck", "Surf & Turf", "Risotto (vegetarian)", "Stuffed Squash (vegetarian)"], "location": ""},
+                {"name": "Church Ceremony", "date_offset": 0, "description": "Main wedding ceremony", "requires_meal_choice": False, "meal_options": [], "location": ""},
+                {"name": "Reception", "date_offset": 0, "description": "Wedding reception with dinner", "requires_meal_choice": True, "meal_options": ["Duck", "Surf & Turf", "Risotto (vegetarian)", "Stuffed Squash (vegetarian)"], "location": ""},
+                {"name": "Mehndi Afterparty", "date_offset": 1, "description": "Mehndi celebration and afterparty", "requires_meal_choice": False, "meal_options": [], "location": ""},
+                {"name": "Indian Ceremony", "date_offset": 1, "description": "Traditional Indian wedding ceremony", "requires_meal_choice": False, "meal_options": [], "location": ""},
+                {"name": "Indian Reception", "date_offset": 1, "description": "Indian reception celebration", "requires_meal_choice": True, "meal_options": ["Duck", "Surf & Turf", "Risotto (vegetarian)", "Stuffed Squash (vegetarian)"], "location": ""}
+            ]
+        }
+    
+    def get_data_file_path(self, filename):
+        """Get full path for data files"""
+        data_dir = self.get_data_directory()
+        return os.path.join(data_dir, filename)
+    
+    def load_json_data(self, filename):
+        """Load JSON data from data directory"""
+        filepath = self.get_data_file_path(filename)
+        if os.path.exists(filepath):
+            try:
+                with open(filepath, 'r') as f:
+                    return json.load(f)
+            except (json.JSONDecodeError, FileNotFoundError):
+                return []
+        return []
+    
+    def save_json_data(self, filename, data):
+        """Save JSON data to data directory"""
+        filepath = self.get_data_file_path(filename)
+        try:
+            with open(filepath, 'w') as f:
+                json.dump(data, f, indent=2)
+            
+            # Sync to Google Drive if enabled
+            if self.google_drive_enabled:
+                self.drive_manager.upload_file(filename, data)
+            
+            return True
+        except Exception as e:
+            print(f"Error saving data to {filename}: {e}")
+            return False
+    
+    def toggle_demo_mode(self):
+        """Toggle demo mode on/off"""
+        self.app_config["demo_mode"] = not self.app_config.get("demo_mode", False)
+        try:
+            with open(self.app_config_file, 'w') as f:
+                json.dump(self.app_config, f, indent=2)
+            return True
+        except Exception as e:
+            print(f"Error saving app config: {e}")
+            return False
+    
+    def set_demo_mode(self, enabled):
+        """Set demo mode to specific value"""
+        self.app_config["demo_mode"] = enabled
+        try:
+            with open(self.app_config_file, 'w') as f:
+                json.dump(self.app_config, f, indent=2)
+            return True
+        except Exception as e:
+            print(f"Error saving app config: {e}")
+            return False
+    
+    def is_google_drive_enabled(self):
+        """Check if Google Drive integration is enabled and working"""
+        return self.google_drive_enabled and self.drive_manager.is_online()
+    
+    def manual_sync_to_drive(self):
+        """Manually sync all data to Google Drive"""
+        if not self.google_drive_enabled:
+            return False
+        
+        try:
+            self._sync_to_google_drive()
+            return True
+        except Exception as e:
+            print(f"Error syncing to Google Drive: {e}")
+            return False
+    
+    def manual_sync_from_drive(self):
+        """Manually sync all data from Google Drive"""
+        if not self.google_drive_enabled:
+            return False
+        
+        try:
+            self._sync_from_google_drive()
+            return True
+        except Exception as e:
+            print(f"Error syncing from Google Drive: {e}")
+            return False
+    
+    def get_google_drive_status(self):
+        """Get status information about Google Drive integration"""
+        if not self.google_drive_enabled:
+            return {
+                'enabled': False,
+                'status': 'Disabled',
+                'message': 'Google Drive integration not configured'
+            }
+        
+        if not self.drive_manager.is_online():
+            return {
+                'enabled': True,
+                'status': 'Offline',
+                'message': 'Google Drive service unavailable'
+            }
+        
+        try:
+            files = self.drive_manager.list_files()
+            return {
+                'enabled': True,
+                'status': 'Online',
+                'message': f'Connected to Google Drive ({len(files)} files found)',
+                'files': [f['name'] for f in files]
+            }
+        except Exception as e:
+            return {
+                'enabled': True,
+                'status': 'Error',
+                'message': f'Error connecting to Google Drive: {str(e)}'
+            }

dashboard.py

@@ -0,0 +1,780 @@
+import streamlit as st
+import pandas as pd
+from datetime import datetime, date
+import plotly.express as px
+import plotly.graph_objects as go
+from config_manager import ConfigManager
+from vendors import VendorManager
+
+class Dashboard:
+    def __init__(self):
+        self.config_manager = ConfigManager()
+    
+    def calculate_actualized_cost(self, vendors):
+        """Calculate total cost for only booked/ordered/delivered items"""
+        total_cost = 0
+        
+        for vendor in vendors:
+            vendor_type = vendor.get('type', 'Vendor/Service')
+            vendor_total_cost = vendor.get('total_cost', vendor.get('cost', 0))
+            
+            # Only include cost if vendor is booked or item is ordered/delivered
+            should_include = False
+            if vendor_type == 'Vendor/Service':
+                if vendor.get('status') == 'Booked':
+                    should_include = True
+            elif vendor_type == 'Item/Purchase':
+                status = vendor.get('status', 'Researching')
+                if status in ['Ordered', 'Shipped', 'Delivered']:
+                    should_include = True
+            
+            if should_include:
+                total_cost += vendor_total_cost
+        
+        return total_cost
+    
+    def render(self, config):
+        wedding_info = config.get('wedding_info', {})
+        venue_city = wedding_info.get('venue_city', '')
+        
+        # Display header with location
+        if venue_city:
+            st.markdown(f"## 📊 Wedding Dashboard - {venue_city}")
+        else:
+            st.markdown("## 📊 Wedding Dashboard")
+        
+        # Main metrics row
+        col1, col2, col3, col4 = st.columns(4)
+        
+        with col1:
+            self.render_countdown_card(wedding_info)
+        
+        with col2:
+            self.render_guest_count_card()
+        
+        with col3:
+            self.render_task_progress_card()
+        
+        with col4:
+            self.render_budget_card()
+        
+        # Add prominent cost breakdown section
+        st.markdown("---")
+        
+        # Calculate costs for the breakdown section
+        vendors = self.config_manager.load_json_data('vendors.json')
+        total_estimated_cost = sum([v.get('total_cost', v.get('cost', 0)) for v in vendors])
+        total_actualized_cost = self.calculate_actualized_cost(vendors)
+        pending_cost = total_estimated_cost - total_actualized_cost
+        
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            st.markdown("### 💰 Total Estimated Cost")
+            st.markdown(f"**${total_estimated_cost:,.0f}**")
+            st.caption("All vendors & items regardless of status")
+        
+        with col2:
+            st.markdown("### ✅ Actualized Cost")
+            st.markdown(f"**${total_actualized_cost:,.0f}**")
+            st.caption("Only booked/ordered/delivered items")
+        
+        with col3:
+            st.markdown("### ⏳ Pending Cost")
+            st.markdown(f"**${pending_cost:,.0f}**")
+            st.caption("Estimated costs not yet confirmed")
+        
+        # Charts section
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            self.render_task_progress_chart()
+        
+        with col2:
+            self.render_guest_rsvp_chart()
+        
+        # Upcoming payments
+        self.render_upcoming_payments()
+        
+        # Food choices section
+        self.render_food_choices_by_event()
+        
+        # Upcoming tasks
+        self.render_upcoming_tasks()
+    
+    def render_countdown_card(self, wedding_info):
+        st.markdown("""
+        <div class="metric-card">
+            <h3>⏰ Wedding Countdown</h3>
+        """, unsafe_allow_html=True)
+        
+        wedding_start_str = wedding_info.get('wedding_start_date', '')
+        wedding_end_str = wedding_info.get('wedding_end_date', '')
+        
+        if wedding_start_str and wedding_end_str:
+            try:
+                wedding_start = datetime.fromisoformat(wedding_start_str).date()
+                wedding_end = datetime.fromisoformat(wedding_end_str).date()
+                today = date.today()
+                
+                if today < wedding_start:
+                    days_until = (wedding_start - today).days
+                    st.markdown(f"<h1 style='margin: 0;'>{days_until}</h1>", unsafe_allow_html=True)
+                    if days_until == 0:
+                        st.markdown("<p style='margin: 0;'>Festivities begin today! 🎉</p>", unsafe_allow_html=True)
+                    elif days_until == 1:
+                        st.markdown("<p style='margin: 0;'>Festivities begin tomorrow! 🎊</p>", unsafe_allow_html=True)
+                    elif days_until <= 7:
+                        st.markdown("<p style='margin: 0;'>Festivities begin this week! ⚡</p>", unsafe_allow_html=True)
+                    else:
+                        st.markdown("<p style='margin: 0;'>days until festivities begin</p>", unsafe_allow_html=True)
+                elif wedding_start <= today <= wedding_end:
+                    days_remaining = (wedding_end - today).days + 1
+                    st.markdown(f"<h1 style='margin: 0;'>{days_remaining}</h1>", unsafe_allow_html=True)
+                    st.markdown("<p style='margin: 0;'>days of festivities remaining! 🎉</p>", unsafe_allow_html=True)
+                else:
+                    days_since = (today - wedding_end).days
+                    st.markdown(f"<h1 style='margin: 0;'>{days_since}</h1>", unsafe_allow_html=True)
+                    st.markdown("<p style='margin: 0;'>days since festivities ended</p>", unsafe_allow_html=True)
+            except:
+                st.markdown("<h1 style='margin: 0;'>-</h1>", unsafe_allow_html=True)
+                st.markdown("<p style='margin: 0;'>Dates not set</p>", unsafe_allow_html=True)
+        else:
+            st.markdown("<h1 style='margin: 0;'>-</h1>", unsafe_allow_html=True)
+            st.markdown("<p style='margin: 0;'>Dates not set</p>", unsafe_allow_html=True)
+        
+        st.markdown("</div>", unsafe_allow_html=True)
+    
+    def render_guest_count_card(self):
+        st.markdown("""
+        <div class="metric-card">
+            <h3>👥 Confirmed Guests</h3>
+        """, unsafe_allow_html=True)
+        
+        # Load RSVP data to get confirmed guests
+        rsvp_data = self.config_manager.load_json_data('rsvp_data.json')
+        confirmed_guests = 0
+        
+        # Handle case where rsvp_data is a list (empty file) instead of dict
+        if isinstance(rsvp_data, list):
+            rsvp_data = {}
+        
+        for group_code, group_data in rsvp_data.items():
+            overall_rsvp = group_data.get('overall_rsvp', '')
+            if overall_rsvp == 'Yes':
+                # Count the number of attendees for this group
+                group_attendees = group_data.get('group_attendees', [])
+                confirmed_guests += len(group_attendees)
+        
+        st.markdown(f"<h1 style='margin: 0;'>{confirmed_guests}</h1>", unsafe_allow_html=True)
+        st.markdown("<p style='margin: 0;'>confirmed attending</p>", unsafe_allow_html=True)
+        
+        st.markdown("</div>", unsafe_allow_html=True)
+    
+    def render_task_progress_card(self):
+        st.markdown("""
+        <div class="metric-card">
+            <h3>✅ Task Progress</h3>
+        """, unsafe_allow_html=True)
+        
+        tasks = self.config_manager.load_json_data('tasks.json')
+        if tasks:
+            completed = len([task for task in tasks if task.get('completed', False)])
+            total = len(tasks)
+            percentage = int((completed / total) * 100) if total > 0 else 0
+            
+            st.markdown(f"<h1 style='margin: 0;'>{percentage}%</h1>", unsafe_allow_html=True)
+            st.markdown(f"<p style='margin: 0;'>{completed}/{total} completed</p>", unsafe_allow_html=True)
+        else:
+            st.markdown("<h1 style='margin: 0;'>0%</h1>", unsafe_allow_html=True)
+            st.markdown("<p style='margin: 0;'>No tasks yet</p>", unsafe_allow_html=True)
+        
+        st.markdown("</div>", unsafe_allow_html=True)
+    
+    def render_budget_card(self):
+        st.markdown("""
+        <div class="metric-card">
+            <h3>💰 Wedding Budget</h3>
+        """, unsafe_allow_html=True)
+        
+        # Calculate both actualized and estimated costs from vendor data
+        vendors = self.config_manager.load_json_data('vendors.json')
+        total_estimated_cost = 0
+        total_actualized_cost = self.calculate_actualized_cost(vendors)
+        total_paid = 0
+        
+        for vendor in vendors:
+            # Use total_cost field (newer format) or cost field (legacy format)
+            cost = vendor.get('total_cost', vendor.get('cost', 0))
+            
+            # Calculate total paid from payment history instead of just deposit_paid
+            payment_history = vendor.get('payment_history', [])
+            total_paid_from_history = sum(payment.get('amount', 0) for payment in payment_history if payment.get('type') != 'credit')
+            total_credits_from_history = sum(payment.get('amount', 0) for payment in payment_history if payment.get('type') == 'credit')
+            net_paid = total_paid_from_history - total_credits_from_history
+            
+            total_estimated_cost += cost
+            total_paid += net_paid
+        
+        pending_cost = total_estimated_cost - total_actualized_cost
+        actualized_remaining = total_actualized_cost - total_paid
+        estimated_remaining = total_estimated_cost - total_paid
+        
+        st.markdown(f"<h1 style='margin: 0;'>${total_actualized_cost:,.0f}</h1>", unsafe_allow_html=True)
+        st.markdown(f"<p style='margin: 0; color: #666;'>${total_estimated_cost:,.0f} estimated total</p>", unsafe_allow_html=True)
+        st.markdown(f"<p style='margin: 0;'>${total_paid:,.0f} paid</p>", unsafe_allow_html=True)
+        st.markdown(f"<p style='margin: 0; color: #d32f2f;'>${actualized_remaining:,.0f} confirmed remaining</p>", unsafe_allow_html=True)
+        
+        st.markdown("</div>", unsafe_allow_html=True)
+    
+    
+    def render_task_progress_chart(self):
+        st.markdown("### Tasks by Event/Category")
+        
+        tasks = self.config_manager.load_json_data('tasks.json')
+        if tasks:
+            # Group tasks by category
+            categories = {}
+            for task in tasks:
+                category = task.get('group', 'Uncategorized')
+                if category not in categories:
+                    categories[category] = {'completed': 0, 'not_completed': 0}
+                if task.get('completed', False):
+                    categories[category]['completed'] += 1
+                else:
+                    categories[category]['not_completed'] += 1
+            
+            # Create data for stacked bar chart
+            category_names = list(categories.keys())
+            completed_counts = [categories[cat]['completed'] for cat in category_names]
+            not_completed_counts = [categories[cat]['not_completed'] for cat in category_names]
+            
+            if category_names:
+                fig = go.Figure(data=[
+                    go.Bar(name='Completed', x=category_names, y=completed_counts, marker_color='#4a7c59'),
+                    go.Bar(name='Not Completed', x=category_names, y=not_completed_counts, marker_color='#d32f2f')
+                ])
+                
+                fig.update_layout(
+                    title="Number of Tasks by Event/Category",
+                    barmode='stack',
+                    xaxis_tickangle=-45,
+                    height=400,
+                    yaxis=dict(tickmode='linear', dtick=1)  # Show whole numbers only
+                )
+                st.plotly_chart(fig, use_container_width=True)
+            else:
+                st.info("No tasks to display")
+        else:
+            st.info("No tasks created yet")
+    
+    def _create_comprehensive_guest_list(self):
+        """Create a comprehensive list of all guests with RSVP data - same logic as guest management"""
+        all_guests = []
+        
+        # Load guest list and RSVP data
+        guest_list_data = self.config_manager.load_json_data('guest_list_data.json')
+        rsvp_data = self.config_manager.load_json_data('rsvp_data.json')
+        
+        # Handle case where rsvp_data is a list (empty file) instead of dict
+        if isinstance(rsvp_data, list):
+            rsvp_data = {}
+        
+        if not guest_list_data:
+            return all_guests
+        
+        for group_name, group_data in guest_list_data.items():
+            # Get RSVP data for this group
+            group_rsvp_data = rsvp_data.get(group_name, {}) if rsvp_data else {}
+            
+            # Add named guests
+            for named_guest in group_data['named_guests']:
+                guest = {
+                    'display_name': named_guest['full_name'],
+                    'first_name': named_guest['first_name'],
+                    'last_name': named_guest['last_name'],
+                    'group_name': group_name,
+                    'party': group_data['party'],
+                    'address': group_data['address'],
+                    'type': 'Named Guest',
+                    'phone': group_rsvp_data.get('phone_number', ''),
+                    'rsvp_by_event': {},
+                    'meal_selections': {}
+                }
+                
+                # Apply RSVP data
+                self._apply_rsvp_to_guest(guest, group_rsvp_data)
+                all_guests.append(guest)
+            
+            # Add plus one spots
+            plus_one_spots = group_data['plus_one_spots']
+            if plus_one_spots > 0:
+                # Get plus one names from RSVP data
+                group_attendees = group_rsvp_data.get('group_attendees', [])
+                named_guest_names = [g['full_name'] for g in group_data['named_guests']]
+                
+                # Find plus one names (attendees not in named guests)
+                plus_one_names = [name for name in group_attendees if name not in named_guest_names]
+                
+                # Create plus one entries
+                for i in range(plus_one_spots):
+                    if i < len(plus_one_names):
+                        # Named plus one
+                        plus_one_name = plus_one_names[i]
+                        guest = {
+                            'display_name': plus_one_name,
+                            'first_name': plus_one_name.split()[0] if plus_one_name.split() else plus_one_name,
+                            'last_name': ' '.join(plus_one_name.split()[1:]) if len(plus_one_name.split()) > 1 else '',
+                            'group_name': group_name,
+                            'party': group_data['party'],
+                            'address': group_data['address'],
+                            'type': 'Plus One (Named)',
+                            'phone': '',
+                            'rsvp_by_event': {},
+                            'meal_selections': {}
+                        }
+                    else:
+                        # Unnamed plus one
+                        guest = {
+                            'display_name': f'Unnamed Plus One {i+1}',
+                            'first_name': '',
+                            'last_name': '',
+                            'group_name': group_name,
+                            'party': group_data['party'],
+                            'address': group_data['address'],
+                            'type': 'Plus One (Unnamed)',
+                            'phone': '',
+                            'rsvp_by_event': {},
+                            'meal_selections': {}
+                        }
+                    
+                    # Apply RSVP data
+                    self._apply_rsvp_to_guest(guest, group_rsvp_data)
+                    all_guests.append(guest)
+        
+        return all_guests
+    
+    def _apply_rsvp_to_guest(self, guest, rsvp_data):
+        """Apply RSVP data to a guest - same logic as guest management"""
+        config = self.config_manager.load_config()
+        wedding_events = config.get('wedding_events', [])
+        
+        # Initialize all events with "Pending" status
+        for event in wedding_events:
+            event_name = event.get('name', '')
+            if event_name:
+                guest['rsvp_by_event'][event_name] = 'Pending'
+        
+        if not rsvp_data:
+            return
+        
+        event_responses = rsvp_data.get('event_responses', {})
+        group_attendees = rsvp_data.get('group_attendees', [])
+        dietary_restrictions = rsvp_data.get('dietary_restrictions', {})
+        
+        guest_name = guest['display_name']
+        
+        # Apply dietary restrictions
+        if guest_name in dietary_restrictions:
+            guest['allergies'] = dietary_restrictions[guest_name]
+        
+        # Apply event responses
+        for event in wedding_events:
+            event_name = event.get('name', '')
+            if event_name in event_responses:
+                event_data = event_responses[event_name]
+                attendees = event_data.get('attendees', [])
+                party_rsvp = event_data.get('rsvp', 'Pending')
+                
+                # Determine individual RSVP status
+                if guest_name in attendees:
+                    guest['rsvp_by_event'][event_name] = party_rsvp
+                    
+                    # Apply meal choice if attending and event requires meal choice
+                    if party_rsvp == 'Yes' and event.get('requires_meal_choice', False):
+                        meal_choice = event_data.get('meal_choice', {})
+                        if guest_name in meal_choice:
+                            guest['meal_selections'][event_name] = meal_choice[guest_name]
+                else:
+                    guest['rsvp_by_event'][event_name] = 'No'
+    
+    def render_guest_rsvp_chart(self):
+        st.markdown("### Attendance by Event")
+        
+        # Get comprehensive guest list using the same logic as guest management
+        all_guests = self._create_comprehensive_guest_list()
+        
+        if all_guests:
+            # Get event names from wedding config
+            config = self.config_manager.load_config()
+            events = [event['name'] for event in config.get('wedding_events', [])]
+            
+            # Count attendance for each event
+            event_attendance = {}
+            for event in events:
+                event_attendance[event] = {'Yes': 0, 'No': 0, 'Pending': 0}
+            
+            # Count attendance for each guest
+            for guest in all_guests:
+                rsvp_by_event = guest.get('rsvp_by_event', {})
+                for event_name in event_attendance.keys():
+                    rsvp_status = rsvp_by_event.get(event_name, 'Pending')
+                    if rsvp_status in event_attendance[event_name]:
+                        event_attendance[event_name][rsvp_status] += 1
+                    else:
+                        event_attendance[event_name]['Pending'] += 1
+            
+            # Create bar chart showing attendance by event
+            event_names = list(event_attendance.keys())
+            yes_counts = [event_attendance[event]['Yes'] for event in event_names]
+            no_counts = [event_attendance[event]['No'] for event in event_names]
+            pending_counts = [event_attendance[event]['Pending'] for event in event_names]
+            
+            fig = go.Figure(data=[
+                go.Bar(name='Yes', x=event_names, y=yes_counts, marker_color='#4a7c59'),
+                go.Bar(name='No', x=event_names, y=no_counts, marker_color='#d32f2f'),
+                go.Bar(name='Pending', x=event_names, y=pending_counts, marker_color='#ffa726')
+            ])
+            
+            # Calculate the maximum value across all events for better y-axis scaling
+            max_value = max(max(yes_counts), max(no_counts), max(pending_counts))
+            # Add some padding to the max value for better visualization
+            y_max = max_value + 2 if max_value > 0 else 10
+            
+            # Calculate appropriate tick spacing based on the max value
+            if y_max <= 10:
+                tick_spacing = 2
+            elif y_max <= 20:
+                tick_spacing = 5
+            elif y_max <= 50:
+                tick_spacing = 10
+            else:
+                tick_spacing = 20
+            
+            fig.update_layout(
+                title="RSVP Responses by Event",
+                barmode='stack',
+                xaxis_tickangle=-45,
+                height=400,
+                yaxis=dict(
+                    tickmode='linear', 
+                    dtick=tick_spacing,  # Show ticks at appropriate intervals
+                    range=[0, y_max]  # Set max based on actual data
+                )
+            )
+            st.plotly_chart(fig, use_container_width=True)
+        else:
+            st.info("No guest data available yet")
+    
+    def render_food_choices_by_event(self):
+        st.markdown("### 🍽️ Food Choices by Event")
+        
+        # Load data
+        rsvp_data = self.config_manager.load_json_data('rsvp_data.json')
+        
+        # Handle case where rsvp_data is a list (empty file) instead of dict
+        if isinstance(rsvp_data, list):
+            rsvp_data = {}
+        
+        config = self.config_manager.load_config()
+        events = config.get('wedding_events', [])
+        
+        if not rsvp_data:
+            st.info("No RSVP data available yet")
+            return
+        
+        # Filter events that require meal choices
+        meal_events = [event for event in events if event.get('requires_meal_choice', False)]
+        
+        if not meal_events:
+            st.info("No events require meal choices.")
+            return
+        
+        for event in meal_events:
+            event_name = event['name']
+            meal_options = event.get('meal_options', [])
+            
+            if meal_options:
+                st.markdown(f"**{event_name}**")
+                
+                # Count meal choices for this event
+                meal_counts = {option: 0 for option in meal_options}
+                meal_counts['Not Selected'] = 0
+                outdated_choices = {}
+                
+                for group_code, group_data in rsvp_data.items():
+                    # Check if this group is attending this event
+                    event_responses = group_data.get('event_responses', {})
+                    if event_name in event_responses:
+                        event_rsvp = event_responses[event_name].get('rsvp', '')
+                        if event_rsvp == 'Yes':
+                            attendees = event_responses[event_name].get('attendees', [])
+                            
+                            # Get meal selections for each attendee from the event response
+                            meal_choices = event_responses[event_name].get('meal_choice', {})
+                            for attendee in attendees:
+                                selected_meal = meal_choices.get(attendee, 'Not Selected')
+                                if selected_meal in meal_counts:
+                                    meal_counts[selected_meal] += 1
+                                elif selected_meal != 'Not Selected':
+                                    # This is an outdated meal choice
+                                    if selected_meal not in outdated_choices:
+                                        outdated_choices[selected_meal] = []
+                                    outdated_choices[selected_meal].append(attendee)
+                                else:
+                                    meal_counts['Not Selected'] += 1
+                
+                # Display meal choice counts
+                col1, col2, col3, col4 = st.columns(4)
+                cols = [col1, col2, col3, col4]
+                
+                for i, (meal, count) in enumerate(meal_counts.items()):
+                    if i < len(cols):
+                        with cols[i]:
+                            st.metric(meal, count)
+                
+                # Show outdated meal choices warning
+                if outdated_choices:
+                    st.warning("⚠️ **Outdated Meal Choices Detected!**")
+                    st.markdown("The following guests selected meal options that are no longer available on the current menu:")
+                    
+                    for outdated_meal, guests in outdated_choices.items():
+                        with st.expander(f"🔍 {outdated_meal} ({len(guests)} guests)", expanded=False):
+                            st.markdown("**Guests who selected this outdated option:**")
+                            
+                            # Create a table for better formatting
+                            guest_data = []
+                            for guest_name in guests:
+                                # Find the group for this guest to get contact info
+                                guest_group = None
+                                for group_code, group_data in rsvp_data.items():
+                                    if guest_name in group_data.get('group_attendees', []):
+                                        guest_group = group_data
+                                        break
+                                
+                                # Get phone number
+                                phone = 'No phone provided'
+                                if guest_group:
+                                    phone_number = guest_group.get('phone_number', '')
+                                    if phone_number and phone_number.strip() and phone_number != 'No phone provided':
+                                        phone = phone_number
+                                
+                                guest_data.append({
+                                    'Name': guest_name,
+                                    'Phone': phone
+                                })
+                            
+                            if guest_data:
+                                guest_df = pd.DataFrame(guest_data)
+                                st.dataframe(guest_df, use_container_width=True, hide_index=True)
+                            
+                            st.markdown("**Action Required:**")
+                            st.markdown(f"Please contact these {len(guests)} guests to update their meal choice from '{outdated_meal}' to one of the current options: {', '.join(meal_options)}")
+                
+                st.markdown("---")  # Separator between events
+    
+    def render_upcoming_tasks(self):
+        st.markdown("### Upcoming Tasks (Next 7 Days)")
+        
+        tasks = self.config_manager.load_json_data('tasks.json')
+        vendors = self.config_manager.load_json_data('vendors.json')
+        
+        # Create a vendor lookup dictionary for quick access
+        vendor_lookup = {}
+        if vendors:
+            for vendor in vendors:
+                vendor_lookup[vendor.get('id', '')] = vendor.get('name', '')
+        
+        if tasks:
+            # Filter incomplete tasks and sort by due date
+            incomplete_tasks = [task for task in tasks if not task.get('completed', False)]
+            incomplete_tasks.sort(key=lambda x: x.get('due_date') or '9999-12-31')
+            
+            # Filter tasks within the next 7 days
+            today = date.today()
+            week_from_now = date(today.year, today.month, today.day + 7)
+            
+            upcoming_tasks = []
+            for task in incomplete_tasks:
+                due_date_str = task.get('due_date', '')
+                if due_date_str:
+                    try:
+                        due_date = datetime.fromisoformat(due_date_str).date()
+                        if today <= due_date <= week_from_now:
+                            upcoming_tasks.append(task)
+                    except:
+                        # If date parsing fails, skip the task (don't include it)
+                        continue
+                # If no due date, skip the task (don't include it)
+            
+            if upcoming_tasks:
+                for i, task in enumerate(upcoming_tasks):
+                    with st.container():
+                        # Task header with completion status and title
+                        title = task.get('title', 'Untitled Task')
+                        completed = task.get('completed', False)
+                        status_icon = "✅" if completed else "⏳"
+                        
+                        # Check if task is associated with a vendor
+                        vendor_id = task.get('vendor_id', '')
+                        vendor_name = vendor_lookup.get(vendor_id, '')
+                        
+                        if vendor_name:
+                            st.markdown(f"**{status_icon} {title}** - *{vendor_name}*")
+                        else:
+                            st.markdown(f"**{status_icon} {title}**")
+                        
+                        # Task details in columns
+                        col1, col2, col3, col4 = st.columns(4)
+                        
+                        with col1:
+                            due_date = task.get('due_date', '')
+                            if due_date:
+                                st.caption(f"📅 Due: {due_date}")
+                            else:
+                                st.caption("📅 No due date")
+                        
+                        with col2:
+                            group = task.get('group', 'Uncategorized')
+                            st.caption(f"📁 Group: {group}")
+                        
+                        with col3:
+                            priority = task.get('priority', 'Medium')
+                            # Priority with color coding
+                            if priority == "Urgent":
+                                st.caption(f"🔴 Priority: {priority}")
+                            elif priority == "High":
+                                st.caption(f"🔴 Priority: {priority}")
+                            elif priority == "Medium":
+                                st.caption(f"🟡 Priority: {priority}")
+                            else:
+                                st.caption(f"🟢 Priority: {priority}")
+                        
+                        with col4:
+                            assigned_to = task.get('assigned_to', '')
+                            # Handle both old single assignee and new multiple assignees format
+                            if isinstance(assigned_to, str):
+                                assigned_to_display = assigned_to if assigned_to else "Unassigned"
+                            elif isinstance(assigned_to, list):
+                                if assigned_to:
+                                    assigned_to_display = ", ".join(assigned_to)
+                                else:
+                                    assigned_to_display = "Unassigned"
+                            else:
+                                assigned_to_display = "Unassigned"
+                            
+                            if assigned_to_display and assigned_to_display != "Unassigned":
+                                st.caption(f"👤 Assigned: {assigned_to_display}")
+                            else:
+                                st.caption("👤 Unassigned")
+                        
+                        # Add some spacing
+                        st.markdown("---")
+            else:
+                st.info("No tasks due within the next 7 days")
+        else:
+            st.info("No tasks created yet")
+    
+    def render_upcoming_payments(self):
+        st.markdown("### 💳 Upcoming Payments (Next 30 Days)")
+        
+        # Create VendorManager instance to use its payment logic
+        vendor_manager = VendorManager()
+        
+        # Load vendors data
+        vendors = self.config_manager.load_json_data('vendors.json')
+        
+        if not vendors:
+            st.info("No vendors added yet")
+            return
+        
+        # Get upcoming payments using the same logic as the vendors page
+        upcoming_payments = []
+        today = date.today()
+        
+        for vendor in vendors:
+            payment_installments = vendor.get('payment_installments', [])
+            
+            if payment_installments and len(payment_installments) > 1:
+                # Handle installments
+                for i, installment in enumerate(payment_installments):
+                    if not installment.get('paid', False):
+                        due_date_str = installment.get('due_date', '')
+                        if due_date_str:
+                            try:
+                                due_date = datetime.fromisoformat(due_date_str).date()
+                                days_until_due = (due_date - today).days
+                                
+                                # Only show if within next 30 days
+                                if 0 <= days_until_due <= 30:
+                                    upcoming_payments.append({
+                                        'vendor_name': vendor.get('name', ''),
+                                        'installment_num': i + 1,
+                                        'amount': installment.get('amount', 0),
+                                        'due_date': due_date,
+                                        'days_until': days_until_due,
+                                        'is_installment': True
+                                    })
+                            except:
+                                continue
+            else:
+                # Handle single payment
+                payment_due_date_str = vendor.get('payment_due_date')
+                if payment_due_date_str:
+                    try:
+                        due_date = datetime.fromisoformat(payment_due_date_str).date()
+                        days_until_due = (due_date - today).days
+                        
+                        # Only show if not fully paid and within next 30 days
+                        total_cost = vendor.get('total_cost', vendor.get('cost', 0))
+                        payment_history = vendor.get('payment_history', [])
+                        total_paid_from_history = sum(payment.get('amount', 0) for payment in payment_history if payment.get('type') != 'credit')
+                        total_credits_from_history = sum(payment.get('amount', 0) for payment in payment_history if payment.get('type') == 'credit')
+                        remaining_balance = total_cost - total_paid_from_history + total_credits_from_history
+                        
+                        if remaining_balance > 0 and 0 <= days_until_due <= 30:
+                            upcoming_payments.append({
+                                'vendor_name': vendor.get('name', ''),
+                                'installment_num': None,
+                                'amount': remaining_balance,
+                                'due_date': due_date,
+                                'days_until': days_until_due,
+                                'is_installment': False
+                            })
+                    except:
+                        continue
+        
+        # Sort by days until due
+        upcoming_payments.sort(key=lambda x: x['days_until'])
+        
+        if upcoming_payments:
+            # Create table data
+            table_data = []
+            for payment in upcoming_payments:
+                # Format payment description
+                if payment['is_installment']:
+                    payment_desc = f"{payment['vendor_name']} - Installment {payment['installment_num']}"
+                else:
+                    payment_desc = f"{payment['vendor_name']} - Final Payment"
+                
+                # Format due date
+                if payment['days_until'] == 0:
+                    due_text = "🟠 Today"
+                elif payment['days_until'] == 1:
+                    due_text = "🟡 Tomorrow"
+                elif payment['days_until'] <= 3:
+                    due_text = f"🟡 {payment['days_until']} days"
+                else:
+                    due_text = f"🟢 {payment['days_until']} days"
+                
+                table_data.append({
+                    'Vendor & Payment': payment_desc,
+                    'Amount': f"${payment['amount']:,.0f}",
+                    'Due': due_text
+                })
+            
+            # Create and display the table
+            df = pd.DataFrame(table_data)
+            st.dataframe(df, use_container_width=True, hide_index=True)
+        else:
+            st.info("No payments due within the next 30 days")

google_drive_manager.py

@@ -0,0 +1,230 @@
+import os
+import json
+import tempfile
+from typing import Dict, List, Optional, Any
+from google.oauth2 import service_account
+from google.oauth2.credentials import Credentials
+from googleapiclient.discovery import build
+from googleapiclient.errors import HttpError
+import streamlit as st
+
+class GoogleDriveManager:
+    def __init__(self):
+        self.service = None
+        self.folder_id = None
+        self.is_huggingface = os.getenv('SPACE_ID') is not None
+        self.temp_dir = "/tmp/wedding_data" if self.is_huggingface else "temp_data"
+        
+        # Ensure temp directory exists
+        os.makedirs(self.temp_dir, exist_ok=True)
+        
+    def initialize(self, folder_id: str = None):
+        """Initialize Google Drive service and set folder ID"""
+        try:
+            if self.is_huggingface:
+                self._setup_huggingface_auth()
+            else:
+                self._setup_local_auth()
+            
+            if folder_id:
+                self.folder_id = folder_id
+            else:
+                # Try to get folder ID from environment
+                self.folder_id = os.getenv('GOOGLE_DRIVE_FOLDER_ID')
+            
+            if not self.folder_id:
+                st.error("Google Drive folder ID not found. Please set GOOGLE_DRIVE_FOLDER_ID environment variable.")
+                return False
+                
+            return True
+        except Exception as e:
+            st.error(f"Failed to initialize Google Drive: {str(e)}")
+            return False
+    
+    def _setup_huggingface_auth(self):
+        """Set up authentication for Hugging Face Spaces"""
+        # For Hugging Face, we'll use service account credentials
+        # stored as environment variables
+        service_account_info = {
+            "type": "service_account",
+            "project_id": os.getenv('GOOGLE_PROJECT_ID'),
+            "private_key_id": os.getenv('GOOGLE_PRIVATE_KEY_ID'),
+            "private_key": os.getenv('GOOGLE_PRIVATE_KEY', '').replace('\\n', '\n'),
+            "client_email": os.getenv('GOOGLE_CLIENT_EMAIL'),
+            "client_id": os.getenv('GOOGLE_CLIENT_ID'),
+            "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+            "token_uri": "https://oauth2.googleapis.com/token",
+            "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+            "client_x509_cert_url": f"https://www.googleapis.com/robot/v1/metadata/x509/{os.getenv('GOOGLE_CLIENT_EMAIL')}"
+        }
+        
+        # Validate that all required fields are present
+        required_fields = ['project_id', 'private_key_id', 'private_key', 'client_email', 'client_id']
+        missing_fields = [field for field in required_fields if not service_account_info.get(field)]
+        
+        if missing_fields:
+            raise ValueError(f"Missing Google service account credentials: {missing_fields}")
+        
+        credentials = service_account.Credentials.from_service_account_info(
+            service_account_info,
+            scopes=['https://www.googleapis.com/auth/drive']
+        )
+        
+        self.service = build('drive', 'v3', credentials=credentials)
+    
+    def _setup_local_auth(self):
+        """Set up authentication for local development"""
+        # For local development, you can use OAuth or service account
+        # This is a simplified version - you might want to implement OAuth flow
+        service_account_path = os.getenv('GOOGLE_SERVICE_ACCOUNT_PATH')
+        
+        if service_account_path and os.path.exists(service_account_path):
+            credentials = service_account.Credentials.from_service_account_file(
+                service_account_path,
+                scopes=['https://www.googleapis.com/auth/drive']
+            )
+            self.service = build('drive', 'v3', credentials=credentials)
+        else:
+            st.warning("Google service account file not found. Using local data only.")
+            self.service = None
+    
+    def list_files(self) -> List[Dict[str, Any]]:
+        """List all files in the Google Drive folder"""
+        if not self.service or not self.folder_id:
+            return []
+        
+        try:
+            query = f"'{self.folder_id}' in parents and trashed=false"
+            results = self.service.files().list(
+                q=query,
+                fields="files(id, name, modifiedTime, size)"
+            ).execute()
+            
+            return results.get('files', [])
+        except HttpError as e:
+            st.error(f"Error listing files: {str(e)}")
+            return []
+    
+    def download_file(self, file_name: str) -> Optional[Dict[str, Any]]:
+        """Download a file from Google Drive and return its content"""
+        if not self.service or not self.folder_id:
+            return None
+        
+        try:
+            # Find the file
+            query = f"name='{file_name}' and '{self.folder_id}' in parents and trashed=false"
+            results = self.service.files().list(q=query).execute()
+            files = results.get('files', [])
+            
+            if not files:
+                st.warning(f"File '{file_name}' not found in Google Drive")
+                return None
+            
+            file_id = files[0]['id']
+            
+            # Download file content
+            request = self.service.files().get_media(fileId=file_id)
+            content = request.execute()
+            
+            # Try to parse as JSON
+            try:
+                return json.loads(content.decode('utf-8'))
+            except json.JSONDecodeError:
+                # If not JSON, return as string
+                return content.decode('utf-8')
+                
+        except HttpError as e:
+            st.error(f"Error downloading file '{file_name}': {str(e)}")
+            return None
+    
+    def upload_file(self, file_name: str, content: Any) -> bool:
+        """Upload a file to Google Drive"""
+        if not self.service or not self.folder_id:
+            return False
+        
+        try:
+            # Convert content to JSON string if it's a dict/list
+            if isinstance(content, (dict, list)):
+                content_str = json.dumps(content, indent=2)
+            else:
+                content_str = str(content)
+            
+            # Check if file already exists
+            query = f"name='{file_name}' and '{self.folder_id}' in parents and trashed=false"
+            results = self.service.files().list(q=query).execute()
+            existing_files = results.get('files', [])
+            
+            if existing_files:
+                # Update existing file
+                file_id = existing_files[0]['id']
+                media_body = self.service.files().update(
+                    fileId=file_id,
+                    media_body=content_str.encode('utf-8')
+                ).execute()
+            else:
+                # Create new file
+                file_metadata = {
+                    'name': file_name,
+                    'parents': [self.folder_id]
+                }
+                media_body = self.service.files().create(
+                    body=file_metadata,
+                    media_body=content_str.encode('utf-8')
+                ).execute()
+            
+            return True
+            
+        except HttpError as e:
+            st.error(f"Error uploading file '{file_name}': {str(e)}")
+            return False
+    
+    def sync_from_drive(self, file_names: List[str]) -> Dict[str, Any]:
+        """Download multiple files from Google Drive"""
+        synced_files = {}
+        
+        for file_name in file_names:
+            content = self.download_file(file_name)
+            if content is not None:
+                synced_files[file_name] = content
+                # Save to local temp directory
+                local_path = os.path.join(self.temp_dir, file_name)
+                with open(local_path, 'w') as f:
+                    if isinstance(content, (dict, list)):
+                        json.dump(content, f, indent=2)
+                    else:
+                        f.write(str(content))
+        
+        return synced_files
+    
+    def sync_to_drive(self, file_names: List[str], local_data: Dict[str, Any]) -> bool:
+        """Upload multiple files to Google Drive"""
+        success = True
+        
+        for file_name in file_names:
+            if file_name in local_data:
+                if not self.upload_file(file_name, local_data[file_name]):
+                    success = False
+        
+        return success
+    
+    def get_file_info(self, file_name: str) -> Optional[Dict[str, Any]]:
+        """Get metadata for a specific file"""
+        if not self.service or not self.folder_id:
+            return None
+        
+        try:
+            query = f"name='{file_name}' and '{self.folder_id}' in parents and trashed=false"
+            results = self.service.files().list(q=query).execute()
+            files = results.get('files', [])
+            
+            if files:
+                return files[0]
+            return None
+            
+        except HttpError as e:
+            st.error(f"Error getting file info for '{file_name}': {str(e)}")
+            return None
+    
+    def is_online(self) -> bool:
+        """Check if Google Drive service is available"""
+        return self.service is not None and self.folder_id is not None

requirements.txt

@@ -0,0 +1,10 @@
+streamlit==1.28.1
+pandas==2.1.3
+plotly==5.17.0
+datetime
+json5==0.9.14
+openpyxl==3.1.2
+google-api-python-client>=2.0.0
+google-auth-httplib2>=0.1.0
+google-auth-oauthlib>=0.5.0
+google-auth>=2.0.0

tasks.py

@@ -0,0 +1,665 @@
+import streamlit as st
+import json
+import html
+from datetime import datetime, date
+from config_manager import ConfigManager
+
+class TasksManager:
+    def __init__(self):
+        self.config_manager = ConfigManager()
+        self.vendors_cache = None
+    
+    def get_vendor_name(self, vendor_id):
+        """Get vendor name by vendor ID"""
+        if not self.vendors_cache or not vendor_id:
+            return None
+        
+        for vendor in self.vendors_cache:
+            if vendor.get('id') == vendor_id:
+                return vendor.get('name')
+        return None
+    
+    def get_vendor_contact_info(self, vendor_id):
+        """Get vendor contact information by vendor ID"""
+        if not self.vendors_cache or not vendor_id:
+            return None
+        
+        for vendor in self.vendors_cache:
+            if vendor.get('id') == vendor_id:
+                vendor_type = vendor.get('type', 'Vendor/Service')
+                
+                if vendor_type == 'Vendor/Service':
+                    # For vendors, return their contact information
+                    return {
+                        'contact_person': vendor.get('contact_person', ''),
+                        'phone': vendor.get('phone', ''),
+                        'email': vendor.get('email', ''),
+                        'website': vendor.get('website', ''),
+                        'address': vendor.get('address', '')
+                    }
+                else:
+                    # For items, return seller contact information
+                    return {
+                        'contact_person': '',  # Items don't have contact person
+                        'phone': vendor.get('seller_phone', ''),
+                        'email': vendor.get('seller_email', ''),
+                        'website': vendor.get('seller_website', ''),
+                        'address': ''  # Items don't have address
+                    }
+        return None
+    
+    def render(self, config):
+        st.markdown("## ✅ Task Management")
+        
+        # Load tasks and vendors
+        tasks = self.config_manager.load_json_data('tasks.json')
+        self.vendors_cache = self.config_manager.load_json_data('vendors.json')
+        custom_settings = config.get('custom_settings', {})
+        custom_tags = custom_settings.get('custom_tags', [])
+        
+        # Get event-based task groups
+        wedding_events = config.get('wedding_events', [])
+        event_names = [event['name'] for event in wedding_events] if wedding_events else []
+        
+        # Add general planning categories
+        task_groups = event_names + ['General Planning', 'Vendor Management', 'Vendor & Item Management', 'Wedding Party', 'Guest Management', 'Timeline']
+        
+        # Task creation section
+        with st.expander("➕ Add New Task", expanded=False):
+            self.render_task_form(task_groups, custom_tags)
+        
+        # View toggle and filters
+        col1, col2, col3, col4, col5 = st.columns(5)
+        
+        with col1:
+            view_mode = st.radio("View Mode", ["Detailed View", "Checklist View"], horizontal=True)
+        
+        with col2:
+            filter_group = st.selectbox("Filter by Group", ["All"] + task_groups)
+        
+        with col3:
+            filter_status = st.selectbox("Filter by Status", ["All", "Completed", "Incomplete"])
+        
+        with col4:
+            # Get unique assignees from tasks (handle both single and multiple assignees)
+            assignees = set()
+            for task in tasks:
+                assigned_to = task.get('assigned_to', '')
+                if isinstance(assigned_to, str) and assigned_to.strip():
+                    assignees.add(assigned_to.strip())
+                elif isinstance(assigned_to, list):
+                    for assignee in assigned_to:
+                        if assignee and assignee.strip():
+                            assignees.add(assignee.strip())
+            assignee_list = sorted(list(assignees))
+            filter_assignees = st.multiselect("Filter by Assignees", assignee_list, help="Select one or more assignees to filter tasks")
+        
+        with col5:
+            sort_by = st.selectbox("Sort by", ["Due Date", "Created Date", "Title", "Group"])
+        
+        # Filter and sort tasks
+        filtered_tasks = self.filter_tasks(tasks, filter_group, filter_status, filter_assignees)
+        sorted_tasks = self.sort_tasks(filtered_tasks, sort_by)
+        
+        # Display tasks based on view mode
+        if sorted_tasks:
+            st.markdown(f"### Tasks ({len(sorted_tasks)} total)")
+            
+            if view_mode == "Checklist View":
+                self.render_checklist_view(sorted_tasks)
+            else:
+                # Group tasks by their group/category for detailed view
+                grouped_tasks = {}
+                for task in sorted_tasks:
+                    group = task.get('group', 'Uncategorized')
+                    if group not in grouped_tasks:
+                        grouped_tasks[group] = []
+                    grouped_tasks[group].append(task)
+                
+                # Display tasks grouped by category
+                for group_name, tasks in grouped_tasks.items():
+                    st.markdown(f"## {group_name} ({len(tasks)} tasks)")
+                    for task in tasks:
+                        self.render_task_card(task, task_groups, custom_tags)
+        else:
+            st.info("No tasks found. Create your first task above!")
+    
+    def render_checklist_view(self, tasks):
+        """Render tasks in a compact checklist format for easy reading"""
+        # Display all tasks in a single checklist without grouping
+        st.markdown("#### All Tasks")
+        
+        # Create a container for the checklist
+        with st.container():
+            for task in tasks:
+                self.render_checklist_item(task)
+    
+    def render_checklist_item(self, task):
+        """Render a single task as a checklist item with interactive checkbox"""
+        task_id = task.get('id', '')
+        title = task.get('title', 'Untitled Task')
+        description = task.get('description', '')
+        due_date = task.get('due_date', '')
+        assigned_to = task.get('assigned_to', '')
+        tags = task.get('tags', [])
+        completed = task.get('completed', False)
+        vendor_id = task.get('vendor_id', '')
+        vendor_name = self.get_vendor_name(vendor_id) if vendor_id else None
+        
+        # Handle both old single assignee and new multiple assignees format
+        if isinstance(assigned_to, str):
+            assigned_to_display = assigned_to if assigned_to else "Unassigned"
+        elif isinstance(assigned_to, list):
+            if assigned_to:
+                assigned_to_display = ", ".join(assigned_to)
+            else:
+                assigned_to_display = "Unassigned"
+        else:
+            assigned_to_display = "Unassigned"
+        
+        # Create a compact checklist item
+        with st.container():
+            # Use a horizontal layout with better spacing
+            col1, col2, col3, col4 = st.columns([0.3, 3.2, 1, 1])
+            
+            with col1:
+                # Interactive checkbox for completion status with label
+                new_completed = st.checkbox(
+                    " ",  # Single space as label to provide spacing
+                    value=completed, 
+                    key=f"checklist_{task_id}",
+                    help="Click to toggle completion status"
+                )
+                
+                # If completion status changed, update the task
+                if new_completed != completed:
+                    self.toggle_task_completion(task_id, new_completed)
+            
+            with col2:
+                # Task title and description with proper spacing
+                if completed:
+                    st.markdown(f"~~**{title}**~~")
+                else:
+                    st.markdown(f"**{title}**")
+                
+                if description:
+                    st.caption(f"📝 {description}")
+                
+                # Display tags if they exist
+                if tags and len(tags) > 0:
+                    st.caption(f"🏷️ {', '.join(tags)}")
+            
+            with col3:
+                # Due date only
+                if due_date:
+                    st.caption(f"📅 {due_date}")
+            
+            with col4:
+                # Assigned to and vendor
+                if assigned_to_display and assigned_to_display != "Unassigned":
+                    st.caption(f"👤 {assigned_to_display}")
+                
+                if vendor_name:
+                    st.caption(f"🏢 {vendor_name}")
+            
+            # Add a subtle separator
+            st.markdown("---")
+    
+    def render_task_form(self, task_groups, custom_tags):
+        with st.form("task_form"):
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                title = st.text_input("Task Title *", placeholder="Enter task title")
+                
+                # Show event-based groups first, then general categories
+                if task_groups:
+                    group = st.selectbox("Event/Category", task_groups, help="Select the wedding event or general category this task relates to")
+                else:
+                    group = st.selectbox("Category", ["General Planning"])
+                
+                due_date = st.date_input("Due Date", value=None)
+                priority = st.selectbox("Priority", ["Low", "Medium", "High", "Urgent"])
+            
+            with col2:
+                description = st.text_area("Description", placeholder="Enter task description")
+                
+                # Assigned to field with wedding party and task assignees selection
+                wedding_party = self.config_manager.load_json_data('wedding_party.json')
+                wedding_party_names = [member.get('name', '') for member in wedding_party if member.get('name')]
+                
+                # Get task assignees from config
+                config = self.config_manager.load_config()
+                custom_settings = config.get('custom_settings', {})
+                task_assignees = custom_settings.get('task_assignees', [])
+                
+                # Create combined options for multiselect
+                all_assignee_options = []
+                if wedding_party_names:
+                    all_assignee_options.extend([f"Wedding Party: {name}" for name in wedding_party_names])
+                if task_assignees:
+                    all_assignee_options.extend([f"Task Assignee: {assignee}" for assignee in task_assignees])
+                
+                # Multiple assignees selection
+                selected_assignees = st.multiselect("Assign to (select multiple people)", all_assignee_options, key="create_assignees")
+                
+                # Custom assignee text input (for additional people not in the lists)
+                custom_assignee = st.text_input("Additional Custom Assignee", placeholder="Enter additional assignee name (optional)", key="create_custom_assignee")
+                
+                # Combine selected assignees and custom assignee
+                assigned_to_list = []
+                for assignee in selected_assignees:
+                    if assignee.startswith("Wedding Party: "):
+                        assigned_to_list.append(assignee.replace("Wedding Party: ", ""))
+                    elif assignee.startswith("Task Assignee: "):
+                        assigned_to_list.append(assignee.replace("Task Assignee: ", ""))
+                
+                if custom_assignee and custom_assignee.strip():
+                    assigned_to_list.append(custom_assignee.strip())
+                
+                # Store as list for multiple assignees
+                assigned_to = assigned_to_list
+            
+            # Tags selection
+            selected_tags = st.multiselect("Tags", custom_tags, default=[])
+            
+            submitted = st.form_submit_button("Create Task", type="primary")
+            
+            if submitted:
+                if title:
+                    new_task = {
+                        'id': datetime.now().strftime("%Y%m%d_%H%M%S"),
+                        'title': title,
+                        'description': description,
+                        'group': group,
+                        'due_date': due_date.isoformat() if due_date else None,
+                        'priority': priority,
+                        'assigned_to': assigned_to,
+                        'tags': selected_tags,
+                        'completed': False,
+                        'created_date': datetime.now().isoformat(),
+                        'completed_date': None
+                    }
+                    
+                    # Load existing tasks and add new one
+                    tasks = self.config_manager.load_json_data('tasks.json')
+                    tasks.append(new_task)
+                    
+                    if self.config_manager.save_json_data('tasks.json', tasks):
+                        st.success("Task created successfully!")
+                        st.rerun()
+                    else:
+                        st.error("Error saving task")
+                else:
+                    st.error("Please enter a task title")
+    
+    def filter_tasks(self, tasks, filter_group, filter_status, filter_assignees):
+        filtered = tasks.copy()
+        
+        # Filter by group
+        if filter_group != "All":
+            filtered = [task for task in filtered if task.get('group') == filter_group]
+        
+        # Filter by status
+        if filter_status == "Completed":
+            filtered = [task for task in filtered if task.get('completed', False)]
+        elif filter_status == "Incomplete":
+            filtered = [task for task in filtered if not task.get('completed', False)]
+        
+        # Filter by assignees (handle both single and multiple assignees)
+        if filter_assignees:  # If any assignees are selected
+            filtered_tasks = []
+            for task in filtered:
+                assigned_to = task.get('assigned_to', '')
+                task_assignees = []
+                
+                # Extract assignees from task (handle both old single and new multiple assignees format)
+                if isinstance(assigned_to, str) and assigned_to.strip():
+                    task_assignees = [assigned_to.strip()]
+                elif isinstance(assigned_to, list):
+                    task_assignees = [assignee.strip() for assignee in assigned_to if assignee and assignee.strip()]
+                
+                # Check if any of the task's assignees match any of the selected filter assignees
+                if any(assignee in filter_assignees for assignee in task_assignees):
+                    filtered_tasks.append(task)
+            
+            filtered = filtered_tasks
+        
+        return filtered
+    
+    def sort_tasks(self, tasks, sort_by):
+        if sort_by == "Due Date":
+            return sorted(tasks, key=lambda x: x.get('due_date') or '9999-12-31')
+        elif sort_by == "Created Date":
+            return sorted(tasks, key=lambda x: x.get('created_date', ''), reverse=True)
+        elif sort_by == "Title":
+            return sorted(tasks, key=lambda x: x.get('title', '').lower())
+        elif sort_by == "Group":
+            return sorted(tasks, key=lambda x: x.get('group', ''))
+        else:
+            return tasks
+    
+    def render_task_card(self, task, task_groups, custom_tags):
+        task_id = task.get('id', '')
+        title = task.get('title', 'Untitled Task')
+        description = task.get('description', '')
+        group = task.get('group', 'Uncategorized')
+        due_date = task.get('due_date', '')
+        priority = task.get('priority', 'Medium')
+        assigned_to = task.get('assigned_to', '')
+        tags = task.get('tags', [])
+        completed = task.get('completed', False)
+        vendor_id = task.get('vendor_id', '')
+        vendor_name = self.get_vendor_name(vendor_id) if vendor_id else None
+        vendor_contact_info = self.get_vendor_contact_info(vendor_id) if vendor_id else None
+        
+        # Handle both old single assignee and new multiple assignees format
+        if isinstance(assigned_to, str):
+            assigned_to_display = assigned_to if assigned_to else "Unassigned"
+        elif isinstance(assigned_to, list):
+            if assigned_to:
+                assigned_to_display = ", ".join(assigned_to)
+            else:
+                assigned_to_display = "Unassigned"
+        else:
+            assigned_to_display = "Unassigned"
+        
+        # Create a container for the task card
+        with st.container():
+            # Task header with completion status and title - make this the most prominent
+            status_icon = "✅" if completed else "⏳"
+            st.markdown(f"### {status_icon} {title}")
+            
+            # Task details in columns
+            col1, col2, col3 = st.columns(3)
+            
+            with col1:
+                if due_date:
+                    st.caption(f"📅 Due: {due_date}")
+                else:
+                    st.caption("📅 No due date")
+                
+                if vendor_name:
+                    st.caption(f"🏢 Vendor: {vendor_name}")
+            
+            with col2:
+                # Priority with color coding
+                if priority == "Urgent":
+                    st.caption(f"🔴 Priority: {priority}")
+                elif priority == "High":
+                    st.caption(f"🔴 Priority: {priority}")
+                elif priority == "Medium":
+                    st.caption(f"🟡 Priority: {priority}")
+                else:
+                    st.caption(f"🟢 Priority: {priority}")
+                
+                if assigned_to_display and assigned_to_display != "Unassigned":
+                    st.caption(f"👤 Assigned: {assigned_to_display}")
+            
+            with col3:
+                st.caption(f"📁 Group: {group}")
+                
+                if tags and len(tags) > 0:
+                    st.caption(f"🏷️ Tags: {', '.join(tags)}")
+            
+            # Description if available
+            if description:
+                st.caption(f"📝 {description}")
+            
+            # Vendor contact information if available
+            if vendor_contact_info and vendor_name:
+                contact_info_items = []
+                
+                # Determine if this is a vendor or item based on contact person
+                is_vendor = vendor_contact_info.get('contact_person', '') != ''
+                contact_type = "Vendor Contact" if is_vendor else "Seller Contact"
+                
+                if is_vendor and vendor_contact_info.get('contact_person'):
+                    contact_info_items.append(f"**Contact Person:** {vendor_contact_info['contact_person']}")
+                
+                if vendor_contact_info.get('phone'):
+                    contact_info_items.append(f"**Phone:** {vendor_contact_info['phone']}")
+                
+                if vendor_contact_info.get('email'):
+                    contact_info_items.append(f"**Email:** {vendor_contact_info['email']}")
+                
+                if vendor_contact_info.get('website'):
+                    contact_info_items.append(f"**Website:** [{vendor_contact_info['website']}]({vendor_contact_info['website']})")
+                
+                if is_vendor and vendor_contact_info.get('address'):
+                    contact_info_items.append(f"**Address:** {vendor_contact_info['address']}")
+                
+                if contact_info_items:
+                    st.markdown(f"**{contact_type} Information:**")
+                    for info in contact_info_items:
+                        st.markdown(f"<small>{info}</small>", unsafe_allow_html=True)
+            
+            # Add some spacing
+            st.markdown("---")
+        
+        # Action buttons below the task card
+        col1, col2, col3, col4 = st.columns([1, 1, 1, 1])
+        
+        with col1:
+            if st.button("Edit", key=f"edit_{task_id}", help="Edit task", use_container_width=True):
+                st.session_state[f"editing_task_{task_id}"] = True
+        
+        with col2:
+            if st.button("Duplicate", key=f"duplicate_{task_id}", help="Duplicate task", use_container_width=True):
+                self.duplicate_task(task_id)
+        
+        with col3:
+            if completed:
+                if st.button("Undo", key=f"undo_{task_id}", help="Mark incomplete", use_container_width=True):
+                    self.toggle_task_completion(task_id, False)
+            else:
+                if st.button("Complete", key=f"complete_{task_id}", help="Mark complete", use_container_width=True):
+                    self.toggle_task_completion(task_id, True)
+        
+        with col4:
+            if st.button("Delete", key=f"delete_{task_id}", help="Delete task", use_container_width=True):
+                self.delete_task(task_id)
+        
+        # Show edit form if editing (outside columns to span full width)
+        if st.session_state.get(f"editing_task_{task_id}", False):
+            self.render_edit_task_form(task, task_groups, custom_tags)
+    
+    def toggle_task_completion(self, task_id, completed):
+        tasks = self.config_manager.load_json_data('tasks.json')
+        for task in tasks:
+            if task.get('id') == task_id:
+                task['completed'] = completed
+                task['completed_date'] = datetime.now().isoformat() if completed else None
+                break
+        
+        self.config_manager.save_json_data('tasks.json', tasks)
+        st.rerun()
+    
+    def delete_task(self, task_id):
+        tasks = self.config_manager.load_json_data('tasks.json')
+        tasks = [task for task in tasks if task.get('id') != task_id]
+        self.config_manager.save_json_data('tasks.json', tasks)
+        st.rerun()
+    
+    def duplicate_task(self, task_id):
+        tasks = self.config_manager.load_json_data('tasks.json')
+        
+        # Find the task to duplicate
+        original_task = None
+        for task in tasks:
+            if task.get('id') == task_id:
+                original_task = task
+                break
+        
+        if original_task:
+            # Create a duplicate with new ID and modified title
+            duplicated_task = original_task.copy()
+            duplicated_task['id'] = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
+            duplicated_task['title'] = f"{original_task.get('title', 'Untitled Task')}"
+            duplicated_task['completed'] = False
+            duplicated_task['completed_date'] = None
+            duplicated_task['created_date'] = datetime.now().isoformat()
+            
+            # Add the duplicated task to the list
+            tasks.append(duplicated_task)
+            
+            if self.config_manager.save_json_data('tasks.json', tasks):
+                st.success("Task duplicated successfully!")
+                st.rerun()
+            else:
+                st.error("Error saving duplicated task")
+        else:
+            st.error("Task not found")
+    
+    def render_edit_task_form(self, task, task_groups, custom_tags):
+        task_id = task.get('id', '')
+        st.markdown("### Edit Task")
+        
+        with st.form(f"edit_task_form_{task_id}"):
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                title = st.text_input("Task Title *", value=task.get('title', ''), key=f"edit_title_{task_id}")
+                
+                # Show event-based groups first, then general categories
+                if task_groups:
+                    current_group = task.get('group', '')
+                    group_index = 0
+                    if current_group in task_groups:
+                        group_index = task_groups.index(current_group)
+                    group = st.selectbox("Event/Category", task_groups, index=group_index, key=f"edit_group_{task_id}")
+                else:
+                    group = st.selectbox("Category", ["General Planning"], key=f"edit_group_{task_id}")
+                
+                due_date_str = task.get('due_date', '')
+                due_date = None
+                if due_date_str:
+                    try:
+                        due_date = datetime.fromisoformat(due_date_str).date()
+                    except:
+                        due_date = None
+                due_date = st.date_input("Due Date", value=due_date, key=f"edit_due_date_{task_id}")
+                
+                priority_options = ["Low", "Medium", "High", "Urgent"]
+                current_priority = task.get('priority', 'Medium')
+                priority_index = priority_options.index(current_priority) if current_priority in priority_options else 1
+                priority = st.selectbox("Priority", priority_options, index=priority_index, key=f"edit_priority_{task_id}")
+            
+            with col2:
+                description = st.text_area("Description", value=task.get('description', ''), key=f"edit_description_{task_id}")
+                
+                # Assigned to field with wedding party and task assignees selection
+                wedding_party = self.config_manager.load_json_data('wedding_party.json')
+                wedding_party_names = [member.get('name', '') for member in wedding_party if member.get('name')]
+                
+                # Get task assignees from config
+                config = self.config_manager.load_config()
+                custom_settings = config.get('custom_settings', {})
+                task_assignees = custom_settings.get('task_assignees', [])
+                
+                # Get current assigned_to value (handle both old single assignee and new multiple assignees)
+                current_assigned_to = task.get('assigned_to', '')
+                
+                # Handle backward compatibility - convert single assignee to list
+                if isinstance(current_assigned_to, str):
+                    if current_assigned_to:
+                        current_assignees = [current_assigned_to]
+                    else:
+                        current_assignees = []
+                elif isinstance(current_assigned_to, list):
+                    current_assignees = current_assigned_to
+                else:
+                    current_assignees = []
+                
+                # Create combined options for multiselect
+                all_assignee_options = []
+                if wedding_party_names:
+                    all_assignee_options.extend([f"Wedding Party: {name}" for name in wedding_party_names])
+                if task_assignees:
+                    all_assignee_options.extend([f"Task Assignee: {assignee}" for assignee in task_assignees])
+                
+                # Determine initial selected values
+                initial_selected = []
+                custom_assignees = []
+                
+                for assignee in current_assignees:
+                    if assignee in wedding_party_names:
+                        initial_selected.append(f"Wedding Party: {assignee}")
+                    elif assignee in task_assignees:
+                        initial_selected.append(f"Task Assignee: {assignee}")
+                    else:
+                        custom_assignees.append(assignee)
+                
+                # Multiple assignees selection
+                selected_assignees = st.multiselect("Assign to (select multiple people)", all_assignee_options, default=initial_selected, key=f"edit_assignees_{task_id}")
+                
+                # Custom assignee text input (for additional people not in the lists)
+                custom_assignee_text = ", ".join(custom_assignees) if custom_assignees else ""
+                custom_assignee = st.text_input("Additional Custom Assignees", value=custom_assignee_text, placeholder="Enter additional assignee names (comma-separated)", key=f"edit_custom_assignee_{task_id}")
+                
+                # Combine selected assignees and custom assignees
+                assigned_to_list = []
+                for assignee in selected_assignees:
+                    if assignee.startswith("Wedding Party: "):
+                        assigned_to_list.append(assignee.replace("Wedding Party: ", ""))
+                    elif assignee.startswith("Task Assignee: "):
+                        assigned_to_list.append(assignee.replace("Task Assignee: ", ""))
+                
+                # Parse custom assignees (comma-separated)
+                if custom_assignee and custom_assignee.strip():
+                    custom_list = [name.strip() for name in custom_assignee.split(',') if name.strip()]
+                    assigned_to_list.extend(custom_list)
+                
+                # Store as list for multiple assignees
+                assigned_to = assigned_to_list
+            
+            # Tags selection
+            current_tags = task.get('tags', [])
+            # Filter current tags to only include those that exist in custom_tags
+            valid_current_tags = [tag for tag in current_tags if tag in custom_tags]
+            selected_tags = st.multiselect("Tags", custom_tags, default=valid_current_tags, key=f"edit_tags_{task_id}")
+            
+            # Form buttons
+            col1, col2 = st.columns(2)
+            with col1:
+                save_clicked = st.form_submit_button("Save Changes", type="primary")
+            with col2:
+                cancel_clicked = st.form_submit_button("Cancel")
+            
+            if save_clicked:
+                if title:
+                    # Update the task
+                    updated_task = {
+                        'id': task_id,
+                        'title': title,
+                        'description': description,
+                        'group': group,
+                        'due_date': due_date.isoformat() if due_date else None,
+                        'priority': priority,
+                        'assigned_to': assigned_to,
+                        'tags': selected_tags,
+                        'completed': task.get('completed', False),
+                        'created_date': task.get('created_date', datetime.now().isoformat()),
+                        'completed_date': task.get('completed_date', None),
+                        'vendor_id': task.get('vendor_id', '')  # Preserve vendor_id if it exists
+                    }
+                    
+                    # Load existing tasks and update the specific one
+                    tasks = self.config_manager.load_json_data('tasks.json')
+                    for i, t in enumerate(tasks):
+                        if t.get('id') == task_id:
+                            tasks[i] = updated_task
+                            break
+                    
+                    if self.config_manager.save_json_data('tasks.json', tasks):
+                        st.success("Task updated successfully!")
+                        st.session_state[f"editing_task_{task_id}"] = False
+                        st.rerun()
+                    else:
+                        st.error("Error saving task")
+                else:
+                    st.error("Please enter a task title")
+            
+            if cancel_clicked:
+                st.session_state[f"editing_task_{task_id}"] = False
+                st.rerun()

wedding_party.py

@@ -0,0 +1,799 @@
+import streamlit as st
+import json
+from datetime import datetime
+from config_manager import ConfigManager
+
+class WeddingPartyManager:
+    def __init__(self):
+        self.config_manager = ConfigManager()
+    
+    def render(self, config):
+        st.markdown("## 👰🤵 Wedding Party Tracker")
+        
+        # Load wedding party members
+        party_members = self.config_manager.load_json_data('wedding_party.json')
+        
+        # Add new member section
+        with st.expander("➕ Add Wedding Party Member", expanded=False):
+            self.render_party_member_form()
+        
+        # Display wedding party members
+        if party_members:
+            st.markdown(f"### Wedding Party ({len(party_members)} members)")
+            
+            # Group by role
+            roles = {}
+            for member in party_members:
+                role = member.get('role', 'Other')
+                if role not in roles:
+                    roles[role] = []
+                roles[role].append(member)
+            
+            # Display by role
+            for role, members in roles.items():
+                st.markdown(f"#### {role}")
+                
+                for member in members:
+                    self.render_party_member_card(member)
+        else:
+            st.info("No wedding party members added yet. Add your first member above!")
+    
+    def render_party_member_form(self):
+        # Option to select from existing guests or add new
+        add_option = st.radio("Add Wedding Party Member", ["Select from Guest List", "Add New Person"], horizontal=True)
+        
+        if add_option == "Select from Guest List":
+            # Load guests from the correct data files
+            guest_list_data = self.config_manager.load_json_data('guest_list_data.json')
+            rsvp_data = self.config_manager.load_json_data('rsvp_data.json')
+            
+            if guest_list_data:
+                # Create a list of guest names for selection
+                guest_options = []
+                guest_data_map = {}
+                
+                for group_code, group_data in guest_list_data.items():
+                    named_guests = group_data.get('named_guests', [])
+                    for guest in named_guests:
+                        first_name = guest.get('first_name', '')
+                        last_name = guest.get('last_name', '')
+                        full_name = guest.get('full_name', '')
+                        
+                        if full_name and first_name != 'nan' and last_name != 'nan':
+                            guest_options.append(full_name)
+                            
+                            # Get additional info from RSVP data if available
+                            rsvp_info = rsvp_data.get(group_code, {})
+                            phone = rsvp_info.get('phone_number', '')
+                            
+                            guest_data_map[full_name] = {
+                                'first_name': first_name,
+                                'last_name': last_name,
+                                'full_name': full_name,
+                                'phone': phone,
+                                'address': group_data.get('address', ''),
+                                'group': group_code,
+                                'party': group_data.get('party', '')
+                            }
+                
+                if guest_options:
+                    # Guest selection outside the form so it updates immediately
+                    guest_options_with_empty = ["-- Select a guest --"] + guest_options
+                    selected_guest_name = st.selectbox("Select Guest", guest_options_with_empty, key="guest_selection")
+                    
+                    # Check if a valid guest is selected
+                    is_guest_selected = selected_guest_name and selected_guest_name != "-- Select a guest --"
+                    
+                    # Show selected guest information only if a valid guest is selected
+                    if is_guest_selected:
+                        selected_guest = guest_data_map[selected_guest_name]
+                        
+                        st.markdown("### Selected Guest Information")
+                        col1, col2 = st.columns(2)
+                        
+                        with col1:
+                            st.info(f"**Name:** {selected_guest_name}")
+                            st.info(f"**Phone:** {selected_guest.get('phone', 'Not provided')}")
+                        
+                        with col2:
+                            st.info(f"**Address:** {selected_guest.get('address', 'Not provided')}")
+                            st.info(f"**Party:** {selected_guest.get('party', 'Not specified')}")
+                    else:
+                        st.info("Please select a guest from the dropdown above to see their information and add them to the wedding party.")
+                    
+                    # Now create the form with the selected guest
+                    with st.form("add_selected_guest_form"):
+                        # Role selection
+                        role = st.selectbox("Wedding Party Role", [
+                            "Maid of Honor", "Best Man", "Bridesmaid", "Groomsman",
+                            "Flower Girl", "Ring Bearer", "Usher", "Reader", "Other"
+                        ], key="role_selection")
+                        
+                        # Submit button - always present but disabled when no guest selected
+                        submitted = st.form_submit_button("Add to Wedding Party", type="primary", disabled=not is_guest_selected)
+                        
+                        # Handle form submission
+                        if submitted and is_guest_selected:
+                            selected_guest = guest_data_map[selected_guest_name]
+                            new_member = {
+                                'id': datetime.now().strftime("%Y%m%d_%H%M%S"),
+                                'name': selected_guest_name,
+                                'role': role,
+                                'phone': selected_guest.get('phone', ''),
+                                'address': selected_guest.get('address', ''),
+                                'group': selected_guest.get('group', ''),
+                                'party': selected_guest.get('party', ''),
+                                'created_date': datetime.now().isoformat(),
+                                'guest_id': selected_guest.get('group', '')  # Link to group code
+                            }
+                            
+                            # Load existing members and add new one
+                            party_members = self.config_manager.load_json_data('wedding_party.json')
+                            if not party_members:
+                                party_members = []
+                            party_members.append(new_member)
+                            
+                            if self.config_manager.save_json_data('wedding_party.json', party_members):
+                                st.success(f"{selected_guest_name} added to wedding party successfully!")
+                                st.rerun()
+                            else:
+                                st.error("Error saving member")
+                else:
+                    st.info("No guests found in the guest list. Please add guests first or choose 'Add New Person'.")
+            else:
+                st.info("No guests found in the guest list. Please add guests first or choose 'Add New Person'.")
+        
+        else:  # Add New Person
+            with st.form("add_new_person_form"):
+                st.markdown("### Add New Wedding Party Member")
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    name = st.text_input("Name *", placeholder="Enter full name")
+                    role = st.selectbox("Wedding Party Role", [
+                        "Maid of Honor", "Best Man", "Bridesmaid", "Groomsman",
+                        "Flower Girl", "Ring Bearer", "Usher", "Reader", "Other"
+                    ])
+                
+                with col2:
+                    phone = st.text_input("Phone Number", placeholder="Enter phone number")
+                    address = st.text_input("Address", placeholder="Enter address")
+                
+                submitted = st.form_submit_button("Add Member", type="primary")
+                
+                if submitted:
+                    if name:
+                        new_member = {
+                            'id': datetime.now().strftime("%Y%m%d_%H%M%S"),
+                            'name': name,
+                            'role': role,
+                            'phone': phone,
+                            'address': address,
+                            'created_date': datetime.now().isoformat()
+                        }
+                        
+                        # Load existing members and add new one
+                        party_members = self.config_manager.load_json_data('wedding_party.json')
+                        if not party_members:
+                            party_members = []
+                        party_members.append(new_member)
+                        
+                        if self.config_manager.save_json_data('wedding_party.json', party_members):
+                            st.success("Wedding party member added successfully!")
+                            st.rerun()
+                        else:
+                            st.error("Error saving member")
+                    else:
+                        st.error("Please enter a name")
+    
+    def render_party_member_card(self, member):
+        member_id = member.get('id', '')
+        name = member.get('name', '')
+        role = member.get('role', '')
+        phone = member.get('phone', '')
+        address = member.get('address', '')
+        group = member.get('group', '')
+        
+        # Get tasks assigned to this member
+        all_tasks = self.config_manager.load_json_data('tasks.json')
+        # Handle both old single assignee and new multiple assignees format
+        member_tasks = []
+        for task in all_tasks:
+            assigned_to = task.get('assigned_to', '')
+            if isinstance(assigned_to, str) and assigned_to.lower() == name.lower():
+                member_tasks.append(task)
+            elif isinstance(assigned_to, list) and name.lower() in [assignee.lower() for assignee in assigned_to]:
+                member_tasks.append(task)
+        
+        with st.container():
+            st.markdown(f"**{name} - {role}**")
+            
+            # Display contact and address information
+            col1, col2 = st.columns(2)
+            with col1:
+                if phone:
+                    st.markdown(f"📞 **Phone:** {phone}")
+                if group:
+                    st.markdown(f"👥 **Group:** {group}")
+            
+            with col2:
+                if address:
+                    st.markdown(f"🏠 **Address:** {address}")
+                party = member.get('party', '')
+                if party:
+                    st.markdown(f"💒 **Party:** {party}")
+            
+            # Tasks section
+            if member_tasks:
+                st.markdown(f"**📋 Tasks ({len(member_tasks)}):**")
+                for task in member_tasks:
+                    # Task header with completion status and title
+                    title = task.get('title', 'Untitled Task')
+                    completed = task.get('completed', False)
+                    status_icon = "✅" if completed else "⏳"
+                    st.markdown(f"**{status_icon} {title}**")
+                    
+                    # Task details in columns
+                    col1, col2, col3 = st.columns(3)
+                    
+                    with col1:
+                        due_date = task.get('due_date', '')
+                        if due_date:
+                            st.caption(f"📅 Due: {due_date}")
+                        else:
+                            st.caption("📅 No due date")
+                    
+                    with col2:
+                        priority = task.get('priority', 'Medium')
+                        # Priority with color coding
+                        if priority == "Urgent":
+                            st.caption(f"🔴 Priority: {priority}")
+                        elif priority == "High":
+                            st.caption(f"🔴 Priority: {priority}")
+                        elif priority == "Medium":
+                            st.caption(f"🟡 Priority: {priority}")
+                        else:
+                            st.caption(f"🟢 Priority: {priority}")
+                    
+                    with col3:
+                        if completed:
+                            st.caption("✅ Completed")
+                        else:
+                            st.caption("⏳ In Progress")
+                    
+                    # Description if available
+                    description = task.get('description', '')
+                    if description:
+                        st.caption(f"📝 {description}")
+                    
+                    # Add some spacing
+                    st.markdown("---")
+            else:
+                st.markdown("📋 **Tasks:** None assigned")
+            
+            # Action buttons before the dividing line
+            button_col1, button_col2, button_col3 = st.columns([1, 1, 1])
+            
+            with button_col1:
+                edit_clicked = st.button("Edit", key=f"edit_party_{member_id}", help="Edit member")
+            
+            with button_col2:
+                tasks_clicked = st.button("Tasks", key=f"tasks_party_{member_id}", help="View/Add Tasks")
+            
+            with button_col3:
+                delete_clicked = st.button("Delete", key=f"delete_party_{member_id}", help="Delete member")
+            
+            st.markdown("---")
+            
+            # Handle button clicks
+            if edit_clicked:
+                # Close other modes and open edit mode
+                st.session_state[f"viewing_tasks_{member_id}"] = False
+                st.session_state[f"deleting_member_{member_id}"] = False
+                st.session_state[f"editing_member_{member_id}"] = True
+            
+            if tasks_clicked:
+                # Close other modes and open task mode
+                st.session_state[f"editing_member_{member_id}"] = False
+                st.session_state[f"deleting_member_{member_id}"] = False
+                st.session_state[f"viewing_tasks_{member_id}"] = True
+            
+            if delete_clicked:
+                # Close other modes and open delete mode
+                st.session_state[f"editing_member_{member_id}"] = False
+                st.session_state[f"viewing_tasks_{member_id}"] = False
+                st.session_state[f"deleting_member_{member_id}"] = True
+            
+            # Handle edit mode
+            if st.session_state.get(f"editing_member_{member_id}", False):
+                self.edit_party_member(member)
+            
+            # Handle task view mode
+            if st.session_state.get(f"viewing_tasks_{member_id}", False):
+                self.manage_member_tasks(member)
+            
+            # Handle delete confirmation
+            if st.session_state.get(f"deleting_member_{member_id}", False):
+                self.delete_party_member(member_id)
+    
+    def edit_party_member(self, member):
+        st.markdown("### Edit Wedding Party Member")
+        
+        member_id = member.get('id', '')
+        form_key = f"edit_form_{member_id}"
+        
+        with st.form(form_key):
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                name = st.text_input("Name", value=member.get('name', ''), disabled=True, key=f"edit_name_{member_id}")
+                role = st.selectbox("Wedding Party Role", [
+                    "Maid of Honor", "Best Man", "Bridesmaid", "Groomsman",
+                    "Flower Girl", "Ring Bearer", "Usher", "Reader", "Other"
+                ], index=self.get_role_index(member.get('role', '')), key=f"edit_role_{member_id}")
+                phone = st.text_input("Phone", value=member.get('phone', ''), disabled=True, key=f"edit_phone_{member_id}")
+            
+            with col2:
+                address = st.text_input("Address", value=member.get('address', ''), disabled=True, key=f"edit_address_{member_id}")
+                group = st.text_input("Group", value=member.get('group', ''), disabled=True, key=f"edit_group_{member_id}")
+                party = st.text_input("Party", value=member.get('party', ''), disabled=True, key=f"edit_party_field_{member_id}")
+            
+            # Form submit buttons
+            col1, col2 = st.columns(2)
+            with col1:
+                save_clicked = st.form_submit_button("Save Changes", type="primary")
+            
+            with col2:
+                cancel_clicked = st.form_submit_button("Cancel")
+            
+            # Handle form submission
+            if save_clicked:
+                self.save_member_edits(member, name, role)
+            
+            if cancel_clicked:
+                st.session_state[f"editing_member_{member_id}"] = False
+                st.rerun()
+    
+    def get_role_index(self, role):
+        roles = ["Maid of Honor", "Best Man", "Bridesmaid", "Groomsman",
+                "Flower Girl", "Ring Bearer", "Usher", "Reader", "Other"]
+        try:
+            return roles.index(role)
+        except ValueError:
+            return 8  # Default to "Other"
+    
+    def save_member_edits(self, member, name, role):
+        if name:
+            # Load existing members
+            party_members = self.config_manager.load_json_data('wedding_party.json')
+            
+            # Find and update the member
+            for i, m in enumerate(party_members):
+                if m.get('id') == member.get('id'):
+                    party_members[i] = {
+                        'id': member.get('id'),
+                        'name': name,
+                        'role': role,
+                        'phone': member.get('phone', ''),
+                        'address': member.get('address', ''),
+                        'group': member.get('group', ''),
+                        'party': member.get('party', ''),
+                        'created_date': member.get('created_date', datetime.now().isoformat()),
+                        'guest_id': member.get('guest_id', '')
+                    }
+                    break
+            
+            # Save updated members
+            if self.config_manager.save_json_data('wedding_party.json', party_members):
+                st.success("Member updated successfully!")
+                st.session_state[f"editing_member_{member.get('id', '')}"] = False
+                st.rerun()
+            else:
+                st.error("Error saving changes")
+        else:
+            st.error("Please enter a name")
+    
+    def manage_member_tasks(self, member):
+        st.markdown(f"### Tasks for {member.get('name', '')}")
+        
+        # Load all tasks
+        all_tasks = self.config_manager.load_json_data('tasks.json')
+        member_name = member.get('name', '')
+        
+        # Filter tasks assigned to this member
+        # Handle both old single assignee and new multiple assignees format
+        member_tasks = []
+        for task in all_tasks:
+            assigned_to = task.get('assigned_to', '')
+            if isinstance(assigned_to, str) and assigned_to.lower() == member_name.lower():
+                member_tasks.append(task)
+            elif isinstance(assigned_to, list) and member_name.lower() in [assignee.lower() for assignee in assigned_to]:
+                member_tasks.append(task)
+        
+        if member_tasks:
+            st.markdown(f"#### Current Tasks ({len(member_tasks)})")
+            for task in member_tasks:
+                self.render_member_task_card(task)
+        else:
+            st.info(f"No tasks currently assigned to {member_name}")
+        
+        # Add new task for this member - full width
+        st.markdown("#### Add New Task")
+        self.render_member_task_form(member_name)
+        
+        # Close tasks view button
+        if st.button("Close Tasks View", key=f"close_tasks_{member.get('id', '')}"):
+            st.session_state[f"viewing_tasks_{member.get('id', '')}"] = False
+            st.rerun()
+    
+    def render_member_task_card(self, task):
+        task_id = task.get('id', '')
+        title = task.get('title', 'Untitled Task')
+        description = task.get('description', '')
+        due_date = task.get('due_date', '')
+        priority = task.get('priority', 'Medium')
+        completed = task.get('completed', False)
+        
+        # Determine card color based on priority and completion
+        if completed:
+            border_color = "#4a7c59"
+            bg_color = "#f0f8f0"
+        elif priority == "Urgent":
+            border_color = "#d32f2f"
+            bg_color = "#fff5f5"
+        elif priority == "High":
+            border_color = "#ff9800"
+            bg_color = "#fff8e1"
+        else:
+            border_color = "#4a7c59"
+            bg_color = "#f8f9fa"
+        
+        with st.container():
+            # Use Streamlit's native components for task cards
+            status_icon = "✅" if completed else "📋"
+            st.markdown(f"{status_icon} **{title}**")
+            
+            if due_date:
+                st.markdown(f"📅 Due: {due_date}")
+            
+            if priority:
+                st.markdown(f"⚡ Priority: {priority}")
+            
+            if description:
+                st.markdown(f"📄 {description}")
+            
+            # Quick action buttons before the separator
+            button_col1, button_col2, button_col3 = st.columns([1, 1, 1])
+            
+            with button_col1:
+                if st.button("Edit", key=f"edit_member_task_{task_id}", help="Edit task"):
+                    st.session_state[f"editing_member_task_{task_id}"] = True
+            
+            with button_col2:
+                if not completed:
+                    if st.button("Mark as Done", key=f"complete_task_{task_id}", help="Mark task as complete"):
+                        self.toggle_task_completion(task_id, True)
+                else:
+                    if st.button("Mark as Incomplete", key=f"undo_task_{task_id}", help="Mark task as incomplete"):
+                        self.toggle_task_completion(task_id, False)
+            
+            with button_col3:
+                if st.button("Delete", key=f"delete_member_task_{task_id}", help="Delete task"):
+                    self.delete_member_task(task_id)
+            
+            st.markdown("---")
+            
+            # Show edit form if editing
+            if st.session_state.get(f"editing_member_task_{task_id}", False):
+                self.render_edit_member_task_form(task)
+    
+    def render_member_task_form(self, member_name):
+        # Load custom tags from config
+        config = self.config_manager.load_config()
+        if isinstance(config, dict):
+            custom_settings = config.get('custom_settings', {})
+            custom_tags = custom_settings.get('custom_tags', [])
+        else:
+            custom_tags = []
+        
+        
+        with st.form(f"member_task_form_{member_name}"):
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                title = st.text_input("Task Title *", placeholder="Enter task title")
+                due_date = st.date_input("Due Date", value=None)
+            
+            with col2:
+                priority = st.selectbox("Priority", ["Low", "Medium", "High", "Urgent"])
+                
+                # Additional assignees selection (beyond the default member)
+                wedding_party = self.config_manager.load_json_data('wedding_party.json')
+                wedding_party_names = [member.get('name', '') for member in wedding_party if member.get('name')]
+                
+                # Get task assignees from config
+                config = self.config_manager.load_config()
+                custom_settings = config.get('custom_settings', {})
+                task_assignees = custom_settings.get('task_assignees', [])
+                
+                # Create combined options for multiselect (excluding the current member)
+                all_assignee_options = []
+                if wedding_party_names:
+                    all_assignee_options.extend([f"Wedding Party: {name}" for name in wedding_party_names if name != member_name])
+                if task_assignees:
+                    all_assignee_options.extend([f"Task Assignee: {assignee}" for assignee in task_assignees])
+                
+                # Additional assignees selection
+                additional_assignees = st.multiselect("Also assign to (optional)", all_assignee_options, key=f"member_additional_assignees_{member_name}")
+                
+                # Custom assignee text input (for additional people not in the lists)
+                custom_assignee = st.text_input("Additional Custom Assignee", placeholder="Enter additional assignee name (optional)", key=f"member_custom_assignee_{member_name}")
+            
+            description = st.text_area("Description", placeholder="Enter task description", height=100)
+            
+            # Tags selection - show all available tags
+            # Pre-select "Wedding Party" tag for consistency with vendor forms
+            default_tags = []
+            if 'Wedding Party' in custom_tags:
+                default_tags.append('Wedding Party')
+            
+            if custom_tags:
+                selected_tags = st.multiselect("Tags", custom_tags, default=default_tags)
+            else:
+                # Fallback if no custom tags are loaded
+                selected_tags = st.multiselect("Tags", ['Wedding Party', 'Urgent', 'Rehearsal', 'Attire', 'Transportation', 'Photography', 'Decorations', 'Music', 'Food & Beverage', 'Timeline'], default=['Wedding Party'])
+            
+            submitted = st.form_submit_button("Add Task", type="primary")
+            
+            if submitted:
+                if title:
+                    # Combine the default member with additional assignees
+                    assigned_to_list = [member_name]  # Start with the default member
+                    
+                    # Add additional assignees from dropdown
+                    for assignee in additional_assignees:
+                        if assignee.startswith("Wedding Party: "):
+                            assigned_to_list.append(assignee.replace("Wedding Party: ", ""))
+                        elif assignee.startswith("Task Assignee: "):
+                            assigned_to_list.append(assignee.replace("Task Assignee: ", ""))
+                    
+                    # Add custom assignee if provided
+                    if custom_assignee and custom_assignee.strip():
+                        assigned_to_list.append(custom_assignee.strip())
+                    
+                    new_task = {
+                        'id': datetime.now().strftime("%Y%m%d_%H%M%S"),
+                        'title': title,
+                        'description': description,
+                        'assigned_to': assigned_to_list,
+                        'due_date': due_date.isoformat() if due_date else None,
+                        'priority': priority,
+                        'group': 'Wedding Party',
+                        'tags': selected_tags,
+                        'completed': False,
+                        'created_date': datetime.now().isoformat(),
+                        'completed_date': None
+                    }
+                    
+                    # Load existing tasks and add new one
+                    tasks = self.config_manager.load_json_data('tasks.json')
+                    tasks.append(new_task)
+                    
+                    if self.config_manager.save_json_data('tasks.json', tasks):
+                        st.success("Task added successfully!")
+                        st.rerun()
+                    else:
+                        st.error("Error saving task")
+                else:
+                    st.error("Please enter a task title")
+    
+    def render_edit_member_task_form(self, task):
+        task_id = task.get('id', '')
+        st.markdown("### Edit Task")
+        
+        # Load custom tags from config
+        config = self.config_manager.load_config()
+        if isinstance(config, dict):
+            custom_settings = config.get('custom_settings', {})
+            custom_tags = custom_settings.get('custom_tags', [])
+        else:
+            custom_tags = []
+        
+        with st.form(f"edit_member_task_form_{task_id}"):
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                title = st.text_input("Task Title *", value=task.get('title', ''), key=f"edit_member_title_{task_id}")
+                due_date_str = task.get('due_date', '')
+                due_date = None
+                if due_date_str:
+                    try:
+                        from datetime import datetime
+                        due_date = datetime.fromisoformat(due_date_str).date()
+                    except:
+                        due_date = None
+                due_date = st.date_input("Due Date", value=due_date, key=f"edit_member_due_date_{task_id}")
+            
+            with col2:
+                priority_options = ["Low", "Medium", "High", "Urgent"]
+                current_priority = task.get('priority', 'Medium')
+                priority_index = priority_options.index(current_priority) if current_priority in priority_options else 1
+                priority = st.selectbox("Priority", priority_options, index=priority_index, key=f"edit_member_priority_{task_id}")
+                
+                # Additional assignees selection (beyond the current assignees)
+                wedding_party = self.config_manager.load_json_data('wedding_party.json')
+                wedding_party_names = [member.get('name', '') for member in wedding_party if member.get('name')]
+                
+                # Get task assignees from config
+                config = self.config_manager.load_config()
+                custom_settings = config.get('custom_settings', {})
+                task_assignees = custom_settings.get('task_assignees', [])
+                
+                # Get current assigned_to value (handle both old single assignee and new multiple assignees)
+                current_assigned_to = task.get('assigned_to', '')
+                
+                # Handle backward compatibility - convert single assignee to list
+                if isinstance(current_assigned_to, str):
+                    if current_assigned_to:
+                        current_assignees = [current_assigned_to]
+                    else:
+                        current_assignees = []
+                elif isinstance(current_assigned_to, list):
+                    current_assignees = current_assigned_to
+                else:
+                    current_assignees = []
+                
+                # Create combined options for multiselect
+                all_assignee_options = []
+                if wedding_party_names:
+                    all_assignee_options.extend([f"Wedding Party: {name}" for name in wedding_party_names])
+                if task_assignees:
+                    all_assignee_options.extend([f"Task Assignee: {assignee}" for assignee in task_assignees])
+                
+                # Determine initial selected values
+                initial_selected = []
+                custom_assignees = []
+                
+                for assignee in current_assignees:
+                    if assignee in wedding_party_names:
+                        initial_selected.append(f"Wedding Party: {assignee}")
+                    elif assignee in task_assignees:
+                        initial_selected.append(f"Task Assignee: {assignee}")
+                    else:
+                        custom_assignees.append(assignee)
+                
+                # Multiple assignees selection
+                selected_assignees = st.multiselect("Assign to (select multiple people)", all_assignee_options, default=initial_selected, key=f"edit_member_assignees_{task_id}")
+                
+                # Custom assignee text input (for additional people not in the lists)
+                custom_assignee_text = ", ".join(custom_assignees) if custom_assignees else ""
+                custom_assignee = st.text_input("Additional Custom Assignees", value=custom_assignee_text, placeholder="Enter additional assignee names (comma-separated)", key=f"edit_member_custom_assignee_{task_id}")
+            
+            description = st.text_area("Description", value=task.get('description', ''), key=f"edit_member_description_{task_id}")
+            
+            # Tags selection
+            current_tags = task.get('tags', [])
+            # Ensure "Wedding Party" tag is included for consistency
+            if 'Wedding Party' in custom_tags and 'Wedding Party' not in current_tags:
+                current_tags.append('Wedding Party')
+            
+            if custom_tags:
+                selected_tags = st.multiselect("Tags", custom_tags, default=current_tags, key=f"edit_member_tags_{task_id}")
+            else:
+                # Ensure "Wedding Party" is in the fallback tags and selected
+                fallback_tags = ['Wedding Party', 'Urgent', 'Rehearsal', 'Attire', 'Transportation', 'Photography', 'Decorations', 'Music', 'Food & Beverage', 'Timeline']
+                if 'Wedding Party' not in current_tags:
+                    current_tags.append('Wedding Party')
+                selected_tags = st.multiselect("Tags", fallback_tags, default=current_tags, key=f"edit_member_tags_{task_id}")
+            
+            # Form buttons
+            col1, col2 = st.columns(2)
+            with col1:
+                save_clicked = st.form_submit_button("Save Changes", type="primary")
+            with col2:
+                cancel_clicked = st.form_submit_button("Cancel")
+            
+            if save_clicked:
+                if title:
+                    # Combine selected assignees and custom assignees
+                    assigned_to_list = []
+                    for assignee in selected_assignees:
+                        if assignee.startswith("Wedding Party: "):
+                            assigned_to_list.append(assignee.replace("Wedding Party: ", ""))
+                        elif assignee.startswith("Task Assignee: "):
+                            assigned_to_list.append(assignee.replace("Task Assignee: ", ""))
+                    
+                    # Parse custom assignees (comma-separated)
+                    if custom_assignee and custom_assignee.strip():
+                        custom_list = [name.strip() for name in custom_assignee.split(',') if name.strip()]
+                        assigned_to_list.extend(custom_list)
+                    
+                    # Update the task
+                    updated_task = {
+                        'id': task_id,
+                        'title': title,
+                        'description': description,
+                        'assigned_to': assigned_to_list,
+                        'due_date': due_date.isoformat() if due_date else None,
+                        'priority': priority,
+                        'group': 'Wedding Party',
+                        'tags': selected_tags,
+                        'completed': task.get('completed', False),
+                        'created_date': task.get('created_date', datetime.now().isoformat()),
+                        'completed_date': task.get('completed_date', None)
+                    }
+                    
+                    # Load existing tasks and update the specific one
+                    tasks = self.config_manager.load_json_data('tasks.json')
+                    for i, t in enumerate(tasks):
+                        if t.get('id') == task_id:
+                            tasks[i] = updated_task
+                            break
+                    
+                    if self.config_manager.save_json_data('tasks.json', tasks):
+                        st.success("Task updated successfully!")
+                        st.session_state[f"editing_member_task_{task_id}"] = False
+                        st.rerun()
+                    else:
+                        st.error("Error saving task")
+                else:
+                    st.error("Please enter a task title")
+            
+            if cancel_clicked:
+                st.session_state[f"editing_member_task_{task_id}"] = False
+                st.rerun()
+    
+    def delete_member_task(self, task_id):
+        tasks = self.config_manager.load_json_data('tasks.json')
+        tasks = [task for task in tasks if task.get('id') != task_id]
+        self.config_manager.save_json_data('tasks.json', tasks)
+        st.rerun()
+    
+    def toggle_task_completion(self, task_id, completed):
+        tasks = self.config_manager.load_json_data('tasks.json')
+        for task in tasks:
+            if task.get('id') == task_id:
+                task['completed'] = completed
+                task['completed_date'] = datetime.now().isoformat() if completed else None
+                break
+        
+        self.config_manager.save_json_data('tasks.json', tasks)
+        st.rerun()
+    
+    def delete_party_member(self, member_id):
+        # Find the member to get their name
+        party_members = self.config_manager.load_json_data('wedding_party.json')
+        member_to_delete = None
+        for member in party_members:
+            if member.get('id') == member_id:
+                member_to_delete = member
+                break
+        
+        if member_to_delete:
+            st.markdown("### Delete Wedding Party Member")
+            st.warning(f"Are you sure you want to delete **{member_to_delete.get('name', '')}** from the wedding party?")
+            st.markdown("This action cannot be undone.")
+            
+            col1, col2, col3 = st.columns([1, 1, 1])
+            
+            with col1:
+                if st.button("✅ Yes, Delete", key=f"confirm_delete_{member_id}", type="primary"):
+                    # Remove the member
+                    updated_members = [member for member in party_members if member.get('id') != member_id]
+                    
+                    if self.config_manager.save_json_data('wedding_party.json', updated_members):
+                        st.success(f"{member_to_delete.get('name', '')} has been deleted from the wedding party.")
+                        st.session_state[f"deleting_member_{member_id}"] = False
+                        st.rerun()
+                    else:
+                        st.error("Error deleting member")
+            
+            with col2:
+                if st.button("❌ Cancel", key=f"cancel_delete_{member_id}"):
+                    st.session_state[f"deleting_member_{member_id}"] = False
+                    st.rerun()
+            
+            with col3:
+                if st.button("🔙 Back", key=f"back_delete_{member_id}"):
+                    st.session_state[f"deleting_member_{member_id}"] = False
+                    st.rerun()