app.py

#!/usr/bin/env python3
"""
ODA Welfare Admin Panel
Separate admin interface for adding new members to MongoDB
"""
import gradio as gr
import pandas as pd
from pymongo import MongoClient
import logging
import os
from dotenv import load_dotenv
from datetime import datetime
from reportlab.lib import colors
from reportlab.lib.pagesizes import A4
from reportlab.platypus import SimpleDocTemplate, Table, TableStyle, Paragraph, Spacer
from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
from reportlab.lib.units import inch
from reportlab.lib.enums import TA_CENTER
import tempfile

load_dotenv()
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def connect_mongodb():
    """Connect to MongoDB database"""
    try:
        connection_string = os.getenv("MONGODB_CONNECTION", "mongodb://localhost:27017/")
        database_name = os.getenv("DATABASE_NAME", "oda_welfare")
        client = MongoClient(connection_string)
        db = client[database_name]
        client.admin.command('ping')
        return db, client
    except Exception as e:
        logger.error(f"Failed to connect to MongoDB: {e}")
        return None, None

def validate_api_key(api_key):
    """Validate API key for admin operations"""
    admin_key = os.getenv("ADMIN_API_KEY")
    if not admin_key or not api_key:
        return False
    return api_key == admin_key

def add_new_member(member_id, name, amount, mission, api_key):
    """Add a new member to MongoDB with API key protection"""
    try:
        # Validate API key
        if not validate_api_key(api_key):
            return False, "❌ Invalid API key. Access denied."
        
        # Validate inputs
        if not name or not name.strip():
            return False, "❌ Member name is required."
        
        # Validate member ID
        try:
            member_id = int(member_id) if member_id else None
        except (ValueError, TypeError):
            return False, "❌ Invalid member ID format."
            
        if not member_id or member_id <= 0:
            return False, "❌ Member ID must be a positive number."
        
        try:
            amount = float(amount) if amount else 0.0
        except ValueError:
            return False, "❌ Invalid amount format."
        
        # Connect to MongoDB
        db, client = connect_mongodb()
        if db is None:
            return False, "❌ Database connection failed."
        
        members_collection = db.members
        
        # Check if member ID already exists
        existing_member = members_collection.find_one({"member_id": member_id})
        if existing_member:
            if client:
                client.close()
            return False, f"❌ Member ID {member_id} already exists. Please use a different ID."
        
        # Create new member document
        new_member = {
            "member_id": member_id,
            "name": name.strip(),
            "amount": amount,
            "mission": mission.strip() if mission else "",
            "indexed_at": datetime.now(),
            "status": "active"
        }
        
        # Insert member
        result = members_collection.insert_one(new_member)
        
        if client:
            client.close()
        
        if result.inserted_id:
            logger.info(f"Added new member: {name} (ID: {member_id})")
            return True, f"✅ Member '{name}' added successfully with ID {member_id}"
        else:
            return False, "❌ Failed to add member to database."
        
    except Exception as e:
        logger.error(f"Error adding member: {e}")
        return False, f"❌ Error: {str(e)}"

def get_member_stats():
    """Get member count and target for progress visualization"""
    try:
        db, client = connect_mongodb()
        if db is None:
            return 0, 450
        
        members_collection = db.members
        member_count = members_collection.count_documents({})
        
        if client:
            client.close()
        
        target_members = 450
        return member_count, target_members
        
    except Exception as e:
        logger.error(f"Error getting stats: {e}")
        return 0, 450

def get_next_member_id():
    """Get the next available member ID (latest member ID + 1)"""
    try:
        db, client = connect_mongodb()
        if db is None:
            return 1

        members_collection = db.members

        # Get the highest member ID
        last_member = members_collection.find().sort("member_id", -1).limit(1)
        last_member_list = list(last_member)
        next_id = (last_member_list[0]["member_id"] + 1) if last_member_list else 1

        if client:
            client.close()

        return next_id

    except Exception as e:
        logger.error(f"Error getting next member ID: {e}")
        return 1

