medicafe 0.250822.2__py3-none-any.whl → 0.250909.0__py3-none-any.whl

MediLink/MediLink_Deductible.py

@@ -50,8 +50,14 @@ UPGRADED TO LATEST CORE_UTILS:
 - Improved import error handling with fallbacks
 """
 # MediLink_Deductible.py
+"""
+TODO Consdier the possibility of being CSV agnostic and looking for the date of service up to 60 days old and
+then with an option to select specific patients to look up for all the valid rows.
+
+"""
 import os, sys, json
 from datetime import datetime
+from collections import defaultdict
 
 # Add parent directory to Python path to access MediCafe module
 current_dir = os.path.dirname(os.path.abspath(__file__))
@@ -78,17 +84,24 @@ try:
     except ImportError:
         api_core = None
     
-    # Import api_core for eligibility functions
+    # Import deductible utilities from MediCafe
     try:
-        from MediCafe import api_core
-    except ImportError:
-        api_core = None
-    
-    # Import api_core for eligibility functions
-    try:
-        from MediCafe import api_core
-    except ImportError:
-        api_core = None
+        from MediCafe.deductible_utils import (
+            validate_and_format_date,
+            convert_eligibility_to_enhanced_format,
+            resolve_payer_ids_from_csv,
+            get_payer_id_for_patient,
+            merge_responses,
+            backfill_enhanced_result
+        )
+    except ImportError as e:
+        print("Warning: Unable to import MediCafe.deductible_utils: {}".format(e))
+        # Fallback to local functions if utilities not available
+        validate_and_format_date = None
+        convert_eligibility_to_enhanced_format = None
+        resolve_payer_ids_from_csv = None
+        get_payer_id_for_patient = None
+        merge_responses = None
 except ImportError as e:
     print("Error: Unable to import MediCafe.core_utils. Please ensure MediCafe package is properly installed.")
     # Don't call log_import_error here since it's not available yet
@@ -112,67 +125,25 @@ try:
     from MediBot import MediBot_Preprocessor_lib
 except ImportError as e:
     print("Warning: Unable to import MediBot_Preprocessor_lib: {}".format(e))
-    import MediBot_Preprocessor_lib
-
-# Function to check if the date format is correct
-def validate_and_format_date(date_str):
-    # Comprehensive list of common DOB date formats
-    date_formats = [
-        # 4-digit year formats
-        '%Y-%m-%d',    # 1990-01-15
-        '%m/%d/%Y',    # 01/15/1990
-        '%m-%d-%Y',    # 01-15-1990
-        '%d-%m-%Y',    # 15-01-1990
-        '%d/%m/%Y',    # 15/01/1990
-        '%d-%b-%Y',    # 15-Jan-1990
-        '%d %b %Y',    # 15 Jan 1990
-        '%b %d, %Y',   # Jan 15, 1990
-        '%b %d %Y',    # Jan 15 1990
-        '%B %d, %Y',   # January 15, 1990
-        '%B %d %Y',    # January 15 1990
-        '%Y/%m/%d',    # 1990/01/15
-        '%Y%m%d',      # 19900115
-
-        # 2-digit year formats
-        '%m/%d/%y',    # 01/15/90
-        '%m-%d-%y',    # 01-15-90
-        '%d/%m/%y',    # 15/01/90
-        '%d-%m-%y',    # 15-01-90
-        '%d %b %y',    # 15 Jan 90
-        '%b %d, %y',   # Jan 15, 90
-        '%b %d %y',    # Jan 15 90
-        '%y/%m/%d',    # 90/01/15
-        '%y-%m-%d',    # 90-01-15
-        '%y%m%d',      # 900115
-
-        # Single digit formats (no leading zeros)
-        '%m/%d/%Y',    # 1/15/1990 (already covered above)
-        '%m-%d-%Y',    # 1-15-1990 (already covered above)
-        '%d/%m/%Y',    # 15/1/1990 (already covered above)
-        '%d-%m-%Y',    # 15-1-1990 (already covered above)
-        '%m/%d/%y',    # 1/15/90 (already covered above)
-        '%m-%d-%y',    # 1-15-90 (already covered above)
-        '%d/%m/%y',    # 15/1/90 (already covered above)
-        '%d-%m-%y',    # 15-1-90 (already covered above)
-    ]
+    try:
+        import MediBot_Preprocessor_lib
+    except ImportError as e2:
+        print("Error: Cannot import MediBot_Preprocessor_lib: {}".format(e2))
+        print("This module is required for CSV processing.")
+        sys.exit(1)
 
-    for fmt in date_formats:
+# Fallback date validation function if utilities not available
+def _fallback_validate_and_format_date(date_str):
+    """Fallback date validation function if MediCafe.deductible_utils not available"""
+    if validate_and_format_date is not None:
+        return validate_and_format_date(date_str)
+    else:
+        # Simple fallback implementation
         try:
-            # For 2-digit years, assume 20th/21st century
-            if '%y' in fmt:
-                parsed_date = datetime.strptime(date_str, fmt)
-                # Handle year 00-99: assume 1950-2049 range
-                if parsed_date.year < 50:
-                    parsed_date = parsed_date.replace(year=parsed_date.year + 2000)
-                elif parsed_date.year < 100:
-                    parsed_date = parsed_date.replace(year=parsed_date.year + 1900)
-                formatted_date = parsed_date.strftime('%Y-%m-%d')
-            else:
-                formatted_date = datetime.strptime(date_str, fmt).strftime('%Y-%m-%d')
-            return formatted_date
+            from datetime import datetime
+            return datetime.strptime(date_str, '%Y-%m-%d').strftime('%Y-%m-%d')
         except ValueError:
-            continue
-    return None
+            return None
 
 # Use latest core_utils configuration cache for better performance
 _get_config, (_config_cache, _crosswalk_cache) = create_config_cache()
@@ -203,15 +174,43 @@ if provider_last_name == 'Unknown':
     MediLink_ConfigLoader.log("Warning: provider_last_name was not found in the configuration.", level="WARNING")
 
 # Define the list of payer_id's to iterate over
-payer_ids = ['87726', '03432', '96385', '95467', '86050', '86047', '95378', '06111', '37602']  # United Healthcare.
+payer_ids = ['87726', '03432', '96385', '95467', '86050', '86047', '95378', '06111', '37602']  # United Healthcare ONLY.
+
 
 # Get the latest CSV
 CSV_FILE_PATH = config.get('CSV_FILE_PATH', "")
-csv_data = MediBot_Preprocessor_lib.load_csv_data(CSV_FILE_PATH)
+try:
+    csv_data = MediBot_Preprocessor_lib.load_csv_data(CSV_FILE_PATH)
+    print("Successfully loaded CSV data: {} records".format(len(csv_data)))
+except Exception as e:
+    print("Error loading CSV data: {}".format(e))
+    print("CSV_FILE_PATH: {}".format(CSV_FILE_PATH))
+    csv_data = []
 
 # Only keep rows that have an exact match with a payer ID from the payer_ids list
+if not csv_data:
+    print("Error: No CSV data loaded. Please check the CSV file path and format.")
+    sys.exit(1)
+
 valid_rows = [row for row in csv_data if str(row.get('Ins1 Payer ID', '')).strip() in payer_ids]
 
+if not valid_rows:
+    print("Error: No valid rows found with supported payer IDs.")
+    print("Supported payer IDs: {}".format(payer_ids))
+    print("Available payer IDs in CSV: {}".format(set(str(row.get('Ins1 Payer ID', '')).strip() for row in csv_data if row.get('Ins1 Payer ID', ''))))
+    sys.exit(1)
+
+# DEBUG: Log available fields in the first row for diagnostic purposes (DEBUG level is suppressed by default)
+if valid_rows:
+    try:
+        first_row = valid_rows[0]
+        MediLink_ConfigLoader.log("DEBUG: Available fields in CSV data:", level="DEBUG")
+        for field_name in sorted(first_row.keys()):
+            MediLink_ConfigLoader.log("  - '{}': '{}'".format(field_name, first_row[field_name]), level="DEBUG")
+        MediLink_ConfigLoader.log("DEBUG: End of available fields", level="DEBUG")
+    except Exception:
+        pass
+
 # Extract important columns for summary with fallback
 summary_valid_rows = [
     {
@@ -222,19 +221,129 @@ summary_valid_rows = [
     for row in valid_rows
 ]
 
-# Print summary of valid rows
-print("\n--- Summary of Valid Rows ---")
-for row in summary_valid_rows:
-    print("DOB: {}, Member ID: {}, Payer ID: {}".format(row['DOB'], row['Ins1 Member ID'], row['Ins1 Payer ID']))
+# Display enhanced summary of valid rows using unified display philosophy
+try:
+    from MediLink.MediLink_Display_Utils import display_enhanced_deductible_table
+except ImportError as e:
+    print("Warning: Unable to import MediLink_Display_Utils: {}".format(e))
+    # Create a fallback display function
+    def display_enhanced_deductible_table(data, context="", title=""):
+        print("Fallback display for {}: {} records".format(context, len(data)))
+        for i, row in enumerate(data, 1):
+            print("{:03d}: {} | {} | {} | {} | {} | {} | [{}]".format(
+                i,
+                row.get('Patient ID', ''),
+                row.get('Patient Name', '')[:20],
+                row.get('Patient DOB', ''),
+                row.get('Primary Policy Number', '')[:12],
+                row.get('Ins1 Payer ID', ''),
+                row.get('Service Date', ''),
+                row.get('status', 'READY')
+            ))
 
-# List of patients with DOB and MemberID from CSV data with fallback
-patients = [
-    (validate_and_format_date(row.get('Patient DOB', row.get('DOB', ''))),  # Try 'Patient DOB' first, then 'DOB'
-     row.get('Primary Policy Number', row.get('Ins1 Member ID', '')).strip())  # Try 'Primary Policy Number' first, then 'Ins1 Member ID'
-    for row in valid_rows 
-    if validate_and_format_date(row.get('Patient DOB', row.get('DOB', ''))) is not None and 
-       row.get('Primary Policy Number', row.get('Ins1 Member ID', '')).strip()
-]
+# Patients will be derived from patient_groups below
+
+# Build fast index for (dob, member_id) -> CSV row to avoid repeated scans
+patient_row_index = {}
+for row in valid_rows:
+    idx_dob = _fallback_validate_and_format_date(row.get('Patient DOB', row.get('DOB', '')))
+    idx_member_id = row.get('Primary Policy Number', row.get('Ins1 Member ID', '')).strip()
+    if idx_dob and idx_member_id:
+        patient_row_index[(idx_dob, idx_member_id)] = row
+
+# Group patients by (dob, member_id)
+patient_groups = defaultdict(list)
+for row in valid_rows:
+    dob = _fallback_validate_and_format_date(row.get('Patient DOB', row.get('DOB', '')))
+    member_id = row.get('Primary Policy Number', row.get('Ins1 Member ID', '')).strip()
+    # Try multiple possible service date field names (after header cleaning)
+    service_date = row.get('Service Date', '')
+    if not service_date:
+        service_date = row.get('Surgery Date', '')
+    if not service_date:
+        service_date = row.get('Date of Service', '')
+    if not service_date:
+        service_date = row.get('DOS', '')
+    if not service_date:
+        service_date = row.get('Date', '')
+    if dob and member_id:
+        # Try to parse service date, but handle various formats
+        service_date_sort = datetime.min
+        if service_date:
+            try:
+                # Try common date formats
+                for fmt in ['%m-%d-%Y', '%m/%d/%Y', '%Y-%m-%d', '%m-%d-%y', '%m/%d/%y']:
+                    try:
+                        service_date_sort = datetime.strptime(service_date, fmt)
+                        break
+                    except ValueError:
+                        continue
+            except:
+                pass  # Keep datetime.min if parsing fails
+        
+        patient_groups[(dob, member_id)].append({
+            'service_date_display': service_date,
+            'service_date_sort': service_date_sort,
+            'patient_id': row.get('Patient ID', '')
+        })
+
+# Update patients to unique
+patients = list(patient_groups.keys())
+
+# Use the enhanced table display for pre-API context
+# Create display data from unique patients with their service dates
+display_data = []
+for (dob, member_id), service_records in patient_groups.items():
+    # Find the original row data for this patient
+    original_row = patient_row_index.get((dob, member_id))
+    
+    if original_row:
+        # Use the first service record for display
+        first_service = service_records[0] if service_records else {}
+        # Try multiple possible field names for patient name (after header cleaning)
+        patient_name = original_row.get('Patient Name', '')
+        if not patient_name:
+            patient_name = original_row.get('Name', '')
+        if not patient_name:
+            patient_name = original_row.get('Member Name', '')
+        if not patient_name:
+            patient_name = original_row.get('Primary Insured Name', '')
+        if not patient_name:
+            patient_name = original_row.get('Subscriber Name', '')
+        if not patient_name:
+            patient_name = original_row.get('First Name', '') + ' ' + original_row.get('Last Name', '')
+        if not patient_name:
+            patient_name = original_row.get('Ins1 Subscriber Name', '')
+        if not patient_name:
+            patient_name = original_row.get('Subscriber First Name', '') + ' ' + original_row.get('Subscriber Last Name', '')
+        if not patient_name:
+            # Try additional field names that might be in the CSV
+            patient_name = original_row.get('Patient', '')
+        if not patient_name:
+            patient_name = original_row.get('Member', '')
+        if not patient_name:
+            patient_name = original_row.get('Subscriber', '')
+        if not patient_name:
+            # Try combining first and last name fields
+            first_name = original_row.get('Patient First', '') or original_row.get('First', '') or original_row.get('FirstName', '') or original_row.get('First Name', '')
+            last_name = original_row.get('Patient Last', '') or original_row.get('Last', '') or original_row.get('LastName', '') or original_row.get('Last Name', '')
+            if first_name or last_name:
+                patient_name = (first_name + ' ' + last_name).strip()
+        if not patient_name.strip():
+            patient_name = 'Unknown Patient'
+        
+        display_row = {
+            'Patient ID': original_row.get('Patient ID', ''),
+            'Patient Name': patient_name,
+            'Patient DOB': dob,
+            'Primary Policy Number': member_id,
+            'Ins1 Payer ID': original_row.get('Ins1 Payer ID', ''),
+            'Service Date': first_service.get('service_date_display', ''),
+            'status': 'Ready'
+        }
+        display_data.append(display_row)
+
+display_enhanced_deductible_table(display_data, context="pre_api")
 
 # Function to handle manual patient deductible lookup
 def manual_deductible_lookup():
@@ -256,7 +365,7 @@ def manual_deductible_lookup():
             print("Returning to main menu.\n")
             break
             
-        formatted_dob = validate_and_format_date(dob_input)
+        formatted_dob = _fallback_validate_and_format_date(dob_input)
         if not formatted_dob:
             print("Invalid DOB format. Please enter in YYYY-MM-DD format.\n")
             continue
@@ -274,6 +383,56 @@ def manual_deductible_lookup():
             eligibility_data = get_eligibility_info(client, payer_id, provider_last_name, formatted_dob, member_id, npi, run_validation=run_validation, is_manual_lookup=True)
             if eligibility_data:
                 found_data = True
+                
+                # Convert to enhanced format and display
+                # Check if we already have processed data (from merge_responses in debug mode)
+                if isinstance(eligibility_data, dict) and 'patient_name' in eligibility_data and 'data_source' in eligibility_data:
+                    # Already processed data from merge_responses
+                    enhanced_result = eligibility_data
+                elif convert_eligibility_to_enhanced_format is not None:
+                    # Raw API data needs conversion with patient info
+                    enhanced_result = convert_eligibility_to_enhanced_format(eligibility_data, formatted_dob, member_id, "", "")
+                else:
+                    # Fallback if utility function not available
+                    enhanced_result = None
+                if enhanced_result:
+                    try:
+                        # Backfill with CSV row data when available
+                        enhanced_result = backfill_enhanced_result(enhanced_result, None)
+                    except Exception:
+                        pass
+                    print("\n" + "=" * 60)
+                    display_enhanced_deductible_table([enhanced_result], context="post_api", 
+                                                    title="Manual Lookup Result")
+                    print("=" * 60)
+                    
+                    # Enhanced manual lookup result display
+                    print("\n" + "=" * 60)
+                    print("MANUAL LOOKUP RESULT")
+                    print("=" * 60)
+                    print("Patient Name: {}".format(enhanced_result['patient_name']))
+                    print("Member ID: {}".format(enhanced_result['member_id']))
+                    print("Date of Birth: {}".format(enhanced_result['dob']))
+                    print("Payer ID: {}".format(enhanced_result['payer_id']))
+                    print("Insurance Type: {}".format(enhanced_result['insurance_type']))
+                    print("Policy Status: {}".format(enhanced_result['policy_status']))
+                    print("Remaining Deductible: {}".format(enhanced_result['remaining_amount']))
+                    print("=" * 60)
+                else:
+                    # Fallback display when enhanced_result is None
+                    print("\n" + "=" * 60)
+                    print("MANUAL LOOKUP RESULT")
+                    print("=" * 60)
+                    print("Patient Name: Not Available")
+                    print("Member ID: {}".format(member_id))
+                    print("Date of Birth: {}".format(formatted_dob))
+                    print("Payer ID: {}".format(payer_id))
+                    print("Insurance Type: Not Available")
+                    print("Policy Status: Not Available")
+                    print("Remaining Deductible: Not Available")
+                    print("Note: Data conversion failed - raw API response available")
+                    print("=" * 60)
+                
                 # Generate unique output file for manual request
                 output_file_name = "eligibility_report_manual_{}_{}.txt".format(member_id, formatted_dob)
                 output_file_path = os.path.join(os.getenv('TEMP'), output_file_name)
@@ -282,8 +441,6 @@ def manual_deductible_lookup():
                         "Patient Name", "DOB", "Insurance Type", "PayID", "Policy Status", "Remaining Amt")
                     output_file.write(table_header + "\n")
                     output_file.write("-" * len(table_header) + "\n")
-                    print(table_header)
-                    print("-" * len(table_header))
                     display_eligibility_info(eligibility_data, formatted_dob, member_id, output_file)
                 
                 # Ask if user wants to open the report
@@ -305,7 +462,10 @@ def manual_deductible_lookup():
 
 
 # Function to get eligibility information
-def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, member_id, npi, run_validation=False, is_manual_lookup=False):
+def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, member_id, npi, run_validation=False, is_manual_lookup=False, printed_messages=None):
+    if printed_messages is None:
+        printed_messages = set()
+
     try:
         # Log the parameters being sent to the function
         MediLink_ConfigLoader.log("Calling eligibility check with parameters:", level="DEBUG")
@@ -322,9 +482,22 @@ def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, me
             
             # Get legacy response
             MediLink_ConfigLoader.log("Getting legacy get_eligibility_v3 API response", level="INFO")
-            legacy_eligibility = api_core.get_eligibility_v3(
-                client, payer_id, provider_last_name, 'MemberIDDateOfBirth', date_of_birth, member_id, npi
-            )
+
+            legacy_eligibility = None
+            if client and hasattr(client, 'get_access_token'):
+                try:
+                    # Try to get access token for UHCAPI endpoint
+                    access_token = client.get_access_token('UHCAPI')
+                    if access_token:
+                        legacy_eligibility = api_core.get_eligibility_v3(
+                            client, payer_id, provider_last_name, 'MemberIDDateOfBirth', date_of_birth, member_id, npi
+                        )
+                    else:
+                        MediLink_ConfigLoader.log("No access token available for Legacy API (UHCAPI endpoint). Check configuration.", level="WARNING")
+                except Exception as e:
+                    MediLink_ConfigLoader.log("Failed to get access token for Legacy API: {}".format(e), level="ERROR")
+            else:
+                MediLink_ConfigLoader.log("API client does not support token authentication for Legacy API.", level="WARNING")
             
             # Get Super Connector response for comparison
             MediLink_ConfigLoader.log("Getting new get_eligibility_super_connector API response", level="INFO")
@@ -368,11 +541,17 @@ def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, me
                     raw_response = super_connector_eligibility.get('rawGraphQLResponse', {})
                     errors = raw_response.get('errors', [])
                     if errors:
-                        print("Super Connector API returned {} error(s):".format(len(errors)))
+                        error_msg = "Super Connector API returned {} error(s):".format(len(errors))
+                        if error_msg not in printed_messages:
+                            print(error_msg)
+                            printed_messages.add(error_msg)
                         for i, error in enumerate(errors):
                             error_code = error.get('code', 'UNKNOWN')
                             error_desc = error.get('description', 'No description')
-                            print("  Error {}: {} - {}".format(i+1, error_code, error_desc))
+                            detail_msg = "  Error {}: {} - {}".format(i+1, error_code, error_desc)
+                            if detail_msg not in printed_messages:
+                                print(detail_msg)
+                                printed_messages.add(detail_msg)
                             
                             # Check for data in error extensions (some APIs return data here)
                             extensions = error.get('extensions', {})
@@ -403,23 +582,52 @@ def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, me
             except Exception as e:
                 print("\nError generating validation report: {}".format(str(e)))
             
-            # Return legacy response for consistency
-            eligibility = legacy_eligibility
+            # After validation, merge responses
+            try:
+                merged_data = merge_responses(super_connector_eligibility, legacy_eligibility, date_of_birth, member_id)
+                return merged_data
+            except Exception as e:
+                MediLink_ConfigLoader.log("Error in merge_responses: {}".format(e), level="ERROR")
+                # Return a safe fallback result
+                return {
+                    'patient_name': 'Unknown Patient',
+                    'dob': date_of_birth,
+                    'member_id': member_id,
+                    'insurance_type': 'Not Available',
+                    'policy_status': 'Not Available',
+                    'remaining_amount': 'Not Found',
+                    'data_source': 'Error',
+                    'is_successful': False
+                }
             
         else:
             # Legacy mode: Only call legacy API
             MediLink_ConfigLoader.log("Running in LEGACY MODE - calling legacy API only", level="INFO")
             
-            # Only get legacy response
-            MediLink_ConfigLoader.log("Getting legacy get_eligibility_v3 API response", level="INFO")
-            eligibility = api_core.get_eligibility_v3(
-                client, payer_id, provider_last_name, 'MemberIDDateOfBirth', date_of_birth, member_id, npi
-            )
+            # Only get legacy response with proper token handling
+            if client and hasattr(client, 'get_access_token'):
+                try:
+                    access_token = client.get_access_token('UHCAPI')
+                    if access_token:
+                        eligibility = api_core.get_eligibility_v3(
+                            client, payer_id, provider_last_name, 'MemberIDDateOfBirth', date_of_birth, member_id, npi
+                        )
+                    else:
+                        MediLink_ConfigLoader.log("No access token available for Legacy API in Legacy mode.", level="WARNING")
+                        return None
+                except Exception as e:
+                    MediLink_ConfigLoader.log("Failed to get access token for Legacy API in Legacy mode: {}".format(e), level="ERROR")
+                    return None
+            else:
+                MediLink_ConfigLoader.log("API client does not support token authentication for Legacy API in Legacy mode.", level="WARNING")
+                return None
         
         # Log the response
-        MediLink_ConfigLoader.log("Eligibility response: {}".format(json.dumps(eligibility, indent=4)), level="DEBUG")
-        
-        return eligibility
+        if 'eligibility' in locals():
+            MediLink_ConfigLoader.log("Eligibility response: {}".format(json.dumps(eligibility, indent=4)), level="DEBUG")
+            return eligibility
+        else:
+            return None
     except Exception as e:
         # Handle HTTP errors if requests is available
         if requests and hasattr(requests, 'exceptions') and isinstance(e, requests.exceptions.HTTPError):
@@ -432,433 +640,64 @@ def get_eligibility_info(client, payer_id, provider_last_name, date_of_birth, me
             print("Eligibility Check Error: {}".format(e))
     return None
 
-# Helper functions to extract data from different API response formats
-# TODO (HIGH PRIORITY - API Response Parser Debugging):
-# PROBLEM: API responses are returning correctly but the parser functions below 
-# are not successfully extracting the super_connector variables (likely eligibility data).
-# This suggests a schema mismatch between expected and actual API response format.
-#
-# IMPLEMENTATION CLARIFICATION:
-# - Primary path should not depend on probing payer_ids via API.
-# - Prefer payer_id provided by CSV/crosswalk as the authoritative source.
-# - Keep API probing behind a non-default debug flag to support troubleshooting sessions only.
-# - Add detailed logging helpers (no-op in production) to inspect mismatches safely on XP.
-#
-# DEBUGGING STEPS:
-# 1. Response Structure Analysis:
-#    - Add comprehensive logging of raw API responses before parsing
-#    - Compare current response format vs expected format in parser functions
-#    - Check if API endpoint has changed response schema recently
-#    - Verify if different endpoints return different response structures
-#
-# 2. Parser Function Validation:
-#    - Test each extract_*_patient_info() function with sample responses
-#    - Check if field names/paths have changed (e.g., 'patientInfo' vs 'patient_info')
-#    - Verify array indexing logic (e.g., [0] access on empty arrays)
-#    - Check case sensitivity in field access
-#
-# 3. Super Connector Variable Mapping:
-#    - Document what "super_connector variables" should contain
-#    - Identify which fields from API response map to these variables
-#    - Verify the expected format vs actual format
-#    - Check if variable names have changed in the application
-#
-# IMPLEMENTATION PLAN:
-# 1. Enhanced Logging:
-#    - Add log_api_response_structure(response) function
-#    - Log raw JSON before each parser function call
-#    - Add field-by-field parsing logs with null checks
-#
-# 2. Parser Robustness:
-#    - Add null/empty checks for all field accesses
-#    - Implement graceful fallbacks for missing fields
-#    - Add validation for expected data types
-#    - Handle both old and new response formats if schema changed
-#
-# 3. Schema Validation:
-#    - Create validate_api_response_schema(response, expected_schema) function
-#    - Define expected schemas for each API endpoint
-#    - Alert when response doesn't match expected schema
-#    - Suggest schema updates when mismatches occur
-#
-# 4. Testing Framework:
-#    - Create test cases with known good API responses
-#    - Test parser functions independently of API calls
-#    - Add integration tests for end-to-end parsing workflow
-#    - Create mock responses for development testing
+# API response parsing functions moved to MediCafe.deductible_utils
+# All parsing logic is now centralized in the utility module for DRY compliance
 #
-# IMMEDIATE ACTIONS:
-# 1. Add detailed logging before each extract_*_patient_info() call
-# 2. Log the structure of the 'policy' object being passed to parsers
-# 3. Check if the issue is in extract_legacy_patient_info() vs extract_super_connector_patient_info()
-# 4. Verify which API endpoint is being called and if it matches expected parser
+# TODO (API DEVELOPER FIX REQUIRED):
+# The following issues from the original commentary still need to be addressed:
+# 1. Complete Super Connector API response schema - API developers are working on this
+# 2. Full response structure validation - depends on stable API response structure  
+# 3. Comprehensive test cases - requires consistent API responses
 #
-# FILES TO EXAMINE:
-# - This file: all extract_*_patient_info() functions
-# - MediCafe/api_core.py: API call implementation and response handling
-# - Config files: Check if API endpoints or credentials have changed
+# CURRENT STATUS:
+#  Enhanced logging and debugging capabilities implemented
+#  Schema validation framework in place
+#  Compatibility analysis functions added
+#  Robust fallback mechanisms implemented
+#  Complete API response schema validation (pending API fix)
+#  Comprehensive test suite (pending stable API responses)
 #
-# RELATED ISSUES:
-# - May be connected to authentication or endpoint configuration problems
-# - Could indicate API version updates that changed response format
-# - Might be related to different payer-specific response formats
-
-def extract_legacy_patient_info(policy):
-    """Extract patient information from legacy API response format"""
-    patient_info = policy.get("patientInfo", [{}])[0]
-    return {
-        'lastName': patient_info.get("lastName", ""),
-        'firstName': patient_info.get("firstName", ""),
-        'middleName': patient_info.get("middleName", "")
-    }
-
-def extract_super_connector_patient_info(eligibility_data):
-    """Extract patient information from Super Connector API response format"""
-    if not eligibility_data:
-        return {'lastName': '', 'firstName': '', 'middleName': ''}
-    
-    # Handle multiple eligibility records - use the first one with valid data
-    if "rawGraphQLResponse" in eligibility_data:
-        raw_response = eligibility_data.get('rawGraphQLResponse', {})
-        data = raw_response.get('data', {})
-        check_eligibility = data.get('checkEligibility', {})
-        eligibility_list = check_eligibility.get('eligibility', [])
-        
-        # Try to get from the first eligibility record
-        if eligibility_list:
-            first_eligibility = eligibility_list[0]
-            member_info = first_eligibility.get('eligibilityInfo', {}).get('member', {})
-            if member_info:
-                return {
-                    'lastName': member_info.get("lastName", ""),
-                    'firstName': member_info.get("firstName", ""),
-                    'middleName': member_info.get("middleName", "")
-                }
-        
-        # Check for data in error extensions (some APIs return data here despite errors)
-        errors = raw_response.get('errors', [])
-        for error in errors:
-            extensions = error.get('extensions', {})
-            if extensions and 'details' in extensions:
-                details = extensions.get('details', [])
-                if details:
-                    # Use the first detail record that has patient info
-                    for detail in details:
-                        if detail.get('lastName') or detail.get('firstName'):
-                            return {
-                                'lastName': detail.get("lastName", ""),
-                                'firstName': detail.get("firstName", ""),
-                                'middleName': detail.get("middleName", "")
-                            }
-    
-    # Fallback to top-level fields
-    return {
-        'lastName': eligibility_data.get("lastName", ""),
-        'firstName': eligibility_data.get("firstName", ""),
-        'middleName': eligibility_data.get("middleName", "")
-    }
-
-def extract_legacy_remaining_amount(policy):
-    """Extract remaining amount from legacy API response format"""
-    deductible_info = policy.get("deductibleInfo", {})
-    if 'individual' in deductible_info:
-        remaining = deductible_info['individual']['inNetwork'].get("remainingAmount", "")
-        return remaining if remaining else "Not Found"
-    elif 'family' in deductible_info:
-        remaining = deductible_info['family']['inNetwork'].get("remainingAmount", "")
-        return remaining if remaining else "Not Found"
-    else:
-        return "Not Found"
-
-def extract_super_connector_remaining_amount(eligibility_data):
-    """Extract remaining amount from Super Connector API response format"""
-    if not eligibility_data:
-        return "Not Found"
-    
-    # First, check top-level metYearToDateAmount which might indicate deductible met
-    met_amount = eligibility_data.get('metYearToDateAmount')
-    if met_amount is not None:
-        return str(met_amount)
-    
-    # Collect all deductible amounts to find the most relevant one
-    all_deductible_amounts = []
-    
-    # Look for deductible information in planLevels (based on validation report)
-    plan_levels = eligibility_data.get('planLevels', [])
-    for plan_level in plan_levels:
-        if plan_level.get('level') == 'deductibleInfo':
-            # Collect individual deductible amounts
-            individual_levels = plan_level.get('individual', [])
-            if individual_levels:
-                for individual in individual_levels:
-                    remaining = individual.get('remainingAmount')
-                    if remaining is not None:
-                        try:
-                            amount = float(remaining)
-                            all_deductible_amounts.append(('individual', amount))
-                        except (ValueError, TypeError):
-                            pass
-            
-            # Collect family deductible amounts
-            family_levels = plan_level.get('family', [])
-            if family_levels:
-                for family in family_levels:
-                    remaining = family.get('remainingAmount')
-                    if remaining is not None:
-                        try:
-                            amount = float(remaining)
-                            all_deductible_amounts.append(('family', amount))
-                        except (ValueError, TypeError):
-                            pass
-    
-    # Navigate to the rawGraphQLResponse structure as fallback
-    raw_response = eligibility_data.get('rawGraphQLResponse', {})
-    if raw_response:
-        data = raw_response.get('data', {})
-        check_eligibility = data.get('checkEligibility', {})
-        eligibility_list = check_eligibility.get('eligibility', [])
-        
-        # Try all eligibility records for deductible information
-        for eligibility in eligibility_list:
-            plan_levels = eligibility.get('eligibilityInfo', {}).get('planLevels', [])
-            for plan_level in plan_levels:
-                if plan_level.get('level') == 'deductibleInfo':
-                    # Collect individual deductible amounts
-                    individual_levels = plan_level.get('individual', [])
-                    if individual_levels:
-                        for individual in individual_levels:
-                            remaining = individual.get('remainingAmount')
-                            if remaining is not None:
-                                try:
-                                    amount = float(remaining)
-                                    all_deductible_amounts.append(('individual', amount))
-                                except (ValueError, TypeError):
-                                    pass
-                    
-                    # Collect family deductible amounts
-                    family_levels = plan_level.get('family', [])
-                    if family_levels:
-                        for family in family_levels:
-                            remaining = family.get('remainingAmount')
-                            if remaining is not None:
-                                try:
-                                    amount = float(remaining)
-                                    all_deductible_amounts.append(('family', amount))
-                                except (ValueError, TypeError):
-                                    pass
-    
-    # Select the most relevant deductible amount
-    if all_deductible_amounts:
-        # Strategy: Prefer individual over family, and prefer non-zero amounts
-        # First, try to find non-zero individual amounts
-        non_zero_individual = [amt for type_, amt in all_deductible_amounts if type_ == 'individual' and amt > 0]
-        if non_zero_individual:
-            return str(max(non_zero_individual))  # Return highest non-zero individual amount
-        
-        # If no non-zero individual, try non-zero family amounts
-        non_zero_family = [amt for type_, amt in all_deductible_amounts if type_ == 'family' and amt > 0]
-        if non_zero_family:
-            return str(max(non_zero_family))  # Return highest non-zero family amount
-        
-        # If all amounts are zero, return the first individual amount (or family if no individual)
-        individual_amounts = [amt for type_, amt in all_deductible_amounts if type_ == 'individual']
-        if individual_amounts:
-            return str(individual_amounts[0])
-        
-        # Fallback to first family amount
-        family_amounts = [amt for type_, amt in all_deductible_amounts if type_ == 'family']
-        if family_amounts:
-            return str(family_amounts[0])
-    
-    return "Not Found"
-
-def extract_legacy_insurance_info(policy):
-    """Extract insurance information from legacy API response format"""
-    insurance_info = policy.get("insuranceInfo", {})
-    return {
-        'insuranceType': insurance_info.get("insuranceType", ""),
-        'insuranceTypeCode': insurance_info.get("insuranceTypeCode", ""),
-        'memberId': insurance_info.get("memberId", ""),
-        'payerId': insurance_info.get("payerId", "")
-    }
-
-def extract_super_connector_insurance_info(eligibility_data):
-    """Extract insurance information from Super Connector API response format"""
-    if not eligibility_data:
-        return {'insuranceType': '', 'insuranceTypeCode': '', 'memberId': '', 'payerId': ''}
-    
-    # Handle multiple eligibility records - use the first one with valid data
-    if "rawGraphQLResponse" in eligibility_data:
-        raw_response = eligibility_data.get('rawGraphQLResponse', {})
-        data = raw_response.get('data', {})
-        check_eligibility = data.get('checkEligibility', {})
-        eligibility_list = check_eligibility.get('eligibility', [])
-        
-        # Try to get from the first eligibility record
-        if eligibility_list:
-            first_eligibility = eligibility_list[0]
-            insurance_info = first_eligibility.get('eligibilityInfo', {}).get('insuranceInfo', {})
-            if insurance_info:
-                return {
-                    'insuranceType': insurance_info.get("planTypeDescription", ""),
-                    'insuranceTypeCode': insurance_info.get("productServiceCode", ""),
-                    'memberId': insurance_info.get("memberId", ""),
-                    'payerId': insurance_info.get("payerId", "")
-                }
-        
-        # Check for data in error extensions (some APIs return data here despite errors)
-        errors = raw_response.get('errors', [])
-        for error in errors:
-            extensions = error.get('extensions', {})
-            if extensions and 'details' in extensions:
-                details = extensions.get('details', [])
-                if details:
-                    # Use the first detail record that has insurance info
-                    for detail in details:
-                        if detail.get('memberId') or detail.get('payerId'):
-                            # Try to determine insurance type from available data
-                            insurance_type = detail.get('planType', '')
-                            if not insurance_type:
-                                insurance_type = detail.get('productType', '')
-                            
-                            return {
-                                'insuranceType': insurance_type,
-                                'insuranceTypeCode': detail.get("productServiceCode", ""),
-                                'memberId': detail.get("memberId", ""),
-                                'payerId': detail.get("payerId", "")
-                            }
-    
-    # Fallback to top-level fields
-    insurance_type = eligibility_data.get("planTypeDescription", "")
-    if not insurance_type:
-        insurance_type = eligibility_data.get("productType", "")
-    
-    # Clean up the insurance type if it's too long (like the LPPO description)
-    if insurance_type and len(insurance_type) > 50:
-        # Extract just the plan type part
-        if "PPO" in insurance_type:
-            insurance_type = "Preferred Provider Organization (PPO)"
-        elif "HMO" in insurance_type:
-            insurance_type = "Health Maintenance Organization (HMO)"
-        elif "EPO" in insurance_type:
-            insurance_type = "Exclusive Provider Organization (EPO)"
-        elif "POS" in insurance_type:
-            insurance_type = "Point of Service (POS)"
-    
-    # Get insurance type code from multiple possible locations
-    insurance_type_code = eligibility_data.get("productServiceCode", "")
-    if not insurance_type_code:
-        # Try to get from coverageTypes
-        coverage_types = eligibility_data.get("coverageTypes", [])
-        if coverage_types:
-            insurance_type_code = coverage_types[0].get("typeCode", "")
-    
-    # Note: We're not mapping "M" to "PR" as "M" likely means "Medical" 
-    # and "PR" should be "12" for PPO according to CMS standards
-    # This mapping should be handled by the API developers
-    
-    return {
-        'insuranceType': insurance_type,
-        'insuranceTypeCode': insurance_type_code,
-        'memberId': eligibility_data.get("subscriberId", ""),
-        'payerId': eligibility_data.get("payerId", "")  # Use payerId instead of legalEntityCode (this should be payer_id from the inputs)
-    }
-
-def extract_legacy_policy_status(policy):
-    """Extract policy status from legacy API response format"""
-    policy_info = policy.get("policyInfo", {})
-    return policy_info.get("policyStatus", "")
-
-def extract_super_connector_policy_status(eligibility_data):
-    """Extract policy status from Super Connector API response format"""
-    if not eligibility_data:
-        return ""
-    
-    # Handle multiple eligibility records - use the first one with valid data
-    if "rawGraphQLResponse" in eligibility_data:
-        raw_response = eligibility_data.get('rawGraphQLResponse', {})
-        data = raw_response.get('data', {})
-        check_eligibility = data.get('checkEligibility', {})
-        eligibility_list = check_eligibility.get('eligibility', [])
-        
-        # Try to get from the first eligibility record
-        if eligibility_list:
-            first_eligibility = eligibility_list[0]
-            insurance_info = first_eligibility.get('eligibilityInfo', {}).get('insuranceInfo', {})
-            if insurance_info:
-                return insurance_info.get("policyStatus", "")
-    
-    # Fallback to top-level field
-    return eligibility_data.get("policyStatus", "")
-
-def is_legacy_response_format(data):
-    """Determine if the response is in legacy format (has memberPolicies)"""
-    return data is not None and "memberPolicies" in data
-
-def is_super_connector_response_format(data):
-    """Determine if the response is in Super Connector format (has rawGraphQLResponse)"""
-    return data is not None and "rawGraphQLResponse" in data
+# NEXT STEPS:
+# - Monitor API developer progress on Super Connector schema fixes
+# - Update schema validation once API responses are stable
+# - Create comprehensive test cases with known good responses
+# - Consider adding automated schema detection for new API versions
 
 # Function to extract required fields and display in a tabular format
-def display_eligibility_info(data, dob, member_id, output_file):
+def display_eligibility_info(data, dob, member_id, output_file, patient_id="", service_date=""):
+    """Legacy display function - converts to enhanced format and displays"""
     if data is None:
         return
 
-    # Determine which API response format we're dealing with
-    if is_legacy_response_format(data):
-        # Handle legacy API response format
-        for policy in data.get("memberPolicies", []):
-            # Skip non-medical policies
-            if policy.get("policyInfo", {}).get("coverageType", "") != "Medical":
-                continue
-
-            patient_info = extract_legacy_patient_info(policy)
-            remaining_amount = extract_legacy_remaining_amount(policy)
-            insurance_info = extract_legacy_insurance_info(policy)
-            policy_status = extract_legacy_policy_status(policy)
-
-            patient_name = "{} {} {}".format(
-                patient_info['firstName'], 
-                patient_info['middleName'], 
-                patient_info['lastName']
-            ).strip()[:20]
-
-            # Display patient information in a table row format
-            table_row = "{:<20} | {:<10} | {:<40} | {:<5} | {:<14} | {:<14}".format(
-                patient_name, dob, insurance_info['insuranceType'], 
-                insurance_info['payerId'], policy_status, remaining_amount)
-            output_file.write(table_row + "\n")
-            print(table_row)  # Print to console for progressive display
-
-    elif is_super_connector_response_format(data):
-        # Handle Super Connector API response format
-        patient_info = extract_super_connector_patient_info(data)
-        remaining_amount = extract_super_connector_remaining_amount(data)
-        insurance_info = extract_super_connector_insurance_info(data)
-        policy_status = extract_super_connector_policy_status(data)
-
-        patient_name = "{} {} {}".format(
-            patient_info['firstName'], 
-            patient_info['middleName'], 
-            patient_info['lastName']
-        ).strip()[:20]
-
-        # Display patient information in a table row format
+    # Convert to enhanced format
+    enhanced_data = convert_eligibility_to_enhanced_format(data, dob, member_id, patient_id, service_date)
+    if enhanced_data:
+        # Write to output file in legacy format for compatibility
         table_row = "{:<20} | {:<10} | {:<40} | {:<5} | {:<14} | {:<14}".format(
-            patient_name, dob, insurance_info['insuranceType'], 
-            insurance_info['payerId'], policy_status, remaining_amount)
+            enhanced_data['patient_name'][:20], 
+            enhanced_data['dob'], 
+            enhanced_data['insurance_type'][:40], 
+            enhanced_data['payer_id'][:5], 
+            enhanced_data['policy_status'][:14], 
+            enhanced_data['remaining_amount'][:14])
         output_file.write(table_row + "\n")
         print(table_row)  # Print to console for progressive display
 
-    else:
-        # Unknown response format - log for debugging
-        MediLink_ConfigLoader.log("Unknown response format in display_eligibility_info", level="WARNING")
-        MediLink_ConfigLoader.log("Response structure: {}".format(json.dumps(data, indent=2)), level="DEBUG")
-
 # Global mode flags (will be set in main)
 LEGACY_MODE = False
 DEBUG_MODE = False
 
+# PERFORMANCE OPTIMIZATION: Feature toggle for payer ID probing
+# When False (default): Use crosswalk-based resolution (O(N) complexity)
+# When True: Use multi-payer probing (O(PxN) complexity) for troubleshooting only
+DEBUG_MODE_PAYER_PROBE = False
+
+# Crosswalk-based payer ID resolution cache
+_payer_id_cache = None
+
+# Payer ID resolution functions moved to MediCafe.deductible_utils
+# All resolution logic is now centralized in the utility module for DRY compliance
+
 # Main Execution Flow
 if __name__ == "__main__":
     print("\n" + "=" * 80)
@@ -871,33 +710,43 @@ if __name__ == "__main__":
     print("\nSelect operation mode:")
     print("1. Legacy Mode (Default) - Single API calls, consolidated output")
     print("2. Debug Mode - Dual API calls with validation reports")
-    print("3. Exit")
+    print("3. Payer Probe Debug Mode - Multi-payer probing for troubleshooting")
+    print("4. Exit")
     
-    mode_choice = input("\nEnter your choice (1-3) [Default: 1]: ").strip()
+    mode_choice = input("\nEnter your choice (1-4) [Default: 1]: ").strip()
     if not mode_choice:
         mode_choice = "1"
     
-    if mode_choice == "3":
+    if mode_choice == "4":
         print("\nExiting. Thank you for using MediLink Deductible Tool!")
         sys.exit(0)
-    elif mode_choice not in ["1", "2"]:
+    elif mode_choice not in ["1", "2", "3"]:
         print("Invalid choice. Using Legacy Mode (Default).")
         mode_choice = "1"
     
     # Set mode flags
     LEGACY_MODE = (mode_choice == "1")
     DEBUG_MODE = (mode_choice == "2")
+    DEBUG_MODE_PAYER_PROBE = (mode_choice == "3")
     
     if LEGACY_MODE:
         print("\nRunning in LEGACY MODE")
         print("- Single API calls (Legacy API only)")
         print("- Progressive output during processing")
         print("- Consolidated output file at the end")
-    else:
+        print("- Crosswalk-based payer ID resolution (O(N) complexity)")
+    elif DEBUG_MODE:
         print("\nRunning in DEBUG MODE")
         print("- Dual API calls (Legacy + Super Connector)")
         print("- Validation reports and comparisons")
         print("- Detailed logging and error reporting")
+        print("- Crosswalk-based payer ID resolution (O(N) complexity)")
+    else:
+        print("\nRunning in PAYER PROBE DEBUG MODE")
+        print("- Multi-payer probing for troubleshooting")
+        print("- Original O(PxN) complexity algorithm")
+        print("- Use only for diagnostic sessions")
+        print("- Not recommended for production use")
     
     while True:
         print("\nChoose an option:")
@@ -928,70 +777,234 @@ if __name__ == "__main__":
                 print("Batch processing cancelled.")
                 continue
             
-            output_file_path = os.path.join(os.getenv('TEMP'), 'eligibility_report.txt')
-            with open(output_file_path, 'w') as output_file:
-                table_header = "{:<20} | {:<10} | {:<40} | {:<5} | {:<14} | {:<14}".format(
-                    "Patient Name", "DOB", "Insurance Type", "PayID", "Policy Status", "Remaining Amt")
-                output_file.write(table_header + "\n")
-                output_file.write("-" * len(table_header) + "\n")
-                print(table_header)
-                print("-" * len(table_header))
+            # PERFORMANCE OPTIMIZATION: Crosswalk-based payer ID resolution
+            # This eliminates O(PxN) complexity by using CSV/crosswalk data as authoritative source
+            # Multi-payer probing is retained behind DEBUG_MODE_PAYER_PROBE toggle for troubleshooting
+            
+            # Load crosswalk data for payer ID resolution
+            try:
+                _, crosswalk = _get_config()
+            except Exception as e:
+                MediLink_ConfigLoader.log("Failed to load crosswalk data: {}".format(e), level="WARNING")
+                crosswalk = {}
+            
+            # Pre-resolve payer IDs for all patients (O(N) operation)
+            if not DEBUG_MODE_PAYER_PROBE:
+                if resolve_payer_ids_from_csv is not None:
+                    _payer_id_cache = resolve_payer_ids_from_csv(csv_data, config, crosswalk, payer_ids)
+                    print("Resolved {} patient-payer mappings from CSV data".format(len(_payer_id_cache)))
+                else:
+                    # Fallback if utility function not available
+                    _payer_id_cache = {}
+                    print("Warning: Payer ID resolution utility not available, using empty cache")
+            
+            errors = []
+            validation_reports = []
+            processed_count = 0
+            validation_files_created = []  # Track validation files that were actually created
+            eligibility_results = []  # Collect all results for enhanced display
+            printed_messages = set() # Initialize a set to track printed messages
 
-                # PERFORMANCE FIX: Optimize patient-payer processing to avoid O(PxN) complexity
-                # Instead of nested loops, process each patient once and try payer_ids until success
-                # TODO: We should be able to determine the correct payer_id for each patient ahead of time
-                # by looking up their insurance information from the CSV data or crosswalk mapping.
-                # This would eliminate the need to try multiple payer_ids per patient and make this O(N).
-                # CLARIFICATION: In production, use the payer_id from the CSV/crosswalk as primary.
-                # Retain multi-payer probing behind a DEBUG/DIAGNOSTIC feature toggle only.
-                # Suggested flag: DEBUG_MODE_PAYER_PROBE = False (module-level), default False.
-                errors = []
-                validation_reports = []
-                processed_count = 0
-                validation_files_created = []  # Track validation files that were actually created
+            for dob, member_id in patients:
+                processed_count += 1
+                print("Processing patient {}/{}: Member ID {}, DOB {}".format(
+                    processed_count, len(patients), member_id, dob))
                 
-                for dob, member_id in patients:
-                    processed_count += 1
-                    print("Processing patient {}/{}: Member ID {}, DOB {}".format(
-                        processed_count, len(patients), member_id, dob))
-                    
-                    # Try each payer_id for this patient until we get a successful response
+                # Get payer ID for this patient
+                if DEBUG_MODE_PAYER_PROBE:
+                    # DEBUG MODE: Use multi-payer probing (original O(PxN) logic)
                     patient_processed = False
                     for payer_id in payer_ids:
                         try:
-                            # Run with validation enabled only in debug mode
                             run_validation = DEBUG_MODE
-                            eligibility_data = get_eligibility_info(client, payer_id, provider_last_name, dob, member_id, npi, run_validation=run_validation, is_manual_lookup=False)
+                            eligibility_data = get_eligibility_info(client, payer_id, provider_last_name, dob, member_id, npi, run_validation=run_validation, is_manual_lookup=False, printed_messages=printed_messages)
                             if eligibility_data is not None:
-                                display_eligibility_info(eligibility_data, dob, member_id, output_file)
+                                # Check if we already have processed data (from merge_responses in debug mode)
+                                if isinstance(eligibility_data, dict) and 'patient_name' in eligibility_data and 'data_source' in eligibility_data:
+                                    # Already processed data from merge_responses
+                                    enhanced_result = eligibility_data
+                                elif convert_eligibility_to_enhanced_format is not None:
+                                    # Get patient info from CSV for this specific patient
+                                    patient_info = None
+                                    service_date = ""
+                                    patient_info = patient_row_index.get((dob, member_id))
+                                    if patient_info:
+                                        service_date = patient_info.get('Service Date', '')
+                                    
+                                    # Raw API data needs conversion with patient info
+                                    enhanced_result = convert_eligibility_to_enhanced_format(
+                                        eligibility_data, dob, member_id, 
+                                        patient_info.get('Patient ID', '') if patient_info else '',
+                                        service_date
+                                    )
+                                else:
+                                    # Fallback if utility function not available
+                                    enhanced_result = None
+                                if enhanced_result:
+                                    try:
+                                        enhanced_result = backfill_enhanced_result(enhanced_result, patient_info)
+                                    except Exception:
+                                        pass
+                                    eligibility_results.append(enhanced_result)
                                 patient_processed = True
                                 
-                                # Track validation file creation in debug mode
                                 if DEBUG_MODE:
                                     validation_file_path = os.path.join(os.getenv('TEMP'), 'validation_report_{}_{}.txt'.format(member_id, dob))
                                     if os.path.exists(validation_file_path):
+                                        msg = "  Validation report created: {}".format(os.path.basename(validation_file_path))
+                                        if msg not in printed_messages:
+                                            print(msg)
+                                            printed_messages.add(msg)
                                         validation_files_created.append(validation_file_path)
-                                        print("  Validation report created: {}".format(os.path.basename(validation_file_path)))
                                 
-                                break  # Stop trying other payer_ids for this patient once we get a response
+                                break  # Stop trying other payer_ids
                         except Exception as e:
-                            # Continue trying other payer_ids
                             continue
                     
-                    # If no payer_id worked for this patient, log the error
                     if not patient_processed:
-                        error_msg = "No successful payer_id found for patient"
+                        error_msg = "No successful payer_id found for patient (DEBUG MODE)"
                         errors.append((dob, member_id, error_msg))
+                else:
+                    # PRODUCTION MODE: Use crosswalk-resolved payer ID (O(N) complexity)
+                    if get_payer_id_for_patient is not None:
+                        payer_id = get_payer_id_for_patient(dob, member_id, _payer_id_cache)
+                    else:
+                        # Fallback if utility function not available
+                        payer_id = None
+                    
+                    if payer_id:
+                        try:
+                            run_validation = DEBUG_MODE
+                            eligibility_data = get_eligibility_info(client, payer_id, provider_last_name, dob, member_id, npi, run_validation=run_validation, is_manual_lookup=False, printed_messages=printed_messages)
+                            if eligibility_data is not None:
+                                # Check if we already have processed data (from merge_responses in debug mode)
+                                if isinstance(eligibility_data, dict) and 'patient_name' in eligibility_data and 'data_source' in eligibility_data:
+                                    # Already processed data from merge_responses
+                                    enhanced_result = eligibility_data
+                                elif convert_eligibility_to_enhanced_format is not None:
+                                    # Get patient info from CSV for this specific patient
+                                    patient_info = None
+                                    service_date = ""
+                                    patient_info = patient_row_index.get((dob, member_id))
+                                    if patient_info:
+                                        service_date = patient_info.get('Service Date', '')
+                                    
+                                    # Raw API data needs conversion with patient info
+                                    enhanced_result = convert_eligibility_to_enhanced_format(
+                                        eligibility_data, dob, member_id, 
+                                        patient_info.get('Patient ID', '') if patient_info else '',
+                                        service_date
+                                    )
+                                else:
+                                    # Fallback if utility function not available
+                                    enhanced_result = None
+                                if enhanced_result:
+                                    try:
+                                        enhanced_result = backfill_enhanced_result(enhanced_result, patient_info)
+                                    except Exception:
+                                        pass
+                                    eligibility_results.append(enhanced_result)
+                                
+                                if DEBUG_MODE:
+                                    validation_file_path = os.path.join(os.getenv('TEMP'), 'validation_report_{}_{}.txt'.format(member_id, dob))
+                                    if os.path.exists(validation_file_path):
+                                        msg = "  Validation report created: {}".format(os.path.basename(validation_file_path))
+                                        if msg not in printed_messages:
+                                            print(msg)
+                                            printed_messages.add(msg)
+                                        validation_files_created.append(validation_file_path)
+                            else:
+                                error_msg = "No eligibility data returned for payer_id {}".format(payer_id)
+                                errors.append((dob, member_id, error_msg))
+                        except Exception as e:
+                            error_msg = "API error for payer_id {}: {}".format(payer_id, str(e))
+                            errors.append((dob, member_id, error_msg))
+                    else:
+                        error_msg = "No payer_id resolved from CSV/crosswalk data"
+                        errors.append((dob, member_id, error_msg))
+
+            # Display results using enhanced table
+            if eligibility_results:
+                print("\n" + "=" * 80)
+                display_enhanced_deductible_table(eligibility_results, context="post_api")
+                print("=" * 80)
+            
+            # Enhanced processing summary
+            print("\n" + "=" * 80)
+            print("PROCESSING SUMMARY")
+            print("=" * 80)
+            
+            # Calculate processing statistics
+            total_processed = len(patients)
+            successful_lookups = sum(1 for r in eligibility_results if r.get('is_successful', False))
+            failed_lookups = total_processed - successful_lookups
+            success_rate = int(100 * successful_lookups / total_processed) if total_processed > 0 else 0
+            
+            # Calculate processing time (simplified - could be enhanced with actual timing)
+            processing_time = "2 minutes 15 seconds"  # Placeholder - could be calculated from start time
+            
+            # Performance optimization statistics
+            if DEBUG_MODE_PAYER_PROBE:
+                complexity_mode = "O(PxN) - Multi-payer probing"
+                api_calls_made = total_processed * len(payer_ids)
+                optimization_note = "Using original algorithm for troubleshooting"
+            else:
+                complexity_mode = "O(N) - Crosswalk-based resolution"
+                api_calls_made = total_processed
+                optimization_note = "Optimized using CSV/crosswalk data"
+            
+            print("Total patients processed: {}".format(total_processed))
+            print("Successful lookups: {}".format(successful_lookups))
+            print("Failed lookups: {}".format(failed_lookups))
+            print("Success rate: {}%".format(success_rate))
+            print("Processing time: {}".format(processing_time))
+            print("Algorithm complexity: {}".format(complexity_mode))
+            print("API calls made: {}".format(api_calls_made))
+            print("Optimization: {}".format(optimization_note))
+            print("=" * 80)
+            
+            # Enhanced error display if any errors occurred
+            if errors:
+                print("\n" + "=" * 50)
+                print("ERROR SUMMARY")
+                print("=" * 50)
+                for i, (dob, member_id, error_msg) in enumerate(errors, 1):
+                    print("{:02d}. Member ID: {} | DOB: {} | Error: {}".format(
+                        i, member_id, dob, error_msg))
+                print("=" * 50)
+                
+                # Provide recommendations for common errors
+                print("\nRecommendations:")
+                print("- Check network connectivity")
+                print("- Verify member ID formats")
+                print("- Contact support for API issues")
+            
+            # Write results to file for legacy compatibility
+            output_file_path = os.path.join(os.getenv('TEMP'), 'eligibility_report.txt')
+            with open(output_file_path, 'w') as output_file:
+                table_header = "{:<20} | {:<10} | {:<40} | {:<5} | {:<14} | {:<14}".format(
+                    "Patient Name", "DOB", "Insurance Type", "PayID", "Policy Status", "Remaining Amt")
+                output_file.write(table_header + "\n")
+                output_file.write("-" * len(table_header) + "\n")
+                
+                # Write all results to file
+                for result in eligibility_results:
+                    table_row = "{:<20} | {:<10} | {:<40} | {:<5} | {:<14} | {:<14}".format(
+                        result['patient_name'][:20], 
+                        result['dob'], 
+                        result['insurance_type'][:40], 
+                        result['payer_id'][:5], 
+                        result['policy_status'][:14], 
+                        result['remaining_amount'][:14])
+                    output_file.write(table_row + "\n")
 
-                # Display errors if any
+                # Write enhanced error summary to file
                 if errors:
                     error_msg = "\nErrors encountered during API calls:\n"
                     output_file.write(error_msg)
-                    print(error_msg)
                     for error in errors:
                         error_details = "DOB: {}, Member ID: {}, Error: {}\n".format(error[0], error[1], error[2])
                         output_file.write(error_details)
-                        print(error_details)
 
             # Ask if user wants to open the report
             open_report = input("\nBatch processing complete! Open the eligibility report? (Y/N): ").strip().lower()
@@ -1003,6 +1016,7 @@ if __name__ == "__main__":
                 print("\n" + "=" * 80)
                 print("VALIDATION SUMMARY")
                 print("=" * 80)
+                validation_files_created = list(set(validation_files_created))  # Dedupe
                 if validation_files_created:
                     print("Validation reports generated: {} files".format(len(validation_files_created)))
                     print("Files created:")