worker_optimizer.py

#!/usr/bin/env python3
"""
Interactive Airbyte Data Worker Optimizer
Fully interactive menu system with arrow key navigation
"""

import sys
import os
import json
from datetime import datetime

# Add src to path for imports
sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))
sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'mode2'))

try:
    import inquirer
    from inquirer.themes import GreenPassion
except ImportError:
    print("❌ Error: 'inquirer' package not found")
    print("Install it with: pip install inquirer")
    sys.exit(1)


def print_banner():
    """Print welcome banner"""
    print("\n" + "=" * 80)
    print("🚀 AIRBYTE DATA WORKER OPTIMIZER")
    print("=" * 80)
    print("Interactive tool for analyzing, estimating, and optimizing worker usage")
    print("=" * 80 + "\n")


def main_menu():
    """Main menu selection"""
    questions = [
        inquirer.List(
            'mode',
            message="What would you like to do?",
            choices=[
                ('📊 Calculate Current Usage - Analyze existing workspace', 'mode1'),
                ('🎯 Estimate Prospect Needs - For new/potential customers', 'mode2'),
                ('⚡ Optimize Worker Usage - Flatten peaks and reduce workers', 'mode3'),
                ('📄 Generate Reports - PDF reports for customers', 'mode4'),
                ('❌ Exit', 'exit')
            ],
        )
    ]

    answers = inquirer.prompt(questions, theme=GreenPassion())
    if not answers:
        return 'exit'
    return answers['mode']


# ============================================================================
# MODE 1: Calculate Current Usage
# ============================================================================

def mode1_calculate_usage():
    """Mode 1: Calculate current usage for existing workspace"""
    print("\n" + "=" * 80)
    print("📊 MODE 1: CALCULATE CURRENT USAGE")
    print("=" * 80 + "\n")

    # Workspace input method
    questions = [
        inquirer.List(
            'input_type',
            message="How do you want to identify the workspace(s)?",
            choices=[
                ('Single Workspace ID', 'single'),
                ('Multiple Workspace IDs (comma-separated)', 'multiple'),
                ('Organization ID', 'org_id'),
                ('Organization Name', 'org_name')
            ]
        )
    ]

    input_answers = inquirer.prompt(questions, theme=GreenPassion())
    if not input_answers:
        return

    input_type = input_answers['input_type']

    # Get workspace/org identifier
    if input_type == 'single':
        workspace_input = inquirer.prompt([
            inquirer.Text('workspace_id', message="Enter Workspace ID")
        ], theme=GreenPassion())
        if not workspace_input:
            return
        workspace_ids = [workspace_input['workspace_id']]

    elif input_type == 'multiple':
        workspace_input = inquirer.prompt([
            inquirer.Text('workspace_ids', message="Enter Workspace IDs (comma-separated)")
        ], theme=GreenPassion())
        if not workspace_input:
            return
        workspace_ids = [w.strip() for w in workspace_input['workspace_ids'].split(',')]

    elif input_type == 'org_id':
        org_input = inquirer.prompt([
            inquirer.Text('org_id', message="Enter Organization ID")
        ], theme=GreenPassion())
        if not org_input:
            return
        print("\n⚠️  Organization analysis requires MCP tools - please use /workers command in Claude Code")
        return

    elif input_type == 'org_name':
        org_input = inquirer.prompt([
            inquirer.Text('org_name', message="Enter Organization Name")
        ], theme=GreenPassion())
        if not org_input:
            return
        print("\n⚠️  Organization analysis requires MCP tools - please use /workers command in Claude Code")
        return

    # Analysis period
    period_input = inquirer.prompt([
        inquirer.Text('days', message="Analysis period (days)", default="30")
    ], theme=GreenPassion())
    if not period_input:
        return

    analysis_days = int(period_input['days'])

    print(f"\n🔄 Analyzing workspace(s): {', '.join(workspace_ids)}")
    print(f"   Worker Model: Universal (API/5 + DB/2)")
    print(f"   Period: Last {analysis_days} days\n")

    # Run analysis
    try:
        from src.analyze_org_workspaces import analyze_workspace

        for workspace_id in workspace_ids:
            print(f"\n📍 Analyzing workspace: {workspace_id}")
            analyze_workspace(
                workspace_id=workspace_id,
                plan_type="pro",
                days=analysis_days
            )

        print("\n✅ Analysis complete! Check generated reports.")

    except Exception as e:
        print(f"\n❌ Error during analysis: {str(e)}")
        print("Make sure env_vars.env is configured with valid credentials")