def get_contribution_types():
    """Get list of available contribution types from database"""
    try:
        db, client = connect_mongodb()
        if db is None:
            return ["Medical Support", "Education Fund", "Emergency Relief"]  # Default options
        
        # Get unique contribution types from contributions collection
        contributions_collection = db.contributions
        contribution_types = contributions_collection.distinct("contribution_type")
        
        # Also check if there's a dedicated contribution_types collection
        try:
            contribution_types_collection = db.contribution_types
            if contribution_types_collection.count_documents({}) > 0:
                stored_types = [doc['type'] for doc in contribution_types_collection.find({"status": "active"}, {"type": 1})]
                contribution_types.extend(stored_types)
        except Exception:
            pass  # Ignore if collection doesn't exist
        
        if client:
            client.close()
        
        # Remove duplicates and sort
        unique_types = sorted(list(set(contribution_types))) if contribution_types else []
        
        # Add some default options if list is empty
        if not unique_types:
            unique_types = ["Medical Support", "Education Fund", "Emergency Relief", "Memorial Fund"]
        
        return unique_types
        
    except Exception as e:
        logger.error(f"Error getting contribution types: {e}")
        return ["Medical Support", "Education Fund", "Emergency Relief"]

def create_membership_progress_display(registered_count, target_count):
    """Create a beautiful membership progress display using HTML/CSS"""
    try:
        progress_percentage = (registered_count / target_count) * 100
        remaining_count = target_count - registered_count
        
        # Create a beautiful HTML progress display
        html_display = f"""
        <div style="padding: 20px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); border-radius: 15px; color: white; margin: 10px 0;">
            <h3 style="text-align: center; margin: 0 0 20px 0;">🎯 ODA Welfare Membership Progress</h3>
            
            <div style="background: rgba(255,255,255,0.2); border-radius: 10px; padding: 20px; margin: 15px 0;">
                <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 10px;">
                    <span style="font-size: 18px; font-weight: bold;">Progress:</span>
                    <span style="font-size: 24px; font-weight: bold;">{progress_percentage:.1f}%</span>
                </div>
                
                <div style="background: rgba(255,255,255,0.3); border-radius: 25px; height: 40px; overflow: hidden; margin: 15px 0;">
                    <div style="background: linear-gradient(45deg, #28a745, #20c997); height: 100%; width: {progress_percentage}%; border-radius: 25px; display: flex; align-items: center; justify-content: center; transition: width 0.5s ease;">
                        <span style="color: white; font-weight: bold; font-size: 14px;">{registered_count} members</span>
                    </div>
                </div>
                
                <div style="display: grid; grid-template-columns: 1fr 1fr 1fr; gap: 15px; margin-top: 20px; text-align: center;">
                    <div style="background: rgba(40, 167, 69, 0.8); padding: 15px; border-radius: 10px;">
                        <div style="font-size: 28px; font-weight: bold;">{registered_count}</div>
                        <div style="font-size: 14px; opacity: 0.9;">Registered</div>
                    </div>
                    <div style="background: rgba(255, 193, 7, 0.8); padding: 15px; border-radius: 10px;">
                        <div style="font-size: 28px; font-weight: bold;">{remaining_count}</div>
                        <div style="font-size: 14px; opacity: 0.9;">Remaining</div>
                    </div>
                    <div style="background: rgba(108, 117, 125, 0.8); padding: 15px; border-radius: 10px;">
                        <div style="font-size: 28px; font-weight: bold;">{target_count}</div>
                        <div style="font-size: 14px; opacity: 0.9;">Target</div>
                    </div>
                </div>
            </div>
            
            <div style="text-align: center; margin-top: 15px; font-size: 16px;">
                <strong>🚀 {remaining_count} more members needed to reach our goal!</strong>
            </div>
        </div>
        """
        
        return html_display
        
    except Exception as e:
        logger.error(f"Error creating progress display: {e}")
        return f"<div style='color: red;'>Error creating progress display: {str(e)}</div>"

