Upload 11 files

Dockerfile

@@ -1,20 +1,36 @@
-FROM python:3.13.5-slim
+# 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 \
-    build-essential \
-    curl \
-    git \
+    gcc \
+    g++ \
     && rm -rf /var/lib/apt/lists/*
 
-COPY requirements.txt ./
-COPY src/ ./src/
+# 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 . .
 
-RUN pip3 install -r requirements.txt
+# 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
 
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+# 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,1646 @@
+import streamlit as st
+import json
+import os
+import yaml
+from datetime import datetime, date, timedelta
+import pandas as pd
+from yaml.loader import SafeLoader
+import streamlit_authenticator as stauth
+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;
+    }
+    
+    .main-header h1, .main-header h2, .main-header h3, .main-header p {
+        color: white !important;
+    }
+    
+    .main-header * {
+        color: white !important;
+    }
+    
+    /* Ensure green background elements always have white text regardless of theme */
+    .main-header, .main-header * {
+        color: white !important;
+    }
+    
+    .metric-card, .metric-card * {
+        color: white !important;
+    }
+    
+    .metric-card {
+        background: linear-gradient(135deg, #4a7c59, #6b8e6b) !important;
+        color: white !important;
+        padding: 1rem;
+        border-radius: 10px;
+        text-align: center;
+        margin: 0.5rem;
+        height: 150px;
+        display: flex;
+        flex-direction: column;
+        justify-content: center;
+        align-items: center;
+    }
+    
+    .metric-card h1, .metric-card h2, .metric-card h3, .metric-card p {
+        color: white !important;
+        background: transparent !important;
+    }
+    
+    .metric-card * {
+        color: white !important;
+        background: transparent !important;
+    }
+    
+    /* Override Streamlit's default styling for elements inside metric cards */
+    .metric-card .stMarkdown {
+        background: transparent !important;
+    }
+    
+    .metric-card .stMarkdown * {
+        color: white !important;
+        background: transparent !important;
+    }
+    
+    /* Additional overrides for Streamlit elements */
+    div[data-testid="stMarkdownContainer"] {
+        background: transparent !important;
+    }
+    
+    .metric-card div[data-testid="stMarkdownContainer"] {
+        background: transparent !important;
+    }
+    
+    .metric-card div[data-testid="stMarkdownContainer"] * {
+        color: white !important;
+        background: transparent !important;
+    }
+    
+    /* Fix text color for dashboard metrics below cards - use dark text for better visibility */
+    .main .block-container h1, 
+    .main .block-container h2, 
+    .main .block-container h3, 
+    .main .block-container h4, 
+    .main .block-container h5, 
+    .main .block-container h6 {
+        color: #262730 !important;
+    }
+    
+    .main .block-container p, 
+    .main .block-container div, 
+    .main .block-container span {
+        color: #262730 !important;
+    }
+    
+    /* Specific styling for dashboard content */
+    .main .block-container .stMarkdown {
+        color: #262730 !important;
+    }
+    
+    .main .block-container .stMarkdown * {
+        color: #262730 !important;
+    }
+    
+    /* Override for dark mode */
+    @media (prefers-color-scheme: dark) {
+        .main .block-container h1, 
+        .main .block-container h2, 
+        .main .block-container h3, 
+        .main .block-container h4, 
+        .main .block-container h5, 
+        .main .block-container h6 {
+            color: #fafafa !important;
+        }
+        
+        .main .block-container p, 
+        .main .block-container div, 
+        .main .block-container span {
+            color: #fafafa !important;
+        }
+        
+        .main .block-container .stMarkdown {
+            color: #fafafa !important;
+        }
+        
+        .main .block-container .stMarkdown * {
+            color: #fafafa !important;
+        }
+        
+        /* But keep green background elements white even in dark mode */
+        .main-header, .main-header * {
+            color: white !important;
+        }
+        
+        .metric-card, .metric-card * {
+            color: white !important;
+        }
+    }
+    
+    .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 load_auth_config():
+    """Load authentication configuration from Google Drive"""
+    try:
+        config_manager = st.session_state.config_manager
+        
+        # Try to load config.yaml from Google Drive root
+        if config_manager.google_drive_enabled:
+            config_content = config_manager.drive_manager.download_file('config.yaml')
+            if config_content:
+                # Parse YAML content
+                config = yaml.load(config_content, Loader=SafeLoader)
+                return config
+        
+        # Fallback to local config.yaml if Google Drive fails
+        if os.path.exists('config.yaml'):
+            with open('config.yaml') as file:
+                config = yaml.load(file, Loader=SafeLoader)
+                return config
+        
+        st.error("❌ No auth config found")
+        return None
+    except Exception as e:
+        st.error(f"Error loading authentication config: {e}")
+        return None
+
+def get_user_folder_from_username(username):
+    """Get the user folder based on username using wedding mappings"""
+    try:
+        # Load auth config to get wedding mappings
+        auth_config = st.session_state.get('auth_config')
+        if not auth_config:
+            # Fallback to loading config directly
+            auth_config = load_auth_config()
+        
+        if auth_config and 'wedding_mappings' in auth_config:
+            wedding_mappings = auth_config['wedding_mappings']
+            
+            # Search through all wedding mappings to find the user
+            for wedding_name, wedding_info in wedding_mappings.items():
+                if 'users' in wedding_info and username in wedding_info['users']:
+                    return wedding_info['folder']
+        
+        # Fallback to old hardcoded logic for backward compatibility
+        if username == 'demo':
+            return 'demo_data'
+        elif username == 'laraandumang':
+            return 'laraandumang'
+        else:
+            return 'demo_data'  # Default fallback
+            
+    except Exception as e:
+        st.error(f"Error getting user folder for {username}: {e}")
+        # Fallback to demo_data on error
+        return 'demo_data'
+
+def get_wedding_info_for_user(username):
+    """Get wedding information for a specific user"""
+    try:
+        auth_config = st.session_state.get('auth_config')
+        if not auth_config:
+            auth_config = load_auth_config()
+        
+        if auth_config and 'wedding_mappings' in auth_config:
+            wedding_mappings = auth_config['wedding_mappings']
+            
+            for wedding_name, wedding_info in wedding_mappings.items():
+                if 'users' in wedding_info and username in wedding_info['users']:
+                    return {
+                        'wedding_name': wedding_name,
+                        'folder': wedding_info['folder'],
+                        'users': wedding_info['users'],
+                        'display_name': wedding_info.get('wedding_name', wedding_name)
+                    }
+        
+        return None
+    except Exception as e:
+        st.error(f"Error getting wedding info for {username}: {e}")
+        return None
+
+def main():
+    # Initialize session state
+    if 'config_manager' not in st.session_state:
+        st.session_state.config_manager = ConfigManager()
+    
+    # Load authentication configuration
+    if 'auth_config' not in st.session_state:
+        st.session_state.auth_config = load_auth_config()
+    
+    if st.session_state.auth_config is None:
+        st.error("Failed to load authentication configuration. Please check your Google Drive setup.")
+        st.stop()
+    
+    # Create authenticator (auto_hash=True by default, so passwords will be hashed automatically)
+    authenticator = stauth.Authenticate(
+        st.session_state.auth_config['credentials'],
+        st.session_state.auth_config['cookie']['name'],
+        st.session_state.auth_config['cookie']['key'],
+        st.session_state.auth_config['cookie']['expiry_days']
+    )
+    
+    # Check authentication status
+    if 'authentication_status' not in st.session_state:
+        st.session_state.authentication_status = None
+    
+    # Check if user is already authenticated
+    if st.session_state.get('authentication_status'):
+        # User is authenticated, show main app
+        show_main_app(authenticator)
+    else:
+        # Show login page and handle authentication
+        show_login_page(authenticator)
+
+def show_login_page(authenticator):
+    """Show the login page"""
+    
+    # Hero Section
+    st.markdown("""
+    <div style="
+        background: linear-gradient(135deg, #2d5016, #4a7c59, #6b8e6b);
+        color: white;
+        padding: 4rem 2rem;
+        text-align: center;
+        border-radius: 15px;
+        margin-bottom: 3rem;
+        box-shadow: 0 10px 30px rgba(0,0,0,0.2);
+    ">
+        <h1 style="font-size: 3.5rem; margin-bottom: 1rem; font-weight: 700;">💒 Wedding Planner</h1>
+        <h2 style="font-size: 1.8rem; margin-bottom: 2rem; font-weight: 300; opacity: 0.9;">
+            Your Complete Wedding Planning Solution
+        </h2>
+        <p style="font-size: 1.2rem; max-width: 600px; margin: 0 auto; line-height: 1.6;">
+            Organize your special day with our comprehensive wedding planning tool. 
+            Manage guests, track tasks, coordinate vendors, and create unforgettable memories.
+        </p>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Features Section
+    st.markdown("## ✨ What You Can Do")
+    
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        st.markdown("""
+        <div style="
+            background: #f8f9fa;
+            padding: 2rem;
+            border-radius: 10px;
+            border-left: 4px solid #4a7c59;
+            margin-bottom: 2rem;
+            box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+        ">
+            <h3 style="color: #2d5016; margin-bottom: 1rem;">👥 Guest Management</h3>
+            <ul style="color: #666; line-height: 1.8;">
+                <li>Organize guest lists by groups</li>
+                <li>Track RSVP responses</li>
+                <li>Manage meal preferences</li>
+                <li>Send invitations</li>
+            </ul>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    with col2:
+        st.markdown("""
+        <div style="
+            background: #f8f9fa;
+            padding: 2rem;
+            border-radius: 10px;
+            border-left: 4px solid #4a7c59;
+            margin-bottom: 2rem;
+            box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+        ">
+            <h3 style="color: #2d5016; margin-bottom: 1rem;">📋 Task Tracking</h3>
+            <ul style="color: #666; line-height: 1.8;">
+                <li>Create and assign tasks</li>
+                <li>Set deadlines and priorities</li>
+                <li>Track progress</li>
+                <li>Organize by categories</li>
+            </ul>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    with col3:
+        st.markdown("""
+        <div style="
+            background: #f8f9fa;
+            padding: 2rem;
+            border-radius: 10px;
+            border-left: 4px solid #4a7c59;
+            margin-bottom: 2rem;
+            box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+        ">
+            <h3 style="color: #2d5016; margin-bottom: 1rem;">🏢 Vendor Management</h3>
+            <ul style="color: #666; line-height: 1.8;">
+                <li>Track vendor contacts</li>
+                <li>Manage payment schedules</li>
+                <li>Store contracts</li>
+                <li>Monitor bookings</li>
+            </ul>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    # Additional Features
+    col4, col5, col6 = st.columns(3)
+    
+    with col4:
+        st.markdown("""
+        <div style="
+            background: #f8f9fa;
+            padding: 2rem;
+            border-radius: 10px;
+            border-left: 4px solid #4a7c59;
+            margin-bottom: 2rem;
+            box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+        ">
+            <h3 style="color: #2d5016; margin-bottom: 1rem;">👰 Wedding Party</h3>
+            <ul style="color: #666; line-height: 1.8;">
+                <li>Manage bridal party</li>
+                <li>Track responsibilities</li>
+                <li>Coordinate schedules</li>
+                <li>Store contact info</li>
+            </ul>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    with col5:
+        st.markdown("""
+        <div style="
+            background: #f8f9fa;
+            padding: 2rem;
+            border-radius: 10px;
+            border-left: 4px solid #4a7c59;
+            margin-bottom: 2rem;
+            box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+        ">
+            <h3 style="color: #2d5016; margin-bottom: 1rem;">📊 Dashboard</h3>
+            <ul style="color: #666; line-height: 1.8;">
+                <li>Visual progress tracking</li>
+                <li>Key metrics overview</li>
+                <li>Timeline management</li>
+                <li>Quick insights</li>
+            </ul>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    with col6:
+        st.markdown("""
+        <div style="
+            background: #f8f9fa;
+            padding: 2rem;
+            border-radius: 10px;
+            border-left: 4px solid #4a7c59;
+            margin-bottom: 2rem;
+            box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+        ">
+            <h3 style="color: #2d5016; margin-bottom: 1rem;">☁️ Cloud Sync</h3>
+            <ul style="color: #666; line-height: 1.8;">
+                <li>Google Drive integration</li>
+                <li>Automatic backups</li>
+                <li>Multi-device access</li>
+                <li>Real-time updates</li>
+            </ul>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    st.markdown("---")
+    
+    # Login Section
+    st.markdown("## 🔐 Login to Your Wedding Planner")
+    
+    # Login form
+    try:
+        authenticator.login(location='main')
+    except Exception as e:
+        st.error(f"Login error: {e}")
+    
+    # Check authentication status and show appropriate message
+    if st.session_state.get('authentication_status') is False:
+        st.error("❌ Invalid username or password")
+    elif st.session_state.get('authentication_status') is None:
+        st.info("🔐 Please enter your username and password")
+    elif st.session_state.get('authentication_status'):
+        st.success(f"✅ Welcome, {st.session_state.get('name', 'User')}!")
+        st.rerun()  # Refresh to show main app
+    
+
+
+def show_wedding_setup_form():
+    """Show the wedding setup form for creating a new wedding"""
+    st.markdown("### 📝 Create Your Wedding Configuration")
+    
+    # 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
+            if 'show_setup_form' in st.session_state:
+                del st.session_state.show_setup_form
+            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(authenticator):
+    # Get current user from session state (set by authenticator.login)
+    username = st.session_state.get('username')
+    name = st.session_state.get('name')
+    
+    if not username or not name:
+        st.error("Authentication error: Missing user information")
+        return
+    
+    # Set user folder based on username
+    user_folder = get_user_folder_from_username(username)
+    
+    # Get wedding info for the user (for future use)
+    wedding_info = get_wedding_info_for_user(username)
+    
+    # Update config manager to use the correct user folder
+    config_manager = st.session_state.config_manager
+    config_manager.set_user_folder(user_folder)
+    
+    # Check if we need to load data (either not initialized or user changed)
+    current_user_folder = config_manager.get_current_user_folder()
+    user_changed = st.session_state.get('last_user_folder') != user_folder
+    
+    if not st.session_state.get('app_initialized', False) or user_changed:
+        with st.spinner(f"Loading {name}'s wedding data..."):
+            if user_folder == 'demo_data':
+                if config_manager.load_demo_data_from_drive():
+                    st.session_state.app_initialized = True
+                    st.session_state.last_user_folder = user_folder
+                    st.success("✅ Demo data loaded successfully!")
+                else:
+                    st.error("Failed to load demo data.")
+                    return
+            else:
+                if config_manager.load_existing_data_from_drive():
+                    st.session_state.app_initialized = True
+                    st.session_state.last_user_folder = user_folder
+                else:
+                    st.error("Failed to load wedding data.")
+                    return
+    
+    # Load config
+    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 wedding mapping info if available
+    user_wedding_info = get_wedding_info_for_user(username)
+    
+    # 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)
+    
+    # Add Google Drive sync status and push button
+    show_google_drive_sync_status()
+    
+    # Sidebar navigation
+    with st.sidebar:
+        # User info and logout
+        # Extract first name for a more friendly greeting
+        first_name = name.split()[0] if name else "User"
+        st.markdown(f"**Welcome, {first_name}!**")
+        if authenticator.logout(location='sidebar', key='logout_button'):
+            # Clear session state on logout
+            for key in list(st.session_state.keys()):
+                if key not in ['config_manager', 'auth_config']:
+                    del st.session_state[key]
+            
+            # Reset app initialization state
+            st.session_state.app_initialized = False
+            st.session_state.last_user_folder = None
+            
+            # Reset config manager state
+            if 'config_manager' in st.session_state:
+                st.session_state.config_manager.reset_app_state()
+                st.session_state.config_manager.user_folder = None
+            
+            st.rerun()
+        
+        st.markdown("---")
+        st.markdown("### Navigation")
+        page = st.radio(
+            "Choose a page:",
+            ["Dashboard", "Tasks", "Guest Management", "Wedding Party", "Wedding Overview", "Vendors & Purchases", "Settings"]
+        )
+        
+        # Add Google Drive sync button in sidebar if enabled
+        config_manager = st.session_state.config_manager
+        drive_status = config_manager.get_google_drive_status()
+        
+        if drive_status['enabled']:
+            st.markdown("---")
+            st.markdown("### ☁️ Google Drive")
+            
+            modified_files = config_manager.get_modified_files()
+            
+            # Always show push button
+            if modified_files:
+                st.warning(f"📝 {len(modified_files)} unsaved changes")
+                if st.button("📤 Push Changes", type="primary", help="Save changes to Google Drive", key="sidebar_push"):
+                    with st.spinner("Pushing changes..."):
+                        if config_manager.manual_sync_to_drive():
+                            st.success("✅ Changes saved!")
+                            st.rerun()
+                        else:
+                            st.error("❌ Failed to save changes")
+            else:
+                st.success("✅ All changes saved")
+                if st.button("📤 Push to Drive", help="Save current data to Google Drive", key="sidebar_push_all"):
+                    with st.spinner("Pushing to Drive..."):
+                        if config_manager.manual_sync_to_drive():
+                            st.success("✅ Data saved!")
+                            st.rerun()
+                        else:
+                            st.error("❌ Failed to save")
+            
+            # Always show pull button
+            if st.button("🔄 Pull Latest", help="Get latest from Google Drive", key="sidebar_pull"):
+                with st.spinner("Pulling latest..."):
+                    if config_manager.manual_sync_from_drive():
+                        st.success("✅ Latest loaded!")
+                        st.rerun()
+                    else:
+                        st.error("❌ Failed to load changes")
+    
+    # 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, tab6 = st.tabs(["Edit Configuration", "Manage Events", "Google Drive", "Cache Management", "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:
+        show_cache_management_section()
+    
+    with tab5:
+        st.markdown("#### Current Configuration")
+        st.json(config)
+    
+    with tab6:
+        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_cache_management_section():
+    """Show cache management section in settings"""
+    st.markdown("#### Cache Management")
+    
+    config_manager = st.session_state.config_manager
+    
+    # Get cache status
+    cache_status = config_manager.get_cache_status()
+    
+    st.markdown("**Current Cache Status:**")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.metric("Total Cached Items", cache_status['total_cached'])
+        if cache_status['config_cached']:
+            st.success("✅ Wedding configuration cached")
+        else:
+            st.info("ℹ️ Wedding configuration not cached")
+    
+    with col2:
+        if cache_status['cached_data_files']:
+            st.success(f"✅ {len(cache_status['cached_data_files'])} data files cached")
+            with st.expander("View cached files"):
+                for filename in cache_status['cached_data_files']:
+                    st.markdown(f"• {filename}")
+        else:
+            st.info("ℹ️ No data files cached")
+    
+    st.markdown("---")
+    
+    # Cache management buttons
+    st.markdown("**Cache Actions:**")
+    
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        if st.button("🗑️ Clear All Cache", help="Clear all cached data to force reload from source"):
+            config_manager.clear_cache()
+            st.success("Cache cleared! Data will be reloaded from source on next access.")
+            st.rerun()
+    
+    with col2:
+        if st.button("🔄 Refresh Cache", help="Reload all data from Google Drive and update cache"):
+            if config_manager.google_drive_enabled:
+                with st.spinner("Refreshing cache from Google Drive..."):
+                    if config_manager.manual_sync_from_drive():
+                        st.success("Cache refreshed from Google Drive!")
+                        st.rerun()
+                    else:
+                        st.error("Failed to refresh cache from Google Drive")
+            else:
+                st.warning("Google Drive not enabled. Cannot refresh from Drive.")
+    
+    with col3:
+        if st.button("ℹ️ Cache Info", help="Show detailed cache information"):
+            st.info("Cache helps improve performance by storing data in memory. Data is automatically cached when first loaded and updated when modified.")
+
+def show_google_drive_status_setup():
+    """Show Google Drive status on the setup page"""
+    config_manager = st.session_state.config_manager
+    drive_status = config_manager.get_google_drive_status()
+    
+    # Create an expander for Google Drive status
+    with st.expander("🔗 Google Drive Connection Status", expanded=False):
+        # 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 found in Google Drive:**")
+            for file_name in drive_status['files']:
+                friendly_name = get_friendly_file_name(file_name)
+                st.markdown(f"• {friendly_name}")
+        
+        # Manual sync buttons (if enabled) - only show pull and load options
+        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", key="setup_sync_from"):
+                    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("🔄 Load Existing Data", help="Load existing wedding data from Google Drive", key="setup_load_existing"):
+                    with st.spinner("Loading existing data from Google Drive..."):
+                        if config_manager.load_existing_data_from_drive():
+                            st.success("Successfully loaded existing data from Google Drive!")
+                            st.info("Your wedding data has been loaded. The page will refresh to show your wedding planner.")
+                            st.rerun()
+                        else:
+                            st.error("Failed to load existing data from Google Drive")
+        
+        # Configuration help
+        if not drive_status['enabled']:
+            st.markdown("**To enable Google Drive integration:**")
+            st.markdown("Set the following **secrets** in your Hugging Face Space settings:")
+            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
+            """)
+            
+            # Debug information
+            st.markdown("**Debug Information:**")
+            folder_id = os.getenv('GOOGLE_DRIVE_FOLDER_ID')
+            if folder_id:
+                st.success(f"✅ GOOGLE_DRIVE_FOLDER_ID found: {folder_id[:10]}...")
+            else:
+                st.error("❌ GOOGLE_DRIVE_FOLDER_ID not found")
+            
+            # Check other variables
+            project_id = os.getenv('GOOGLE_PROJECT_ID')
+            client_email = os.getenv('GOOGLE_CLIENT_EMAIL')
+            private_key_id = os.getenv('GOOGLE_PRIVATE_KEY_ID')
+            private_key = os.getenv('GOOGLE_PRIVATE_KEY')
+            client_id = os.getenv('GOOGLE_CLIENT_ID')
+            
+            if project_id:
+                st.success(f"✅ GOOGLE_PROJECT_ID found: {project_id[:10]}...")
+            else:
+                st.error("❌ GOOGLE_PROJECT_ID not found")
+                
+            if client_email:
+                st.success(f"✅ GOOGLE_CLIENT_EMAIL found: {client_email}")
+            else:
+                st.error("❌ GOOGLE_CLIENT_EMAIL not found")
+                
+            if private_key_id:
+                st.success(f"✅ GOOGLE_PRIVATE_KEY_ID found: {private_key_id[:10]}...")
+            else:
+                st.error("❌ GOOGLE_PRIVATE_KEY_ID not found")
+                
+            if private_key:
+                st.success(f"✅ GOOGLE_PRIVATE_KEY found: {len(private_key)} characters")
+            else:
+                st.error("❌ GOOGLE_PRIVATE_KEY not found")
+                
+            if client_id:
+                st.success(f"✅ GOOGLE_CLIENT_ID found: {client_id[:10]}...")
+            else:
+                st.error("❌ GOOGLE_CLIENT_ID not found")
+            
+            # Check if all required variables are present
+            all_required = all([folder_id, project_id, private_key_id, private_key, client_email, client_id])
+            if all_required:
+                st.success("🎉 All required secrets are present!")
+                st.info("If Google Drive is still not working, there might be an authentication issue. Try restarting your Space.")
+                
+                # Test file writing permissions
+                st.markdown("**Testing file permissions:**")
+                try:
+                    test_file = "/tmp/test_write.txt"
+                    with open(test_file, 'w') as f:
+                        f.write("test")
+                    st.success("✅ Can write to /tmp directory")
+                    os.remove(test_file)
+                except Exception as e:
+                    st.error(f"❌ Cannot write to /tmp directory: {e}")
+                    
+                try:
+                    test_dir = "wedding_data"
+                    os.makedirs(test_dir, exist_ok=True)
+                    test_file = os.path.join(test_dir, "test.txt")
+                    with open(test_file, 'w') as f:
+                        f.write("test")
+                    st.success("✅ Can write to wedding_data directory")
+                    os.remove(test_file)
+                except Exception as e:
+                    st.error(f"❌ Cannot write to wedding_data directory: {e}")
+            else:
+                st.warning("⚠️ Some required secrets are missing. Please add all secrets and restart your Space.")
+
+def get_friendly_file_name(filename):
+    """Convert technical file names to user-friendly names"""
+    friendly_names = {
+        'wedding_config.json': 'Wedding Configuration',
+        'guest_list_data.json': 'Guest List',
+        'rsvp_data.json': 'RSVP Responses',
+        'tasks.json': 'Tasks',
+        'vendors.json': 'Vendors',
+        'wedding_party.json': 'Wedding Party'
+    }
+    return friendly_names.get(filename, filename)
+
+def show_google_drive_sync_status():
+    """Show Google Drive sync status and push button prominently in main app"""
+    config_manager = st.session_state.config_manager
+    drive_status = config_manager.get_google_drive_status()
+    
+    # Only show if Google Drive is enabled
+    if not drive_status['enabled']:
+        return
+    
+    # Get modified files
+    modified_files = config_manager.get_modified_files()
+    
+    # Create a prominent status bar with always-visible push button
+    col1, col2, col3 = st.columns([2, 1, 1])
+    
+    with col1:
+        if modified_files:
+            friendly_names = [get_friendly_file_name(f) for f in modified_files]
+            st.warning(f"📝 **{len(modified_files)} unsaved changes** - {', '.join(friendly_names)}")
+        else:
+            st.success("✅ **All changes saved** - Your data is up to date with Google Drive")
+    
+    with col2:
+        # Always show push button - it will sync all current data
+        if modified_files:
+            button_text = f"📤 Push {len(modified_files)} Changes"
+            button_help = f"Save {len(modified_files)} modified files to Google Drive"
+        else:
+            button_text = "📤 Push to Drive"
+            button_help = "Save current data to Google Drive"
+        
+        if st.button(button_text, type="primary", help=button_help):
+            with st.spinner("Pushing changes to Google Drive..."):
+                if config_manager.manual_sync_to_drive():
+                    st.success("✅ Changes saved to Google Drive!")
+                    st.rerun()
+                else:
+                    st.error("❌ Failed to save changes to Google Drive")
+    
+    with col3:
+        if st.button("🔄 Pull Latest", help="Get latest changes from Google Drive"):
+            with st.spinner("Pulling latest changes from Google Drive..."):
+                if config_manager.manual_sync_from_drive():
+                    st.success("✅ Latest changes loaded from Google Drive!")
+                    st.rerun()
+                else:
+                    st.error("❌ Failed to load changes from Google Drive")
+    
+    # Add a small separator
+    st.markdown("---")
+
+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']:
+            friendly_name = get_friendly_file_name(file_name)
+            st.markdown(f"• {friendly_name}")
+    
+    # Show modified files status
+    if drive_status['enabled']:
+        modified_files = config_manager.get_modified_files()
+        if modified_files:
+            st.markdown("#### 📝 Modified Files (Not Synced)")
+            st.warning(f"The following files have been modified and need to be synced to Google Drive:")
+            for file_name in modified_files:
+                friendly_name = get_friendly_file_name(file_name)
+                st.markdown(f"• {friendly_name}")
+        else:
+            st.markdown("#### ✅ All Files Synced")
+            st.success("All your data is up to date with Google Drive.")
+    
+    # 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:
+            # Show different button text based on whether there are modified files
+            modified_files = config_manager.get_modified_files()
+            if modified_files:
+                button_text = f"📤 Sync {len(modified_files)} Modified Files to Drive"
+                button_help = f"Upload {len(modified_files)} modified files to Google Drive"
+            else:
+                button_text = "📤 Sync to Google Drive"
+                button_help = "Upload current data to Google Drive (no changes to sync)"
+            
+            if st.button(button_text, help=button_help, disabled=not modified_files):
+                with st.spinner("Syncing to Google Drive..."):
+                    if config_manager.manual_sync_to_drive():
+                        st.success("Successfully synced to Google Drive!")
+                        st.rerun()
+                    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,789 @@
+import json
+import os
+from datetime import datetime
+from google_drive_manager import GoogleDriveManager
+import streamlit as st
+
+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
+        
+        # For Hugging Face Spaces, use in-memory storage
+        if self.is_huggingface:
+            self.use_memory_storage = True
+            self.memory_data = {}
+            self.data_loaded_from_drive = False  # Track if data has been loaded
+        else:
+            self.use_memory_storage = False
+            self.data_loaded_from_drive = False
+            # Set up data directory for local development
+            try:
+                if not os.path.exists(self.data_dir):
+                    os.makedirs(self.data_dir, exist_ok=True)
+                if not os.path.exists(self.demo_data_dir):
+                    os.makedirs(self.demo_data_dir, exist_ok=True)
+            except Exception as e:
+                print(f"Error creating directories: {e}")
+        
+        # Load app configuration
+        self.app_config = self.load_app_config()
+        
+        # Initialize Google Drive if enabled
+        self._initialize_google_drive()
+    
+    def get_user_folder(self):
+        """Get the user-specific folder name"""
+        # Use demo_data folder if in demo mode, otherwise use laraandumang
+        if self.is_demo_mode():
+            return "demo_data"
+        return "laraandumang"
+    
+    def set_user_folder(self, folder_name):
+        """Set the user-specific folder name"""
+        self.user_folder = folder_name
+    
+    def get_current_user_folder(self):
+        """Get the currently set user folder"""
+        return getattr(self, 'user_folder', self.get_user_folder())
+    
+    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
+                    # Don't automatically sync on startup - let user choose
+                    print("Google Drive initialized successfully. Manual sync required.")
+        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
+        
+        try:
+            # Get user-specific folder
+            user_folder = self.get_current_user_folder()
+            
+            # 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 from user folder
+            config_content = self.drive_manager.download_file(f'{user_folder}/wedding_config.json')
+            if config_content:
+                if self.use_memory_storage:
+                    # Store in memory for Hugging Face Spaces
+                    self.memory_data['wedding_config.json'] = config_content
+                    # Update cache in session state
+                    st.session_state['cached_wedding_config'] = config_content
+                    print("✅ Loaded wedding configuration from Google Drive")
+                else:
+                    # Store in file for local development
+                    config_path = self.get_config_file_path()
+                    config_dir = os.path.dirname(config_path)
+                    if config_dir:
+                        os.makedirs(config_dir, exist_ok=True)
+                    with open(config_path, 'w') as f:
+                        json.dump(config_content, f, indent=2)
+                    # Update cache in session state
+                    st.session_state['cached_wedding_config'] = config_content
+                    print(f"Stored wedding_config.json in file: {config_path}")
+            
+            # Sync data files from user folder
+            for file_name in data_files:
+                content = self.drive_manager.download_file(f'{user_folder}/{file_name}')
+                if content:
+                    if self.use_memory_storage:
+                        # Store in memory for Hugging Face Spaces
+                        self.memory_data[file_name] = content
+                        # Update cache in session state
+                        cache_key = f"cached_{file_name}"
+                        st.session_state[cache_key] = content
+                        # Only print once per sync operation
+                        if file_name == data_files[0]:  # First file
+                            print(f"✅ Loaded {len(data_files)} data files from Google Drive")
+                    else:
+                        # Store in file for local development
+                        file_path = self.get_data_file_path(file_name)
+                        file_dir = os.path.dirname(file_path)
+                        if file_dir:
+                            os.makedirs(file_dir, exist_ok=True)
+                        with open(file_path, 'w') as f:
+                            json.dump(content, f, indent=2)
+                        # Update cache in session state
+                        cache_key = f"cached_{file_name}"
+                        st.session_state[cache_key] = content
+                        print(f"Stored {file_name} in file: {file_path}")
+        except Exception as e:
+            print(f"Error syncing from Google Drive: {e}")
+            # Don't fail the entire initialization if sync fails
+            # This is expected behavior - user can manually sync later
+    
+    def _sync_to_google_drive(self):
+        """Sync local data files to Google Drive"""
+        if not self.google_drive_enabled:
+            return
+        
+        # Get user-specific folder
+        user_folder = self.get_user_folder()
+        
+        # Sync config file to user folder
+        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(f'{user_folder}/wedding_config.json', config_content)
+        
+        # Sync data files to user folder
+        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(f'{user_folder}/{file_name}', content)
+    
+    def load_app_config(self):
+        """Load app configuration from file"""
+        # For Hugging Face Spaces, check /tmp directory first
+        if self.is_huggingface:
+            tmp_config_path = f"/tmp/{self.app_config_file}"
+            if os.path.exists(tmp_config_path):
+                try:
+                    with open(tmp_config_path, 'r') as f:
+                        return json.load(f)
+                except (json.JSONDecodeError, FileNotFoundError):
+                    pass
+        
+        # Check original location
+        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")
+        
+        # For Hugging Face Spaces, use app directory to avoid permission issues
+        if self.is_huggingface:
+            return "wedding_config.json"
+        
+        # For local development, use the original path
+        if os.path.isabs(self.config_file):
+            return self.config_file
+        else:
+            return os.path.join(os.getcwd(), self.config_file)
+    
+    def config_exists(self):
+        """Check if configuration file exists"""
+        if self.use_memory_storage:
+            return 'wedding_config.json' in self.memory_data
+        else:
+            config_path = self.get_config_file_path()
+            return os.path.exists(config_path)
+    
+    def load_config(self):
+        """Load configuration from cache, file or memory"""
+        # Check if we have cached config in session state
+        if 'cached_wedding_config' in st.session_state:
+            return st.session_state['cached_wedding_config']
+        
+        if self.config_exists():
+            try:
+                if self.use_memory_storage:
+                    config = self.memory_data['wedding_config.json']
+                else:
+                    config_path = self.get_config_file_path()
+                    with open(config_path, 'r') as f:
+                        config = json.load(f)
+                
+                # Cache the config in session state
+                st.session_state['cached_wedding_config'] = config
+                return config
+            except (json.JSONDecodeError, FileNotFoundError, KeyError):
+                default_config = self.get_default_config()
+                st.session_state['cached_wedding_config'] = default_config
+                return default_config
+        
+        default_config = self.get_default_config()
+        st.session_state['cached_wedding_config'] = default_config
+        return default_config
+    
+    def save_config(self, config):
+        """Save configuration to file or memory"""
+        try:
+            if self.use_memory_storage:
+                # Store in memory for Hugging Face Spaces
+                self.memory_data['wedding_config.json'] = config
+            else:
+                # Store in file for local development
+                config_path = self.get_config_file_path()
+                with open(config_path, 'w') as f:
+                    json.dump(config, f, indent=2)
+            
+            # Update cache in session state
+            st.session_state['cached_wedding_config'] = config
+            
+            # Mark config as modified for manual sync
+            st.session_state['config_modified'] = True
+            
+            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 cache, data directory, or memory"""
+        # Check if we have cached data in session state
+        cache_key = f"cached_{filename}"
+        if cache_key in st.session_state:
+            # Data loaded from cache
+            return st.session_state[cache_key]
+        
+        # Load data from source
+        if self.use_memory_storage:
+            # Load from memory for Hugging Face Spaces
+            data = self.memory_data.get(filename, [])
+        else:
+            # Load from file for local development
+            filepath = self.get_data_file_path(filename)
+            if os.path.exists(filepath):
+                try:
+                    with open(filepath, 'r') as f:
+                        data = json.load(f)
+                except (json.JSONDecodeError, FileNotFoundError):
+                    data = []
+            else:
+                data = []
+        
+        # Cache the data in session state
+        st.session_state[cache_key] = data
+        return data
+    
+    def save_json_data(self, filename, data):
+        """Save JSON data to data directory or memory"""
+        try:
+            if self.use_memory_storage:
+                # Store in memory for Hugging Face Spaces
+                self.memory_data[filename] = data
+            else:
+                # Store in file for local development
+                filepath = self.get_data_file_path(filename)
+                with open(filepath, 'w') as f:
+                    json.dump(data, f, indent=2)
+            
+            # Update cache in session state
+            cache_key = f"cached_{filename}"
+            st.session_state[cache_key] = data
+            
+            # Mark data as modified for manual sync
+            st.session_state[f'{filename}_modified'] = True
+            
+            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:
+            # For Hugging Face Spaces, use /tmp directory to avoid permission issues
+            if self.is_huggingface:
+                config_path = f"/tmp/{self.app_config_file}"
+            else:
+                config_path = self.app_config_file
+            
+            with open(config_path, '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:
+            # For Hugging Face Spaces, use /tmp directory to avoid permission issues
+            if self.is_huggingface:
+                config_path = f"/tmp/{self.app_config_file}"
+            else:
+                config_path = self.app_config_file
+            
+            with open(config_path, '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 clear_cache(self):
+        """Clear all cached data from session state"""
+        data_files = [
+            'guest_list_data.json',
+            'rsvp_data.json', 
+            'tasks.json',
+            'vendors.json',
+            'wedding_party.json',
+            'guests.json'
+        ]
+        
+        for filename in data_files:
+            cache_key = f"cached_{filename}"
+            if cache_key in st.session_state:
+                del st.session_state[cache_key]
+        
+        # Also clear config cache
+        if 'cached_wedding_config' in st.session_state:
+            del st.session_state['cached_wedding_config']
+    
+    def get_cache_status(self):
+        """Get information about what data is currently cached"""
+        data_files = [
+            'guest_list_data.json',
+            'rsvp_data.json', 
+            'tasks.json',
+            'vendors.json',
+            'wedding_party.json',
+            'guests.json'
+        ]
+        
+        cached_files = []
+        for filename in data_files:
+            cache_key = f"cached_{filename}"
+            if cache_key in st.session_state:
+                cached_files.append(filename)
+        
+        config_cached = 'cached_wedding_config' in st.session_state
+        
+        return {
+            'cached_data_files': cached_files,
+            'config_cached': config_cached,
+            'total_cached': len(cached_files) + (1 if config_cached else 0)
+        }
+    
+    def invalidate_cache_for_file(self, filename):
+        """Invalidate cache for a specific file"""
+        cache_key = f"cached_{filename}"
+        if cache_key in st.session_state:
+            del st.session_state[cache_key]
+    
+    def invalidate_config_cache(self):
+        """Invalidate the config cache"""
+        if 'cached_wedding_config' in st.session_state:
+            del st.session_state['cached_wedding_config']
+    
+    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()
+            self.data_loaded_from_drive = True
+            # Clear modified flags since data is now in sync with Google Drive
+            self.clear_modified_flags()
+            return True
+        except Exception as e:
+            print(f"Error syncing from Google Drive: {e}")
+            return False
+    
+    def load_existing_data_from_drive(self):
+        """Load existing wedding data from Google Drive and create local config"""
+        if not self.google_drive_enabled:
+            return False
+        
+        try:
+            # Disable demo mode when loading real data
+            self.set_demo_mode(False)
+            
+            # Get user-specific folder
+            user_folder = self.get_current_user_folder()
+            
+            # Check if wedding_config.json exists in Google Drive user folder
+            config_content = self.drive_manager.download_file(f'{user_folder}/wedding_config.json')
+            if config_content:
+                # Save config locally (in memory or file)
+                if self.use_memory_storage:
+                    self.memory_data['wedding_config.json'] = config_content
+                    # Update cache in session state
+                    st.session_state['cached_wedding_config'] = config_content
+                    print("Stored wedding_config.json in memory")
+                else:
+                    config_path = self.get_config_file_path()
+                    config_dir = os.path.dirname(config_path)
+                    if config_dir:
+                        os.makedirs(config_dir, exist_ok=True)
+                    with open(config_path, 'w') as f:
+                        json.dump(config_content, f, indent=2)
+                    # Update cache in session state
+                    st.session_state['cached_wedding_config'] = config_content
+                    print(f"Stored wedding_config.json in file: {config_path}")
+                
+                # Load data files from user folder
+                data_files = [
+                    'guest_list_data.json',
+                    'rsvp_data.json', 
+                    'tasks.json',
+                    'vendors.json',
+                    'wedding_party.json'
+                ]
+                
+                for file_name in data_files:
+                    content = self.drive_manager.download_file(f'{user_folder}/{file_name}')
+                    if content:
+                        if self.use_memory_storage:
+                            self.memory_data[file_name] = content
+                            # Update cache in session state
+                            cache_key = f"cached_{file_name}"
+                            st.session_state[cache_key] = content
+                            print(f"Stored {file_name} in memory")
+                        else:
+                            file_path = self.get_data_file_path(file_name)
+                            file_dir = os.path.dirname(file_path)
+                            if file_dir:
+                                os.makedirs(file_dir, exist_ok=True)
+                            with open(file_path, 'w') as f:
+                                json.dump(content, f, indent=2)
+                            # Update cache in session state
+                            cache_key = f"cached_{file_name}"
+                            st.session_state[cache_key] = content
+                            print(f"Stored {file_name} in file: {file_path}")
+                
+                self.data_loaded_from_drive = True
+                return True
+            return False
+        except Exception as e:
+            print(f"Error loading existing data from Google Drive: {e}")
+            # This is a common issue on Hugging Face Spaces due to network/SSL issues
+            # The error is expected and the user can retry manually
+            return False
+    
+    def load_demo_data_from_drive(self):
+        """Load demo wedding data from Google Drive and enable demo mode"""
+        if not self.google_drive_enabled:
+            return False
+        
+        try:
+            # Enable demo mode first
+            self.set_demo_mode(True)
+            
+            # Load demo data from demo folder in Google Drive
+            demo_folder = self.get_current_user_folder()  # Will return "demo_data" since demo mode is enabled
+            
+            # Check if wedding_config.json exists in demo folder
+            config_content = self.drive_manager.download_file(f'{demo_folder}/wedding_config.json')
+            if config_content:
+                # Save config locally (in memory or file)
+                if self.use_memory_storage:
+                    self.memory_data['wedding_config.json'] = config_content
+                    # Update cache in session state
+                    st.session_state['cached_wedding_config'] = config_content
+                    print("Stored demo wedding_config.json in memory")
+                else:
+                    config_path = self.get_config_file_path()
+                    config_dir = os.path.dirname(config_path)
+                    if config_dir:
+                        os.makedirs(config_dir, exist_ok=True)
+                    with open(config_path, 'w') as f:
+                        json.dump(config_content, f, indent=2)
+                    # Update cache in session state
+                    st.session_state['cached_wedding_config'] = config_content
+                    print(f"Stored demo wedding_config.json in file: {config_path}")
+                
+                # Load demo data files from demo folder
+                data_files = [
+                    'guest_list_data.json',
+                    'rsvp_data.json', 
+                    'tasks.json',
+                    'vendors.json',
+                    'wedding_party.json'
+                ]
+                
+                for file_name in data_files:
+                    content = self.drive_manager.download_file(f'{demo_folder}/{file_name}')
+                    if content:
+                        if self.use_memory_storage:
+                            self.memory_data[file_name] = content
+                            # Update cache in session state
+                            cache_key = f"cached_{file_name}"
+                            st.session_state[cache_key] = content
+                            print(f"Stored demo {file_name} in memory")
+                        else:
+                            file_path = self.get_data_file_path(file_name)
+                            file_dir = os.path.dirname(file_path)
+                            if file_dir:
+                                os.makedirs(file_dir, exist_ok=True)
+                            with open(file_path, 'w') as f:
+                                json.dump(content, f, indent=2)
+                            # Update cache in session state
+                            cache_key = f"cached_{file_name}"
+                            st.session_state[cache_key] = content
+                            print(f"Stored demo {file_name} in file: {file_path}")
+                
+                self.data_loaded_from_drive = True
+                return True
+            return False
+        except Exception as e:
+            print(f"Error loading demo data from Google Drive: {e}")
+            # This is a common issue on Hugging Face Spaces due to network/SSL issues
+            # The error is expected and the user can retry manually
+            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)}'
+            }
+    
+    def get_modified_files(self):
+        """Get list of files that have been modified since last sync"""
+        modified_files = []
+        
+        # Check config
+        if st.session_state.get('config_modified', False):
+            modified_files.append('wedding_config.json')
+        
+        # Check data files
+        data_files = [
+            'guest_list_data.json',
+            'rsvp_data.json', 
+            'tasks.json',
+            'vendors.json',
+            'wedding_party.json'
+        ]
+        
+        for filename in data_files:
+            if st.session_state.get(f'{filename}_modified', False):
+                modified_files.append(filename)
+        
+        return modified_files
+    
+    def clear_modified_flags(self):
+        """Clear all modified flags after successful sync"""
+        st.session_state['config_modified'] = False
+        
+        data_files = [
+            'guest_list_data.json',
+            'rsvp_data.json', 
+            'tasks.json',
+            'vendors.json',
+            'wedding_party.json'
+        ]
+        
+        for filename in data_files:
+            st.session_state[f'{filename}_modified'] = False
+    
+    def manual_sync_to_drive(self):
+        """Manually sync all current data to Google Drive"""
+        if not self.google_drive_enabled:
+            return False
+        
+        try:
+            # Get user-specific folder
+            user_folder = self.get_current_user_folder()
+            
+            modified_files = self.get_modified_files()
+            
+            if not modified_files:
+                print("No modified files detected, but syncing all current data to ensure consistency")
+            else:
+                print(f"Syncing {len(modified_files)} modified files to Google Drive: {modified_files}")
+            
+            # Always sync config (current state) to user folder
+            config = self.load_config()
+            if not self.drive_manager.upload_file(f'{user_folder}/wedding_config.json', config):
+                return False
+            
+            # Always sync all data files (current state) to user folder
+            data_files = [
+                'guest_list_data.json',
+                'rsvp_data.json', 
+                'tasks.json',
+                'vendors.json',
+                'wedding_party.json'
+            ]
+            
+            for filename in data_files:
+                data = self.load_json_data(filename)
+                if not self.drive_manager.upload_file(f'{user_folder}/{filename}', data):
+                    return False
+            
+            # Clear modified flags after successful sync
+            self.clear_modified_flags()
+            return True
+            
+        except Exception as e:
+            print(f"Error syncing to Google Drive: {e}")
+            return False
+    
+    def reset_app_state(self):
+        """Reset the app state by clearing all cached data and memory storage"""
+        try:
+            # Clear memory data
+            if hasattr(self, 'memory_data'):
+                self.memory_data.clear()
+            
+            # Clear session state cache
+            if 'cached_wedding_config' in st.session_state:
+                del st.session_state['cached_wedding_config']
+            
+            # Clear other cached data files
+            for key in list(st.session_state.keys()):
+                if key.startswith('cached_'):
+                    del st.session_state[key]
+            
+            # Reset data loaded flag
+            self.data_loaded_from_drive = False
+            
+            print("App state reset successfully")
+            return True
+        except Exception as e:
+            print(f"Error resetting app state: {e}")
+            return False

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; color: white;'>{days_until}</h1>", unsafe_allow_html=True)
+                    if days_until == 0:
+                        st.markdown("<p style='margin: 0; color: white;'>Festivities begin today! 🎉</p>", unsafe_allow_html=True)
+                    elif days_until == 1:
+                        st.markdown("<p style='margin: 0; color: white;'>Festivities begin tomorrow! 🎊</p>", unsafe_allow_html=True)
+                    elif days_until <= 7:
+                        st.markdown("<p style='margin: 0; color: white;'>Festivities begin this week! ⚡</p>", unsafe_allow_html=True)
+                    else:
+                        st.markdown("<p style='margin: 0; color: white;'>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; color: white;'>{days_remaining}</h1>", unsafe_allow_html=True)
+                    st.markdown("<p style='margin: 0; color: white;'>days of festivities remaining! 🎉</p>", unsafe_allow_html=True)
+                else:
+                    days_since = (today - wedding_end).days
+                    st.markdown(f"<h1 style='margin: 0; color: white;'>{days_since}</h1>", unsafe_allow_html=True)
+                    st.markdown("<p style='margin: 0; color: white;'>days since festivities ended</p>", unsafe_allow_html=True)
+            except:
+                st.markdown("<h1 style='margin: 0; color: white;'>-</h1>", unsafe_allow_html=True)
+                st.markdown("<p style='margin: 0; color: white;'>Dates not set</p>", unsafe_allow_html=True)
+        else:
+            st.markdown("<h1 style='margin: 0; color: white;'>-</h1>", unsafe_allow_html=True)
+            st.markdown("<p style='margin: 0; color: white;'>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; color: white;'>{confirmed_guests}</h1>", unsafe_allow_html=True)
+        st.markdown("<p style='margin: 0; color: white;'>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; color: white;'>{percentage}%</h1>", unsafe_allow_html=True)
+            st.markdown(f"<p style='margin: 0; color: white;'>{completed}/{total} completed</p>", unsafe_allow_html=True)
+        else:
+            st.markdown("<h1 style='margin: 0; color: white;'>0%</h1>", unsafe_allow_html=True)
+            st.markdown("<p style='margin: 0; color: white;'>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; color: white;'>${total_actualized_cost:,.0f}</h1>", unsafe_allow_html=True)
+        st.markdown(f"<p style='margin: 0; color: white;'>${total_estimated_cost:,.0f} estimated total</p>", unsafe_allow_html=True)
+        st.markdown(f"<p style='margin: 0; color: white;'>${total_paid:,.0f} paid</p>", unsafe_allow_html=True)
+        st.markdown(f"<p style='margin: 0; color: white;'>${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,332 @@
+import os
+import json
+import tempfile
+import time
+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
+import ssl
+
+def retry_on_ssl_error(max_retries=3, delay=1):
+    """Decorator to retry functions on SSL errors"""
+    def decorator(func):
+        def wrapper(*args, **kwargs):
+            for attempt in range(max_retries):
+                try:
+                    return func(*args, **kwargs)
+                except (ssl.SSLError, ConnectionError, OSError) as e:
+                    if attempt == max_retries - 1:
+                        print(f"SSL/Connection error after {max_retries} attempts: {e}")
+                        raise
+                    print(f"SSL/Connection error (attempt {attempt + 1}/{max_retries}): {e}")
+                    time.sleep(delay * (attempt + 1))  # Exponential backoff
+                except Exception as e:
+                    # Don't retry on other types of errors
+                    raise
+            return None
+        return wrapper
+    return decorator
+
+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
+    
+    @retry_on_ssl_error(max_retries=3, delay=1)
+    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 []
+    
+    @retry_on_ssl_error(max_retries=3, delay=1)
+    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:
+            # Handle subfolder paths like 'laraandumang/wedding_config.json'
+            if '/' in file_name:
+                folder_name, actual_file_name = file_name.split('/', 1)
+                
+                # First, find the subfolder
+                folder_query = f"name='{folder_name}' and '{self.folder_id}' in parents and trashed=false and mimeType='application/vnd.google-apps.folder'"
+                folder_results = self.service.files().list(q=folder_query).execute()
+                folders = folder_results.get('files', [])
+                
+                if not folders:
+                    st.warning(f"File '{file_name}' not found in Google Drive")
+                    return None
+                
+                folder_id = folders[0]['id']
+                
+                # Now search for the file within that folder
+                file_query = f"name='{actual_file_name}' and '{folder_id}' in parents and trashed=false"
+                results = self.service.files().list(q=file_query).execute()
+                files = results.get('files', [])
+                
+                if not files:
+                    st.warning(f"File '{file_name}' not found in Google Drive")
+                    return None
+            else:
+                # Direct file search in root folder
+                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
+    
+    @retry_on_ssl_error(max_retries=3, delay=1)
+    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 appropriate string format
+            if isinstance(content, (dict, list)):
+                if file_name.endswith('.yaml') or file_name.endswith('.yml'):
+                    # For YAML files, convert to YAML string
+                    import yaml
+                    content_str = yaml.dump(content, default_flow_style=False, sort_keys=False)
+                else:
+                    # For JSON files, convert to JSON string
+                    content_str = json.dumps(content, indent=2)
+            else:
+                content_str = str(content)
+            
+            # Convert string to bytes
+            content_bytes = content_str.encode('utf-8')
+            
+            # Create a temporary file-like object
+            from io import BytesIO
+            media_body = BytesIO(content_bytes)
+            
+            # Determine MIME type based on file extension
+            if file_name.endswith('.yaml') or file_name.endswith('.yml'):
+                mimetype = 'text/yaml'
+            else:
+                mimetype = 'application/json'
+            
+            # Handle subfolder paths like 'laraandumang/wedding_config.json'
+            target_folder_id = self.folder_id
+            actual_file_name = file_name
+            
+            if '/' in file_name:
+                folder_name, actual_file_name = file_name.split('/', 1)
+                
+                # First, find the subfolder
+                folder_query = f"name='{folder_name}' and '{self.folder_id}' in parents and trashed=false and mimeType='application/vnd.google-apps.folder'"
+                folder_results = self.service.files().list(q=folder_query).execute()
+                folders = folder_results.get('files', [])
+                
+                if not folders:
+                    # Create the subfolder if it doesn't exist
+                    folder_metadata = {
+                        'name': folder_name,
+                        'mimeType': 'application/vnd.google-apps.folder',
+                        'parents': [self.folder_id]
+                    }
+                    created_folder = self.service.files().create(
+                        body=folder_metadata,
+                        fields='id'
+                    ).execute()
+                    target_folder_id = created_folder.get('id')
+                else:
+                    target_folder_id = folders[0]['id']
+            
+            # Check if file already exists in the target folder
+            query = f"name='{actual_file_name}' and '{target_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']
+                from googleapiclient.http import MediaIoBaseUpload
+                media = MediaIoBaseUpload(media_body, mimetype=mimetype, resumable=True)
+                self.service.files().update(
+                    fileId=file_id,
+                    media_body=media
+                ).execute()
+            else:
+                # Create new file
+                file_metadata = {
+                    'name': actual_file_name,
+                    'parents': [target_folder_id]
+                }
+                from googleapiclient.http import MediaIoBaseUpload
+                media = MediaIoBaseUpload(media_body, mimetype=mimetype, resumable=True)
+                self.service.files().create(
+                    body=file_metadata,
+                    media_body=media
+                ).execute()
+            
+            return True
+            
+        except HttpError as e:
+            st.error(f"Error uploading file '{file_name}': {str(e)}")
+            return False
+        except Exception as e:
+            st.error(f"Unexpected 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

guests.py

@@ -0,0 +1,1602 @@
+import streamlit as st
+import json
+import pandas as pd
+import io
+import hashlib
+import plotly.graph_objects as go
+from datetime import datetime
+from config_manager import ConfigManager
+
+class GuestManager:
+    def __init__(self):
+        self.config_manager = ConfigManager()
+        self.guest_list_data = None
+        self.rsvp_data = None
+    
+    def render(self, config):
+        st.markdown("## 👥 Guest Management")
+        
+        # Load current data
+        self.load_data()
+        
+        # Import section
+        st.markdown("### Import Data")
+        import_type = st.radio("Import Type", ["Guest List (CSV)", "RSVP Responses (CSV)"], horizontal=True)
+        
+        if import_type == "Guest List (CSV)":
+            uploaded_file = st.file_uploader("Upload Guest List (CSV)", type=['csv'], help="Upload a CSV file with guest data")
+        else:
+            uploaded_file = st.file_uploader("Upload RSVP Responses (CSV)", type=['csv'], help="Upload a CSV file with RSVP responses")
+        
+        if uploaded_file is not None:
+            try:
+                df = pd.read_csv(uploaded_file)
+                
+                if import_type == "Guest List (CSV)":
+                    self.process_guest_list_csv(df)
+                    st.success("Guest list processed successfully!")
+                    st.rerun()
+                else:
+                    self.process_rsvp_csv(df, config)
+                    st.success("RSVP data processed successfully!")
+                    st.rerun()
+                    
+            except Exception as e:
+                st.error(f"Error processing CSV: {e}")
+        
+        # Display current data
+        if self.guest_list_data is not None:
+            self.render_guest_table(config)
+        else:
+            st.info("Please upload a guest list CSV file to get started.")
+    
+    def get_confirmed_attendees(self, guests):
+        """Get list of guests who have RSVPed 'Yes' to at least one event"""
+        confirmed = []
+        for guest in guests:
+            rsvp_by_event = guest.get('rsvp_by_event', {})
+            if any(status == 'Yes' for status in rsvp_by_event.values()):
+                confirmed.append(guest)
+        return confirmed
+    
+    def render_confirmed_attendees_view(self, confirmed_guests, config):
+        """Render detailed view for confirmed attendees with stats"""
+        
+        # Create tabs for different views
+        tab1, tab2, tab3, tab4 = st.tabs(["Guest List", "Attendance by Event", "Meal Choices", "Summary Stats"])
+        
+        with tab1:
+            self.render_guests_table(confirmed_guests, config)
+        
+        with tab2:
+            st.markdown("### Attendance by Event for Confirmed Guests")
+            self.render_attendance_chart(confirmed_guests, config)
+        
+        with tab3:
+            st.markdown("### Meal Choices for Confirmed Guests")
+            self.render_meal_choices_chart(confirmed_guests, config)
+        
+        with tab4:
+            st.markdown("### Summary Statistics")
+            self.render_confirmed_attendees_stats(confirmed_guests, config)
+    
+    def render_attendance_chart(self, confirmed_guests, config):
+        """Render attendance chart for confirmed guests with guest list functionality"""
+        wedding_events = config.get('wedding_events', [])
+        
+        # Count attendance for each event
+        event_attendance = {}
+        for event in wedding_events:
+            event_name = event.get('name', '')
+            if event_name:
+                event_attendance[event_name] = {'Yes': 0, 'No': 0, 'Pending': 0}
+        
+        for guest in confirmed_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
+        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')
+        ])
+        
+        fig.update_layout(
+            title="Event Attendance for Confirmed Guests",
+            barmode='stack',
+            xaxis_tickangle=-45,
+            height=400
+        )
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # Add guest list functionality below the chart
+        st.markdown("---")
+        st.markdown("### 📋 View Guest Lists by Event")
+        
+        if event_names:
+            # Create columns for event selection and guest list display
+            col1, col2 = st.columns([1, 2])
+            
+            with col1:
+                selected_event = st.selectbox(
+                    "Select Event to View Guest List:",
+                    event_names,
+                    help="Choose an event to see the list of guests who confirmed attendance"
+                )
+                
+                # Show attendance summary for selected event
+                if selected_event in event_attendance:
+                    st.markdown("#### Attendance Summary")
+                    st.metric("Confirmed", event_attendance[selected_event]['Yes'])
+                    st.metric("Declined", event_attendance[selected_event]['No'])
+                    st.metric("Pending", event_attendance[selected_event]['Pending'])
+            
+            with col2:
+                if selected_event:
+                    self.render_event_guest_list(confirmed_guests, selected_event, config)
+        else:
+            st.info("No events configured yet.")
+    
+    def render_event_guest_list(self, confirmed_guests, selected_event, config):
+        """Render the list of guests who confirmed for a specific event"""
+        st.markdown(f"#### Guest List for {selected_event}")
+        
+        # Get guests who confirmed for this event
+        confirmed_for_event = []
+        declined_for_event = []
+        pending_for_event = []
+        
+        for guest in confirmed_guests:
+            rsvp_by_event = guest.get('rsvp_by_event', {})
+            rsvp_status = rsvp_by_event.get(selected_event, 'Pending')
+            
+            if rsvp_status == 'Yes':
+                confirmed_for_event.append(guest)
+            elif rsvp_status == 'No':
+                declined_for_event.append(guest)
+            else:
+                pending_for_event.append(guest)
+        
+        # Create tabs for different RSVP statuses
+        tab1, tab2, tab3 = st.tabs([
+            f"✅ Confirmed ({len(confirmed_for_event)})",
+            f"❌ Declined ({len(declined_for_event)})",
+            f"⏳ Pending ({len(pending_for_event)})"
+        ])
+        
+        with tab1:
+            if confirmed_for_event:
+                self.render_guest_list_table(confirmed_for_event, selected_event, config, "confirmed")
+            else:
+                st.info("No guests have confirmed for this event yet.")
+        
+        with tab2:
+            if declined_for_event:
+                self.render_guest_list_table(declined_for_event, selected_event, config, "declined")
+            else:
+                st.info("No guests have declined this event.")
+        
+        with tab3:
+            if pending_for_event:
+                self.render_guest_list_table(pending_for_event, selected_event, config, "pending")
+            else:
+                st.info("All guests have responded to this event.")
+    
+    def render_guest_list_table(self, guests, event_name, config, status="confirmed"):
+        """Render a table of guests for a specific event"""
+        if not guests:
+            return
+        
+        # Create data for the table
+        table_data = []
+        for guest in guests:
+            first_name = guest.get('first_name', '')
+            last_name = guest.get('last_name', '')
+            
+            # Handle guests with "nan" names
+            if first_name in ['nan', ''] and last_name in ['nan', '']:
+                first_name = '[Unassigned Plus One]'
+                last_name = ''
+            
+            # Get meal selection for this event
+            meal_selections = guest.get('meal_selections', {})
+            meal_choice = meal_selections.get(event_name, 'Not Selected')
+            
+            # Check if this event requires meal choice
+            wedding_events = config.get('wedding_events', [])
+            event_requires_meal = False
+            for event in wedding_events:
+                if event.get('name') == event_name and event.get('requires_meal_choice', False):
+                    event_requires_meal = True
+                    break
+            
+            row = {
+                'Name': f"{first_name} {last_name}".strip(),
+                'Group': guest.get('group', ''),
+                'Party': guest.get('party', ''),
+                'Phone': guest.get('phone', ''),
+                'Plus One Name': guest.get('plus_one_name', '')
+            }
+            
+            # Add meal choice column only if event requires meal choice
+            if event_requires_meal:
+                row['Meal Choice'] = meal_choice
+            
+            table_data.append(row)
+        
+        if table_data:
+            df = pd.DataFrame(table_data)
+            
+            # Display the table
+            st.dataframe(
+                df,
+                use_container_width=True,
+                hide_index=True,
+                height=min(400, len(table_data) * 35 + 50)  # Dynamic height based on number of guests
+            )
+            
+            # Add export functionality
+            csv_data = df.to_csv(index=False)
+            st.download_button(
+                label=f"📥 Download {event_name} Guest List (CSV)",
+                data=csv_data,
+                file_name=f"{event_name.replace(' ', '_')}_{status}_guest_list.csv",
+                mime="text/csv",
+                key=f"download_{event_name.replace(' ', '_')}_{status}_{len(guests)}"
+            )
+    
+    def render_meal_choices_chart(self, confirmed_guests, config):
+        """Render meal choices chart for confirmed guests"""
+        wedding_events = config.get('wedding_events', [])
+        
+        # Get events that require meal choices
+        meal_events = [event for event in wedding_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.get('name', '')
+            meal_options = event.get('meal_options', [])
+            
+            if not meal_options:
+                continue
+            
+            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
+            
+            for guest in confirmed_guests:
+                meal_selections = guest.get('meal_selections', {})
+                selected_meal = meal_selections.get(event_name, 'Not Selected')
+                if selected_meal in meal_counts:
+                    meal_counts[selected_meal] += 1
+                else:
+                    meal_counts['Not Selected'] += 1
+            
+            # Create pie chart
+            fig = go.Figure(data=[go.Pie(
+                labels=list(meal_counts.keys()),
+                values=list(meal_counts.values()),
+                marker_colors=['#4a7c59', '#ff9800', '#2196f3', '#9c27b0', '#f44336', '#ffa726']
+            )])
+            
+            fig.update_layout(title=f"Meal Choices for {event_name}")
+            st.plotly_chart(fig, use_container_width=True)
+    
+    def render_confirmed_attendees_stats(self, confirmed_guests, config):
+        """Render summary statistics for confirmed attendees"""
+        wedding_events = config.get('wedding_events', [])
+        
+        # Basic stats
+        col1, col2, col3, col4 = st.columns(4)
+        
+        with col1:
+            st.metric("Total Confirmed", len(confirmed_guests))
+        
+        with col2:
+            plus_ones = sum(1 for guest in confirmed_guests if guest.get('plus_one', False))
+            st.metric("With Plus Ones", plus_ones)
+        
+        with col3:
+            total_attending = len(confirmed_guests) + plus_ones
+            st.metric("Total Attending", total_attending)
+        
+        with col4:
+            # Calculate average attendance across all events
+            total_yes = 0
+            total_possible = len(confirmed_guests) * len(wedding_events)
+            for guest in confirmed_guests:
+                rsvp_by_event = guest.get('rsvp_by_event', {})
+                total_yes += sum(1 for status in rsvp_by_event.values() if status == 'Yes')
+            
+            avg_attendance = (total_yes / total_possible * 100) if total_possible > 0 else 0
+            st.metric("Avg Event Attendance", f"{avg_attendance:.1f}%")
+        
+        # Event-specific stats
+        st.markdown("#### Event Attendance Summary")
+        event_stats = []
+        for event in wedding_events:
+            event_name = event.get('name', '')
+            yes_count = 0
+            for guest in confirmed_guests:
+                rsvp_by_event = guest.get('rsvp_by_event', {})
+                if rsvp_by_event.get(event_name) == 'Yes':
+                    yes_count += 1
+            
+            attendance_rate = (yes_count / len(confirmed_guests) * 100) if confirmed_guests else 0
+            event_stats.append({
+                'Event': event_name,
+                'Attending': yes_count,
+                'Attendance Rate': f"{attendance_rate:.1f}%"
+            })
+        
+        if event_stats:
+            stats_df = pd.DataFrame(event_stats)
+            st.dataframe(stats_df, use_container_width=True, hide_index=True)
+    
+    def convert_csv_to_guests(self, df):
+        """Convert CSV data to guest format"""
+        guest_data = []
+        
+        for _, row in df.iterrows():
+            first_name = str(row.get('First Name (Empty Rows are +1s)', '')).strip()
+            last_name = str(row.get('Last Name', '')).strip()
+            group = str(row.get('Group', '')).strip()
+            group_size = str(row.get('Group Size', '')).strip()
+            party = str(row.get('Party', '')).strip()
+            street_address = str(row.get('  Street address', '')).strip()
+            apt_suite = str(row.get('  Apt/Suite', '')).strip()
+            city = str(row.get('  City', '')).strip()
+            state = str(row.get('  State', '')).strip()
+            zip_code = str(row.get('  ZIP', '')).strip()
+            country = str(row.get('Country', '')).strip()
+            
+            # Skip completely empty rows
+            if not first_name and not last_name and not group:
+                continue
+            
+            # Build full address
+            address_parts = []
+            if street_address and street_address != 'nan':
+                address_parts.append(street_address)
+            if apt_suite and apt_suite != 'nan':
+                address_parts.append(f"Apt {apt_suite}")
+            if city and city != 'nan':
+                address_parts.append(city)
+            if state and state != 'nan':
+                address_parts.append(state)
+            if zip_code and zip_code != 'nan':
+                address_parts.append(zip_code)
+            if country and country != 'nan':
+                address_parts.append(country)
+            
+            full_address = ', '.join(address_parts) if address_parts else ''
+            
+            # Determine if this is a plus one (empty first name but has party/group)
+            is_plus_one = not first_name and (group or party)
+            
+            if is_plus_one:
+                # This is a plus one entry - create a guest entry with "nan" names
+                # The plus_one_name will be filled in from RSVP data
+                guest = {
+                    'id': datetime.now().strftime("%Y%m%d_%H%M%S_%f"),
+                    'first_name': 'nan',
+                    'last_name': 'nan',
+                    'party': party,
+                    'group': group,
+                    'group_size': group_size,
+                    'phone': '',
+                    'address': full_address,  # Use full address as address info
+                    'lodging': '',  # Leave lodging empty for manual entry
+                    'allergies': '',
+                    'plus_one': False,  # This will be updated from RSVP data
+                    'plus_one_name': '',  # This will be filled from RSVP data
+                    'plus_one_phone': '',
+                    'plus_one_allergies': '',
+                    'rsvp_by_event': {},
+                    'meal_selections': {},
+                    'created_date': datetime.now().isoformat()
+                }
+            else:
+                # Create guest object for main guests
+                guest = {
+                    'id': datetime.now().strftime("%Y%m%d_%H%M%S_%f"),
+                    'first_name': first_name,
+                    'last_name': last_name,
+                    'party': party,
+                    'group': group,
+                    'group_size': group_size,
+                    'phone': '',
+                    'address': full_address,  # Use full address as address info
+                    'lodging': '',  # Leave lodging empty for manual entry
+                    'allergies': '',
+                    'plus_one': False,  # Will be updated from RSVP data
+                    'plus_one_name': '',
+                    'plus_one_phone': '',
+                    'plus_one_allergies': '',
+                    'rsvp_by_event': {},
+                    'meal_selections': {},
+                    'created_date': datetime.now().isoformat()
+                }
+            
+            guest_data.append(guest)
+        
+        return guest_data
+    
+    def update_guests_with_rsvp(self, df, config):
+        """Update existing guests with RSVP responses from CSV"""
+        import json
+        
+        existing_guests = self.config_manager.load_json_data('guests.json')
+        updated_count = 0
+        
+        # Track new meal options found in RSVP data
+        new_meal_options_by_event = {}
+        
+        # Track which plus one names have been assigned to avoid duplicates across all parties
+        global_assigned_plus_ones = set()
+        
+        for _, row in df.iterrows():
+            party_code = str(row.get('party_code', '')).strip()
+            name = str(row.get('name', '')).strip()
+            overall_rsvp = str(row.get('overall_rsvp', '')).strip()
+            bringing_plus_one = str(row.get('bringing_plus_one', '')).strip().lower() == 'yes'
+            party_attendees = str(row.get('party_attendees', '')).strip()
+            event_responses = str(row.get('event_responses', '')).strip()
+            dietary_restrictions = str(row.get('dietary_restrictions', '')).strip()
+            phone_number = str(row.get('phone_number', '')).strip()
+            
+            # Skip empty rows
+            if not party_code and not name:
+                continue
+            
+            # Parse party attendees to get all names in the party
+            party_attendee_names = []
+            if party_attendees and party_attendees != 'nan':
+                party_attendee_names = [name.strip() for name in party_attendees.split(';') if name.strip()]
+            
+            # Parse dietary restrictions
+            dietary_dict = {}
+            if dietary_restrictions and dietary_restrictions != 'nan' and dietary_restrictions != '{}':
+                try:
+                    dietary_dict = json.loads(dietary_restrictions)
+                except:
+                    pass
+            
+            # Parse event responses
+            event_dict = {}
+            if event_responses and event_responses != 'nan' and event_responses != '{}':
+                try:
+                    event_dict = json.loads(event_responses)
+                except Exception as e:
+                    st.warning(f"Could not parse event responses for {name}: {e}")
+            
+            # First, ensure all party attendees exist as separate guest entries
+            # This handles cases where RSVP data includes people not in the original guest list
+            for attendee_name in party_attendee_names:
+                # Check if this attendee already exists as a guest
+                attendee_exists = False
+                for guest in existing_guests:
+                    guest_name = f"{guest.get('first_name', '')} {guest.get('last_name', '')}".strip()
+                    if attendee_name.lower() == guest_name.lower():
+                        attendee_exists = True
+                        break
+                
+                # If attendee doesn't exist, create a new guest entry
+                if not attendee_exists:
+                    # Parse the attendee name into first and last name
+                    name_parts = attendee_name.strip().split()
+                    if len(name_parts) >= 2:
+                        first_name = name_parts[0]
+                        last_name = ' '.join(name_parts[1:])
+                    else:
+                        first_name = attendee_name
+                        last_name = ''
+                    
+                    # Find the group/party info from existing guests with the same party code
+                    group_name = party_code
+                    party_name = 'Lara'  # Default party
+                    address = ''
+                    group_size = '1'
+                    
+                    for guest in existing_guests:
+                        guest_group = guest.get('group', '').strip()
+                        if party_code.lower() == guest_group.lower():
+                            group_name = guest_group
+                            party_name = guest.get('party', 'Lara')
+                            address = guest.get('address', '')
+                            group_size = guest.get('group_size', '1')
+                            break
+                    
+                    # Create new guest entry
+                    new_guest = {
+                        'id': datetime.now().strftime("%Y%m%d_%H%M%S_%f"),
+                        'first_name': first_name,
+                        'last_name': last_name,
+                        'party': party_name,
+                        'group': group_name,
+                        'group_size': group_size,
+                        'phone': phone_number if phone_number != 'nan' else '',
+                        'address': address,
+                        'lodging': '',
+                        'allergies': dietary_dict.get(attendee_name, ''),
+                        'plus_one': False,  # This is a main guest, not a plus one
+                        'plus_one_name': '',
+                        'plus_one_phone': '',
+                        'plus_one_allergies': '',
+                        'rsvp_by_event': {},
+                        'meal_selections': {},
+                        'created_date': datetime.now().isoformat()
+                    }
+                    
+                    # Apply RSVP data to the new guest
+                    if event_dict:
+                        rsvp_by_event = {}
+                        meal_selections = {}
+                        
+                        for event_name, event_data in event_dict.items():
+                            if isinstance(event_data, dict):
+                                attendees = event_data.get('attendees', [])
+                                party_rsvp = event_data.get('rsvp', 'Pending')
+                                
+                                # Determine individual RSVP status
+                                if attendee_name in attendees:
+                                    rsvp_status = party_rsvp
+                                else:
+                                    rsvp_status = 'No'
+                                
+                                rsvp_by_event[event_name] = rsvp_status
+                                
+                                # Update meal choices if provided and guest is attending
+                                if rsvp_status == 'Yes':
+                                    meal_choice = event_data.get('meal_choice', {})
+                                    if meal_choice and isinstance(meal_choice, dict) and attendee_name in meal_choice:
+                                        selected_meal = meal_choice[attendee_name]
+                                        meal_selections[event_name] = selected_meal
+                                        
+                                        # Track new meal options for this event
+                                        if event_name not in new_meal_options_by_event:
+                                            new_meal_options_by_event[event_name] = set()
+                                        new_meal_options_by_event[event_name].add(selected_meal)
+                        
+                        new_guest['rsvp_by_event'] = rsvp_by_event
+                        new_guest['meal_selections'] = meal_selections
+                    
+                    existing_guests.append(new_guest)
+                    updated_count += 1
+            
+            # Now update existing guests with RSVP data
+            # Find matching guest(s) by name or party
+            matching_guests = []
+            for guest in existing_guests:
+                guest_name = f"{guest.get('first_name', '')} {guest.get('last_name', '')}".strip()
+                guest_party = guest.get('party', '').strip()
+                guest_group = guest.get('group', '').strip()
+                
+                # Match by exact name, party code, or exact group name (including guests with "nan" names)
+                # Use exact group matching to prevent partial matches (e.g., "Perrin" matching "Ben Perrin")
+                if (name and name.lower() in guest_name.lower()) or \
+                   (party_code and (party_code.lower() == guest_party.lower() or party_code.lower() == guest_group.lower())):
+                    matching_guests.append(guest)
+            
+            # Track which plus one names have been assigned for this specific party
+            party_assigned_plus_ones = set()
+            
+            # Update matching guests
+            for guest in matching_guests:
+                guest_name = f"{guest.get('first_name', '')} {guest.get('last_name', '')}".strip()
+                is_nan_guest = guest.get('first_name') == 'nan' and guest.get('last_name') == 'nan'
+                
+                # Update phone if provided
+                if phone_number and phone_number != 'nan':
+                    guest['phone'] = self._format_phone_number(phone_number)
+                
+                # Handle guests with "nan" names (these are plus ones that need names)
+                if is_nan_guest and party_attendee_names:
+                    # Find the plus one name that matches this guest's party/group
+                    # Look for names that aren't the main guest name
+                    main_guest_name = name  # The main guest from RSVP data
+                    plus_one_candidates = [name for name in party_attendee_names if name.lower() != main_guest_name.lower()]
+                    
+                    # Find the first plus one candidate that hasn't been assigned yet for this party
+                    plus_one_name = None
+                    for candidate in plus_one_candidates:
+                        if candidate not in party_assigned_plus_ones:
+                            plus_one_name = candidate
+                            party_assigned_plus_ones.add(candidate)
+                            break
+                    
+                    if plus_one_name:
+                        # Parse the plus one name into first and last name
+                        name_parts = plus_one_name.strip().split()
+                        if len(name_parts) >= 2:
+                            guest['first_name'] = name_parts[0]
+                            guest['last_name'] = ' '.join(name_parts[1:])  # Join remaining parts as last name
+                        else:
+                            guest['first_name'] = plus_one_name
+                            guest['last_name'] = ''
+                        
+                        guest['plus_one'] = False  # This is now a named guest
+                        guest['plus_one_name'] = ''  # Clear the plus one name field
+                        
+                        # Update allergies for the plus one
+                        if plus_one_name in dietary_dict:
+                            guest['allergies'] = dietary_dict[plus_one_name]
+                        
+                        # Apply party RSVP to this plus one
+                        if event_dict:
+                            rsvp_by_event = {}
+                            meal_selections = {}
+                            
+                            for event_name, event_data in event_dict.items():
+                                if isinstance(event_data, dict):
+                                    # Check if this plus one is specifically listed as an attendee
+                                    attendees = event_data.get('attendees', [])
+                                    party_rsvp = event_data.get('rsvp', 'Pending')
+                                    
+                                    # Determine individual RSVP status
+                                    if plus_one_name in attendees:
+                                        # Plus one is listed as attending, use party RSVP
+                                        rsvp_status = party_rsvp
+                                    else:
+                                        # Plus one is not listed as attending, mark as "No"
+                                        rsvp_status = 'No'
+                                    
+                                    rsvp_by_event[event_name] = rsvp_status
+                                    
+                                    # Update meal choices if provided and plus one is attending
+                                    if rsvp_status == 'Yes':
+                                        meal_choice = event_data.get('meal_choice', {})
+                                        if meal_choice and isinstance(meal_choice, dict) and plus_one_name in meal_choice:
+                                            selected_meal = meal_choice[plus_one_name]
+                                            meal_selections[event_name] = selected_meal
+                                            
+                                            # Track new meal options for this event
+                                            if event_name not in new_meal_options_by_event:
+                                                new_meal_options_by_event[event_name] = set()
+                                            new_meal_options_by_event[event_name].add(selected_meal)
+                            
+                            guest['rsvp_by_event'] = rsvp_by_event
+                            guest['meal_selections'] = meal_selections
+                
+                # Handle named guests (main guests) - but don't assign plus ones if they're separate guests
+                elif not is_nan_guest:
+                    # Check if this guest should have a plus one
+                    # Only assign plus one if there are attendees not already represented as separate guests
+                    other_attendees = [name for name in party_attendee_names if name.lower() != guest_name.lower()]
+                    
+                    # Check if any of these other attendees are already separate guests
+                    separate_guests = []
+                    for other_attendee in other_attendees:
+                        for existing_guest in existing_guests:
+                            existing_guest_name = f"{existing_guest.get('first_name', '')} {existing_guest.get('last_name', '')}".strip()
+                            if other_attendee.lower() == existing_guest_name.lower():
+                                separate_guests.append(other_attendee)
+                    
+                    # Only assign plus one if there are attendees that aren't separate guests
+                    plus_one_candidates = [name for name in other_attendees if name not in separate_guests]
+                    
+                    if plus_one_candidates:
+                        guest['plus_one'] = True
+                        guest['plus_one_name'] = plus_one_candidates[0]  # Take the first plus one
+                        
+                        # Update plus one allergies
+                        if plus_one_candidates[0] in dietary_dict:
+                            guest['plus_one_allergies'] = dietary_dict[plus_one_candidates[0]]
+                    else:
+                        guest['plus_one'] = False
+                        guest['plus_one_name'] = ''
+                    
+                    # Update allergies for the main guest
+                    if guest_name in dietary_dict:
+                        guest['allergies'] = dietary_dict[guest_name]
+                    
+                    # Apply party RSVP to main guest
+                    if event_dict:
+                        rsvp_by_event = guest.get('rsvp_by_event', {})
+                        meal_selections = guest.get('meal_selections', {})
+                        
+                        for event_name, event_data in event_dict.items():
+                            if isinstance(event_data, dict):
+                                # Check if this guest is specifically listed as an attendee
+                                attendees = event_data.get('attendees', [])
+                                party_rsvp = event_data.get('rsvp', 'Pending')
+                                
+                                # Determine individual RSVP status
+                                if guest_name in attendees:
+                                    # Guest is listed as attending, use party RSVP
+                                    rsvp_status = party_rsvp
+                                else:
+                                    # Guest is not listed as attending, mark as "No"
+                                    rsvp_status = 'No'
+                                
+                                rsvp_by_event[event_name] = rsvp_status
+                                
+                                # Update meal choices if provided and guest is attending
+                                if rsvp_status == 'Yes':
+                                    meal_choice = event_data.get('meal_choice', {})
+                                    if meal_choice and isinstance(meal_choice, dict) and guest_name in meal_choice:
+                                        selected_meal = meal_choice[guest_name]
+                                        meal_selections[event_name] = selected_meal
+                                        
+                                        # Track new meal options for this event
+                                        if event_name not in new_meal_options_by_event:
+                                            new_meal_options_by_event[event_name] = set()
+                                        new_meal_options_by_event[event_name].add(selected_meal)
+                        
+                        guest['rsvp_by_event'] = rsvp_by_event
+                        guest['meal_selections'] = meal_selections
+                
+                updated_count += 1
+        
+        # Update event configuration with new meal options
+        config_updated = False
+        if new_meal_options_by_event:
+            wedding_events = config.get('wedding_events', [])
+            for event in wedding_events:
+                event_name = event.get('name', '')
+                if event_name in new_meal_options_by_event:
+                    # Get existing meal options for this event
+                    existing_meal_options = set(event.get('meal_options', []))
+                    # Get new meal options from RSVP data
+                    new_meal_options = new_meal_options_by_event[event_name]
+                    
+                    # Merge existing and new meal options
+                    all_meal_options = existing_meal_options.union(new_meal_options)
+                    
+                    # Update the event configuration
+                    event['meal_options'] = sorted(list(all_meal_options))
+                    config_updated = True
+            
+            # Save updated configuration if changes were made
+            if config_updated:
+                self.config_manager.save_config(config)
+                st.info(f"Updated event meal options with new choices from RSVP data")
+        
+        # Clean up any remaining "nan" guests that weren't updated
+        # These are likely plus ones that don't have corresponding RSVP data
+        for guest in existing_guests:
+            if guest.get('first_name') == 'nan' and guest.get('last_name') == 'nan':
+                # If this nan guest still has no name, it means no RSVP data was provided
+                # We can either keep it as a placeholder or remove it
+                # For now, we'll keep it but mark it as inactive
+                guest['plus_one'] = False
+                guest['plus_one_name'] = ''
+        
+        # Clean up duplicate guests
+        existing_guests = self.remove_duplicate_guests(existing_guests)
+        
+        # Save updated guests
+        if updated_count > 0:
+            self.config_manager.save_json_data('guests.json', existing_guests)
+        
+        return updated_count
+    
+    def remove_duplicate_guests(self, guests):
+        """Remove duplicate guests based on name and group"""
+        seen_guests = set()
+        unique_guests = []
+        
+        for guest in guests:
+            first_name = guest.get('first_name', '').strip()
+            last_name = guest.get('last_name', '').strip()
+            group = guest.get('group', '').strip()
+            
+            # Create a unique identifier for this guest
+            guest_key = f"{first_name.lower()}_{last_name.lower()}_{group.lower()}"
+            
+            if guest_key not in seen_guests:
+                seen_guests.add(guest_key)
+                unique_guests.append(guest)
+            else:
+                # This is a duplicate - we can optionally log it or merge data
+                st.warning(f"Removed duplicate guest: {first_name} {last_name} from {group}")
+        
+        return unique_guests
+    
+    def render_guest_form(self, config):
+        """Render form to add new guest"""
+        with st.form("guest_form"):
+            st.markdown("#### Basic Information")
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                first_name = st.text_input("First Name *", placeholder="Enter first name")
+                last_name = st.text_input("Last Name *", placeholder="Enter last name")
+                group = st.text_input("Group", placeholder="Enter group name")
+                party = st.text_input("Party/Family", placeholder="Enter party or family name")
+            
+            with col2:
+                phone = st.text_input("Phone Number", placeholder="Enter phone number")
+                address = st.text_input("Address", placeholder="Home address")
+                lodging = st.text_input("Wedding Lodging", placeholder="Hotel, Airbnb, etc. for wedding")
+                allergies = st.text_area("Allergies/Dietary Restrictions", placeholder="List any allergies or dietary restrictions")
+            
+            st.markdown("#### Plus One Information")
+            plus_one = st.checkbox("Bringing Plus One")
+            
+            if plus_one:
+                col1, col2 = st.columns(2)
+                with col1:
+                    plus_one_name = st.text_input("Plus One Name", placeholder="Enter plus one's name")
+                    plus_one_phone = st.text_input("Plus One Phone", placeholder="Enter plus one's phone")
+                with col2:
+                    plus_one_allergies = st.text_area("Plus One Allergies", placeholder="Plus one's allergies/dietary restrictions")
+            else:
+                plus_one_name = ""
+                plus_one_phone = ""
+                plus_one_allergies = ""
+            
+            # RSVP and meal selections for each event
+            wedding_events = config.get('wedding_events', [])
+            if wedding_events:
+                st.markdown("#### RSVP & Meal Selections")
+                rsvp_by_event = {}
+                meal_selections = {}
+                
+                for event in wedding_events:
+                    event_name = event.get('name', '')
+                    if event_name:
+                        col1, col2 = st.columns(2)
+                        
+                        with col1:
+                            # RSVP selection
+                            rsvp_options = ['Pending', 'Yes', 'No']
+                            rsvp = st.selectbox(f"RSVP for {event_name}", rsvp_options, key=f"add_rsvp_{event_name}")
+                            rsvp_by_event[event_name] = rsvp
+                        
+                        with col2:
+                            # Meal selection (only if event requires meal choice)
+                            if event.get('requires_meal_choice', False):
+                                meal_options = event.get('meal_options', [])
+                                if meal_options:
+                                    meal_options_with_default = ['Not Selected'] + meal_options
+                                    meal = st.selectbox(f"Meal for {event_name}", meal_options_with_default, key=f"add_meal_{event_name}")
+                                    meal_selections[event_name] = meal
+            
+            submitted = st.form_submit_button("Add Guest", type="primary")
+            
+            if submitted:
+                if first_name and last_name:
+                    new_guest = {
+                        'id': datetime.now().strftime("%Y%m%d_%H%M%S_%f"),
+                        'first_name': first_name,
+                        'last_name': last_name,
+                        'group': group,
+                        'party': party,
+                        'phone': phone,
+                        'address': address,
+                        'lodging': lodging,
+                        'allergies': allergies,
+                        'plus_one': plus_one,
+                        'plus_one_name': plus_one_name,
+                        'plus_one_phone': plus_one_phone,
+                        'plus_one_allergies': plus_one_allergies,
+                        'rsvp_by_event': rsvp_by_event if wedding_events else {},
+                        'meal_selections': meal_selections if wedding_events else {},
+                        'created_date': datetime.now().isoformat()
+                    }
+                    
+                    # Load existing guests and add new one
+                    guests = self.config_manager.load_json_data('guests.json')
+                    guests.append(new_guest)
+                    
+                    if self.config_manager.save_json_data('guests.json', guests):
+                        st.success("Guest added successfully!")
+                        st.rerun()
+                    else:
+                        st.error("Error saving guest")
+                else:
+                    st.error("Please enter at least first and last name")
+    
+    def render_guests_table(self, guests, config):
+        """Render guests in an editable table format"""
+        # Get wedding events for RSVP and meal options
+        wedding_events = config.get('wedding_events', [])
+        
+        # Create DataFrame for display
+        df_data = []
+        for guest in guests:
+            # Handle guests with "nan" names (these are plus ones)
+            first_name = guest.get('first_name', '')
+            last_name = guest.get('last_name', '')
+            
+            # If first/last name is "nan" or empty, this is likely an unassigned plus one
+            if first_name in ['nan', ''] and last_name in ['nan', '']:
+                # This is an unassigned plus one placeholder
+                first_name = '[Unassigned Plus One]'
+                last_name = ''
+            
+            row = {
+                'First Name': first_name,
+                'Last Name': last_name,
+                'Group': guest.get('group', ''),
+                'Party': guest.get('party', ''),
+                'Phone': guest.get('phone', ''),
+                'Address': guest.get('address', ''),
+                'Wedding Lodging': guest.get('lodging', ''),
+                'Allergies': guest.get('allergies', ''),
+                'Plus One Allergies': guest.get('plus_one_allergies', '')
+            }
+            
+            # Add RSVP columns for each event
+            rsvp_by_event = guest.get('rsvp_by_event', {})
+            for event in wedding_events:
+                event_name = event.get('name', '')
+                if event_name:
+                    row[f'RSVP - {event_name}'] = rsvp_by_event.get(event_name, 'Pending')
+            
+            # Add meal selection columns for events that require meal choice
+            meal_selections = guest.get('meal_selections', {})
+            for event in wedding_events:
+                if event.get('requires_meal_choice', False):
+                    event_name = event.get('name', '')
+                    if event_name:
+                        row[f'Meal - {event_name}'] = meal_selections.get(event_name, 'Not Selected')
+            
+            df_data.append(row)
+        
+        if df_data:
+            df = pd.DataFrame(df_data)
+            
+            # Display the table
+            st.dataframe(
+                df,
+                use_container_width=True,
+                hide_index=True,
+                height=400
+            )
+            
+            # Edit/Delete guest section
+            st.markdown("### Manage Guest")
+            guest_ids = [f"{guest.get('first_name', '')} {guest.get('last_name', '')}" for guest in guests]
+            selected_guest_name = st.selectbox("Select Guest to Manage", guest_ids)
+            
+            if selected_guest_name:
+                # Find the selected guest
+                selected_guest = None
+                for guest in guests:
+                    if f"{guest.get('first_name', '')} {guest.get('last_name', '')}" == selected_guest_name:
+                        selected_guest = guest
+                        break
+                
+                if selected_guest:
+                    # Create tabs for edit and delete
+                    tab1, tab2 = st.tabs(["Edit Guest", "Delete Guest"])
+                    
+                    with tab1:
+                        self.render_guest_edit_form(selected_guest, guests, config)
+                    
+                    with tab2:
+                        self.render_guest_delete_form(selected_guest, guests)
+    
+    def render_guest_edit_form(self, guest, all_guests, config):
+        """Render form to edit guest information"""
+        with st.form(f"edit_guest_{guest.get('id', '')}"):
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                first_name = st.text_input("First Name", value=guest.get('first_name', ''), key=f"edit_first_{guest.get('id', '')}")
+                last_name = st.text_input("Last Name", value=guest.get('last_name', ''), key=f"edit_last_{guest.get('id', '')}")
+                group = st.text_input("Group", value=guest.get('group', ''), key=f"edit_group_{guest.get('id', '')}")
+                party = st.text_input("Party/Family", value=guest.get('party', ''), key=f"edit_party_{guest.get('id', '')}")
+                phone = st.text_input("Phone Number", value=guest.get('phone', ''), key=f"edit_phone_{guest.get('id', '')}")
+                address = st.text_input("Address", value=guest.get('address', ''), key=f"edit_address_{guest.get('id', '')}")
+                lodging = st.text_input("Wedding Lodging", value=guest.get('lodging', ''), key=f"edit_lodging_{guest.get('id', '')}")
+            
+            with col2:
+                allergies = st.text_area("Allergies/Dietary Restrictions", value=guest.get('allergies', ''), key=f"edit_allergies_{guest.get('id', '')}")
+                plus_one = st.checkbox("Bringing Plus One", value=guest.get('plus_one', False), key=f"edit_plus_one_{guest.get('id', '')}")
+                
+                if plus_one:
+                    plus_one_name = st.text_input("Plus One Name", value=guest.get('plus_one_name', ''), key=f"edit_plus_one_name_{guest.get('id', '')}")
+                    plus_one_phone = st.text_input("Plus One Phone", value=guest.get('plus_one_phone', ''), key=f"edit_plus_one_phone_{guest.get('id', '')}")
+                    plus_one_allergies = st.text_area("Plus One Allergies", value=guest.get('plus_one_allergies', ''), key=f"edit_plus_one_allergies_{guest.get('id', '')}")
+                else:
+                    plus_one_name = ""
+                    plus_one_phone = ""
+                    plus_one_allergies = ""
+            
+            # RSVP and meal selections for each event
+            st.markdown("#### RSVP & Meal Selections")
+            wedding_events = config.get('wedding_events', [])
+            rsvp_by_event = guest.get('rsvp_by_event', {})
+            meal_selections = guest.get('meal_selections', {})
+            
+            for event in wedding_events:
+                event_name = event.get('name', '')
+                if event_name:
+                    col1, col2 = st.columns(2)
+                    
+                    with col1:
+                        # RSVP selection
+                        current_rsvp = rsvp_by_event.get(event_name, 'Pending')
+                        rsvp_options = ['Pending', 'Yes', 'No']
+                        rsvp_index = rsvp_options.index(current_rsvp) if current_rsvp in rsvp_options else 0
+                        new_rsvp = st.selectbox(f"RSVP for {event_name}", rsvp_options, index=rsvp_index, key=f"edit_rsvp_{event_name}_{guest.get('id', '')}")
+                        rsvp_by_event[event_name] = new_rsvp
+                    
+                    with col2:
+                        # Meal selection (only if event requires meal choice)
+                        if event.get('requires_meal_choice', False):
+                            meal_options = event.get('meal_options', [])
+                            if meal_options:
+                                current_meal = meal_selections.get(event_name, 'Not Selected')
+                                meal_options_with_default = ['Not Selected'] + meal_options
+                                meal_index = meal_options_with_default.index(current_meal) if current_meal in meal_options_with_default else 0
+                                new_meal = st.selectbox(f"Meal for {event_name}", meal_options_with_default, index=meal_index, key=f"edit_meal_{event_name}_{guest.get('id', '')}")
+                                meal_selections[event_name] = new_meal
+            
+            submitted = st.form_submit_button("Save Changes", type="primary")
+            
+            if submitted:
+                # Update guest data
+                guest['first_name'] = first_name
+                guest['last_name'] = last_name
+                guest['group'] = group
+                guest['party'] = party
+                guest['phone'] = phone
+                guest['address'] = address
+                guest['lodging'] = lodging
+                guest['allergies'] = allergies
+                guest['plus_one'] = plus_one
+                guest['plus_one_name'] = plus_one_name
+                guest['plus_one_phone'] = plus_one_phone
+                guest['plus_one_allergies'] = plus_one_allergies
+                guest['rsvp_by_event'] = rsvp_by_event
+                guest['meal_selections'] = meal_selections
+                
+                # Save updated guests
+                if self.config_manager.save_json_data('guests.json', all_guests):
+                    st.success("Guest updated successfully!")
+                    st.rerun()
+                else:
+                    st.error("Error saving guest changes")
+    
+    def render_guest_delete_form(self, guest, all_guests):
+        """Render form to delete guest"""
+        st.markdown("### ⚠️ Delete Guest")
+        
+        # Show guest information for confirmation
+        st.markdown(f"**Guest to Delete:** {guest.get('first_name', '')} {guest.get('last_name', '')}")
+        st.markdown(f"**Party:** {guest.get('party', 'N/A')}")
+        st.markdown(f"**Phone:** {guest.get('phone', 'N/A')}")
+        
+        if guest.get('plus_one', False):
+            st.markdown(f"**Plus One:** {guest.get('plus_one_name', 'N/A')}")
+        
+        st.warning("⚠️ **Warning:** This action cannot be undone. All guest information, RSVP responses, and meal selections will be permanently deleted.")
+        
+        # Confirmation checkbox
+        confirm_delete = st.checkbox("I understand this action cannot be undone", key=f"confirm_delete_{guest.get('id', '')}")
+        
+        # Delete button
+        if st.button("🗑️ Delete Guest", type="secondary", disabled=not confirm_delete, key=f"delete_guest_{guest.get('id', '')}"):
+            # Remove guest from list
+            all_guests = [g for g in all_guests if g.get('id') != guest.get('id')]
+            
+            # Save updated guests
+            if self.config_manager.save_json_data('guests.json', all_guests):
+                st.success(f"Guest {guest.get('first_name', '')} {guest.get('last_name', '')} has been deleted successfully!")
+                st.rerun()
+            else:
+                st.error("Error deleting guest")
+    
+    def get_guest_summary(self, guests):
+        """Get summary statistics for guests"""
+        total_guests = len(guests)
+        plus_ones = sum(1 for guest in guests if guest.get('plus_one', False))
+        total_attendees = total_guests + plus_ones
+        
+        return {
+            'total_guests': total_guests,
+            'plus_ones': plus_ones,
+            'total_attendees': total_attendees
+        }
+    
+    def load_data(self):
+        """Load guest list and RSVP data from storage"""
+        self.guest_list_data = self.config_manager.load_json_data('guest_list_data.json')
+        self.rsvp_data = self.config_manager.load_json_data('rsvp_data.json')
+    
+    def save_data(self):
+        """Save guest list and RSVP data to storage"""
+        if self.guest_list_data is not None:
+            self.config_manager.save_json_data('guest_list_data.json', self.guest_list_data)
+        if self.rsvp_data is not None:
+            self.config_manager.save_json_data('rsvp_data.json', self.rsvp_data)
+    
+    def process_guest_list_csv(self, df):
+        """Process guest list CSV and create structured data"""
+        groups = {}
+        
+        for _, row in df.iterrows():
+            first_name = str(row.get('First Name (Empty Rows are +1s)', '')).strip()
+            last_name = str(row.get('Last Name', '')).strip()
+            group_name = str(row.get('Group', '')).strip()
+            group_size = str(row.get('Group Size', '')).strip()
+            party = str(row.get('Party', '')).strip()
+            
+            # Skip empty rows
+            if not group_name:
+                continue
+            
+            # Initialize group if not exists
+            if group_name not in groups:
+                groups[group_name] = {
+                    'group_name': group_name,
+                    'group_size': int(group_size) if group_size.isdigit() else 0,
+                    'party': party,
+                    'address': self._build_address(row),
+                    'named_guests': [],
+                    'plus_one_spots': 0
+                }
+            
+            # Check if this is a named guest or plus one spot
+            # A named guest has at least a first name (last name can be empty)
+            # A plus one spot has both first and last names empty
+            if first_name and first_name != 'nan':
+                # Named guest (even if last name is empty)
+                full_name = f"{first_name} {last_name}".strip() if last_name and last_name != 'nan' else first_name
+                groups[group_name]['named_guests'].append({
+                    'first_name': first_name,
+                    'last_name': last_name if last_name and last_name != 'nan' else '',
+                    'full_name': full_name
+                })
+            else:
+                # Plus one spot (both first and last names are empty)
+                groups[group_name]['plus_one_spots'] += 1
+        
+        self.guest_list_data = groups
+        self.save_data()
+    
+    def process_rsvp_csv(self, df, config):
+        """Process RSVP CSV and update guest data"""
+        if self.guest_list_data is None:
+            st.error("Please upload guest list first")
+            return
+        
+        rsvp_responses = {}
+        
+        for _, row in df.iterrows():
+            group_code = str(row.get('group_code', '')).strip()
+            name = str(row.get('name', '')).strip()
+            overall_rsvp = str(row.get('overall_rsvp', '')).strip()
+            bringing_plus_one = str(row.get('bringing_plus_one', '')).strip().lower() == 'yes'
+            group_attendees = str(row.get('group_attendees', '')).strip()
+            event_responses = str(row.get('event_responses', '')).strip()
+            dietary_restrictions = str(row.get('dietary_restrictions', '')).strip()
+            phone_number = str(row.get('phone_number', '')).strip()
+            
+            if not group_code:
+                continue
+            
+            # Parse event responses
+            event_dict = {}
+            if event_responses and event_responses != 'nan' and event_responses != '{}':
+                try:
+                    event_dict = json.loads(event_responses)
+                except:
+                    pass
+            
+            # Parse dietary restrictions
+            dietary_dict = {}
+            if dietary_restrictions and dietary_restrictions != 'nan' and dietary_restrictions != '{}':
+                try:
+                    dietary_dict = json.loads(dietary_restrictions)
+                except:
+                    pass
+            
+            # Parse group attendees
+            attendee_names = []
+            if group_attendees and group_attendees != 'nan':
+                attendee_names = [name.strip() for name in group_attendees.split(';') if name.strip()]
+            
+            rsvp_responses[group_code] = {
+                'group_code': group_code,
+                'name': name,
+                'overall_rsvp': overall_rsvp,
+                'bringing_plus_one': bringing_plus_one,
+                'group_attendees': attendee_names,
+                'event_responses': event_dict,
+                'dietary_restrictions': dietary_dict,
+                'phone_number': self._format_phone_number(phone_number)
+            }
+        
+        self.rsvp_data = rsvp_responses
+        self.save_data()
+    
+    def _format_phone_number(self, phone):
+        """Format phone number for display"""
+        if not phone or phone.strip() == '' or phone == 'nan':
+            return 'No phone provided'
+        
+        # Remove all non-digit characters
+        digits_only = ''.join(filter(str.isdigit, phone))
+        
+        # Handle empty result
+        if not digits_only:
+            return 'No phone provided'
+        
+        # US phone numbers (10 digits)
+        if len(digits_only) == 10:
+            return f"({digits_only[:3]}) {digits_only[3:6]}-{digits_only[6:]}"
+        
+        # US phone numbers with country code (11 digits starting with 1)
+        elif len(digits_only) == 11 and digits_only.startswith('1'):
+            return f"+1 ({digits_only[1:4]}) {digits_only[4:7]}-{digits_only[7:]}"
+        
+        # International numbers (more than 11 digits or doesn't start with 1)
+        elif len(digits_only) > 11 or (len(digits_only) == 11 and not digits_only.startswith('1')):
+            # Format as international with + prefix
+            return f"+{digits_only}"
+        
+        # Other cases - return as is with some formatting
+        else:
+            return phone.strip()
+    
+    def _build_address(self, row):
+        """Build full address from row data"""
+        address_parts = []
+        street = str(row.get('  Street address', '')).strip()
+        apt = str(row.get('  Apt/Suite', '')).strip()
+        city = str(row.get('  City', '')).strip()
+        state = str(row.get('  State', '')).strip()
+        zip_code = str(row.get('  ZIP', '')).strip()
+        country = str(row.get('Country', '')).strip()
+        
+        if street and street != 'nan':
+            address_parts.append(street)
+        if apt and apt != 'nan':
+            address_parts.append(f"Apt {apt}")
+        if city and city != 'nan':
+            address_parts.append(city)
+        if state and state != 'nan':
+            address_parts.append(state)
+        if zip_code and zip_code != 'nan':
+            address_parts.append(zip_code)
+        if country and country != 'nan':
+            address_parts.append(country)
+        
+        return ', '.join(address_parts)
+    
+    def render_guest_table(self, config):
+        """Render the comprehensive guest table"""
+        if not self.guest_list_data:
+            return
+        
+        st.markdown("### Guest List Overview")
+        
+        # Create comprehensive guest list
+        all_guests = self._create_comprehensive_guest_list(config)
+        
+        if not all_guests:
+            st.info("No guests to display")
+            return
+        
+        # Add filter options
+        col1, col2 = st.columns([1, 3])
+        with col1:
+            filter_option = st.selectbox(
+                "Filter Guests:",
+                ["All Guests", "Confirmed Guests Only"],
+                help="Filter to show all guests or only those who have confirmed attendance to at least one event"
+            )
+        
+        # Filter guests based on selection
+        if filter_option == "Confirmed Guests Only":
+            confirmed_guests = [guest for guest in all_guests if any(status == 'Yes' for status in guest.get('rsvp_by_event', {}).values())]
+            display_guests = confirmed_guests
+            st.info(f"Showing {len(confirmed_guests)} confirmed guests out of {len(all_guests)} total guests")
+        else:
+            display_guests = all_guests
+            st.info(f"Showing all {len(all_guests)} guests")
+        
+        # Create DataFrame for display
+        df_data = []
+        for guest in display_guests:
+            row = {
+                'Name': guest['display_name'],
+                'Group': guest['group_name'],
+                'Party': guest['party'],
+                'Phone': guest.get('phone', ''),
+                'Address': guest.get('address', '')
+            }
+            
+            # Add RSVP columns for each event
+            wedding_events = config.get('wedding_events', [])
+            for event in wedding_events:
+                event_name = event.get('name', '')
+                if event_name:
+                    row[f'RSVP - {event_name}'] = guest.get('rsvp_by_event', {}).get(event_name, 'Pending')
+            
+            # Add meal selection columns for events that require meal choice
+            for event in wedding_events:
+                if event.get('requires_meal_choice', False):
+                    event_name = event.get('name', '')
+                    if event_name:
+                        row[f'Meal - {event_name}'] = guest.get('meal_selections', {}).get(event_name, 'Not Selected')
+            
+            df_data.append(row)
+        
+        if df_data:
+            df = pd.DataFrame(df_data)
+            
+            # Display the table
+            st.dataframe(
+                df,
+                use_container_width=True,
+                hide_index=True,
+                height=min(600, len(df_data) * 35 + 50)
+            )
+            
+            # Summary statistics
+            self._render_summary_stats(display_guests, config)
+    
+    def _create_comprehensive_guest_list(self, config):
+        """Create a comprehensive list of all guests with RSVP data"""
+        all_guests = []
+        
+        for group_name, group_data in self.guest_list_data.items():
+            # Get RSVP data for this group
+            rsvp_data = self.rsvp_data.get(group_name, {}) if self.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': rsvp_data.get('phone_number', ''),
+                    'rsvp_by_event': {},
+                    'meal_selections': {}
+                }
+                
+                # Apply RSVP data
+                self._apply_rsvp_to_guest(guest, rsvp_data, config)
+                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 = 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, rsvp_data, config)
+                    all_guests.append(guest)
+        
+        return all_guests
+    
+    def _apply_rsvp_to_guest(self, guest, rsvp_data, config):
+        """Apply RSVP data to a guest"""
+        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_summary_stats(self, all_guests, config):
+        """Render summary statistics"""
+        st.markdown("### Summary Statistics")
+        
+        col1, col2, col3, col4, col5 = st.columns(5)
+        
+        with col1:
+            total_guests = len(all_guests)
+            st.metric("Total Guests", total_guests)
+        
+        with col2:
+            named_guests = len([g for g in all_guests if g['type'] == 'Named Guest'])
+            st.metric("Named Guests", named_guests)
+        
+        with col3:
+            plus_ones = len([g for g in all_guests if 'Plus One' in g['type']])
+            st.metric("Plus Ones", plus_ones)
+        
+        with col4:
+            confirmed = len([g for g in all_guests if any(status == 'Yes' for status in g.get('rsvp_by_event', {}).values())])
+            st.metric("Confirmed Attendees", confirmed)
+        
+        with col5:
+            # Count confirmed plus ones (plus ones who have confirmed to at least one event)
+            confirmed_plus_ones = len([g for g in all_guests if 'Plus One' in g['type'] and any(status == 'Yes' for status in g.get('rsvp_by_event', {}).values())])
+            st.metric("Confirmed Plus Ones", confirmed_plus_ones)
+        
+        # Event attendance breakdown
+        st.markdown("#### Event Attendance")
+        wedding_events = config.get('wedding_events', [])
+        
+        event_stats = []
+        for event in wedding_events:
+            event_name = event.get('name', '')
+            yes_count = len([g for g in all_guests if g.get('rsvp_by_event', {}).get(event_name) == 'Yes'])
+            no_count = len([g for g in all_guests if g.get('rsvp_by_event', {}).get(event_name) == 'No'])
+            pending_count = len([g for g in all_guests if g.get('rsvp_by_event', {}).get(event_name) == 'Pending'])
+            
+            event_stats.append({
+                'Event': event_name,
+                'Yes': yes_count,
+                'No': no_count,
+                'Pending': pending_count
+            })
+        
+        if event_stats:
+            stats_df = pd.DataFrame(event_stats)
+            st.dataframe(stats_df, use_container_width=True, hide_index=True)
+        
+        # Meal choice breakdown
+        st.markdown("#### Meal Choices")
+        wedding_events = config.get('wedding_events', [])
+        
+        # Get events that require meal choices
+        meal_events = [event for event in wedding_events if event.get('requires_meal_choice', False)]
+        
+        if meal_events:
+            for event in meal_events:
+                event_name = event.get('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 guest in all_guests:
+                        meal_selections = guest.get('meal_selections', {})
+                        selected_meal = meal_selections.get(event_name, '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(guest['display_name'])
+                        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 guest to get their phone number
+                                    guest_info = next((g for g in all_guests if g['display_name'] == guest_name), None)
+                                    
+                                    # Get phone number - prefer individual phone, fall back to group contact
+                                    phone = 'No phone provided'
+                                    if guest_info:
+                                        # Check if guest has individual phone number
+                                        individual_phone = guest_info.get('phone', '')
+                                        if individual_phone and individual_phone.strip() and individual_phone != 'No phone provided':
+                                            phone = individual_phone
+                                        else:
+                                            # Use group contact phone number
+                                            group_name = guest_info.get('group_name', '')
+                                            if group_name and self.rsvp_data and group_name in self.rsvp_data:
+                                                group_phone = self.rsvp_data[group_name].get('phone_number', '')
+                                                if group_phone and group_phone.strip() and group_phone != 'No phone provided':
+                                                    phone = f"{group_phone} (Group Contact)"
+                                    
+                                    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)}")
+        else:
+            st.info("No events require meal choices.")

requirements.txt

@@ -1,3 +1,12 @@
-altair
-pandas
-streamlit
+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
+streamlit-authenticator>=0.2.3
+PyYAML>=6.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()