# ============================================================================
# MODE 2: Estimate Prospect Needs
# ============================================================================

def mode2_estimate_menu():
    """Mode 2: Estimate prospect needs - submenu"""
    print("\n" + "=" * 80)
    print("🎯 MODE 2: ESTIMATE PROSPECT NEEDS")
    print("=" * 80 + "\n")

    questions = [
        inquirer.List(
            'submode',
            message="What type of prospect estimate do you need?",
            choices=[
                ('2A: New Prospect Questionnaire - 9 standardized questions', 'mode2a'),
                ('2B: Current OSS/Cloud User - Analyze existing usage', 'mode2b'),
                ('2C: Quick Custom Estimate - Fast ballpark for sales calls', 'mode2c'),
                ('← Back to Main Menu', 'back')
            ]
        )
    ]

    answers = inquirer.prompt(questions, theme=GreenPassion())
    if not answers or answers['submode'] == 'back':
        return

    if answers['submode'] == 'mode2a':
        mode2a_questionnaire()
    elif answers['submode'] == 'mode2b':
        mode2b_oss_cloud()
    elif answers['submode'] == 'mode2c':
        mode2c_quick_estimate()


def mode2a_questionnaire():
    """Mode 2A: New prospect questionnaire"""
    print("\n" + "=" * 80)
    print("📋 MODE 2A: NEW PROSPECT QUESTIONNAIRE")
    print("=" * 80 + "\n")

    print("Let's gather information about the planned Airbyte deployment...\n")

    # Question 1: Total connections
    q1 = inquirer.prompt([
        inquirer.Text('total_connections', message="Total number of Connections", validate=lambda _, x: x.isdigit())
    ], theme=GreenPassion())
    if not q1:
        return

    # Question 2: DB/File percentage
    q2 = inquirer.prompt([
        inquirer.Text('db_percent', message="Database or File Connections (%)", default="50", validate=lambda _, x: x.replace('.', '').isdigit())
    ], theme=GreenPassion())
    if not q2:
        return

    # Question 3: API percentage
    q3 = inquirer.prompt([
        inquirer.Text('api_percent', message="API Connections (%)", default="50", validate=lambda _, x: x.replace('.', '').isdigit())
    ], theme=GreenPassion())
    if not q3:
        return

    # Question 4: Sub-hourly percentage
    q4 = inquirer.prompt([
        inquirer.Text('sub_hourly', message="Sub-hourly Syncs (%)", default="10", validate=lambda _, x: x.replace('.', '').isdigit())
    ], theme=GreenPassion())
    if not q4:
        return

    # Question 5: Hourly percentage
    q5 = inquirer.prompt([
        inquirer.Text('hourly', message="Hourly Syncs (%)", default="30", validate=lambda _, x: x.replace('.', '').isdigit())
    ], theme=GreenPassion())
    if not q5:
        return

    # Question 6: Daily percentage
    q6 = inquirer.prompt([
        inquirer.Text('daily', message="Daily or Less Frequent Syncs (%)", default="60", validate=lambda _, x: x.replace('.', '').isdigit())
    ], theme=GreenPassion())
    if not q6:
        return

    # Optional: Sync duration
    q8 = inquirer.prompt([
        inquirer.Confirm('add_duration', message="Add average sync duration? (optional)", default=False)
    ], theme=GreenPassion())

    sync_duration = None
    if q8 and q8['add_duration']:
        q8b = inquirer.prompt([
            inquirer.Text('duration', message="Most syncs under (minutes)", default="5")
        ], theme=GreenPassion())
        if q8b:
            sync_duration = float(q8b['duration'])

    # Optional: Maintenance window
    q9 = inquirer.prompt([
        inquirer.Confirm('add_window', message="Add maintenance window info? (optional)", default=False)
    ], theme=GreenPassion())

    maintenance_window = None
    if q9 and q9['add_window']:
        q9b = inquirer.prompt([
            inquirer.Text('window', message="Maintenance window (hours)", default="4")
        ], theme=GreenPassion())
        if q9b:
            maintenance_window = float(q9b['window'])

    # Run estimation
    try:
        from mode2_prospect_questionnaire import estimate_from_questionnaire

        result = estimate_from_questionnaire(
            total_connections=int(q1['total_connections']),
            db_file_percent=float(q2['db_percent']),
            api_percent=float(q3['api_percent']),
            sub_hourly_percent=float(q4['sub_hourly']),
            hourly_percent=float(q5['hourly']),
            daily_percent=float(q6['daily']),
            plan_type="pro",
            sync_duration_minutes=sync_duration,
            maintenance_window_hours=maintenance_window
        )

        # Save result
        output_file = "prospect_estimate.json"
        with open(output_file, 'w') as f:
            json.dump({
                'mode': '2A_questionnaire',
                'timestamp': datetime.utcnow().isoformat(),
                'result': result
            }, f, indent=2, default=str)

        print(f"\n📁 Results saved to: {output_file}")

    except Exception as e:
        print(f"\n❌ Error during estimation: {str(e)}")