def search_member_for_edit(search_term):
    """Search for a member to edit"""
    try:
        if not search_term or not search_term.strip():
            return None, "Please enter a search term"
        
        db, client = connect_mongodb()
        if db is None:
            return None, "Database connection failed"
        
        members_collection = db.members
        search_term_clean = search_term.strip()

        # Check if search term is numeric (member ID search)
        try:
            member_id_search = int(search_term_clean)
            # Search by exact member ID or name
            query = {
                "$or": [
                    {"member_id": member_id_search},
                    {"name": {"$regex": search_term_clean, "$options": "i"}}
                ]
            }
        except ValueError:
            # Not a number, search by name only
            query = {"name": {"$regex": search_term_clean, "$options": "i"}}

        members = list(members_collection.find(query, {"_id": 0}))
        
        if client:
            client.close()
        
        if not members:
            return None, f"No member found matching '{search_term}'"
        
        return members, f"Found {len(members)} member(s)"
        
    except Exception as e:
        logger.error(f"Error searching member: {e}")
        return None, f"Error: {str(e)}"

def update_member(member_id, name, amount, mission, api_key):
    """Update an existing member"""
    try:
        # Validate API key
        if not validate_api_key(api_key):
            return False, "❌ Invalid API key. Access denied."

        # Validate inputs
        if not name or not name.strip():
            return False, "❌ Member name is required."

        try:
            amount = float(amount) if amount else 0.0
        except ValueError:
            return False, "❌ Invalid amount format."

        try:
            member_id = int(member_id)
        except ValueError:
            return False, "❌ Invalid member ID."

        # Connect to MongoDB
        db, client = connect_mongodb()
        if db is None:
            return False, "❌ Database connection failed."

        members_collection = db.members

        # Update member document
        update_data = {
            "name": name.strip(),
            "amount": amount,
            "mission": mission.strip() if mission else "",
            "updated_at": datetime.now()
        }

        result = members_collection.update_one(
            {"member_id": member_id},
            {"$set": update_data}
        )

        if client:
            client.close()

        if result.modified_count > 0:
            logger.info(f"Updated member ID {member_id}: {name}")
            return True, f"✅ Member '{name}' updated successfully"
        else:
            return False, "❌ Member not found or no changes made"

    except Exception as e:
        logger.error(f"Error updating member: {e}")
        return False, f"❌ Error: {str(e)}"

def delete_member(member_id, api_key):
    """Delete a member from the database"""
    try:
        # Validate API key
        if not validate_api_key(api_key):
            return False, "❌ Invalid API key. Access denied."

        try:
            member_id = int(member_id)
        except (ValueError, TypeError):
            return False, "❌ Invalid member ID."

        # Connect to MongoDB
        db, client = connect_mongodb()
        if db is None:
            return False, "❌ Database connection failed."

        members_collection = db.members

        # Get member info before deleting
        member = members_collection.find_one({"member_id": member_id})
        if not member:
            if client:
                client.close()
            return False, f"❌ Member with ID {member_id} not found."

        member_name = member.get('name', 'Unknown')

        # Delete the member
        result = members_collection.delete_one({"member_id": member_id})

        if client:
            client.close()

        if result.deleted_count > 0:
            logger.info(f"Deleted member ID {member_id}: {member_name}")
            return True, f"✅ Member '{member_name}' (ID: {member_id}) deleted successfully"
        else:
            return False, "❌ Failed to delete member"

    except Exception as e:
        logger.error(f"Error deleting member: {e}")
        return False, f"❌ Error: {str(e)}"

def create_contribution_type(contribution_type, description, api_key):
    """Create a new contribution type"""
    try:
        # Validate API key
        if not validate_api_key(api_key):
            return False, "❌ Invalid API key. Access denied."
        
        if not contribution_type or not contribution_type.strip():
            return False, "❌ Contribution type name is required."
        
        # Connect to MongoDB
        db, client = connect_mongodb()
        if db is None:
            return False, "❌ Database connection failed."
        
        contribution_types_collection = db.contribution_types
        
        # Check if contribution type already exists
        existing = contribution_types_collection.find_one({"type": contribution_type.strip()})
        if existing:
            if client:
                client.close()
            return False, f"❌ Contribution type '{contribution_type}' already exists."
        
        # Create new contribution type
        new_type = {
            "type": contribution_type.strip(),
            "description": description.strip() if description else "",
            "created_at": datetime.now(),
            "status": "active"
        }
        
        result = contribution_types_collection.insert_one(new_type)
        
        if client:
            client.close()
        
        if result.inserted_id:
            logger.info(f"Created new contribution type: {contribution_type}")
            return True, f"✅ Contribution type '{contribution_type}' created successfully"
        else:
            return False, "❌ Failed to create contribution type"
        
    except Exception as e:
        logger.error(f"Error creating contribution type: {e}")
        return False, f"❌ Error: {str(e)}"