def mode2b_oss_cloud():
    """Mode 2B: Current OSS/Cloud user"""
    print("\n" + "=" * 80)
    print("💾 MODE 2B: CURRENT OSS/CLOUD USER")
    print("=" * 80 + "\n")

    questions = [
        inquirer.List(
            'user_type',
            message="What type of Airbyte user is the prospect?",
            choices=[
                ('Airbyte Cloud user (with access)', 'cloud'),
                ('Airbyte OSS user (needs export script)', 'oss'),
                ('← Back', 'back')
            ]
        )
    ]

    answers = inquirer.prompt(questions, theme=GreenPassion())
    if not answers or answers['user_type'] == 'back':
        return

    if answers['user_type'] == 'cloud':
        print("\n✅ For Cloud users with access, use Mode 1 (Calculate Current Usage)")
        print("   This will give the most accurate estimate based on actual usage.")

    elif answers['user_type'] == 'oss':
        print("\n📋 For OSS users:")
        print("   1. Provide them with: mode2/mode2_oss_export_script.py")
        print("   2. Have them run it on their Airbyte OSS instance")
        print("   3. They'll generate a JSON export file")
        print("   4. Use mode2/mode2_analyze_oss_export.py to analyze the export")
        print("\n⚠️  This workflow requires file exchange - best handled via /workers command")


def mode2c_quick_estimate():
    """Mode 2C: Quick custom estimate"""
    print("\n" + "=" * 80)
    print("💡 MODE 2C: QUICK CUSTOM ESTIMATE")
    print("=" * 80 + "\n")

    print("Let's get some high-level information for a ballpark estimate...\n")

    # Use case description
    q1 = inquirer.prompt([
        inquirer.Text('description', message="Brief description of use case")
    ], theme=GreenPassion())
    if not q1:
        return

    # Connection count range
    q2 = inquirer.prompt([
        inquirer.List(
            'conn_range',
            message="Connection count range",
            choices=[
                ('Small (1-25 connections)', 'small'),
                ('Medium (25-100 connections)', 'medium'),
                ('Large (100-500 connections)', 'large'),
                ('X-Large (500+ connections)', 'xlarge')
            ]
        )
    ], theme=GreenPassion())
    if not q2:
        return

    # Connector mix
    q3 = inquirer.prompt([
        inquirer.List(
            'connector_mix',
            message="Connector mix",
            choices=[
                ('Mostly API (Salesforce, HubSpot, Stripe, etc.)', 'mostly_api'),
                ('Mostly Database/Files (Postgres, MySQL, S3, etc.)', 'mostly_db'),
                ('Mixed', 'mixed')
            ]
        )
    ], theme=GreenPassion())
    if not q3:
        return

    # Sync frequency
    q4 = inquirer.prompt([
        inquirer.List(
            'frequency',
            message="Sync frequency",
            choices=[
                ('Real-time (sub-hourly)', 'realtime'),
                ('Frequent (hourly)', 'frequent'),
                ('Daily', 'daily'),
                ('Mixed', 'mixed')
            ]
        )
    ], theme=GreenPassion())
    if not q4:
        return

    # Run estimation
    try:
        from mode2_custom_estimate import quick_estimate

        result = quick_estimate(
            description=q1['description'],
            connection_count_range=q2['conn_range'],
            connector_mix=q3['connector_mix'],
            sync_frequency=q4['frequency'],
            plan_type="pro"
        )

        # Save result
        output_file = "custom_estimate.json"
        with open(output_file, 'w') as f:
            json.dump(result, f, indent=2, default=str)

        print(f"\n📁 Estimate saved to: {output_file}")

    except Exception as e:
        print(f"\n❌ Error during estimation: {str(e)}")


# ============================================================================
# MODE 3: Optimize Worker Usage
# ============================================================================

def mode3_optimize_usage():
    """Mode 3: Optimize worker usage"""
    print("\n" + "=" * 80)
    print("⚡ MODE 3: OPTIMIZE WORKER USAGE")
    print("=" * 80 + "\n")

    print("Optimization analyzes peak usage periods and recommends schedule changes")
    print("to flatten worker usage and potentially reduce worker requirements.\n")

    # Workspace ID
    q1 = inquirer.prompt([
        inquirer.Text('workspace_id', message="Enter Workspace ID")
    ], theme=GreenPassion())
    if not q1:
        return

    # Current worker allocation
    q2 = inquirer.prompt([
        inquirer.Text('current_workers', message="Current worker allocation", validate=lambda _, x: x.isdigit())
    ], theme=GreenPassion())
    if not q2:
        return

    print(f"\n🔄 Analyzing workspace: {q1['workspace_id']}")
    print(f"   Current Workers: {q2['current_workers']}")
    print(f"   Worker Model: Universal (API/5 + DB/2)\n")

    # Run optimization
    try:
        from src.optimize_worker_usage_fast import optimize_workspace

        results = optimize_workspace(
            workspace_id=q1['workspace_id'],
            current_workers=int(q2['current_workers']),
            plan_type="pro"
        )

        print("\n✅ Optimization analysis complete!")
        print("   Check generated optimization report for detailed recommendations.")

    except Exception as e:
        print(f"\n❌ Error during optimization: {str(e)}")
        print("Make sure env_vars.env is configured with valid credentials")


# ============================================================================
# MODE 4: Generate Reports
# ============================================================================

def mode4_generate_reports():
    """Mode 4: Generate reports - submenu"""
    print("\n" + "=" * 80)
    print("📄 MODE 4: GENERATE REPORTS")
    print("=" * 80 + "\n")

    questions = [
        inquirer.List(
            'submode',
            message="What type of report do you want to generate?",
            choices=[
                ('4A: Single Customer Report - Generate for one customer', 'mode4a'),
                ('4B: Batch Reports - Generate for multiple/all customers', 'mode4b'),
                ('4C: List Available Customers - See available data', 'mode4c'),
                ('← Back to Main Menu', 'back')
            ]
        )
    ]

    answers = inquirer.prompt(questions, theme=GreenPassion())
    if not answers or answers['submode'] == 'back':
        return

    if answers['submode'] == 'mode4a':
        mode4a_single_customer_report()
    elif answers['submode'] == 'mode4b':
        mode4b_batch_reports()
    elif answers['submode'] == 'mode4c':
        mode4c_list_customers()


def _get_customer_data():
    """Load customer data from generate_scheduling_reports.py"""
    try:
        from generate_scheduling_reports import SUMMARY_DATA, parse_summary_row, get_report_type
        return SUMMARY_DATA, parse_summary_row, get_report_type
    except ImportError as e:
        print(f"❌ Error loading customer data: {e}")
        return None, None, None


def _fuzzy_match_customer(search_term, customer_names):
    """Simple fuzzy matching for customer names"""
    search_lower = search_term.lower()
    matches = []

    for name in customer_names:
        name_lower = name.lower()
        # Exact match
        if search_lower == name_lower:
            return [name]
        # Starts with
        if name_lower.startswith(search_lower):
            matches.append((name, 0))
        # Contains
        elif search_lower in name_lower:
            matches.append((name, 1))

    # Sort by match quality
    matches.sort(key=lambda x: x[1])
    return [m[0] for m in matches]