def generate_members_pdf(api_key):
    """Generate a PDF with list of all registered members"""
    try:
        # Validate API key
        if not validate_api_key(api_key):
            return None, "❌ Invalid API key. Access denied."

        # Connect to MongoDB
        db, client = connect_mongodb()
        if db is None:
            return None, "❌ Database connection failed."

        members_collection = db.members

        # Fetch all members sorted by member_id
        members = list(members_collection.find({}, {"_id": 0}).sort("member_id", 1))

        if client:
            client.close()

        if not members:
            return None, "❌ No members found in database."

        # Create temporary PDF file
        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.pdf')
        pdf_path = temp_file.name
        temp_file.close()

        # Create PDF document
        doc = SimpleDocTemplate(pdf_path, pagesize=A4)
        elements = []

        # Define styles
        styles = getSampleStyleSheet()
        title_style = ParagraphStyle(
            'CustomTitle',
            parent=styles['Heading1'],
            fontSize=20,
            textColor=colors.HexColor('#2c3e50'),
            spaceAfter=30,
            alignment=TA_CENTER,
            fontName='Helvetica-Bold'
        )

        subtitle_style = ParagraphStyle(
            'CustomSubtitle',
            parent=styles['Normal'],
            fontSize=12,
            textColor=colors.HexColor('#7f8c8d'),
            spaceAfter=20,
            alignment=TA_CENTER
        )

        # Add title
        title = Paragraph("ODA WELFARE - REGISTERED MEMBERS", title_style)
        elements.append(title)

        # Add generation date and member count
        generation_date = datetime.now().strftime("%B %d, %Y at %I:%M %p")
        subtitle = Paragraph(f"Generated on: {generation_date}<br/>Total Members: {len(members)}", subtitle_style)
        elements.append(subtitle)
        elements.append(Spacer(1, 0.3*inch))

        # Prepare table data
        table_data = [['ID', 'Name', 'Amount (KSH)', 'Parish', 'Status']]

        for member in members:
            table_data.append([
                str(member.get('member_id', '')),
                str(member.get('name', '')),
                f"{member.get('amount', 0):,.2f}",
                str(member.get('mission', '')),
                str(member.get('status', 'active')).upper()
            ])

        # Create table
        table = Table(table_data, colWidths=[0.7*inch, 2.5*inch, 1.3*inch, 2*inch, 1*inch])

        # Style the table
        table.setStyle(TableStyle([
            # Header row
            ('BACKGROUND', (0, 0), (-1, 0), colors.HexColor('#3498db')),
            ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
            ('ALIGN', (0, 0), (-1, 0), 'CENTER'),
            ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
            ('FONTSIZE', (0, 0), (-1, 0), 11),
            ('BOTTOMPADDING', (0, 0), (-1, 0), 12),
            ('TOPPADDING', (0, 0), (-1, 0), 12),

            # Data rows
            ('BACKGROUND', (0, 1), (-1, -1), colors.beige),
            ('TEXTCOLOR', (0, 1), (-1, -1), colors.black),
            ('ALIGN', (0, 1), (0, -1), 'CENTER'),  # ID column center
            ('ALIGN', (2, 1), (2, -1), 'RIGHT'),   # Amount column right
            ('ALIGN', (4, 1), (4, -1), 'CENTER'),  # Status column center
            ('FONTNAME', (0, 1), (-1, -1), 'Helvetica'),
            ('FONTSIZE', (0, 1), (-1, -1), 9),
            ('TOPPADDING', (0, 1), (-1, -1), 6),
            ('BOTTOMPADDING', (0, 1), (-1, -1), 6),

            # Grid
            ('GRID', (0, 0), (-1, -1), 0.5, colors.grey),
            ('LINEBELOW', (0, 0), (-1, 0), 2, colors.HexColor('#2980b9')),

            # Alternating row colors
            ('ROWBACKGROUNDS', (0, 1), (-1, -1), [colors.white, colors.HexColor('#ecf0f1')]),
        ]))

        elements.append(table)

        # Add footer
        elements.append(Spacer(1, 0.5*inch))
        footer_style = ParagraphStyle(
            'Footer',
            parent=styles['Normal'],
            fontSize=8,
            textColor=colors.grey,
            alignment=TA_CENTER
        )
        footer = Paragraph("This document is generated by ODA Welfare Admin System - Confidential", footer_style)
        elements.append(footer)

        # Build PDF
        doc.build(elements)

        logger.info(f"Generated PDF with {len(members)} members")
        return pdf_path, f"✅ PDF generated successfully with {len(members)} members"

    except Exception as e:
        logger.error(f"Error generating PDF: {e}")
        return None, f"❌ Error generating PDF: {str(e)}"