def mode4a_single_customer_report():
    """Mode 4A: Generate report for a single customer"""
    print("\n" + "=" * 80)
    print("📄 MODE 4A: SINGLE CUSTOMER REPORT")
    print("=" * 80 + "\n")

    SUMMARY_DATA, parse_summary_row, get_report_type = _get_customer_data()
    if SUMMARY_DATA is None:
        return

    # Get all customer names
    customer_names = [row[0] for row in SUMMARY_DATA]

    # Ask for customer name with fuzzy search
    q1 = inquirer.prompt([
        inquirer.Text('customer_name', message="Enter customer name (or partial name)")
    ], theme=GreenPassion())
    if not q1:
        return

    search_term = q1['customer_name'].strip()
    matches = _fuzzy_match_customer(search_term, customer_names)

    if not matches:
        print(f"\n❌ No customers found matching '{search_term}'")
        print("Use Mode 4C to see available customers.")
        return

    # If multiple matches, let user select
    if len(matches) > 1:
        q2 = inquirer.prompt([
            inquirer.List(
                'customer',
                message=f"Multiple matches found for '{search_term}'. Select customer:",
                choices=matches[:10]  # Limit to 10 options
            )
        ], theme=GreenPassion())
        if not q2:
            return
        customer_name = q2['customer']
    else:
        customer_name = matches[0]

    # Find customer data
    customer_row = None
    for row in SUMMARY_DATA:
        if row[0] == customer_name:
            customer_row = row
            break

    if not customer_row:
        print(f"❌ Customer '{customer_name}' not found in data.")
        return

    summary = parse_summary_row(customer_row)
    report_type = get_report_type(summary)

    print(f"\n📊 Customer: {customer_name}")
    print(f"   Contracted Workers: {summary['contracted_workers']}")
    print(f"   P99 Workers: {summary['p99_workers']}")
    print(f"   Utilization: {summary['billing_utilization_pct']:.0f}%")
    print(f"   Status: {summary['capacity_status'].upper()}")

    if report_type == "skip":
        print(f"\n⚠️  No report generated - customer has no data (0 workers)")
        return

    report_type_label = "Scheduling Optimization" if report_type == "scheduling" else "Capacity Analysis"
    print(f"   Report Type: {report_type_label}")

    # Ask about Airbyte API
    q3 = inquirer.prompt([
        inquirer.Confirm('use_api', message="Fetch real-time connection data from Airbyte API?", default=True)
    ], theme=GreenPassion())
    if not q3:
        return

    # Output directory
    default_output = f"/Users/ryanwaskewich/Documents/Claude/Worker/FinalReports/{customer_name}"
    q4 = inquirer.prompt([
        inquirer.Text('output_dir', message="Output directory", default=default_output)
    ], theme=GreenPassion())
    if not q4:
        return

    output_dir = q4['output_dir']
    os.makedirs(output_dir, exist_ok=True)

    # Generate the report
    print(f"\n🔄 Generating {report_type_label} report for {customer_name}...")

    try:
        from generate_scheduling_reports import (
            load_hourly_data, HOURLY_FILE,
            get_connection_data, generate_mock_connection_data,
            identify_peak_hours
        )
        from src.scheduling_optimization_report import generate_scheduling_optimization_report
        from src.underutilization_report import generate_underutilization_report
        from src.job_history_analyzer import fetch_and_analyze_job_history
        from src.scheduling_queries import identify_quiet_hours

        # Load hourly data
        hourly_data = load_hourly_data(HOURLY_FILE)
        customer_hourly = hourly_data.get(customer_name, {})

        if not customer_hourly:
            print(f"⚠️  No hourly data available for {customer_name}")
            print("   Generating report with limited data...")

        if report_type == "underutilization":
            # Generate Capacity Analysis Report
            result = generate_underutilization_report(
                customer_name=customer_name,
                summary_data=summary,
                hourly_data=customer_hourly,
                output_dir=output_dir,
            )
        else:
            # Generate Scheduling Optimization Report
            connection_data = get_connection_data(
                customer_name=customer_name,
                hourly_data=customer_hourly,
                use_airbyte_api=q3['use_api'],
            )

            # Analyze job history for confidence
            job_history_analysis = None
            if q3['use_api'] and customer_hourly and connection_data:
                print("  Analyzing job history for confidence...")
                peak_hours = identify_peak_hours(customer_hourly, top_n=3)
                quiet_hours = identify_quiet_hours(customer_hourly, bottom_n=5)

                for conn in connection_data:
                    run_hour = conn.get("typical_run_hour")
                    if run_hour is not None and run_hour in peak_hours:
                        conn["recommended_for_rescheduling"] = True

                job_history_analysis = fetch_and_analyze_job_history(
                    connections=connection_data,
                    peak_hours=peak_hours,
                    quiet_hours=quiet_hours,
                    current_p99=summary.get("p99_workers", 0),
                    jobs_per_connection=100,
                )

            result = generate_scheduling_optimization_report(
                customer_name=customer_name,
                summary_data=summary,
                hourly_data=customer_hourly,
                connection_data=connection_data,
                output_dir=output_dir,
                job_history_analysis=job_history_analysis,
            )

        if result.get("success"):
            print(f"\n✅ Report generated successfully!")
            print(f"   File: {result['file_path']}")
        else:
            print(f"\n❌ Error: {result.get('error', 'Unknown error')}")

    except Exception as e:
        print(f"\n❌ Error generating report: {str(e)}")
        import traceback
        traceback.print_exc()


def mode4b_batch_reports():
    """Mode 4B: Generate batch reports"""
    print("\n" + "=" * 80)
    print("📄 MODE 4B: BATCH REPORTS")
    print("=" * 80 + "\n")

    SUMMARY_DATA, parse_summary_row, get_report_type = _get_customer_data()
    if SUMMARY_DATA is None:
        return

    # Filter options
    questions = [
        inquirer.List(
            'filter',
            message="Which customers to generate reports for?",
            choices=[
                ('Over-utilized only (>= 85% utilization)', 'over'),
                ('Under-utilized only (< 85% utilization)', 'under'),
                ('All customers', 'all'),
                ('← Back', 'back')
            ]
        )
    ]

    answers = inquirer.prompt(questions, theme=GreenPassion())
    if not answers or answers['filter'] == 'back':
        return

    # Count candidates
    over_count = 0
    under_count = 0
    skip_count = 0

    for row in SUMMARY_DATA:
        summary = parse_summary_row(row)
        rtype = get_report_type(summary)
        if rtype == "scheduling":
            over_count += 1
        elif rtype == "underutilization":
            under_count += 1
        else:
            skip_count += 1

    filter_type = answers['filter']
    if filter_type == 'over':
        total = over_count
        print(f"\n📊 Found {over_count} over-utilized/near-capacity customers")
    elif filter_type == 'under':
        total = under_count
        print(f"\n📊 Found {under_count} under-utilized customers")
    else:
        total = over_count + under_count
        print(f"\n📊 Found {total} total customers ({over_count} over-utilized, {under_count} under-utilized)")

    if total == 0:
        print("   No customers match the filter criteria.")
        return

    # Ask about Airbyte API
    q2 = inquirer.prompt([
        inquirer.Confirm('use_api', message="Fetch real-time connection data from Airbyte API?", default=True)
    ], theme=GreenPassion())
    if not q2:
        return

    # Output directory
    default_output = "/Users/ryanwaskewich/Documents/Claude/Worker/FinalReports"
    q3 = inquirer.prompt([
        inquirer.Text('output_dir', message="Output directory", default=default_output)
    ], theme=GreenPassion())
    if not q3:
        return

    # Confirm generation
    q4 = inquirer.prompt([
        inquirer.Confirm('confirm', message=f"Generate {total} reports?", default=True)
    ], theme=GreenPassion())
    if not q4 or not q4['confirm']:
        print("   Cancelled.")
        return

    output_dir = q3['output_dir']
    os.makedirs(output_dir, exist_ok=True)

    # Build command
    cmd_parts = ["python3", "generate_scheduling_reports.py"]
    cmd_parts.append(f"--output-dir \"{output_dir}\"")

    if q2['use_api']:
        cmd_parts.append("--use-airbyte-api")

    if filter_type == 'over':
        cmd_parts.append("--over-utilized-only")
    elif filter_type == 'under':
        cmd_parts.append("--under-utilized-only")

    cmd = " ".join(cmd_parts)

    print(f"\n🔄 Running batch generation...")
    print(f"   Command: {cmd}\n")

    # Run the command
    import subprocess
    try:
        # Source environment variables and run
        full_cmd = f"source ~/.env 2>/dev/null; {cmd}"
        result = subprocess.run(
            full_cmd,
            shell=True,
            cwd=os.path.dirname(os.path.abspath(__file__)),
            capture_output=False,
            text=True
        )

        if result.returncode == 0:
            print(f"\n✅ Batch generation complete!")
        else:
            print(f"\n⚠️  Process exited with code {result.returncode}")

    except Exception as e:
        print(f"\n❌ Error running batch generation: {str(e)}")