def add_member_contribution(member_name, contribution_type, amount, date, api_key):
    """Add a contribution for a member"""
    try:
        # Validate API key
        if not validate_api_key(api_key):
            return False, "❌ Invalid API key. Access denied."
        
        # Validate inputs
        if not member_name or not member_name.strip():
            return False, "❌ Member name is required."
        
        if not contribution_type or not contribution_type.strip():
            return False, "❌ Contribution type is required."
        
        try:
            amount = float(amount) if amount else 0.0
        except ValueError:
            return False, "❌ Invalid amount format."
        
        # Connect to MongoDB
        db, client = connect_mongodb()
        if db is None:
            return False, "❌ Database connection failed."
        
        contributions_collection = db.contributions
        
        # Create new contribution
        new_contribution = {
            "name": member_name.strip(),
            "contribution_type": contribution_type.strip(),
            "amount": amount,
            "date": date if date else datetime.now().strftime("%Y-%m-%d"),
            "created_at": datetime.now()
        }
        
        result = contributions_collection.insert_one(new_contribution)
        
        if client:
            client.close()
        
        if result.inserted_id:
            logger.info(f"Added contribution for {member_name}: {contribution_type} - {amount}")
            return True, f"✅ Contribution added for '{member_name}'"
        else:
            return False, "❌ Failed to add contribution"
        
    except Exception as e:
        logger.error(f"Error adding contribution: {e}")
        return False, f"❌ Error: {str(e)}"

def create_admin_app():
    """Create admin interface for ODA Welfare"""
    
    with gr.Blocks(title="ODA Welfare - Admin Panel") as demo:
        
        gr.Markdown("# 🔐 ODA Welfare Admin Panel")
        gr.Markdown("*Protected administrative interface for member and contribution management*")
        
        # Global API key input
        global_api_key = gr.Textbox(
            placeholder="Enter admin API key...",
            label="🔑 Master API Key",
            type="password",
            container=True
        )
        
        with gr.Tabs():
            # Add New Member Tab
            with gr.TabItem("➕ Add Member"):
                with gr.Row():
                    with gr.Column(scale=2):
                        gr.Markdown("## Add New Member")
                        
                        # Get suggested next member ID
                        suggested_id = get_next_member_id()

                        with gr.Row():
                            member_id_input = gr.Number(
                                label="🔢 Member ID",
                                container=True,
                                minimum=1,
                                precision=0,
                                value=suggested_id,
                                placeholder="Enter unique member ID...",
                                scale=3
                            )
                            refresh_id_btn = gr.Button("🔄", size="sm", scale=1, variant="secondary")

                        suggested_id_display = gr.Markdown(f"*Suggested ID: **{suggested_id}** (Latest member ID + 1)*")
                        
                        name_input = gr.Textbox(
                            placeholder="Enter member full name...",
                            label="👤 Member Name",
                            container=True
                        )
                        
                        amount_input = gr.Number(
                            label="💰 Initial Amount (KSH)",
                            value=0,
                            container=True,
                            minimum=0
                        )
                        
                        mission_input = gr.Textbox(
                            placeholder="Enter member's parish...",
                            label="⛪ Parish",
                            container=True
                        )
                        
                        add_btn = gr.Button("➕ Add Member", variant="primary", size="lg")
                        add_status = gr.Markdown()
                        
                    with gr.Column(scale=1):
                        gr.Markdown("## 📊 Membership Progress")
                        refresh_btn = gr.Button("🔄 Refresh Progress", variant="secondary")
                        
                        # Get initial stats and create progress display
                        member_count, target_count = get_member_stats()
                        initial_progress = create_membership_progress_display(member_count, target_count)
                        progress_display = gr.HTML(value=initial_progress)
            
            # Edit Member Tab
            with gr.TabItem("✏️ Edit Member"):
                gr.Markdown("## Search and Edit Members")
                
                search_input = gr.Textbox(
                    placeholder="Enter member name or ID...",
                    label="🔍 Search Member",
                    container=True
                )
                
                search_btn = gr.Button("🔍 Search", variant="secondary")
                search_status = gr.Markdown()
                search_results = gr.Dataframe(
                    headers=["ID", "Name", "Amount", "Parish", "Status"],
                    datatype=["number", "str", "number", "str", "str"],
                    interactive=True,
                    wrap=True
                )
                
                gr.Markdown("*💡 Click on a row above to select a member for editing*")
                
                with gr.Row():
                    with gr.Column():
                        edit_id_input = gr.Number(
                            label="Member ID",
                            container=True
                        )
                        
                        edit_name_input = gr.Textbox(
                            label="👤 Name",
                            container=True
                        )
                        
                        edit_amount_input = gr.Number(
                            label="💰 Amount (KSH)",
                            container=True,
                            minimum=0
                        )
                        
                        edit_mission_input = gr.Textbox(
                            label="⛪ Parish",
                            container=True
                        )
                        
                        with gr.Row():
                            update_btn = gr.Button("💾 Update Member", variant="primary", scale=2)
                            delete_btn = gr.Button("🗑️ Delete Member", variant="stop", scale=1)

                        edit_status = gr.Markdown()

                        # Delete confirmation dialog
                        with gr.Group(visible=False) as delete_confirm_group:
                            gr.Markdown("### ⚠️ Confirm Deletion")
                            delete_warning = gr.Markdown()
                            with gr.Row():
                                confirm_delete_btn = gr.Button("✅ Yes, Delete", variant="stop")
                                cancel_delete_btn = gr.Button("❌ Cancel", variant="secondary")

                        selected_member_info = gr.Markdown("*No member selected*")
            
            # Contribution Types Tab
            with gr.TabItem("📋 Contribution Types"):
                gr.Markdown("## Manage Contribution Types")
                
                with gr.Row():
                    with gr.Column():
                        contrib_type_input = gr.Textbox(
                            placeholder="e.g. Medical Support, Education Fund...",
                            label="🏷️ Contribution Type Name",
                            container=True
                        )
                        
                        contrib_desc_input = gr.Textbox(
                            placeholder="Description of this contribution type...",
                            label="📝 Description",
                            lines=3,
                            container=True
                        )
                        
                        create_type_btn = gr.Button("➕ Create Type", variant="primary")
                        type_status = gr.Markdown()
            
            # Download Reports Tab
            with gr.TabItem("📥 Download Reports"):
                gr.Markdown("## Download Member Reports")
                gr.Markdown("Generate and download reports in PDF format")

                with gr.Row():
                    with gr.Column():
                        gr.Markdown("### 📋 All Registered Members")
                        gr.Markdown("Download a complete list of all registered members with their details")

                        download_pdf_btn = gr.Button("📥 Download Members PDF", variant="primary", size="lg")
                        download_status = gr.Markdown()
                        download_file = gr.File(label="Generated PDF", visible=False)

            # Manage Contributions Tab
            with gr.TabItem("💰 Manage Contributions"):
                gr.Markdown("## Add Member Contributions")
                
                with gr.Row():
                    with gr.Column():
                        contrib_member_input = gr.Textbox(
                            placeholder="Enter member name...",
                            label="👤 Member Name",
                            container=True
                        )
                        
                        # Get available contribution types for dropdown
                        available_contrib_types = get_contribution_types()
                        contrib_type_dropdown = gr.Dropdown(
                            choices=available_contrib_types,
                            label="🏷️ Contribution Type",
                            container=True,
                            allow_custom_value=True,  # Allow adding new types
                            info="Select existing type or type a new one"
                        )
                        
                        contrib_amount_input = gr.Number(
                            label="💰 Amount (KSH)",
                            container=True,
                            minimum=0
                        )
                        
                        contrib_date_input = gr.Textbox(
                            placeholder="YYYY-MM-DD (leave empty for today)",
                            label="📅 Date",
                            container=True
                        )
                        
                        add_contrib_btn = gr.Button("➕ Add Contribution", variant="primary")
                        refresh_contrib_types_btn = gr.Button("🔄 Refresh Types", variant="secondary", size="sm")
                        contrib_status = gr.Markdown()
        
        # Event handlers
        def handle_add_member(member_id, name, amount, mission, api_key):
            success, message = add_new_member(member_id, name, amount, mission, api_key)
            if success:
                member_count, target_count = get_member_stats()
                new_progress = create_membership_progress_display(member_count, target_count)
                # Get the new suggested ID after adding a member
                new_suggested_id = get_next_member_id()
                suggested_text = f"*Suggested ID: **{new_suggested_id}** (Latest member ID + 1)*"
                return new_suggested_id, "", 0, "", message, new_progress, suggested_text
            else:
                current_suggested = get_next_member_id()
                suggested_text = f"*Suggested ID: **{current_suggested}** (Latest member ID + 1)*"
                return member_id, name, amount, mission, message, progress_display.value, suggested_text
        
        def handle_search_member(search_term, api_key):
            if not validate_api_key(api_key):
                return pd.DataFrame(), "❌ Invalid API key"
            
            members, message = search_member_for_edit(search_term)
            if members:
                df_data = []
                for member in members:
                    df_data.append([
                        int(member.get('member_id', 0)),  # Ensure integer
                        str(member.get('name', '')),      # Ensure string
                        float(member.get('amount', 0)),   # Ensure float
                        str(member.get('mission', '')),   # Ensure string
                        str(member.get('status', 'active'))  # Ensure string
                    ])
                df = pd.DataFrame(df_data, columns=["ID", "Name", "Amount", "Parish", "Status"])
                # Ensure proper data types
                df['ID'] = df['ID'].astype(int)
                df['Amount'] = df['Amount'].astype(float)
                return df, message
            else:
                return pd.DataFrame(columns=["ID", "Name", "Amount", "Parish", "Status"]), message
        
        def handle_update_member(member_id, name, amount, mission, api_key):
            success, message = update_member(member_id, name, amount, mission, api_key)
            if success:
                return "", "", "", "", message
            else:
                return member_id, name, amount, mission, message
        
        def handle_create_type(contrib_type, description, api_key):
            success, message = create_contribution_type(contrib_type, description, api_key)
            if success:
                return "", "", message
            else:
                return contrib_type, description, message
        
        def handle_add_contribution(member_name, contrib_type, amount, date, api_key):
            success, message = add_member_contribution(member_name, contrib_type, amount, date, api_key)
            if success:
                return "", "", "", "", message
            else:
                return member_name, contrib_type, amount, date, message
        
        def refresh_progress():
            member_count, target_count = get_member_stats()
            progress = create_membership_progress_display(member_count, target_count)
            return progress
        
        def handle_member_selection(df, evt: gr.SelectData):
            """Handle when user clicks on a row in the search results"""
            try:
                if df is None or len(df) == 0:
                    return None, "", "", "", "*No member selected*"
                
                # Get the selected row data
                row_index = evt.index[0] if evt.index else 0
                selected_row = df.iloc[row_index]
                
                # Ensure proper data type conversion
                member_id = int(selected_row['ID']) if pd.notna(selected_row['ID']) else None
                member_name = str(selected_row['Name']) if pd.notna(selected_row['Name']) else ""
                member_amount = float(selected_row['Amount']) if pd.notna(selected_row['Amount']) else 0.0
                member_mission = str(selected_row['Parish']) if pd.notna(selected_row['Parish']) else ""
                member_status = str(selected_row['Status']) if pd.notna(selected_row['Status']) else "active"
                
                # Create info message
                info_msg = f"**✅ Selected Member:** {member_name} (ID: {member_id}) - Status: {member_status}"
                
                return member_id, member_name, member_amount, member_mission, info_msg
                
            except Exception as e:
                logger.error(f"Error handling member selection: {e}")
                return None, "", "", "", "*Error selecting member*"
        
        def refresh_contribution_types():
            """Refresh the list of contribution types"""
            return gr.Dropdown(choices=get_contribution_types())

        def show_delete_confirmation(member_id, member_name):
            """Show delete confirmation dialog"""
            if not member_id or not member_name:
                return gr.update(visible=False), "❌ No member selected"

            warning_msg = f"**Are you sure you want to delete '{member_name}' (ID: {member_id})?**\n\nThis action cannot be undone."
            return gr.update(visible=True), warning_msg

        def handle_delete_member(member_id, api_key):
            """Handle member deletion"""
            success, message = delete_member(member_id, api_key)
            if success:
                # Clear form and hide confirmation
                return None, "", "", "", gr.update(visible=False), "", message, pd.DataFrame(columns=["ID", "Name", "Amount", "Parish", "Status"])
            else:
                return member_id, gr.update(visible=True), "", message, gr.update()

        def cancel_delete():
            """Cancel deletion and hide confirmation dialog"""
            return gr.update(visible=False), ""

        def handle_download_pdf(api_key):
            """Handle PDF download request"""
            pdf_path, message = generate_members_pdf(api_key)
            if pdf_path:
                return message, gr.update(value=pdf_path, visible=True)
            else:
                return message, gr.update(visible=False)

        def refresh_suggested_id():
            """Refresh the suggested member ID"""
            new_suggested_id = get_next_member_id()
            return new_suggested_id, f"*Suggested ID: **{new_suggested_id}** (Latest member ID + 1)*"
        
        # Wire up events
        add_btn.click(
            handle_add_member,
            inputs=[member_id_input, name_input, amount_input, mission_input, global_api_key],
            outputs=[member_id_input, name_input, amount_input, mission_input, add_status, progress_display, suggested_id_display]
        )

        refresh_id_btn.click(
            refresh_suggested_id,
            outputs=[member_id_input, suggested_id_display]
        )
        
        search_btn.click(
            handle_search_member,
            inputs=[search_input, global_api_key],
            outputs=[search_results, search_status]
        )
        
        # Handle row selection in search results
        search_results.select(
            handle_member_selection,
            inputs=[search_results],
            outputs=[edit_id_input, edit_name_input, edit_amount_input, edit_mission_input, selected_member_info]
        )
        
        update_btn.click(
            handle_update_member,
            inputs=[edit_id_input, edit_name_input, edit_amount_input, edit_mission_input, global_api_key],
            outputs=[edit_id_input, edit_name_input, edit_amount_input, edit_mission_input, edit_status]
        )

        delete_btn.click(
            show_delete_confirmation,
            inputs=[edit_id_input, edit_name_input],
            outputs=[delete_confirm_group, delete_warning]
        )

        confirm_delete_btn.click(
            handle_delete_member,
            inputs=[edit_id_input, global_api_key],
            outputs=[edit_id_input, edit_name_input, edit_amount_input, edit_mission_input, delete_confirm_group, delete_warning, edit_status, search_results]
        )

        cancel_delete_btn.click(
            cancel_delete,
            outputs=[delete_confirm_group, delete_warning]
        )
        
        create_type_btn.click(
            handle_create_type,
            inputs=[contrib_type_input, contrib_desc_input, global_api_key],
            outputs=[contrib_type_input, contrib_desc_input, type_status]
        )
        
        add_contrib_btn.click(
            handle_add_contribution,
            inputs=[contrib_member_input, contrib_type_dropdown, contrib_amount_input, contrib_date_input, global_api_key],
            outputs=[contrib_member_input, contrib_type_dropdown, contrib_amount_input, contrib_date_input, contrib_status]
        )
        
        refresh_contrib_types_btn.click(
            refresh_contribution_types,
            outputs=contrib_type_dropdown
        )
        
        refresh_btn.click(refresh_progress, outputs=progress_display)
        demo.load(refresh_progress, outputs=progress_display)
        demo.load(refresh_suggested_id, outputs=[member_id_input, suggested_id_display])

        download_pdf_btn.click(
            handle_download_pdf,
            inputs=[global_api_key],
            outputs=[download_status, download_file]
        )
        
        gr.Markdown("---")
        gr.Markdown("**Security:** This interface requires valid API key authentication for all operations.")
        gr.Markdown("**Note:** All operations are logged and timestamped in the database.")
    
    return demo

if __name__ == "__main__":
    admin_app = create_admin_app()
    admin_app.launch(
        share=False
    )