def mode4c_list_customers():
    """Mode 4C: List available customers with utilization status"""
    print("\n" + "=" * 80)
    print("📋 MODE 4C: AVAILABLE CUSTOMERS")
    print("=" * 80 + "\n")

    SUMMARY_DATA, parse_summary_row, get_report_type = _get_customer_data()
    if SUMMARY_DATA is None:
        return

    # Parse all customers
    customers = []
    for row in SUMMARY_DATA:
        summary = parse_summary_row(row)
        report_type = get_report_type(summary)
        customers.append({
            "name": summary["account_name"],
            "contracted": summary["contracted_workers"],
            "p99": summary["p99_workers"],
            "utilization": summary["billing_utilization_pct"],
            "status": summary["capacity_status"],
            "report_type": report_type
        })

    # Sort by utilization (highest first)
    customers.sort(key=lambda x: x["utilization"], reverse=True)

    # Count by category
    over_utilized = [c for c in customers if c["report_type"] == "scheduling"]
    under_utilized = [c for c in customers if c["report_type"] == "underutilization"]
    no_data = [c for c in customers if c["report_type"] == "skip"]

    print(f"Total Customers: {len(customers)}")
    print(f"  Over-utilized/Near-capacity (>= 85%): {len(over_utilized)} - Scheduling Optimization Report")
    print(f"  Under-utilized (< 85%): {len(under_utilized)} - Capacity Analysis Report")
    print(f"  No data: {len(no_data)} - No report")
    print()

    # Display options
    q = inquirer.prompt([
        inquirer.List(
            'view',
            message="Which customers to display?",
            choices=[
                ('Over-utilized (scheduling report candidates)', 'over'),
                ('Under-utilized (capacity report candidates)', 'under'),
                ('All customers', 'all'),
                ('← Back', 'back')
            ]
        )
    ], theme=GreenPassion())

    if not q or q['view'] == 'back':
        return

    # Select customers to display
    if q['view'] == 'over':
        display_list = over_utilized
        title = "OVER-UTILIZED CUSTOMERS (Scheduling Optimization Report)"
    elif q['view'] == 'under':
        display_list = under_utilized
        title = "UNDER-UTILIZED CUSTOMERS (Capacity Analysis Report)"
    else:
        display_list = [c for c in customers if c["report_type"] != "skip"]
        title = "ALL CUSTOMERS"

    print(f"\n{title}")
    print("-" * 80)
    print(f"{'Customer':<30} {'Contracted':>10} {'P99':>8} {'Util%':>8} {'Status':>15}")
    print("-" * 80)

    for c in display_list:
        status_display = c["status"].upper()
        if c["report_type"] == "scheduling":
            status_display = f"[SCHED] {status_display}"
        else:
            status_display = f"[CAP] {status_display}"

        print(f"{c['name']:<30} {c['contracted']:>10.1f} {c['p99']:>8.1f} {c['utilization']:>7.0f}% {status_display:>15}")

    print("-" * 80)
    print(f"Total: {len(display_list)} customers")


# ============================================================================
# MAIN
# ============================================================================

def main():
    """Main entry point"""
    print_banner()

    while True:
        mode = main_menu()

        if mode == 'exit':
            print("\n👋 Thanks for using Airbyte Data Worker Optimizer!")
            break
        elif mode == 'mode1':
            mode1_calculate_usage()
        elif mode == 'mode2':
            mode2_estimate_menu()
        elif mode == 'mode3':
            mode3_optimize_usage()
        elif mode == 'mode4':
            mode4_generate_reports()

        # Ask to continue
        print("\n")
        continue_q = inquirer.prompt([
            inquirer.Confirm('continue', message="Return to main menu?", default=True)
        ], theme=GreenPassion())

        if not continue_q or not continue_q['continue']:
            print("\n👋 Thanks for using Airbyte Data Worker Optimizer!")
            break


if __name__ == "__main__":
    main()